irnode.c 54.3 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"
Christian Schäfer's avatar
Christian Schäfer committed
22

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

Götz Lindenmaier's avatar
Götz Lindenmaier committed
27
28
29
30
31
/* 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 */
32
#define END_KEEPALIVE_OFFSET 0
Götz Lindenmaier's avatar
Götz Lindenmaier committed
33

34
/* Declarations for inlineing */
35
36
37
38
39
40
41
42
43
44
45
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
46
47
48
49
50
static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
				"Gt", "Ge", "Lg", "Leg", "Uo",
				"Ue", "Ul", "Ule", "Ug", "Uge",
				"Ne", "True" };

51
INLINE char *get_pnc_string(int pnc) {
Christian Schäfer's avatar
Christian Schäfer committed
52
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
  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 */
93
INLINE ir_node *
Götz Lindenmaier's avatar
Götz Lindenmaier committed
94
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
95
96
97
98
99
100
101
102
103
104
	     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;
105
  res->visited = 0;
Christian Schäfer's avatar
Christian Schäfer committed
106
107
  res->link = NULL;
  if (arity < 0) {
108
    res->in = NEW_ARR_F (ir_node *, 1);  /* 1: space for block */
Christian Schäfer's avatar
Christian Schäfer committed
109
110
111
112
113
  } 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
114
  set_irn_dbg_info(res, db);
115
  res->out = NULL;
Götz Lindenmaier's avatar
Götz Lindenmaier committed
116
117
118
119
120

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

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

Götz Lindenmaier's avatar
Götz Lindenmaier committed
124
125
126
127
/* 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) {
128
  assert (get_irn_op(old) == get_irn_op(new));
Götz Lindenmaier's avatar
Götz Lindenmaier committed
129
130
  memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
}
Christian Schäfer's avatar
Christian Schäfer committed
131
132
133
134
135
136
137
138
139
140
141
142
143

/* 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
144
  XPF1 ("%I", get_irn_opident(np));
Christian Schäfer's avatar
Christian Schäfer committed
145
146
147
148
149
150
151
152

  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:
153
    if (get_irn_mode (np) == mode_b) {
Christian Schäfer's avatar
Christian Schäfer committed
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
      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]);
169
    XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
Christian Schäfer's avatar
Christian Schäfer committed
170
171
172
173
174
175
176
177
    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:
178
179
180
181
  case iro_Break:
  case iro_EndReg:
  case iro_EndExcept:
  case iro_CallBegin:
Christian Schäfer's avatar
Christian Schäfer committed
182
183
184
185
186
187
188
189
190
191
192
    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. */
193
INLINE int
194
get_irn_arity (ir_node *node) {
Götz Lindenmaier's avatar
Götz Lindenmaier committed
195
  assert(node);
196
197
198
199
200
201
202
203
204
205
  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
206
207
}

208
209
210
211
212
213
/* 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. */
214
INLINE ir_node **
215
216
217
218
219
220
221
222
223
224
225
226
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
227
228
}

229
INLINE void
230
set_irn_in (ir_node *node, int arity, ir_node **in) {
231
  ir_node *** arr;
232
  assert(node);
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
  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;
249
  }
250
  memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
251
252
}

Christian Schäfer's avatar
Christian Schäfer committed
253
254
255
/* 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
256
257
   i < get_irn_arity.
   If it is a block, the entry -1 is NULL. */
258
INLINE ir_node *
259
get_irn_n (ir_node *node, int n) {
260
261
262
263
264
265
  /* debug @@@ */
  if (-1 > n || get_irn_arity(node) <= n) {
    printf("pos: %d, arity: %d ", n, get_irn_arity(node));
    DDMN(node);
  }
  assert(node); assert(-1 <= n && n < get_irn_arity(node));
266
267
268
269
270
271
272
273
274
275
  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
276
277
}

278
INLINE void
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
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
300
301
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

392
INLINE void
393
set_irn_link (ir_node *node, void *link) {
Christian Schäfer's avatar
Christian Schäfer committed
394
395
396
397
  assert (node);
  node->link = link;
}

398
INLINE void *
Christian Schäfer's avatar
Christian Schäfer committed
399
400
401
402
403
get_irn_link (ir_node *node) {
  assert (node);
  return node->link;
}

