irnode.c 54.9 KB
Newer Older
Christian Schäfer's avatar
Christian Schäfer committed
1
2
3
4
/* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
** All rights reserved.
**
** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
Götz Lindenmaier's avatar
Götz Lindenmaier committed
5
**
Christian Schäfer's avatar
Christian Schäfer committed
6
7
*/

Boris Boesler's avatar
Boris Boesler committed
8
9
/* $Id$ */

Boris Boesler's avatar
added    
Boris Boesler committed
10
11
12
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
13
#include <string.h>
Boris Boesler's avatar
added    
Boris Boesler committed
14

Götz Lindenmaier's avatar
Götz Lindenmaier committed
15
#include "irnode_t.h"
Götz Lindenmaier's avatar
Götz Lindenmaier committed
16
17
#include "irgraph_t.h"
#include "ident_t.h"
Götz Lindenmaier's avatar
Götz Lindenmaier committed
18
#include "irmode_t.h"
19
#include "typegmod_t.h"
Christian Schäfer's avatar
Christian Schäfer committed
20
#include "array.h"
21
#include "irbackedge_t.h"
22
#include "irdump.h"
Christian Schäfer's avatar
Christian Schäfer committed
23

Götz Lindenmaier's avatar
Götz Lindenmaier committed
24
#ifdef DEBUG_libfirm
25
#include "irprog_t.h"
Götz Lindenmaier's avatar
Götz Lindenmaier committed
26
27
#endif

Götz Lindenmaier's avatar
Götz Lindenmaier committed
28
29
30
31
32
/* some constants fixing the positions of nodes predecessors
   in the in array */
#define CALL_PARAM_OFFSET 2
#define SEL_INDEX_OFFSET 2
#define RETURN_RESULT_OFFSET 1  /* mem is not a result */
33
#define END_KEEPALIVE_OFFSET 0
Götz Lindenmaier's avatar
Götz Lindenmaier committed
34

35
/* Declarations for inlineing */
36
37
38
39
40
41
42
43
44
45
46
INLINE ir_node ** get_irn_in (ir_node *node);
INLINE ir_mode *get_irn_mode (ir_node *node);
INLINE ir_op *get_irn_op (ir_node *node);
INLINE opcode get_irn_opcode (ir_node *node);
INLINE ident *get_irn_opident (ir_node *node);
INLINE type *get_SymConst_type (ir_node *node);
INLINE ir_node *skip_nop (ir_node *node);
INLINE ir_node *skip_nop (ir_node *node);
INLINE int is_Proj (ir_node *node);


Christian Schäfer's avatar
Christian Schäfer committed
47
48
49
50
51
static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
				"Gt", "Ge", "Lg", "Leg", "Uo",
				"Ue", "Ul", "Ule", "Ug", "Uge",
				"Ne", "True" };

52
INLINE char *get_pnc_string(int pnc) {
Christian Schäfer's avatar
Christian Schäfer committed
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
  return pnc_name_arr[pnc];
}


int
get_negated_pnc(int pnc) {
  switch (pnc) {
  case False: return True;  break;
  case Eq:    return Ne;    break;
  case Lt:    return Uge;   break;
  case Le:    return Ug;    break;
  case Gt:    return Ule;   break;
  case Ge:    return Ul;    break;
  case Lg:    return Ue;    break;
  case Leg:   return Uo;    break;
  case Uo:    return Leg;   break;
  case Ue:    return Lg;    break;
  case Ul:    return Ge;    break;
  case Ule:   return Gt;    break;
  case Ug:    return Le;    break;
  case Uge:   return Lt;    break;
  case Ne:    return Eq;    break;
  case True:  return False; break;
  }
  return 99; /* to shut up gcc */
}

static char *pns_name_arr [] = {"initial_exec", "global_store",
				"frame_base", "globals", "args"};

static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};

void
init_irnode (void)
{
}

/* irnode constructor                                             */
/* create a new irnode in irg, with an op, mode, arity and        */
/* some incoming irnodes                                          */
/* this constructor is used in every specified irnode constructor */
94
INLINE ir_node *
Götz Lindenmaier's avatar
Götz Lindenmaier committed
95
new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
Christian Schäfer's avatar
Christian Schäfer committed
96
97
98
99
100
101
102
103
104
105
	     int arity, ir_node **in)
{
  ir_node *res;
  int node_size = offsetof (ir_node, attr) +  op->attr_size;

  res = (ir_node *) obstack_alloc (irg->obst, node_size);

  res->kind = k_ir_node;
  res->op = op;
  res->mode = mode;
106
  res->visited = 0;
Christian Schäfer's avatar
Christian Schäfer committed
107
108
  res->link = NULL;
  if (arity < 0) {
109
    res->in = NEW_ARR_F (ir_node *, 1);  /* 1: space for block */
Christian Schäfer's avatar
Christian Schäfer committed
110
111
112
113
114
  } else {
    res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
    memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
  }
  res->in[0] = block;
Götz Lindenmaier's avatar
Götz Lindenmaier committed
115
  set_irn_dbg_info(res, db);
116
  res->out = NULL;
Götz Lindenmaier's avatar
Götz Lindenmaier committed
117
118
119
120
121

#ifdef DEBUG_libfirm
  res->node_nr = get_irp_new_node_nr();
#endif

Christian Schäfer's avatar
Christian Schäfer committed
122
123
124
  return res;
}

