1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
16 #include "irgraph_t.h"
19 #include "typegmod_t.h"
26 /* some constants fixing the positions of nodes predecessors
28 #define CALL_PARAM_OFFSET 2
29 #define SEL_INDEX_OFFSET 2
30 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
31 #define END_KEEPALIVE_OFFSET 0
33 /* Declarations for INLINEing */
34 INLINE ir_node ** get_irn_in (ir_node *node);
35 INLINE ir_mode *get_irn_mode (ir_node *node);
36 INLINE ir_op *get_irn_op (ir_node *node);
37 INLINE opcode get_irn_opcode (ir_node *node);
38 INLINE ident *get_irn_opident (ir_node *node);
39 INLINE type *get_SymConst_type (ir_node *node);
40 INLINE ir_node *skip_nop (ir_node *node);
41 INLINE ir_node *skip_nop (ir_node *node);
42 INLINE int is_Proj (ir_node *node);
45 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
46 "Gt", "Ge", "Lg", "Leg", "Uo",
47 "Ue", "Ul", "Ule", "Ug", "Uge",
50 INLINE char *get_pnc_string(int pnc) {
51 return pnc_name_arr[pnc];
56 get_negated_pnc(int pnc) {
58 case False: return True; break;
59 case Eq: return Ne; break;
60 case Lt: return Uge; break;
61 case Le: return Ug; break;
62 case Gt: return Ule; break;
63 case Ge: return Ul; break;
64 case Lg: return Ue; break;
65 case Leg: return Uo; break;
66 case Uo: return Leg; break;
67 case Ue: return Lg; break;
68 case Ul: return Ge; break;
69 case Ule: return Gt; break;
70 case Ug: return Le; break;
71 case Uge: return Lt; break;
72 case Ne: return Eq; break;
73 case True: return False; break;
75 return 99; /* to shut up gcc */
78 static char *pns_name_arr [] = {"initial_exec", "global_store",
79 "frame_base", "globals", "args"};
81 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
88 /* irnode constructor */
89 /* create a new irnode in irg, with an op, mode, arity and */
90 /* some incoming irnodes */
91 /* this constructor is used in every specified irnode constructor */
93 new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
94 int arity, ir_node **in)
97 int node_size = offsetof (ir_node, attr) + op->attr_size;
99 res = (ir_node *) obstack_alloc (irg->obst, node_size);
101 res->kind = k_ir_node;
107 res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
109 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
110 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
113 set_irn_dbg_info(res, db);
117 res->node_nr = get_irp_new_node_nr();
123 /* Copies all attributes stored in the old node to the new node.
124 Assumes both have the same opcode and sufficient size. */
126 copy_attrs (ir_node *old, ir_node *new) {
127 assert (get_irn_op(old) == get_irn_op(new));
128 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
131 /* IR-Nodes with attributes */
133 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
136 ir_node *np = XP_GETARG (ir_node *, 0);
139 XPS ("<null ir_node>");
143 XPF1 ("%I", get_irn_opident(np));
145 switch (get_irn_opcode (np)) { /* node label */
147 XPF1 ("%I", get_irn_mode(np)->name);
149 XPF1 ("%v", get_irn_const_attr);
152 if (get_irn_mode (np) == mode_b) {
154 XP (pnc_name_arr[get_irn_proj_attr(np)]);
155 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
157 XP (pns_name_arr[get_irn_proj_attr(np)]);
159 XPF1 ("%I", get_irn_mode(np)->name);
161 XPF1 ("%d", get_irn_proj_attr(np));
165 XPF1 ("%I", get_irn_mode(np)->name);
167 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
168 XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
170 case iro_Start: /* don't dump mode of these */
183 XPF1 ("%I", get_irn_mode(np)->name);
189 /** getting some parameters from ir_nodes **/
191 /* returns the number of predecessors without the block predecessor. */
193 get_irn_arity (ir_node *node) {
195 if (interprocedural_view) { /* handle Filter and Block specially */
196 if (get_irn_opcode(node) == iro_Filter) {
197 assert(node->attr.filter.in_cg);
198 return ARR_LEN(node->attr.filter.in_cg) - 1;
199 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
200 return ARR_LEN(node->attr.block.in_cg) - 1;
202 /* else fall through */
204 return ARR_LEN(node->in) - 1;
207 /* Returns the array with ins. This array is shifted with respect to the
208 array accessed by get_irn_n: The block operand is at position 0 not -1.
209 (@@@ This should be changed.)
210 The order of the predecessors in this array is not guaranteed, except that
211 lists of operands as predecessors of Block or arguments of a Call are
214 get_irn_in (ir_node *node) {
216 if (interprocedural_view) { /* handle Filter and Block specially */
217 if (get_irn_opcode(node) == iro_Filter) {
218 assert(node->attr.filter.in_cg);
219 return node->attr.filter.in_cg;
220 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
221 return node->attr.block.in_cg;
223 /* else fall through */
229 set_irn_in (ir_node *node, int arity, ir_node **in) {
232 if (interprocedural_view) { /* handle Filter and Block specially */
233 if (get_irn_opcode(node) == iro_Filter) {
234 assert(node->attr.filter.in_cg);
235 arr = &node->attr.filter.in_cg;
236 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
237 arr = &node->attr.block.in_cg;
244 if (arity != ARR_LEN(*arr) - 1) {
245 ir_node * block = (*arr)[0];
246 *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
249 memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
252 /* to iterate through the predecessors without touching the array */
253 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
254 to iterate includind the Block predecessor iterate from i = -1 to
256 If it is a block, the entry -1 is NULL. */
258 get_irn_n (ir_node *node, int n) {
259 assert(node && -1 <= n && n < get_irn_arity(node));
260 if (interprocedural_view) { /* handle Filter and Block specially */
261 if (get_irn_opcode(node) == iro_Filter) {
262 assert(node->attr.filter.in_cg);
263 return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
264 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
265 return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
267 /* else fall through */
269 return (node->in[n + 1] = skip_nop(node->in[n + 1]));
273 set_irn_n (ir_node *node, int n, ir_node *in) {
274 assert(node && -1 <= n && n < get_irn_arity(node));
275 if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
276 /* Change block pred in both views! */
277 node->in[n + 1] = in;
278 assert(node->attr.filter.in_cg);
279 node->attr.filter.in_cg[n + 1] = in;
282 if (interprocedural_view) { /* handle Filter and Block specially */
283 if (get_irn_opcode(node) == iro_Filter) {
284 assert(node->attr.filter.in_cg);
285 node->attr.filter.in_cg[n + 1] = in;
287 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
288 node->attr.block.in_cg[n + 1] = in;
291 /* else fall through */
293 node->in[n + 1] = in;
297 get_irn_mode (ir_node *node)
304 get_irn_modecode (ir_node *node)
307 return node->mode->code;
312 get_irn_modeident (ir_node *node)
315 return node->mode->name;
319 get_irn_op (ir_node *node)
325 /* should be private to the library: */
327 set_irn_op (ir_node *node, ir_op *op)
334 get_irn_opcode (ir_node *node)
337 return node->op->code;
341 get_irn_opname (ir_node *node)
344 return id_to_str(node->op->name);
348 get_irn_opident (ir_node *node)
351 return node->op->name;
355 get_irn_visited (ir_node *node)
358 return node->visited;
362 set_irn_visited (ir_node *node, unsigned long visited)
365 node->visited = visited;
369 mark_irn_visited (ir_node *node) {
371 node->visited = current_ir_graph->visited;
375 irn_not_visited (ir_node *node) {
377 return (node->visited < current_ir_graph->visited);
381 set_irn_link (ir_node *node, ir_node *link) {
387 get_irn_link (ir_node *node) {
392 /* Outputs a unique number for this node */
394 get_irn_node_nr(ir_node *node) {
397 return node->node_nr;
404 get_irn_const_attr (ir_node *node)
406 assert (node->op == op_Const);
407 return node->attr.con;
411 get_irn_proj_attr (ir_node *node)
413 assert (node->op == op_Proj);
414 return node->attr.proj;
418 get_irn_alloc_attr (ir_node *node)
420 assert (node->op == op_Alloc);
425 get_irn_free_attr (ir_node *node)
427 assert (node->op == op_Free);
428 return node->attr.f = skip_tid(node->attr.f);
432 get_irn_symconst_attr (ir_node *node)
434 assert (node->op == op_SymConst);
439 get_irn_call_attr (ir_node *node)
441 assert (node->op == op_Call);
442 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
446 get_irn_sel_attr (ir_node *node)
448 assert (node->op == op_Sel);
453 get_irn_phi_attr (ir_node *node)
455 assert (node->op == op_Phi);
456 return node->attr.phi0_pos;
460 get_irn_block_attr (ir_node *node)
462 assert (node->op == op_Block);
463 return node->attr.block;
466 /** manipulate fields of individual nodes **/
468 /* this works for all except Block */
470 get_nodes_Block (ir_node *node) {
471 assert (!(node->op == op_Block));
472 return get_irn_n(node, -1);
476 set_nodes_Block (ir_node *node, ir_node *block) {
477 assert (!(node->op == op_Block));
478 set_irn_n(node, -1, block);
481 /* Returns an array with the predecessors of the Block. Depending on
482 the implementation of the graph datastructure this can be a copy of
483 the internal representation of predecessors as well as the internal
484 array itself. Therefore writing to this array might obstruct the ir. */
486 get_Block_cfgpred_arr (ir_node *node)
488 assert ((node->op == op_Block));
489 return (ir_node **)&(get_irn_in(node)[1]);
494 get_Block_n_cfgpreds (ir_node *node) {
495 assert ((node->op == op_Block));
496 return (get_irn_arity(node));
501 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
502 assert ((node->op == op_Block));
507 get_Block_cfgpred (ir_node *node, int pos) {
508 assert (node->op == op_Block);
509 return get_irn_n(node, pos);
513 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
514 assert (node->op == op_Block);
515 set_irn_n(node, pos, pred);
519 get_Block_matured (ir_node *node) {
520 assert (node->op == op_Block);
521 return node->attr.block.matured;
525 set_Block_matured (ir_node *node, bool matured) {
526 assert (node->op == op_Block);
527 node->attr.block.matured = matured;
530 get_Block_block_visited (ir_node *node) {
531 assert (node->op == op_Block);
532 return node->attr.block.block_visited;
536 set_Block_block_visited (ir_node *node, unsigned long visit) {
537 assert (node->op == op_Block);
538 node->attr.block.block_visited = visit;
541 /* For this current_ir_graph must be set. */
542 INLINE void mark_Block_block_visited (ir_node *node) {
543 assert (node->op == op_Block);
544 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
547 INLINE int Block_not_block_visited(ir_node *node) {
548 assert (node->op == op_Block);
549 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
553 get_Block_graph_arr (ir_node *node, int pos) {
554 assert (node->op == op_Block);
555 return node->attr.block.graph_arr[pos+1];
559 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
560 assert (node->op == op_Block);
561 node->attr.block.graph_arr[pos+1] = value;
564 /* handler handling for Blocks */
565 void set_Block_handler (ir_node *block, ir_node *handler)
567 assert ((block->op == op_Block));
568 assert ((handler->op == op_Block));
570 block->attr.block.handler_entry = handler;
573 ir_node *get_Block_handler (ir_node *block)
575 assert ((block->op == op_Block));
577 return (block->attr.block.handler_entry);
580 /* handler handling for Nodes */
581 void set_Node_handler (ir_node *node, ir_node *handler)
583 set_Block_handler (get_nodes_Block (node), handler);
586 ir_node *get_Node_handler (ir_node *node)
588 return (get_Block_handler (get_nodes_Block (node)));
592 /* exc_t handling for Blocks */
593 void set_Block_exc (ir_node *block, exc_t exc)
595 assert ((block->op == op_Block));
596 block->attr.block.exc = exc;
599 exc_t get_Block_exc (ir_node *block)
601 assert ((block->op == op_Block));
603 return (block->attr.block.exc);
606 /* exc_t handling for Nodes */
607 void set_Node_exc (ir_node *node, exc_t exc)
609 set_Block_exc (get_nodes_Block (node), exc);
612 exc_t get_Node_exc (ir_node *node)
614 return (get_Block_exc (get_nodes_Block (node)));
617 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
618 assert(node->op == op_Block);
619 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
620 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
621 node->attr.block.in_cg[0] = NULL;
623 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
626 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
627 assert(node->op == op_Block &&
628 node->attr.block.in_cg &&
629 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
630 node->attr.block.in_cg[pos + 1] = pred;
633 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
634 assert(node->op == op_Block);
635 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
638 int get_Block_cg_n_cfgpreds(ir_node * node) {
639 assert(node->op == op_Block && node->attr.block.in_cg);
640 return ARR_LEN(node->attr.block.in_cg) - 1;
643 void remove_Block_cg_cfgpred_arr(ir_node * node) {
644 assert(node->op == op_Block);
645 node->attr.block.in_cg = NULL;
649 get_End_n_keepalives(ir_node *end) {
650 assert (end->op == op_End);
651 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
655 get_End_keepalive(ir_node *end, int pos) {
656 assert (end->op == op_End);
657 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
661 add_End_keepalive (ir_node *end, ir_node *ka) {
662 assert (end->op == op_End);
663 ARR_APP1 (ir_node *, end->in, ka);
667 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
668 assert (end->op == op_End);
669 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
673 free_End (ir_node *end) {
674 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
675 end->in = NULL; /* @@@ make sure we get an error if we use the in array afterwards ... */
679 > Implementing the case construct (which is where the constant Proj node is
680 > important) involves far more than simply determining the constant values.
681 > We could argue that this is more properly a function of the translator from
682 > Firm to the target machine. That could be done if there was some way of
683 > projecting "default" out of the Cond node.
684 I know it's complicated.
685 Basically there are two proglems:
686 - determining the gaps between the projs
687 - determining the biggest case constant to konw the proj number for
689 I see several solutions:
690 1. Introduce a ProjDefault node. Solves both problems.
691 This means to extend all optimizations executed during construction.
692 2. Give the Cond node for switch two flavors:
693 a) there are no gaps in the projs (existing flavor)
694 b) gaps may exist, default proj is still the Proj with the largest
695 projection number. This covers also the gaps.
696 3. Fix the semantic of the Cond to that of 2b)
698 Solution 2 seems to be the best:
699 Computing the gaps in the Firm representation is not too hard, i.e.,
700 libfirm can implement a routine that transforms betweeen the two
701 flavours. This is also possible for 1) but 2) does not require to
702 change any existing optimization.
703 Further it should be far simpler to determine the biggest constant than
705 I don't want to choose 3) as 2a) seems to have advantages for
706 dataflow analysis and 3) does not allow to convert the representation to
710 get_Cond_selector (ir_node *node) {
711 assert (node->op == op_Cond);
712 return get_irn_n(node, 0);
716 set_Cond_selector (ir_node *node, ir_node *selector) {
717 assert (node->op == op_Cond);
718 set_irn_n(node, 0, selector);
722 get_Cond_kind (ir_node *node) {
723 assert (node->op == op_Cond);
724 return node->attr.c.kind;
728 set_Cond_kind (ir_node *node, cond_kind kind) {
729 assert (node->op == op_Cond);
730 node->attr.c.kind = kind;
734 get_Return_mem (ir_node *node) {
735 assert (node->op == op_Return);
736 return get_irn_n(node, 0);
740 set_Return_mem (ir_node *node, ir_node *mem) {
741 assert (node->op == op_Return);
742 set_irn_n(node, 0, mem);
746 get_Return_n_res (ir_node *node) {
747 assert (node->op == op_Return);
748 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
752 get_Return_res_arr (ir_node *node)
754 assert ((node->op == op_Return));
755 if (get_Return_n_res(node) > 0)
756 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
763 set_Return_n_res (ir_node *node, int results) {
764 assert (node->op == op_Return);
769 get_Return_res (ir_node *node, int pos) {
770 assert (node->op == op_Return);
771 assert (get_Return_n_res(node) > pos);
772 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
776 set_Return_res (ir_node *node, int pos, ir_node *res){
777 assert (node->op == op_Return);
778 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
782 get_Raise_mem (ir_node *node) {
783 assert (node->op == op_Return);
784 return get_irn_n(node, 0);
788 set_Raise_mem (ir_node *node, ir_node *mem) {
789 assert (node->op == op_Raise);
790 set_irn_n(node, 0, mem);
794 get_Raise_exo_ptr (ir_node *node) {
795 assert (node->op == op_Raise);
796 return get_irn_n(node, 1);
800 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
801 assert (node->op == op_Raise);
802 set_irn_n(node, 1, exo_ptr);
805 INLINE tarval *get_Const_tarval (ir_node *node) {
806 assert (node->op == op_Const);
807 return get_irn_const_attr(node);
811 set_Const_tarval (ir_node *node, tarval *con) {
812 assert (node->op == op_Const);
813 node->attr.con = con;
817 get_SymConst_kind (ir_node *node) {
818 assert (node->op == op_SymConst);
819 return node->attr.i.num;
823 set_SymConst_kind (ir_node *node, symconst_kind num) {
824 assert (node->op == op_SymConst);
825 node->attr.i.num = num;
829 get_SymConst_type (ir_node *node) {
830 assert ( (node->op == op_SymConst)
831 && ( get_SymConst_kind(node) == type_tag
832 || get_SymConst_kind(node) == size));
833 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
837 set_SymConst_type (ir_node *node, type *type) {
838 assert ( (node->op == op_SymConst)
839 && ( get_SymConst_kind(node) == type_tag
840 || get_SymConst_kind(node) == size));
841 node->attr.i.tori.typ = type;
845 get_SymConst_ptrinfo (ir_node *node) {
846 assert ( (node->op == op_SymConst)
847 && (get_SymConst_kind(node) == linkage_ptr_info));
848 return node->attr.i.tori.ptrinfo;
852 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
853 assert ( (node->op == op_SymConst)
854 && (get_SymConst_kind(node) == linkage_ptr_info));
855 node->attr.i.tori.ptrinfo = ptrinfo;
859 get_SymConst_type_or_id (ir_node *node) {
860 assert (node->op == op_SymConst);
861 return &(node->attr.i.tori);
865 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
866 assert (node->op == op_SymConst);
867 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
871 get_Sel_mem (ir_node *node) {
872 assert (node->op == op_Sel);
873 return get_irn_n(node, 0);
877 set_Sel_mem (ir_node *node, ir_node *mem) {
878 assert (node->op == op_Sel);
879 set_irn_n(node, 0, mem);
883 get_Sel_ptr (ir_node *node) {
884 assert (node->op == op_Sel);
885 return get_irn_n(node, 1);
889 set_Sel_ptr (ir_node *node, ir_node *ptr) {
890 assert (node->op == op_Sel);
891 set_irn_n(node, 1, ptr);
895 get_Sel_n_index (ir_node *node) {
896 assert (node->op == op_Sel);
897 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
901 get_Sel_index_arr (ir_node *node)
903 assert ((node->op == op_Sel));
904 if (get_Sel_n_index(node) > 0)
905 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
912 set_Sel_n_index (ir_node *node, int n_index) {
913 assert (node->op == op_Sel);
918 get_Sel_index (ir_node *node, int pos) {
919 assert (node->op == op_Sel);
920 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
924 set_Sel_index (ir_node *node, int pos, ir_node *index) {
925 assert (node->op == op_Sel);
926 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
930 get_Sel_entity (ir_node *node) {
931 assert (node->op == op_Sel);
932 return node->attr.s.ent;
936 set_Sel_entity (ir_node *node, entity *ent) {
937 assert (node->op == op_Sel);
938 node->attr.s.ent = ent;
942 get_Sel_linkage_type (ir_node *node) {
943 assert (node->op == op_Sel);
944 return node->attr.s.ltyp;
948 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
949 assert (node->op == op_Sel);
950 node->attr.s.ltyp = lt;
954 get_InstOf_ent (ir_node *node) {
955 assert (node->op = op_InstOf);
956 return (node->attr.io.ent);
960 set_InstOf_ent (ir_node *node, type *ent) {
961 assert (node->op = op_InstOf);
962 node->attr.io.ent = ent;
966 get_InstOf_store (ir_node *node) {
967 assert (node->op = op_InstOf);
968 return (get_irn_n (node, 0));
972 set_InstOf_store (ir_node *node, ir_node *obj) {
973 assert (node->op = op_InstOf);
974 set_irn_n (node, 0, obj);
978 get_InstOf_obj (ir_node *node) {
979 assert (node->op = op_InstOf);
980 return (get_irn_n (node, 1));
984 set_InstOf_obj (ir_node *node, ir_node *obj) {
985 assert (node->op = op_InstOf);
986 set_irn_n (node, 1, obj);
990 /* For unary and binary arithmetic operations the access to the
991 operands can be factored out. Left is the first, right the
992 second arithmetic value as listed in tech report 0999-33.
993 unops are: Minus, Abs, Not, Conv
994 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
995 Shr, Shrs, Rotate, Cmp */
999 get_Call_mem (ir_node *node) {
1000 assert (node->op == op_Call);
1001 return get_irn_n(node, 0);
1005 set_Call_mem (ir_node *node, ir_node *mem) {
1006 assert (node->op == op_Call);
1007 set_irn_n(node, 0, mem);
1011 get_Call_ptr (ir_node *node) {
1012 assert (node->op == op_Call);
1013 return get_irn_n(node, 1);
1017 set_Call_ptr (ir_node *node, ir_node *ptr) {
1018 assert (node->op == op_Call);
1019 set_irn_n(node, 1, ptr);
1023 get_Call_param_arr (ir_node *node) {
1024 assert (node->op == op_Call);
1025 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1029 get_Call_n_params (ir_node *node) {
1030 assert (node->op == op_Call);
1031 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1035 get_Call_arity (ir_node *node) {
1036 assert (node->op == op_Call);
1037 return get_Call_n_params(node);
1041 set_Call_arity (ir_node *node, ir_node *arity) {
1042 assert (node->op == op_Call);
1047 get_Call_param (ir_node *node, int pos) {
1048 assert (node->op == op_Call);
1049 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1053 set_Call_param (ir_node *node, int pos, ir_node *param) {
1054 assert (node->op == op_Call);
1055 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1059 get_Call_type (ir_node *node) {
1060 assert (node->op == op_Call);
1061 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1065 set_Call_type (ir_node *node, type *type) {
1066 assert (node->op == op_Call);
1067 assert (is_method_type(type));
1068 node->attr.call.cld_tp = type;
1071 int get_Call_n_callees(ir_node * node) {
1072 assert(node->op == op_Call && node->attr.call.callee_arr);
1073 return ARR_LEN(node->attr.call.callee_arr);
1076 entity * get_Call_callee(ir_node * node, int pos) {
1077 assert(node->op == op_Call && node->attr.call.callee_arr);
1078 return node->attr.call.callee_arr[pos];
1081 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1082 assert(node->op == op_Call);
1083 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1084 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1086 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1089 void remove_Call_callee_arr(ir_node * node) {
1090 assert(node->op == op_Call);
1091 node->attr.call.callee_arr = NULL;
1095 get_Add_left (ir_node *node) {
1096 assert (node->op == op_Add);
1097 return get_irn_n(node, 0);
1101 set_Add_left (ir_node *node, ir_node *left) {
1102 assert (node->op == op_Add);
1103 set_irn_n(node, 0, left);
1107 get_Add_right (ir_node *node) {
1108 assert (node->op == op_Add);
1109 return get_irn_n(node, 1);
1113 set_Add_right (ir_node *node, ir_node *right) {
1114 assert (node->op == op_Add);
1115 set_irn_n(node, 1, right);
1119 get_Sub_left (ir_node *node) {
1120 assert (node->op == op_Sub);
1121 return get_irn_n(node, 0);
1125 set_Sub_left (ir_node *node, ir_node *left) {
1126 assert (node->op == op_Sub);
1127 set_irn_n(node, 0, left);
1131 get_Sub_right (ir_node *node) {
1132 assert (node->op == op_Sub);
1133 return get_irn_n(node, 1);
1137 set_Sub_right (ir_node *node, ir_node *right) {
1138 assert (node->op == op_Sub);
1139 set_irn_n(node, 1, right);
1144 get_Minus_op (ir_node *node) {
1145 assert (node->op == op_Minus);
1146 return get_irn_n(node, 0);
1150 set_Minus_op (ir_node *node, ir_node *op) {
1151 assert (node->op == op_Minus);
1152 set_irn_n(node, 0, op);
1157 get_Mul_left (ir_node *node) {
1158 assert (node->op == op_Mul);
1159 return get_irn_n(node, 0);
1163 set_Mul_left (ir_node *node, ir_node *left) {
1164 assert (node->op == op_Mul);
1165 set_irn_n(node, 0, left);
1169 get_Mul_right (ir_node *node) {
1170 assert (node->op == op_Mul);
1171 return get_irn_n(node, 1);
1175 set_Mul_right (ir_node *node, ir_node *right) {
1176 assert (node->op == op_Mul);
1177 set_irn_n(node, 1, right);
1181 get_Quot_left (ir_node *node) {
1182 assert (node->op == op_Quot);
1183 return get_irn_n(node, 1);
1187 set_Quot_left (ir_node *node, ir_node *left) {
1188 assert (node->op == op_Quot);
1189 set_irn_n(node, 1, left);
1193 get_Quot_right (ir_node *node) {
1194 assert (node->op == op_Quot);
1195 return get_irn_n(node, 2);
1199 set_Quot_right (ir_node *node, ir_node *right) {
1200 assert (node->op == op_Quot);
1201 set_irn_n(node, 2, right);
1205 get_Quot_mem (ir_node *node) {
1206 assert (node->op == op_Quot);
1207 return get_irn_n(node, 0);
1211 set_Quot_mem (ir_node *node, ir_node *mem) {
1212 assert (node->op == op_Quot);
1213 set_irn_n(node, 0, mem);
1217 get_DivMod_left (ir_node *node) {
1218 assert (node->op == op_DivMod);
1219 return get_irn_n(node, 1);
1223 set_DivMod_left (ir_node *node, ir_node *left) {
1224 assert (node->op == op_DivMod);
1225 set_irn_n(node, 1, left);
1229 get_DivMod_right (ir_node *node) {
1230 assert (node->op == op_DivMod);
1231 return get_irn_n(node, 2);
1235 set_DivMod_right (ir_node *node, ir_node *right) {
1236 assert (node->op == op_DivMod);
1237 set_irn_n(node, 2, right);
1241 get_DivMod_mem (ir_node *node) {
1242 assert (node->op == op_DivMod);
1243 return get_irn_n(node, 0);
1247 set_DivMod_mem (ir_node *node, ir_node *mem) {
1248 assert (node->op == op_DivMod);
1249 set_irn_n(node, 0, mem);
1253 get_Div_left (ir_node *node) {
1254 assert (node->op == op_Div);
1255 return get_irn_n(node, 1);
1259 set_Div_left (ir_node *node, ir_node *left) {
1260 assert (node->op == op_Div);
1261 set_irn_n(node, 1, left);
1265 get_Div_right (ir_node *node) {
1266 assert (node->op == op_Div);
1267 return get_irn_n(node, 2);
1271 set_Div_right (ir_node *node, ir_node *right) {
1272 assert (node->op == op_Div);
1273 set_irn_n(node, 2, right);
1277 get_Div_mem (ir_node *node) {
1278 assert (node->op == op_Div);
1279 return get_irn_n(node, 0);
1283 set_Div_mem (ir_node *node, ir_node *mem) {
1284 assert (node->op == op_Div);
1285 set_irn_n(node, 0, mem);
1289 get_Mod_left (ir_node *node) {
1290 assert (node->op == op_Mod);
1291 return get_irn_n(node, 1);
1295 set_Mod_left (ir_node *node, ir_node *left) {
1296 assert (node->op == op_Mod);
1297 set_irn_n(node, 1, left);
1301 get_Mod_right (ir_node *node) {
1302 assert (node->op == op_Mod);
1303 return get_irn_n(node, 2);
1307 set_Mod_right (ir_node *node, ir_node *right) {
1308 assert (node->op == op_Mod);
1309 set_irn_n(node, 2, right);
1313 get_Mod_mem (ir_node *node) {
1314 assert (node->op == op_Mod);
1315 return get_irn_n(node, 0);
1319 set_Mod_mem (ir_node *node, ir_node *mem) {
1320 assert (node->op == op_Mod);
1321 set_irn_n(node, 0, mem);
1325 get_Abs_op (ir_node *node) {
1326 assert (node->op == op_Abs);
1327 return get_irn_n(node, 0);
1331 set_Abs_op (ir_node *node, ir_node *op) {
1332 assert (node->op == op_Abs);
1333 set_irn_n(node, 0, op);
1337 get_And_left (ir_node *node) {
1338 assert (node->op == op_And);
1339 return get_irn_n(node, 0);
1343 set_And_left (ir_node *node, ir_node *left) {
1344 assert (node->op == op_And);
1345 set_irn_n(node, 0, left);
1349 get_And_right (ir_node *node) {
1350 assert (node->op == op_And);
1351 return get_irn_n(node, 1);
1355 set_And_right (ir_node *node, ir_node *right) {
1356 assert (node->op == op_And);
1357 set_irn_n(node, 1, right);
1361 get_Or_left (ir_node *node) {
1362 assert (node->op == op_Or);
1363 return get_irn_n(node, 0);
1367 set_Or_left (ir_node *node, ir_node *left) {
1368 assert (node->op == op_Or);
1369 set_irn_n(node, 0, left);
1373 get_Or_right (ir_node *node) {
1374 assert (node->op == op_Or);
1375 return get_irn_n(node, 1);
1379 set_Or_right (ir_node *node, ir_node *right) {
1380 assert (node->op == op_Or);
1381 set_irn_n(node, 1, right);
1385 get_Eor_left (ir_node *node) {
1386 assert (node->op == op_Eor);
1387 return get_irn_n(node, 0);
1391 set_Eor_left (ir_node *node, ir_node *left) {
1392 assert (node->op == op_Eor);
1393 set_irn_n(node, 0, left);
1397 get_Eor_right (ir_node *node) {
1398 assert (node->op == op_Eor);
1399 return get_irn_n(node, 1);
1403 set_Eor_right (ir_node *node, ir_node *right) {
1404 assert (node->op == op_Eor);
1405 set_irn_n(node, 1, right);
1410 get_Not_op (ir_node *node) {
1411 assert (node->op == op_Not);
1412 return get_irn_n(node, 0);
1416 set_Not_op (ir_node *node, ir_node *op) {
1417 assert (node->op == op_Not);
1418 set_irn_n(node, 0, op);
1423 get_Shl_left (ir_node *node) {
1424 assert (node->op == op_Shl);
1425 return get_irn_n(node, 0);
1429 set_Shl_left (ir_node *node, ir_node *left) {
1430 assert (node->op == op_Shl);
1431 set_irn_n(node, 0, left);
1435 get_Shl_right (ir_node *node) {
1436 assert (node->op == op_Shl);
1437 return get_irn_n(node, 1);
1441 set_Shl_right (ir_node *node, ir_node *right) {
1442 assert (node->op == op_Shl);
1443 set_irn_n(node, 1, right);
1447 get_Shr_left (ir_node *node) {
1448 assert (node->op == op_Shr);
1449 return get_irn_n(node, 0);
1453 set_Shr_left (ir_node *node, ir_node *left) {
1454 assert (node->op == op_Shr);
1455 set_irn_n(node, 0, left);
1459 get_Shr_right (ir_node *node) {
1460 assert (node->op == op_Shr);
1461 return get_irn_n(node, 1);
1465 set_Shr_right (ir_node *node, ir_node *right) {
1466 assert (node->op == op_Shr);
1467 set_irn_n(node, 1, right);
1471 get_Shrs_left (ir_node *node) {
1472 assert (node->op == op_Shrs);
1473 return get_irn_n(node, 0);
1477 set_Shrs_left (ir_node *node, ir_node *left) {
1478 assert (node->op == op_Shrs);
1479 set_irn_n(node, 0, left);
1483 get_Shrs_right (ir_node *node) {
1484 assert (node->op == op_Shrs);
1485 return get_irn_n(node, 1);
1489 set_Shrs_right (ir_node *node, ir_node *right) {
1490 assert (node->op == op_Shrs);
1491 set_irn_n(node, 1, right);
1495 get_Rot_left (ir_node *node) {
1496 assert (node->op == op_Rot);
1497 return get_irn_n(node, 0);
1501 set_Rot_left (ir_node *node, ir_node *left) {
1502 assert (node->op == op_Rot);
1503 set_irn_n(node, 0, left);
1507 get_Rot_right (ir_node *node) {
1508 assert (node->op == op_Rot);
1509 return get_irn_n(node, 1);
1513 set_Rot_right (ir_node *node, ir_node *right) {
1514 assert (node->op == op_Rot);
1515 set_irn_n(node, 1, right);
1519 get_Cmp_left (ir_node *node) {
1520 assert (node->op == op_Cmp);
1521 return get_irn_n(node, 0);
1525 set_Cmp_left (ir_node *node, ir_node *left) {
1526 assert (node->op == op_Cmp);
1527 set_irn_n(node, 0, left);
1531 get_Cmp_right (ir_node *node) {
1532 assert (node->op == op_Cmp);
1533 return get_irn_n(node, 1);
1537 set_Cmp_right (ir_node *node, ir_node *right) {
1538 assert (node->op == op_Cmp);
1539 set_irn_n(node, 1, right);
1543 get_Conv_op (ir_node *node) {
1544 assert (node->op == op_Conv);
1545 return get_irn_n(node, 0);
1549 set_Conv_op (ir_node *node, ir_node *op) {
1550 assert (node->op == op_Conv);
1551 set_irn_n(node, 0, op);
1557 is_unop (ir_node *node) {
1558 return ( node->op == op_Minus ||
1559 node->op == op_Abs ||
1560 node->op == op_Not ||
1561 node->op == op_Conv );
1565 get_unop_op (ir_node *node) {
1566 assert ( node->op == op_Minus ||
1567 node->op == op_Abs ||
1568 node->op == op_Not ||
1569 node->op == op_Conv );
1570 switch (get_irn_opcode (node)) {
1571 case iro_Minus: return get_Minus_op(node); break;
1572 case iro_Abs: return get_Abs_op(node); break;
1573 case iro_Not: return get_Not_op(node); break;
1574 case iro_Conv: return get_Conv_op(node); break;
1575 default: return NULL;
1580 set_unop_op (ir_node *node, ir_node *op) {
1581 assert (node->op == op_Minus ||
1582 node->op == op_Abs ||
1583 node->op == op_Not ||
1584 node->op == op_Conv );
1585 switch (get_irn_opcode (node)) {
1586 case iro_Minus: set_Minus_op(node, op); break;
1587 case iro_Abs: set_Abs_op(node, op); break;
1588 case iro_Not: set_Not_op(node, op); break;
1589 case iro_Conv: set_Conv_op(node, op); break;
1596 is_binop (ir_node *node) {
1597 return (node->op == op_Add ||
1598 node->op == op_Sub ||
1599 node->op == op_Mul ||
1600 node->op == op_Quot ||
1601 node->op == op_DivMod ||
1602 node->op == op_Div ||
1603 node->op == op_Mod ||
1604 node->op == op_And ||
1605 node->op == op_Or ||
1606 node->op == op_Eor ||
1607 node->op == op_Shl ||
1608 node->op == op_Shr ||
1609 node->op == op_Shrs ||
1610 node->op == op_Rot ||
1611 node->op == op_Cmp );
1615 get_binop_left (ir_node *node) {
1616 assert (node->op == op_Add ||
1617 node->op == op_Sub ||
1618 node->op == op_Mul ||
1619 node->op == op_Quot ||
1620 node->op == op_DivMod ||
1621 node->op == op_Div ||
1622 node->op == op_Mod ||
1623 node->op == op_And ||
1624 node->op == op_Or ||
1625 node->op == op_Eor ||
1626 node->op == op_Shl ||
1627 node->op == op_Shr ||
1628 node->op == op_Shrs ||
1629 node->op == op_Rot ||
1630 node->op == op_Cmp );
1632 switch (get_irn_opcode (node)) {
1633 case iro_Add : return get_Add_left(node); break;
1634 case iro_Sub : return get_Sub_left(node); break;
1635 case iro_Mul : return get_Mul_left(node); break;
1636 case iro_Quot : return get_Quot_left(node); break;
1637 case iro_DivMod: return get_DivMod_left(node); break;
1638 case iro_Div : return get_Div_left(node); break;
1639 case iro_Mod : return get_Mod_left(node); break;
1640 case iro_And : return get_And_left(node); break;
1641 case iro_Or : return get_Or_left(node); break;
1642 case iro_Eor : return get_Eor_left(node); break;
1643 case iro_Shl : return get_Shl_left(node); break;
1644 case iro_Shr : return get_Shr_left(node); break;
1645 case iro_Shrs : return get_Shrs_left(node); break;
1646 case iro_Rot : return get_Rot_left(node); break;
1647 case iro_Cmp : return get_Cmp_left(node); break;
1648 default: return NULL;
1653 set_binop_left (ir_node *node, ir_node *left) {
1654 assert (node->op == op_Add ||
1655 node->op == op_Sub ||
1656 node->op == op_Mul ||
1657 node->op == op_Quot ||
1658 node->op == op_DivMod ||
1659 node->op == op_Div ||
1660 node->op == op_Mod ||
1661 node->op == op_And ||
1662 node->op == op_Or ||
1663 node->op == op_Eor ||
1664 node->op == op_Shl ||
1665 node->op == op_Shr ||
1666 node->op == op_Shrs ||
1667 node->op == op_Rot ||
1668 node->op == op_Cmp );
1670 switch (get_irn_opcode (node)) {
1671 case iro_Add : set_Add_left(node, left); break;
1672 case iro_Sub : set_Sub_left(node, left); break;
1673 case iro_Mul : set_Mul_left(node, left); break;
1674 case iro_Quot : set_Quot_left(node, left); break;
1675 case iro_DivMod: set_DivMod_left(node, left); break;
1676 case iro_Div : set_Div_left(node, left); break;
1677 case iro_Mod : set_Mod_left(node, left); break;
1678 case iro_And : set_And_left(node, left); break;
1679 case iro_Or : set_Or_left(node, left); break;
1680 case iro_Eor : set_Eor_left(node, left); break;
1681 case iro_Shl : set_Shl_left(node, left); break;
1682 case iro_Shr : set_Shr_left(node, left); break;
1683 case iro_Shrs : set_Shrs_left(node, left); break;
1684 case iro_Rot : set_Rot_left(node, left); break;
1685 case iro_Cmp : set_Cmp_left(node, left); break;
1691 get_binop_right (ir_node *node) {
1692 assert (node->op == op_Add ||
1693 node->op == op_Sub ||
1694 node->op == op_Mul ||
1695 node->op == op_Quot ||
1696 node->op == op_DivMod ||
1697 node->op == op_Div ||
1698 node->op == op_Mod ||
1699 node->op == op_And ||
1700 node->op == op_Or ||
1701 node->op == op_Eor ||
1702 node->op == op_Shl ||
1703 node->op == op_Shr ||
1704 node->op == op_Shrs ||
1705 node->op == op_Rot ||
1706 node->op == op_Cmp );
1708 switch (get_irn_opcode (node)) {
1709 case iro_Add : return get_Add_right(node); break;
1710 case iro_Sub : return get_Sub_right(node); break;
1711 case iro_Mul : return get_Mul_right(node); break;
1712 case iro_Quot : return get_Quot_right(node); break;
1713 case iro_DivMod: return get_DivMod_right(node); break;
1714 case iro_Div : return get_Div_right(node); break;
1715 case iro_Mod : return get_Mod_right(node); break;
1716 case iro_And : return get_And_right(node); break;
1717 case iro_Or : return get_Or_right(node); break;
1718 case iro_Eor : return get_Eor_right(node); break;
1719 case iro_Shl : return get_Shl_right(node); break;
1720 case iro_Shr : return get_Shr_right(node); break;
1721 case iro_Shrs : return get_Shrs_right(node); break;
1722 case iro_Rot : return get_Rot_right(node); break;
1723 case iro_Cmp : return get_Cmp_right(node); break;
1724 default: return NULL;
1729 set_binop_right (ir_node *node, ir_node *right) {
1730 assert (node->op == op_Add ||
1731 node->op == op_Sub ||
1732 node->op == op_Mul ||
1733 node->op == op_Quot ||
1734 node->op == op_DivMod ||
1735 node->op == op_Div ||
1736 node->op == op_Mod ||
1737 node->op == op_And ||
1738 node->op == op_Or ||
1739 node->op == op_Eor ||
1740 node->op == op_Shl ||
1741 node->op == op_Shr ||
1742 node->op == op_Shrs ||
1743 node->op == op_Rot ||
1744 node->op == op_Cmp );
1746 switch (get_irn_opcode (node)) {
1747 case iro_Add : set_Add_right(node, right); break;
1748 case iro_Sub : set_Sub_right(node, right); break;
1749 case iro_Mul : set_Mul_right(node, right); break;
1750 case iro_Quot : set_Quot_right(node, right); break;
1751 case iro_DivMod: set_DivMod_right(node, right); break;
1752 case iro_Div : set_Div_right(node, right); break;
1753 case iro_Mod : set_Mod_right(node, right); break;
1754 case iro_And : set_And_right(node, right); break;
1755 case iro_Or : set_Or_right(node, right); break;
1756 case iro_Eor : set_Eor_right(node, right); break;
1757 case iro_Shl : set_Shl_right(node, right); break;
1758 case iro_Shr : set_Shr_right(node, right); break;
1759 case iro_Shrs : set_Shrs_right(node, right); break;
1760 case iro_Rot : set_Rot_right(node, right); break;
1761 case iro_Cmp : set_Cmp_right(node, right); break;
1768 get_Phi_preds_arr (ir_node *node) {
1769 assert (node->op == op_Phi);
1770 return (ir_node **)&(get_irn_in(node)[1]);
1774 get_Phi_n_preds (ir_node *node) {
1775 assert (node->op == op_Phi);
1776 return (get_irn_arity(node));
1780 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1781 assert (node->op == op_Phi);
1786 get_Phi_pred (ir_node *node, int pos) {
1787 assert (node->op == op_Phi);
1788 return get_irn_n(node, pos);
1792 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1793 assert (node->op == op_Phi);
1794 set_irn_n(node, pos, pred);
1798 get_Load_mem (ir_node *node) {
1799 assert (node->op == op_Load);
1800 return get_irn_n(node, 0);
1804 set_Load_mem (ir_node *node, ir_node *mem) {
1805 assert (node->op == op_Load);
1806 set_irn_n(node, 0, mem);
1810 get_Load_ptr (ir_node *node) {
1811 assert (node->op == op_Load);
1812 return get_irn_n(node, 1);
1816 set_Load_ptr (ir_node *node, ir_node *ptr) {
1817 assert (node->op == op_Load);
1818 set_irn_n(node, 1, ptr);
1823 get_Store_mem (ir_node *node) {
1824 assert (node->op == op_Store);
1825 return get_irn_n(node, 0);
1829 set_Store_mem (ir_node *node, ir_node *mem) {
1830 assert (node->op == op_Store);
1831 set_irn_n(node, 0, mem);
1835 get_Store_ptr (ir_node *node) {
1836 assert (node->op == op_Store);
1837 return get_irn_n(node, 1);
1841 set_Store_ptr (ir_node *node, ir_node *ptr) {
1842 assert (node->op == op_Store);
1843 set_irn_n(node, 1, ptr);
1847 get_Store_value (ir_node *node) {
1848 assert (node->op == op_Store);
1849 return get_irn_n(node, 2);
1853 set_Store_value (ir_node *node, ir_node *value) {
1854 assert (node->op == op_Store);
1855 set_irn_n(node, 2, value);
1859 get_Alloc_mem (ir_node *node) {
1860 assert (node->op == op_Alloc);
1861 return get_irn_n(node, 0);
1865 set_Alloc_mem (ir_node *node, ir_node *mem) {
1866 assert (node->op == op_Alloc);
1867 set_irn_n(node, 0, mem);
1871 get_Alloc_size (ir_node *node) {
1872 assert (node->op == op_Alloc);
1873 return get_irn_n(node, 1);
1877 set_Alloc_size (ir_node *node, ir_node *size) {
1878 assert (node->op == op_Alloc);
1879 set_irn_n(node, 1, size);
1883 get_Alloc_type (ir_node *node) {
1884 assert (node->op == op_Alloc);
1885 return node->attr.a.type = skip_tid(node->attr.a.type);
1889 set_Alloc_type (ir_node *node, type *type) {
1890 assert (node->op == op_Alloc);
1891 node->attr.a.type = type;
1895 get_Alloc_where (ir_node *node) {
1896 assert (node->op == op_Alloc);
1897 return node->attr.a.where;
1901 set_Alloc_where (ir_node *node, where_alloc where) {
1902 assert (node->op == op_Alloc);
1903 node->attr.a.where = where;
1908 get_Free_mem (ir_node *node) {
1909 assert (node->op == op_Free);
1910 return get_irn_n(node, 0);
1914 set_Free_mem (ir_node *node, ir_node *mem) {
1915 assert (node->op == op_Free);
1916 set_irn_n(node, 0, mem);
1920 get_Free_ptr (ir_node *node) {
1921 assert (node->op == op_Free);
1922 return get_irn_n(node, 1);
1926 set_Free_ptr (ir_node *node, ir_node *ptr) {
1927 assert (node->op == op_Free);
1928 set_irn_n(node, 1, ptr);
1932 get_Free_size (ir_node *node) {
1933 assert (node->op == op_Free);
1934 return get_irn_n(node, 2);
1938 set_Free_size (ir_node *node, ir_node *size) {
1939 assert (node->op == op_Free);
1940 set_irn_n(node, 2, size);
1944 get_Free_type (ir_node *node) {
1945 assert (node->op == op_Free);
1946 return node->attr.f = skip_tid(node->attr.f);
1950 set_Free_type (ir_node *node, type *type) {
1951 assert (node->op == op_Free);
1952 node->attr.f = type;
1956 get_Sync_preds_arr (ir_node *node) {
1957 assert (node->op == op_Sync);
1958 return (ir_node **)&(get_irn_in(node)[1]);
1962 get_Sync_n_preds (ir_node *node) {
1963 assert (node->op == op_Sync);
1964 return (get_irn_arity(node));
1969 set_Sync_n_preds (ir_node *node, int n_preds) {
1970 assert (node->op == op_Sync);
1975 get_Sync_pred (ir_node *node, int pos) {
1976 assert (node->op == op_Sync);
1977 return get_irn_n(node, pos);
1981 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1982 assert (node->op == op_Sync);
1983 set_irn_n(node, pos, pred);
1987 get_Proj_pred (ir_node *node) {
1988 assert (is_Proj(node));
1989 return get_irn_n(node, 0);
1993 set_Proj_pred (ir_node *node, ir_node *pred) {
1994 assert (is_Proj(node));
1995 set_irn_n(node, 0, pred);
1999 get_Proj_proj (ir_node *node) {
2000 assert (is_Proj(node));
2001 if (get_irn_opcode(node) == iro_Proj) {
2002 return node->attr.proj;
2004 assert(get_irn_opcode(node) == iro_Filter);
2005 return node->attr.filter.proj;
2010 set_Proj_proj (ir_node *node, long proj) {
2011 assert (node->op == op_Proj);
2012 node->attr.proj = proj;
2016 get_Tuple_preds_arr (ir_node *node) {
2017 assert (node->op == op_Tuple);
2018 return (ir_node **)&(get_irn_in(node)[1]);
2022 get_Tuple_n_preds (ir_node *node) {
2023 assert (node->op == op_Tuple);
2024 return (get_irn_arity(node));
2029 set_Tuple_n_preds (ir_node *node, int n_preds) {
2030 assert (node->op == op_Tuple);
2035 get_Tuple_pred (ir_node *node, int pos) {
2036 assert (node->op == op_Tuple);
2037 return get_irn_n(node, pos);
2041 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2042 assert (node->op == op_Tuple);
2043 set_irn_n(node, pos, pred);
2047 get_Id_pred (ir_node *node) {
2048 assert (node->op == op_Id);
2049 return get_irn_n(node, 0);
2053 set_Id_pred (ir_node *node, ir_node *pred) {
2054 assert (node->op == op_Id);
2055 set_irn_n(node, 0, pred);
2060 get_Filter_pred(ir_node *node) {
2061 assert(node->op == op_Filter);
2066 get_Filter_proj(ir_node *node) {
2067 assert(node->op == op_Filter);
2068 return node->attr.filter.proj;
2071 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2072 assert(node->op == op_Filter);
2073 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2074 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2075 node->attr.filter.in_cg[0] = node->in[0];
2077 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2080 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2081 assert(node->op == op_Filter && node->attr.filter.in_cg && 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2082 node->attr.filter.in_cg[pos + 1] = pred;
2087 get_irn_irg(ir_node *node) {
2088 if (get_irn_op(node) == op_CallBegin) {
2089 return node->attr.callbegin.irg;
2090 } else if (get_irn_op(node) == op_EndReg || get_irn_op(node) == op_EndExcept) {
2091 return node->attr.end.irg;
2093 assert(0 && "no irg attr");
2098 /******************************************************************/
2099 /* Auxiliary routines */
2100 /******************************************************************/
2103 skip_Proj (ir_node *node) {
2104 /* don't assert node !!! */
2105 if (node && is_Proj(node)) {
2106 return get_Proj_pred(node);
2113 skip_Tuple (ir_node *node) {
2116 node = skip_nop(node);
2117 if (get_irn_op(node) == op_Proj) {
2118 pred = skip_nop(get_Proj_pred(node));
2119 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2120 pred = skip_nop(skip_Tuple(pred));
2121 if (get_irn_op(pred) == op_Tuple)
2122 return get_Tuple_pred(pred, get_Proj_proj(node));
2128 skip_nop (ir_node *node) {
2129 /* don't assert node !!! */
2131 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
2132 /* Don't use get_Id_pred: We get into an endless loop for
2133 self-referencing Ids. */
2134 assert (get_irn_arity (node) > 0);
2135 return node->in[0+1];
2142 skip_Id (ir_node *node) {
2143 return skip_nop(node);
2147 is_Bad (ir_node *node) {
2149 if ((node) && get_irn_opcode(node) == iro_Bad)
2155 is_no_Block (ir_node *node) {
2157 return (get_irn_opcode(node) != iro_Block);
2161 is_Proj (ir_node *node) {
2163 return node->op == op_Proj
2164 || (!interprocedural_view && node->op == op_Filter);
2167 /* Returns true if the operation manipulates control flow. */
2169 is_cfop(ir_node *node) {
2170 return is_cfopcode(get_irn_op(node));
2173 /* Returns true if the operation can change the control flow because
2176 is_fragile_op(ir_node *node) {
2177 return ( (get_irn_opcode(node) == iro_Call)
2178 || (get_irn_opcode(node) == iro_Quot)
2179 || (get_irn_opcode(node) == iro_DivMod)
2180 || (get_irn_opcode(node) == iro_Div)
2181 || (get_irn_opcode(node) == iro_Mod)
2182 || (get_irn_opcode(node) == iro_Load)
2183 || (get_irn_opcode(node) == iro_Store)
2184 || (get_irn_opcode(node) == iro_Alloc)
2185 || (get_irn_opcode(node) == iro_Bad)
2186 || (get_irn_opcode(node) == iro_Unknown));
2190 /* Returns the memory operand of fragile operations. */
2191 ir_node *get_fragile_op_mem(ir_node *node) {
2192 assert(node && is_fragile_op(node));
2194 switch (get_irn_opcode (node)) {
2203 return get_irn_n(node, 0);
2208 assert(0 && "not reached");