Götz Lindenmaier's avatar
Götz Lindenmaier committed
404
/* Outputs a unique number for this node */
405
INLINE long
Götz Lindenmaier's avatar
Götz Lindenmaier committed
406
407
get_irn_node_nr(ir_node *node) {
  assert(node);
408
#ifdef DEBUG_libfirm
Götz Lindenmaier's avatar
Götz Lindenmaier committed
409
  return node->node_nr;
410
411
#else
  return 0;
Götz Lindenmaier's avatar
Götz Lindenmaier committed
412
#endif
413
}
Götz Lindenmaier's avatar
Götz Lindenmaier committed
414

415
INLINE tarval *
Christian Schäfer's avatar
Christian Schäfer committed
416
417
418
419
420
421
get_irn_const_attr (ir_node *node)
{
  assert (node->op == op_Const);
  return node->attr.con;
}

422
INLINE long
Christian Schäfer's avatar
Christian Schäfer committed
423
424
425
426
427
428
get_irn_proj_attr (ir_node *node)
{
  assert (node->op == op_Proj);
  return node->attr.proj;
}

429
INLINE alloc_attr
Christian Schäfer's avatar
Christian Schäfer committed
430
431
432
433
434
435
get_irn_alloc_attr (ir_node *node)
{
  assert (node->op == op_Alloc);
  return node->attr.a;
}

436
INLINE type *
Christian Schäfer's avatar
Christian Schäfer committed
437
438
439
get_irn_free_attr     (ir_node *node)
{
  assert (node->op == op_Free);
440
  return node->attr.f = skip_tid(node->attr.f);
Christian Schäfer's avatar
Christian Schäfer committed
441
442
}

443
INLINE symconst_attr
Christian Schäfer's avatar
Christian Schäfer committed
444
445
446
447
448
449
get_irn_symconst_attr (ir_node *node)
{
  assert (node->op == op_SymConst);
  return node->attr.i;
}

450
INLINE type *
Christian Schäfer's avatar
Christian Schäfer committed
451
452
453
get_irn_call_attr (ir_node *node)
{
  assert (node->op == op_Call);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
454
  return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
Christian Schäfer's avatar
Christian Schäfer committed
455
456
}

457
INLINE sel_attr
Christian Schäfer's avatar
Christian Schäfer committed
458
459
460
461
462
463
get_irn_sel_attr (ir_node *node)
{
  assert (node->op == op_Sel);
  return node->attr.s;
}

464
INLINE int
Christian Schäfer's avatar
Christian Schäfer committed
465
466
467
468
469
470
get_irn_phi_attr (ir_node *node)
{
  assert (node->op == op_Phi);
  return node->attr.phi0_pos;
}

471
INLINE block_attr
Christian Schäfer's avatar
Christian Schäfer committed
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
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);
}

487
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
488
489
490
491
492
set_nodes_Block (ir_node *node, ir_node *block) {
  assert (!(node->op == op_Block));
  set_irn_n(node, -1, block);
}

493
494
495
496
/* 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. */
497
INLINE ir_node **
498
499
500
get_Block_cfgpred_arr (ir_node *node)
{
  assert ((node->op == op_Block));
Götz Lindenmaier's avatar
Götz Lindenmaier committed
501
  return (ir_node **)&(get_irn_in(node)[1]);
502
503
504
}


505
INLINE int
Christian Schäfer's avatar
Christian Schäfer committed
506
507
508
509
510
get_Block_n_cfgpreds (ir_node *node) {
  assert ((node->op == op_Block));
  return (get_irn_arity(node));
}

511
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
512
get_Block_cfgpred (ir_node *node, int pos) {
513
  /* debug @@@ */
Christian Schäfer's avatar
Christian Schäfer committed
514
  assert (node->op == op_Block);
515
516
517
518
519
520
  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);
  }
  assert(node); assert(-1 <= pos && pos < get_irn_arity(node));
Christian Schäfer's avatar
Christian Schäfer committed
521
522
523
  return get_irn_n(node, pos);
}

524
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
525
526
527
528
529
set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
  assert (node->op == op_Block);
  set_irn_n(node, pos, pred);
}

530
INLINE bool
Christian Schäfer's avatar
Christian Schäfer committed
531
532
533
534
535
get_Block_matured (ir_node *node) {
  assert (node->op == op_Block);
  return node->attr.block.matured;
}

536
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
537
538
539
540
set_Block_matured (ir_node *node, bool matured) {
  assert (node->op == op_Block);
  node->attr.block.matured = matured;
}
541
INLINE unsigned long
542
get_Block_block_visited (ir_node *node) {
Christian Schäfer's avatar
Christian Schäfer committed
543
  assert (node->op == op_Block);
544
  return node->attr.block.block_visited;
Christian Schäfer's avatar
Christian Schäfer committed
545
546
}