Götz Lindenmaier's avatar
Götz Lindenmaier committed
125
126
127
128
/* Copies all attributes stored in the old node to the new node.
   Assumes both have the same opcode and sufficient size. */
void
copy_attrs (ir_node *old, ir_node *new) {
129
  assert (get_irn_op(old) == get_irn_op(new));
Götz Lindenmaier's avatar
Götz Lindenmaier committed
130
131
  memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
}
Christian Schäfer's avatar
Christian Schäfer committed
132
133
134
135
136
137
138
139
140
141
142
143
144

/* IR-Nodes with attributes */
int
ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
{
  int printed = 0;
  ir_node *np = XP_GETARG (ir_node *, 0);

  if (!np) {
    XPS ("<null ir_node>");
    return printed;
  }

Götz Lindenmaier's avatar
Götz Lindenmaier committed
145
  XPF1 ("%I", get_irn_opident(np));
Christian Schäfer's avatar
Christian Schäfer committed
146
147
148
149
150
151
152
153

  switch (get_irn_opcode (np)) {	/* node label */
  case iro_Const:
    XPF1 ("%I", get_irn_mode(np)->name);
    XPS (" : ");
    XPF1 ("%v", get_irn_const_attr);
    break;
  case iro_Proj:
154
    if (get_irn_mode (np) == mode_b) {
Christian Schäfer's avatar
Christian Schäfer committed
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
      XPC (" ");
      XP (pnc_name_arr[get_irn_proj_attr(np)]);
    } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
      XPC (" ");
      XP (pns_name_arr[get_irn_proj_attr(np)]);
    } else {
      XPF1 ("%I", get_irn_mode(np)->name);
      XPC (" ");
      XPF1 ("%d", get_irn_proj_attr(np));
    }
    break;
  case iro_SymConst:
    XPF1 ("%I", get_irn_mode(np)->name);
    XPC  (" ");
    XP   (symconst_name_arr[get_irn_symconst_attr(np).num]);
170
    XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
Christian Schäfer's avatar
Christian Schäfer committed
171
172
173
174
175
176
177
178
    break;
  case iro_Start:		/* don't dump mode of these */
  case iro_Cond:
  case iro_Block:
  case iro_Call:
  case iro_Jmp:
  case iro_Return:
  case iro_End:
179
180
181
182
  case iro_Break:
  case iro_EndReg:
  case iro_EndExcept:
  case iro_CallBegin:
Christian Schäfer's avatar
Christian Schäfer committed
183
184
185
186
187
188
189
190
191
192
193
    break;
  default:
    XPF1 ("%I", get_irn_mode(np)->name);
  }

  return printed;
}

/** getting some parameters from ir_nodes **/

/* returns the number of predecessors without the block predecessor. */
194
INLINE int
195
get_irn_arity (ir_node *node) {
Götz Lindenmaier's avatar
Götz Lindenmaier committed
196
  assert(node);
197
198
199
200
201
202
203
204
205
206
  if (interprocedural_view) { /* handle Filter and Block specially */
    if (get_irn_opcode(node) == iro_Filter) {
      assert(node->attr.filter.in_cg);
      return ARR_LEN(node->attr.filter.in_cg) - 1;
    } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
      return ARR_LEN(node->attr.block.in_cg) - 1;
    }
    /* else fall through */
  }
  return ARR_LEN(node->in) - 1;
Christian Schäfer's avatar
Christian Schäfer committed
207
208
}

209
210
211
212
213
214
/* Returns the array with ins. This array is shifted with respect to the
   array accessed by get_irn_n: The block operand is at position 0 not -1.
   (@@@ This should be changed.)
   The order of the predecessors in this array is not guaranteed, except that
   lists of operands as predecessors of Block or arguments of a Call are
   consecutive. */
215
INLINE ir_node **
216
217
218
219
220
221
222
223
224
225
226
227
get_irn_in (ir_node *node) {
  assert(node);
  if (interprocedural_view) { /* handle Filter and Block specially */
    if (get_irn_opcode(node) == iro_Filter) {
      assert(node->attr.filter.in_cg);
      return node->attr.filter.in_cg;
    } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
      return node->attr.block.in_cg;
    }
    /* else fall through */
  }
  return node->in;
Christian Schäfer's avatar
Christian Schäfer committed
228
229
}

230
INLINE void
231
set_irn_in (ir_node *node, int arity, ir_node **in) {
232
  ir_node *** arr;
233
  assert(node);
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
  if (interprocedural_view) { /* handle Filter and Block specially */
    if (get_irn_opcode(node) == iro_Filter) {
      assert(node->attr.filter.in_cg);
      arr = &node->attr.filter.in_cg;
    } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
      arr = &node->attr.block.in_cg;
    } else {
      arr = &node->in;
    }
  } else {
    arr = &node->in;
  }
  if (arity != ARR_LEN(*arr) - 1) {
    ir_node * block = (*arr)[0];
    *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
    (*arr)[0] = block;
250
  }
Götz Lindenmaier's avatar
Götz Lindenmaier committed
251
  //fix_backedges(current_ir_graph->obst, node);
252
  memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
253
254
}

Christian Schäfer's avatar
Christian Schäfer committed
255
256
257
/* to iterate through the predecessors without touching the array */
/* To iterate over the operands iterate from 0 to i < get_irn_arity(),
   to iterate includind the Block predecessor iterate from i = -1 to
258
259
   i < get_irn_arity.
   If it is a block, the entry -1 is NULL. */
260
INLINE ir_node *
261
get_irn_n (ir_node *node, int n) {
262
  /* debug @@@
263
264
265
  if (-1 > n || get_irn_arity(node) <= n) {
    printf("pos: %d, arity: %d ", n, get_irn_arity(node));
    DDMN(node);
266
    } */
267
  assert(node); assert(-1 <= n && n < get_irn_arity(node));
268
269
270
271
272
273
274
275
276
277
  if (interprocedural_view) { /* handle Filter and Block specially */
    if (get_irn_opcode(node) == iro_Filter) {
      assert(node->attr.filter.in_cg);
      return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
    } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
      return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
    }
    /* else fall through */
  }
  return (node->in[n + 1] = skip_nop(node->in[n + 1]));
Christian Schäfer's avatar
Christian Schäfer committed
278
279
}

280
INLINE void
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
set_irn_n (ir_node *node, int n, ir_node *in) {
  assert(node && -1 <= n && n < get_irn_arity(node));
  if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
    /* Change block pred in both views! */
    node->in[n + 1] = in;
    assert(node->attr.filter.in_cg);
    node->attr.filter.in_cg[n + 1] = in;
    return;
  }
  if (interprocedural_view) { /* handle Filter and Block specially */
    if (get_irn_opcode(node) == iro_Filter) {
      assert(node->attr.filter.in_cg);
      node->attr.filter.in_cg[n + 1] = in;
      return;
    } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
      node->attr.block.in_cg[n + 1] = in;
      return;
    }
    /* else fall through */
  }
  node->in[n + 1] = in;
Christian Schäfer's avatar
Christian Schäfer committed
302
303
}

304
INLINE ir_mode *
Christian Schäfer's avatar
Christian Schäfer committed
305
306
307
308
309
310
get_irn_mode (ir_node *node)
{
  assert (node);
  return node->mode;
}

311
INLINE modecode
Christian Schäfer's avatar
Christian Schäfer committed
312
313
314
315
316
317
get_irn_modecode (ir_node *node)
{
  assert (node);
  return node->mode->code;
}

Götz Lindenmaier's avatar
Götz Lindenmaier committed
318

319
INLINE ident *
Götz Lindenmaier's avatar
Götz Lindenmaier committed
320
get_irn_modeident (ir_node *node)
Götz Lindenmaier's avatar
Götz Lindenmaier committed
321
322
323
324
325
{
  assert(node);
  return node->mode->name;
}

326
INLINE ir_op *
Christian Schäfer's avatar
Christian Schäfer committed
327
328
329
330
331
332
333
get_irn_op (ir_node *node)
{
  assert (node);
  return node->op;
}

/* should be private to the library: */
334
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
335
336
337
338
339
340
set_irn_op (ir_node *node, ir_op *op)
{
  assert (node);
  node->op = op;
}

341
INLINE opcode
Götz Lindenmaier's avatar
Götz Lindenmaier committed
342
get_irn_opcode (ir_node *node)
343
344
{
  assert (node);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
345
346
347
  return node->op->code;
}

348
INLINE const char *
Götz Lindenmaier's avatar
Götz Lindenmaier committed
349
get_irn_opname (ir_node *node)
Götz Lindenmaier's avatar
Götz Lindenmaier committed
350
351
352
353
354
{
  assert(node);
  return id_to_str(node->op->name);
}

355
INLINE ident *
Götz Lindenmaier's avatar
Götz Lindenmaier committed
356
get_irn_opident (ir_node *node)
Götz Lindenmaier's avatar
Götz Lindenmaier committed
357
358
359
{
  assert(node);
  return node->op->name;
360
361
}

362
INLINE unsigned long
363
364
365
366
367
368
get_irn_visited (ir_node *node)
{
  assert (node);
  return node->visited;
}

369
INLINE void
Götz Lindenmaier's avatar
Götz Lindenmaier committed
370
set_irn_visited (ir_node *node, unsigned long visited)
Christian Schäfer's avatar
Christian Schäfer committed
371
372
{
  assert (node);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
373
  node->visited = visited;
Christian Schäfer's avatar
Christian Schäfer committed
374
}
375

376
INLINE void
377
378
379
380
381
mark_irn_visited (ir_node *node) {
  assert (node);
  node->visited = current_ir_graph->visited;
}

382
INLINE int
Götz Lindenmaier's avatar
Götz Lindenmaier committed
383
384
385
386
387
irn_not_visited  (ir_node *node) {
  assert (node);
  return (node->visited < current_ir_graph->visited);
}

388
389
390
391
392
393
INLINE int
irn_visited  (ir_node *node) {
  assert (node);
  return (node->visited >= current_ir_graph->visited);
}

394
INLINE void
395
set_irn_link (ir_node *node, void *link) {
Christian Schäfer's avatar
Christian Schäfer committed
396
  assert (node);
397
398
399
400
  /* Link field is used for Phi construction and various optimizations
     in iropt. */
  assert(get_irg_phase_state(current_ir_graph) != phase_building);

Christian Schäfer's avatar
Christian Schäfer committed
401
402
403
  node->link = link;
}

404
INLINE void *
Christian Schäfer's avatar
Christian Schäfer committed
405
406
407
408
409
get_irn_link (ir_node *node) {
  assert (node);
  return node->link;
}