547
INLINE void
548
set_Block_block_visited (ir_node *node, unsigned long visit) {
Christian Schäfer's avatar
Christian Schäfer committed
549
  assert (node->op == op_Block);
550
  node->attr.block.block_visited = visit;
Christian Schäfer's avatar
Christian Schäfer committed
551
552
}

Götz Lindenmaier's avatar
Götz Lindenmaier committed
553
/* For this current_ir_graph must be set. */
554
555
INLINE void
mark_Block_block_visited (ir_node *node) {
Götz Lindenmaier's avatar
Götz Lindenmaier committed
556
557
558
559
  assert (node->op == op_Block);
  node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
}

560
561
INLINE int
Block_not_block_visited(ir_node *node) {
562
563
564
  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
565

566
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
567
568
569
570
571
get_Block_graph_arr (ir_node *node, int pos) {
  assert (node->op == op_Block);
  return node->attr.block.graph_arr[pos+1];
}

572
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
573
574
575
576
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;
}
577

578
/* handler handling for Blocks */
579
580
void
set_Block_handler (ir_node *block, ir_node *handler)  {
581
582
583
584
585
  assert ((block->op == op_Block));
  assert ((handler->op == op_Block));
  block->attr.block.handler_entry = handler;
}

586
587
ir_node *
get_Block_handler (ir_node *block) {
588
589
590
591
592
  assert ((block->op == op_Block));
  return (block->attr.block.handler_entry);
}

/* handler handling for Nodes */
593
594
void
set_Node_handler (ir_node *node, ir_node *handler) {
595
596
597
  set_Block_handler (get_nodes_Block (node), handler);
}

598
599
ir_node *
get_Node_handler (ir_node *node) {
600
601
602
603
  return (get_Block_handler (get_nodes_Block (node)));
}

/* exc_t handling for Blocks */
604
void set_Block_exc (ir_node *block, exc_t exc) {
605
  assert ((block->op == op_Block));
606
607
608
  block->attr.block.exc = exc;
}

609
exc_t get_Block_exc (ir_node *block) {
610
611
  assert ((block->op == op_Block));

612
613
614
  return (block->attr.block.exc);
}

615
/* exc_t handling for Nodes */
616
void set_Node_exc (ir_node *node, exc_t exc) {
617
618
619
  set_Block_exc (get_nodes_Block (node), exc);
}

620
exc_t get_Node_exc (ir_node *node) {
621
622
623
  return (get_Block_exc (get_nodes_Block (node)));
}

624
625
626
627
628
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;
629
    node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
630
631
632
633
634
  }
  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
635
636
637
  assert(node->op == op_Block &&
	 node->attr.block.in_cg &&
	 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
638
639
640
641
642
643
644
645
646
647
648
649
650
  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) {
  assert(node->op == op_Block && node->attr.block.in_cg);
  return ARR_LEN(node->attr.block.in_cg) - 1;
}

651
652
653
654
655
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];
}

656
657
658
659
660
void remove_Block_cg_cfgpred_arr(ir_node * node) {
  assert(node->op == op_Block);
  node->attr.block.in_cg = NULL;
}

661
INLINE int
662
663
664
665
666
get_End_n_keepalives(ir_node *end) {
  assert (end->op == op_End);
  return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
}

667
INLINE ir_node *
668
669
670
671
672
get_End_keepalive(ir_node *end, int pos) {
  assert (end->op == op_End);
  return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
}

673
INLINE void
674
675
676
677
678
add_End_keepalive (ir_node *end, ir_node *ka) {
  assert (end->op == op_End);
  ARR_APP1 (ir_node *, end->in, ka);
}

679
INLINE void
680
681
682
683
684
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);
}

685
INLINE void
686
free_End (ir_node *end) {
687
  assert (end->op == op_End);
688
  /* DEL_ARR_F(end->in);   GL @@@ tut nicht ! */
689
690
691
692
693
694
695
696
697
698
699
700
  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;
701
702
}

Götz Lindenmaier's avatar
Götz Lindenmaier committed
703
704
705
706
707
708
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
/*
> 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).
*/
734
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
735
736
737
738
739
get_Cond_selector (ir_node *node) {
  assert (node->op == op_Cond);
  return get_irn_n(node, 0);
}

740
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
741
742
743
744
745
set_Cond_selector (ir_node *node, ir_node *selector) {
  assert (node->op == op_Cond);
  set_irn_n(node, 0, selector);
}

746
INLINE cond_kind
747
748
get_Cond_kind (ir_node *node) {
  assert (node->op == op_Cond);
749
  return node->attr.c.kind;
750
751
}

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