Götz Lindenmaier's avatar
Götz Lindenmaier committed
410
/* Outputs a unique number for this node */
411
INLINE long
Götz Lindenmaier's avatar
Götz Lindenmaier committed
412
413
get_irn_node_nr(ir_node *node) {
  assert(node);
414
#ifdef DEBUG_libfirm
Götz Lindenmaier's avatar
Götz Lindenmaier committed
415
  return node->node_nr;
416
417
#else
  return 0;
Götz Lindenmaier's avatar
Götz Lindenmaier committed
418
#endif
419
}
Götz Lindenmaier's avatar
Götz Lindenmaier committed
420

421
INLINE tarval *
Christian Schäfer's avatar
Christian Schäfer committed
422
423
424
425
426
427
get_irn_const_attr (ir_node *node)
{
  assert (node->op == op_Const);
  return node->attr.con;
}

428
INLINE long
Christian Schäfer's avatar
Christian Schäfer committed
429
430
431
432
433
434
get_irn_proj_attr (ir_node *node)
{
  assert (node->op == op_Proj);
  return node->attr.proj;
}

435
INLINE alloc_attr
Christian Schäfer's avatar
Christian Schäfer committed
436
437
438
439
440
441
get_irn_alloc_attr (ir_node *node)
{
  assert (node->op == op_Alloc);
  return node->attr.a;
}

442
INLINE type *
Christian Schäfer's avatar
Christian Schäfer committed
443
444
445
get_irn_free_attr     (ir_node *node)
{
  assert (node->op == op_Free);
446
  return node->attr.f = skip_tid(node->attr.f);
Christian Schäfer's avatar
Christian Schäfer committed
447
448
}

449
INLINE symconst_attr
Christian Schäfer's avatar
Christian Schäfer committed
450
451
452
453
454
455
get_irn_symconst_attr (ir_node *node)
{
  assert (node->op == op_SymConst);
  return node->attr.i;
}

456
INLINE type *
Christian Schäfer's avatar
Christian Schäfer committed
457
458
459
get_irn_call_attr (ir_node *node)
{
  assert (node->op == op_Call);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
460
  return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
Christian Schäfer's avatar
Christian Schäfer committed
461
462
}

463
INLINE sel_attr
Christian Schäfer's avatar
Christian Schäfer committed
464
465
466
467
468
469
get_irn_sel_attr (ir_node *node)
{
  assert (node->op == op_Sel);
  return node->attr.s;
}

470
INLINE int
Christian Schäfer's avatar
Christian Schäfer committed
471
472
473
474
475
476
get_irn_phi_attr (ir_node *node)
{
  assert (node->op == op_Phi);
  return node->attr.phi0_pos;
}

477
INLINE block_attr
Christian Schäfer's avatar
Christian Schäfer committed
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
get_irn_block_attr (ir_node *node)
{
  assert (node->op == op_Block);
  return node->attr.block;
}

/** manipulate fields of individual nodes **/

/* this works for all except Block */
ir_node *
get_nodes_Block (ir_node *node) {
  assert (!(node->op == op_Block));
  return get_irn_n(node, -1);
}

493
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
494
495
496
497
498
set_nodes_Block (ir_node *node, ir_node *block) {
  assert (!(node->op == op_Block));
  set_irn_n(node, -1, block);
}

499
500
501
502
/* Returns an array with the predecessors of the Block. Depending on
   the implementation of the graph datastructure this can be a copy of
   the internal representation of predecessors as well as the internal
   array itself. Therefore writing to this array might obstruct the ir. */
503
INLINE ir_node **
504
505
506
get_Block_cfgpred_arr (ir_node *node)
{
  assert ((node->op == op_Block));
Götz Lindenmaier's avatar
Götz Lindenmaier committed
507
  return (ir_node **)&(get_irn_in(node)[1]);
508
509
510
}


511
INLINE int
Christian Schäfer's avatar
Christian Schäfer committed
512
513
514
515
516
get_Block_n_cfgpreds (ir_node *node) {
  assert ((node->op == op_Block));
  return (get_irn_arity(node));
}

517
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
518
519
get_Block_cfgpred (ir_node *node, int pos) {
  assert (node->op == op_Block);
520
  /* debug @@@
521
522
523
524
  if (-1 > pos || get_irn_arity(node) <= pos) {
    dump_ir_block_graph(current_ir_graph);
    printf("pos: %d, arity: %d ", pos, get_irn_arity(node));
    DDMN(node);
525
    } */
526
  assert(node); assert(-1 <= pos && pos < get_irn_arity(node));
Christian Schäfer's avatar
Christian Schäfer committed
527
528
529
  return get_irn_n(node, pos);
}

530
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
531
532
533
534
535
set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
  assert (node->op == op_Block);
  set_irn_n(node, pos, pred);
}

536
INLINE bool
Christian Schäfer's avatar
Christian Schäfer committed
537
538
539
540
541
get_Block_matured (ir_node *node) {
  assert (node->op == op_Block);
  return node->attr.block.matured;
}

542
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
543
544
545
546
set_Block_matured (ir_node *node, bool matured) {
  assert (node->op == op_Block);
  node->attr.block.matured = matured;
}
547
INLINE unsigned long
548
get_Block_block_visited (ir_node *node) {
Christian Schäfer's avatar
Christian Schäfer committed
549
  assert (node->op == op_Block);
550
  return node->attr.block.block_visited;
Christian Schäfer's avatar
Christian Schäfer committed
551
552
}

553
INLINE void
554
set_Block_block_visited (ir_node *node, unsigned long visit) {
Christian Schäfer's avatar
Christian Schäfer committed
555
  assert (node->op == op_Block);
556
  node->attr.block.block_visited = visit;
Christian Schäfer's avatar
Christian Schäfer committed
557
558
}

Götz Lindenmaier's avatar
Götz Lindenmaier committed
559
/* For this current_ir_graph must be set. */
560
561
INLINE void
mark_Block_block_visited (ir_node *node) {
Götz Lindenmaier's avatar
Götz Lindenmaier committed
562
563
564
565
  assert (node->op == op_Block);
  node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
}

566
567
INLINE int
Block_not_block_visited(ir_node *node) {
568
569
570
  assert (node->op == op_Block);
  return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
}
Götz Lindenmaier's avatar
Götz Lindenmaier committed
571

572
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
573
574
575
576
577
get_Block_graph_arr (ir_node *node, int pos) {
  assert (node->op == op_Block);
  return node->attr.block.graph_arr[pos+1];
}

578
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
579
580
581
582
set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
  assert (node->op == op_Block);
  node->attr.block.graph_arr[pos+1] = value;
}
583

584
/* handler handling for Blocks */
585
586
void
set_Block_handler (ir_node *block, ir_node *handler)  {
587
588
589
590
591
  assert ((block->op == op_Block));
  assert ((handler->op == op_Block));
  block->attr.block.handler_entry = handler;
}

592
593
ir_node *
get_Block_handler (ir_node *block) {
594
595
596
597
598
  assert ((block->op == op_Block));
  return (block->attr.block.handler_entry);
}

/* handler handling for Nodes */
599
600
void
set_Node_handler (ir_node *node, ir_node *handler) {
601
602
603
  set_Block_handler (get_nodes_Block (node), handler);
}

604
605
ir_node *
get_Node_handler (ir_node *node) {
606
607
608
609
  return (get_Block_handler (get_nodes_Block (node)));
}

/* exc_t handling for Blocks */
610
void set_Block_exc (ir_node *block, exc_t exc) {
611
  assert ((block->op == op_Block));
612
613
614
  block->attr.block.exc = exc;
}

615
exc_t get_Block_exc (ir_node *block) {
616
617
  assert ((block->op == op_Block));

618
619
620
  return (block->attr.block.exc);
}

621
/* exc_t handling for Nodes */
622
void set_Node_exc (ir_node *node, exc_t exc) {
623
624
625
  set_Block_exc (get_nodes_Block (node), exc);
}

626
exc_t get_Node_exc (ir_node *node) {
627
628
629
  return (get_Block_exc (get_nodes_Block (node)));
}

630
631
632
633
634
void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
  assert(node->op == op_Block);
  if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
    node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
    node->attr.block.in_cg[0] = NULL;
635
    node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
636
637
638
639
640
  }
  memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
}

void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
Götz Lindenmaier's avatar
Götz Lindenmaier committed
641
642
643
  assert(node->op == op_Block &&
	 node->attr.block.in_cg &&
	 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
644
645
646
647
648
649
650
651
652
  node->attr.block.in_cg[pos + 1] = pred;
}

ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
  assert(node->op == op_Block);
  return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg  + 1;
}

int get_Block_cg_n_cfgpreds(ir_node * node) {
653
654
  assert(node->op == op_Block);
  return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
655
656
}

657
658
659
660
661
ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
  assert(node->op == op_Block && node->attr.block.in_cg);
  return node->attr.block.in_cg[pos + 1];
}

662
663
664
665
666
void remove_Block_cg_cfgpred_arr(ir_node * node) {
  assert(node->op == op_Block);
  node->attr.block.in_cg = NULL;
}

667
INLINE int
668
669
670
671
672
get_End_n_keepalives(ir_node *end) {
  assert (end->op == op_End);
  return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
}

673
INLINE ir_node *
674
675
676
677
678
get_End_keepalive(ir_node *end, int pos) {
  assert (end->op == op_End);
  return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
}

679
INLINE void
680
681
682
683
684
add_End_keepalive (ir_node *end, ir_node *ka) {
  assert (end->op == op_End);
  ARR_APP1 (ir_node *, end->in, ka);
}

685
INLINE void
686
687
688
689
690
set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
  assert (end->op == op_End);
  set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
}

691
INLINE void
692
free_End (ir_node *end) {
693
  assert (end->op == op_End);
694
  /* DEL_ARR_F(end->in);   GL @@@ tut nicht ! */
695
696
697
698
699
700
701
702
703
704
705
706
  end->in = NULL;   /* @@@ make sure we get an error if we use the
		       in array afterwards ... */
}

ir_graph *get_EndReg_irg (ir_node *end) {
  assert (end->op == op_EndReg);
  return end->attr.end.irg;
}

ir_graph *get_EndExcept_irg  (ir_node *end) {
  assert (end->op == op_EndReg);
  return end->attr.end.irg;
707
708
}