758
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
759
get_Return_mem (ir_node *node) {
760
  assert (node->op == op_Return);
Christian Schäfer's avatar
Christian Schäfer committed
761
762
763
  return get_irn_n(node, 0);
}

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

770
INLINE int
771
get_Return_n_ress (ir_node *node) {
772
773
774
775
776
  assert (node->op == op_Return);
  return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
}

INLINE ir_node **
777
778
779
get_Return_res_arr (ir_node *node)
{
  assert ((node->op == op_Return));
780
  if (get_Return_n_ress(node) > 0)
Götz Lindenmaier's avatar
Götz Lindenmaier committed
781
    return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
782
783
  else
    return NULL;
784
785
}

Christian Schäfer's avatar
Christian Schäfer committed
786
/*
787
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
788
789
790
791
792
set_Return_n_res (ir_node *node, int results) {
  assert (node->op == op_Return);
}
*/

793
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
794
795
get_Return_res (ir_node *node, int pos) {
  assert (node->op == op_Return);
796
  assert (get_Return_n_ress(node) > pos);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
797
  return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
Christian Schäfer's avatar
Christian Schäfer committed
798
799
}

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

806
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
807
808
809
810
811
get_Raise_mem (ir_node *node) {
  assert (node->op == op_Return);
  return get_irn_n(node, 0);
}

812
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
813
814
815
816
817
set_Raise_mem (ir_node *node, ir_node *mem) {
  assert (node->op == op_Raise);
  set_irn_n(node, 0, mem);
}

818
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
819
820
821
822
823
get_Raise_exo_ptr (ir_node *node) {
  assert (node->op == op_Raise);
  return get_irn_n(node, 1);
}

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

830
INLINE tarval *get_Const_tarval (ir_node *node) {
Christian Schäfer's avatar
Christian Schäfer committed
831
832
833
834
  assert (node->op == op_Const);
  return get_irn_const_attr(node);
}

835
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
836
837
838
839
840
set_Const_tarval (ir_node *node, tarval *con) {
  assert (node->op == op_Const);
  node->attr.con = con;
}

841
INLINE symconst_kind
Christian Schäfer's avatar
Christian Schäfer committed
842
843
844
845
846
get_SymConst_kind (ir_node *node) {
  assert (node->op == op_SymConst);
  return node->attr.i.num;
}

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

853
INLINE type *
Christian Schäfer's avatar
Christian Schäfer committed
854
855
856
857
get_SymConst_type (ir_node *node) {
  assert (   (node->op == op_SymConst)
          && (   get_SymConst_kind(node) == type_tag
              || get_SymConst_kind(node) == size));
858
  return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
Christian Schäfer's avatar
Christian Schäfer committed
859
860
}

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

869
INLINE ident *
Christian Schäfer's avatar
Christian Schäfer committed
870
871
872
873
874
875
get_SymConst_ptrinfo (ir_node *node) {
  assert (   (node->op == op_SymConst)
          && (get_SymConst_kind(node) == linkage_ptr_info));
  return node->attr.i.tori.ptrinfo;
}

876
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
877
878
879
880
881
882
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;
}

883
INLINE type_or_id_p
Götz Lindenmaier's avatar
Götz Lindenmaier committed
884
885
886
887
888
get_SymConst_type_or_id (ir_node *node) {
  assert (node->op == op_SymConst);
  return &(node->attr.i.tori);
}

889
INLINE void
Götz Lindenmaier's avatar
Götz Lindenmaier committed
890
891
892
893
894
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));
}

895
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
896
897
898
899
900
get_Sel_mem (ir_node *node) {
  assert (node->op == op_Sel);
  return get_irn_n(node, 0);
}

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

907
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
908
909
910
911
912
get_Sel_ptr (ir_node *node) {
  assert (node->op == op_Sel);
  return get_irn_n(node, 1);
}

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

919
INLINE int
920
get_Sel_n_indexs (ir_node *node) {
921
922
923
924
925
  assert (node->op == op_Sel);
  return (get_irn_arity(node) - SEL_INDEX_OFFSET);
}

INLINE ir_node **
926
927
928
get_Sel_index_arr (ir_node *node)
{
  assert ((node->op == op_Sel));
929
  if (get_Sel_n_indexs(node) > 0)
Götz Lindenmaier's avatar
Götz Lindenmaier committed
930
    return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
Götz Lindenmaier's avatar
Götz Lindenmaier committed
931
932
  else
    return NULL;
933
934
}