Götz Lindenmaier's avatar
Götz Lindenmaier committed
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
/*
> Implementing the case construct (which is where the constant Proj node is
> important) involves far more than simply determining the constant values.
> We could argue that this is more properly a function of the translator from
> Firm to the target machine.  That could be done if there was some way of
> projecting "default" out of the Cond node.
I know it's complicated.
Basically there are two proglems:
 - determining the gaps between the projs
 - determining the biggest case constant to konw the proj number for
   the default node.
I see several solutions:
1. Introduce a ProjDefault node.  Solves both problems.
   This means to extend all optimizations executed during construction.
2. Give the Cond node for switch two flavors:
   a) there are no gaps in the projs  (existing flavor)
   b) gaps may exist, default proj is still the Proj with the largest
      projection number.  This covers also the gaps.
3. Fix the semantic of the Cond to that of 2b)

Solution 2 seems to be the best:
Computing the gaps in the Firm representation is not too hard, i.e.,
libfirm can implement a routine that transforms betweeen the two
flavours.  This is also possible for 1) but 2) does not require to
change any existing optimization.
Further it should be far simpler to determine the biggest constant than
to compute all gaps.
I don't want to choose 3) as 2a) seems to have advantages for
dataflow analysis and 3) does not allow to convert the representation to
2a).
*/
740
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
741
742
743
744
745
get_Cond_selector (ir_node *node) {
  assert (node->op == op_Cond);
  return get_irn_n(node, 0);
}

746
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
747
748
749
750
751
set_Cond_selector (ir_node *node, ir_node *selector) {
  assert (node->op == op_Cond);
  set_irn_n(node, 0, selector);
}

752
INLINE cond_kind
753
754
get_Cond_kind (ir_node *node) {
  assert (node->op == op_Cond);
755
  return node->attr.c.kind;
756
757
}

758
INLINE void
759
760
set_Cond_kind (ir_node *node, cond_kind kind) {
  assert (node->op == op_Cond);
761
  node->attr.c.kind = kind;
762
763
}

764
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
765
get_Return_mem (ir_node *node) {
766
  assert (node->op == op_Return);
Christian Schäfer's avatar
Christian Schäfer committed
767
768
769
  return get_irn_n(node, 0);
}

770
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
771
772
773
774
775
set_Return_mem (ir_node *node, ir_node *mem) {
  assert (node->op == op_Return);
  set_irn_n(node, 0, mem);
}

776
INLINE int
777
get_Return_n_ress (ir_node *node) {
778
779
780
781
782
  assert (node->op == op_Return);
  return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
}

INLINE ir_node **
783
784
785
get_Return_res_arr (ir_node *node)
{
  assert ((node->op == op_Return));
786
  if (get_Return_n_ress(node) > 0)
Götz Lindenmaier's avatar
Götz Lindenmaier committed
787
    return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
788
789
  else
    return NULL;
790
791
}

Christian Schäfer's avatar
Christian Schäfer committed
792
/*
793
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
794
795
796
797
798
set_Return_n_res (ir_node *node, int results) {
  assert (node->op == op_Return);
}
*/

799
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
800
801
get_Return_res (ir_node *node, int pos) {
  assert (node->op == op_Return);
802
  assert (get_Return_n_ress(node) > pos);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
803
  return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
Christian Schäfer's avatar
Christian Schäfer committed
804
805
}

806
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
807
set_Return_res (ir_node *node, int pos, ir_node *res){
808
  assert (node->op == op_Return);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
809
  set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
Christian Schäfer's avatar
Christian Schäfer committed
810
811
}

812
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
813
814
815
816
817
get_Raise_mem (ir_node *node) {
  assert (node->op == op_Return);
  return get_irn_n(node, 0);
}

818
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
819
820
821
822
823
set_Raise_mem (ir_node *node, ir_node *mem) {
  assert (node->op == op_Raise);
  set_irn_n(node, 0, mem);
}

824
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
825
826
827
828
829
get_Raise_exo_ptr (ir_node *node) {
  assert (node->op == op_Raise);
  return get_irn_n(node, 1);
}

830
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
831
832
833
834
835
set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
  assert (node->op == op_Raise);
  set_irn_n(node, 1, exo_ptr);
}

836
INLINE tarval *get_Const_tarval (ir_node *node) {
Christian Schäfer's avatar
Christian Schäfer committed
837
838
839
840
  assert (node->op == op_Const);
  return get_irn_const_attr(node);
}

841
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
842
843
844
845
846
set_Const_tarval (ir_node *node, tarval *con) {
  assert (node->op == op_Const);
  node->attr.con = con;
}

847
INLINE symconst_kind
Christian Schäfer's avatar
Christian Schäfer committed
848
849
850
851
852
get_SymConst_kind (ir_node *node) {
  assert (node->op == op_SymConst);
  return node->attr.i.num;
}

853
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
854
855
856
857
858
set_SymConst_kind (ir_node *node, symconst_kind num) {
  assert (node->op == op_SymConst);
  node->attr.i.num = num;
}

859
INLINE type *
Christian Schäfer's avatar
Christian Schäfer committed
860
861
862
863
get_SymConst_type (ir_node *node) {
  assert (   (node->op == op_SymConst)
          && (   get_SymConst_kind(node) == type_tag
              || get_SymConst_kind(node) == size));
864
  return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
Christian Schäfer's avatar
Christian Schäfer committed
865
866
}

867
INLINE void
868
set_SymConst_type (ir_node *node, type *tp) {
Christian Schäfer's avatar
Christian Schäfer committed
869
870
871
  assert (   (node->op == op_SymConst)
          && (   get_SymConst_kind(node) == type_tag
              || get_SymConst_kind(node) == size));
872
  node->attr.i.tori.typ = tp;
Christian Schäfer's avatar
Christian Schäfer committed
873
874
}

875
INLINE ident *
Christian Schäfer's avatar
Christian Schäfer committed
876
877
878
879
880
881
get_SymConst_ptrinfo (ir_node *node) {
  assert (   (node->op == op_SymConst)
          && (get_SymConst_kind(node) == linkage_ptr_info));
  return node->attr.i.tori.ptrinfo;
}

882
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
883
884
885
886
887
888
set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
  assert (   (node->op == op_SymConst)
          && (get_SymConst_kind(node) == linkage_ptr_info));
  node->attr.i.tori.ptrinfo = ptrinfo;
}

889
INLINE type_or_id_p
Götz Lindenmaier's avatar
Götz Lindenmaier committed
890
891
892
893
894
get_SymConst_type_or_id (ir_node *node) {
  assert (node->op == op_SymConst);
  return &(node->attr.i.tori);
}

895
INLINE void
Götz Lindenmaier's avatar
Götz Lindenmaier committed
896
897
898
899
900
set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
  assert (node->op == op_SymConst);
  memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
}

901
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
902
903
904
905
906
get_Sel_mem (ir_node *node) {
  assert (node->op == op_Sel);
  return get_irn_n(node, 0);
}

907
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
908
909
910
911
912
set_Sel_mem (ir_node *node, ir_node *mem) {
  assert (node->op == op_Sel);
  set_irn_n(node, 0, mem);
}

913
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
914
915
916
917
918
get_Sel_ptr (ir_node *node) {
  assert (node->op == op_Sel);
  return get_irn_n(node, 1);
}

919
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
920
921
922
923
924
set_Sel_ptr (ir_node *node, ir_node *ptr) {
  assert (node->op == op_Sel);
  set_irn_n(node, 1, ptr);
}

925
INLINE int
926
get_Sel_n_indexs (ir_node *node) {
927
928
929
930
931
  assert (node->op == op_Sel);
  return (get_irn_arity(node) - SEL_INDEX_OFFSET);
}

INLINE ir_node **
932
933
934
get_Sel_index_arr (ir_node *node)
{
  assert ((node->op == op_Sel));
935
  if (get_Sel_n_indexs(node) > 0)
Götz Lindenmaier's avatar
Götz Lindenmaier committed
936
    return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
Götz Lindenmaier's avatar
Götz Lindenmaier committed
937
938
  else
    return NULL;
939
940
}

941
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
942
943
get_Sel_index (ir_node *node, int pos) {
  assert (node->op == op_Sel);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
944
  return get_irn_n(node, pos + SEL_INDEX_OFFSET);
Christian Schäfer's avatar
Christian Schäfer committed
945
946
}

947
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
948
949
set_Sel_index (ir_node *node, int pos, ir_node *index) {
  assert (node->op == op_Sel);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
950
  set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
Christian Schäfer's avatar
Christian Schäfer committed
951
952
}

953
INLINE entity *
Christian Schäfer's avatar
Christian Schäfer committed
954
955
956
957
958
get_Sel_entity (ir_node *node) {
  assert (node->op == op_Sel);
  return node->attr.s.ent;
}

959
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
960
961
962
963
964
set_Sel_entity (ir_node *node, entity *ent) {
  assert (node->op == op_Sel);
  node->attr.s.ent = ent;
}

965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
type *
get_InstOf_ent (ir_node *node) {
  assert (node->op = op_InstOf);
  return (node->attr.io.ent);
}

void
set_InstOf_ent (ir_node *node, type *ent) {
  assert (node->op = op_InstOf);
  node->attr.io.ent = ent;
}

ir_node *
get_InstOf_store (ir_node *node) {
  assert (node->op = op_InstOf);
  return (get_irn_n (node, 0));
}

void
set_InstOf_store (ir_node *node, ir_node *obj) {
  assert (node->op = op_InstOf);
  set_irn_n (node, 0, obj);
}

ir_node *
get_InstOf_obj (ir_node *node) {
  assert (node->op = op_InstOf);
  return (get_irn_n (node, 1));
}

void
set_InstOf_obj (ir_node *node, ir_node *obj) {
  assert (node->op = op_InstOf);
  set_irn_n (node, 1, obj);
}

1001
1002
1003
1004
1005
1006
1007
1008
1009
1010

/* For unary and binary arithmetic operations the access to the
   operands can be factored out.  Left is the first, right the
   second arithmetic value  as listed in tech report 0999-33.
   unops are: Minus, Abs, Not, Conv
   binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
   Shr, Shrs, Rotate, Cmp */


INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
1011
1012
1013
1014
1015
get_Call_mem (ir_node *node) {
  assert (node->op == op_Call);
  return get_irn_n(node, 0);
}

1016
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
1017
1018
1019
1020
1021
set_Call_mem (ir_node *node, ir_node *mem) {
  assert (node->op == op_Call);
  set_irn_n(node, 0, mem);
}

1022
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
1023
1024
1025
1026
1027
get_Call_ptr (ir_node *node) {
  assert (node->op == op_Call);
  return get_irn_n(node, 1);
}

1028
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
1029
1030
1031
1032
1033
set_Call_ptr (ir_node *node, ir_node *ptr) {
  assert (node->op == op_Call);
  set_irn_n(node, 1, ptr);
}