935
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
936
937
get_Sel_index (ir_node *node, int pos) {
  assert (node->op == op_Sel);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
938
  return get_irn_n(node, pos + SEL_INDEX_OFFSET);
Christian Schäfer's avatar
Christian Schäfer committed
939
940
}

941
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
942
943
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
944
  set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
Christian Schäfer's avatar
Christian Schäfer committed
945
946
}

947
INLINE entity *
Christian Schäfer's avatar
Christian Schäfer committed
948
949
950
951
952
get_Sel_entity (ir_node *node) {
  assert (node->op == op_Sel);
  return node->attr.s.ent;
}

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

959
960
961
962
963
964
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
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);
}

995
996
997
998
999
1000
1001
1002
1003
1004

/* 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
1005
1006
1007
1008
1009
get_Call_mem (ir_node *node) {
  assert (node->op == op_Call);
  return get_irn_n(node, 0);
}

1010
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
1011
1012
1013
1014
1015
set_Call_mem (ir_node *node, ir_node *mem) {
  assert (node->op == op_Call);
  set_irn_n(node, 0, mem);
}

1016
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
1017
1018
1019
1020
1021
get_Call_ptr (ir_node *node) {
  assert (node->op == op_Call);
  return get_irn_n(node, 1);
}

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

1028
INLINE ir_node **
1029
1030
get_Call_param_arr (ir_node *node) {
  assert (node->op == op_Call);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
1031
  return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1032
1033
}

1034
INLINE int
Götz Lindenmaier's avatar
Götz Lindenmaier committed
1035
get_Call_n_params (ir_node *node)  {
Christian Schäfer's avatar
Christian Schäfer committed
1036
  assert (node->op == op_Call);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
1037
  return (get_irn_arity(node) - CALL_PARAM_OFFSET);
Christian Schäfer's avatar
Christian Schäfer committed
1038
1039
}

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

1046
/* INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
1047
1048
1049
1050
1051
set_Call_arity (ir_node *node, ir_node *arity) {
  assert (node->op == op_Call);
}
*/

1052
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
1053
1054
get_Call_param (ir_node *node, int pos) {
  assert (node->op == op_Call);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
1055
  return get_irn_n(node, pos + CALL_PARAM_OFFSET);
Christian Schäfer's avatar
Christian Schäfer committed
1056
1057
}

1058
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
1059
1060
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
1061
  set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
Christian Schäfer's avatar
Christian Schäfer committed
1062
1063
}

1064
INLINE type *
Christian Schäfer's avatar
Christian Schäfer committed
1065
1066
get_Call_type (ir_node *node) {
  assert (node->op == op_Call);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
1067
  return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
Christian Schäfer's avatar
Christian Schäfer committed
1068
1069
}

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

1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
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;
}

1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
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;
}

1121
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
1122
1123
1124
1125
1126
get_Add_left (ir_node *node) {
  assert (node->op == op_Add);
  return get_irn_n(node, 0);
}

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

1133
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
1134
1135
1136
1137
1138
get_Add_right (ir_node *node) {
  assert (node->op == op_Add);
  return get_irn_n(node, 1);
}

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

1145
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
1146
1147
1148
1149
1150
get_Sub_left (ir_node *node) {
  assert (node->op == op_Sub);
  return get_irn_n(node, 0);
}

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

1157
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
1158
1159
1160
1161
1162
get_Sub_right (ir_node *node) {
  assert (node->op == op_Sub);
  return get_irn_n(node, 1);
}

1163
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
1164
1165
1166
1167
1168
1169
set_Sub_right (ir_node *node, ir_node *right) {
  assert (node->op == op_Sub);
  set_irn_n(node, 1, right);
}


1170
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
1171
1172
1173
1174
1175
get_Minus_op (ir_node *node) {
  assert (node->op == op_Minus);
  return get_irn_n(node, 0);
}

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


1183
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
1184
1185
1186
1187
1188
get_Mul_left (ir_node *node) {
  assert (node->op == op_Mul);
  return get_irn_n(node, 0);
}

1189
INLINE void
Christian Schäfer's avatar
Christian Schäfer committed
1190
1191
1192
1193
1194
set_Mul_left (ir_node *node, ir_node *left) {
  assert (node->op == op_Mul);
  set_irn_n(node, 0, left);
}

1195
INLINE ir_node *
Christian Schäfer's avatar
Christian Schäfer committed
1196
1197
1198
1199
1200
get_Mul_right (ir_node *node) {
  assert (node->op == op_Mul);
  return get_irn_n(node, 1);
}

1201
INLINE void