1034
INLINE ir_node **
1035
1036
get_Call_param_arr (ir_node *node) {
  assert (node->op == op_Call);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
1037
  return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1038
1039
}

1040
INLINE int
Götz Lindenmaier's avatar
Götz Lindenmaier committed
1041
get_Call_n_params (ir_node *node)  {
Christian Schäfer's avatar
Christian Schäfer committed
1042
  assert (node->op == op_Call);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
1043
  return (get_irn_arity(node) - CALL_PARAM_OFFSET);
Christian Schäfer's avatar
Christian Schäfer committed
1044
1045
}

1046
INLINE int
Götz Lindenmaier's avatar
Götz Lindenmaier committed
1047
get_Call_arity (ir_node *node) {
1048
  assert (node->op == op_Call);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
1049
1050
1051
  return get_Call_n_params(node);
}

1052
/* INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
1053
1054
1055
1056
1057
set_Call_arity (ir_node *node, ir_node *arity) {
  assert (node->op == op_Call);
}
*/

1058
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
1059
1060
get_Call_param (ir_node *node, int pos) {
  assert (node->op == op_Call);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
1061
  return get_irn_n(node, pos + CALL_PARAM_OFFSET);
Christian Schäfer's avatar
Christian Schäfer committed
1062
1063
}

1064
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
1065
1066
set_Call_param (ir_node *node, int pos, ir_node *param) {
  assert (node->op == op_Call);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
1067
  set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
Christian Schäfer's avatar
Christian Schäfer committed
1068
1069
}

1070
INLINE type *
Christian Schäfer's avatar
Christian Schäfer committed
1071
1072
get_Call_type (ir_node *node) {
  assert (node->op == op_Call);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
1073
  return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
Christian Schäfer's avatar
Christian Schäfer committed
1074
1075
}

1076
INLINE void
1077
set_Call_type (ir_node *node, type *tp) {
Christian Schäfer's avatar
Christian Schäfer committed
1078
  assert (node->op == op_Call);
1079
1080
  assert (is_method_type(tp));
  node->attr.call.cld_tp = tp;
Christian Schäfer's avatar
Christian Schäfer committed
1081
1082
}

1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
int get_Call_n_callees(ir_node * node) {
  assert(node->op == op_Call && node->attr.call.callee_arr);
  return ARR_LEN(node->attr.call.callee_arr);
}

entity * get_Call_callee(ir_node * node, int pos) {
  assert(node->op == op_Call && node->attr.call.callee_arr);
  return node->attr.call.callee_arr[pos];
}

void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
  assert(node->op == op_Call);
  if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
    node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
  }
  memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
}

void remove_Call_callee_arr(ir_node * node) {
  assert(node->op == op_Call);
  node->attr.call.callee_arr = NULL;
}

1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
ir_node * get_CallBegin_ptr (ir_node *node) {
  assert(node->op == op_CallBegin);
  return get_irn_n(node, 0);
}
void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
  assert(node->op == op_CallBegin);
  set_irn_n(node, 0, ptr);
}
ir_graph * get_CallBegin_irg (ir_node *node) {
  assert(node->op == op_CallBegin);
  return node->attr.callbegin.irg;
}
ir_node * get_CallBegin_call (ir_node *node) {
  assert(node->op == op_CallBegin);
  return node->attr.callbegin.call;
}
void  set_CallBegin_call (ir_node *node, ir_node *call) {
  assert(node->op == op_CallBegin);
  node->attr.callbegin.call = call;
}

1127
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
1128
1129
1130
1131
1132
get_Add_left (ir_node *node) {
  assert (node->op == op_Add);
  return get_irn_n(node, 0);
}

1133
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
1134
1135
1136
1137
1138
set_Add_left (ir_node *node, ir_node *left) {
  assert (node->op == op_Add);
  set_irn_n(node, 0, left);
}

1139
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
1140
1141
1142
1143
1144
get_Add_right (ir_node *node) {
  assert (node->op == op_Add);
  return get_irn_n(node, 1);
}

1145
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
1146
1147
1148
1149
1150
set_Add_right (ir_node *node, ir_node *right) {
  assert (node->op == op_Add);
  set_irn_n(node, 1, right);
}

1151
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
1152
1153
1154
1155
1156
get_Sub_left (ir_node *node) {
  assert (node->op == op_Sub);
  return get_irn_n(node, 0);
}

1157
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
1158
1159
1160
1161
1162
set_Sub_left (ir_node *node, ir_node *left) {
  assert (node->op == op_Sub);
  set_irn_n(node, 0, left);
}

1163
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
1164
1165
1166
1167
1168
get_Sub_right (ir_node *node) {
  assert (node->op == op_Sub);
  return get_irn_n(node, 1);
}

1169
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
1170
1171
1172
1173
1174
1175
set_Sub_right (ir_node *node, ir_node *right) {
  assert (node->op == op_Sub);
  set_irn_n(node, 1, right);
}


1176
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
1177
1178
1179
1180
1181
get_Minus_op (ir_node *node) {
  assert (node->op == op_Minus);
  return get_irn_n(node, 0);
}

1182
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
1183
1184
1185
1186
1187
1188
set_Minus_op (ir_node *node, ir_node *op) {
  assert (node->op == op_Minus);
  set_irn_n(node