1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
4 * Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
16 #include "irgraph_t.h"
19 #include "typegmod_t.h"
21 #include "irbackedge_t.h"
29 /* some constants fixing the positions of nodes predecessors
31 #define CALL_PARAM_OFFSET 2
32 #define SEL_INDEX_OFFSET 2
33 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
34 #define END_KEEPALIVE_OFFSET 0
36 /* Declarations for inlineing */
37 INLINE ir_node ** get_irn_in (const ir_node *node);
38 INLINE ir_mode *get_irn_mode (const ir_node *node);
39 INLINE ir_op *get_irn_op (const ir_node *node);
40 INLINE opcode get_irn_opcode (const ir_node *node);
41 INLINE ident *get_irn_opident (const ir_node *node);
42 INLINE type *get_SymConst_type (ir_node *node);
43 INLINE ir_node *skip_nop (ir_node *node);
44 INLINE int is_Proj (const ir_node *node);
47 static const char *pnc_name_arr [] = {
48 "False", "Eq", "Lt", "Le",
49 "Gt", "Ge", "Lg", "Leg", "Uo",
50 "Ue", "Ul", "Ule", "Ug", "Uge",
54 INLINE const char *get_pnc_string(int pnc) {
55 return pnc_name_arr[pnc];
60 get_negated_pnc(int pnc) {
62 case False: return True; break;
63 case Eq: return Ne; break;
64 case Lt: return Uge; break;
65 case Le: return Ug; break;
66 case Gt: return Ule; break;
67 case Ge: return Ul; break;
68 case Lg: return Ue; break;
69 case Leg: return Uo; break;
70 case Uo: return Leg; break;
71 case Ue: return Lg; break;
72 case Ul: return Ge; break;
73 case Ule: return Gt; break;
74 case Ug: return Le; break;
75 case Uge: return Lt; break;
76 case Ne: return Eq; break;
77 case True: return False; break;
79 return 99; /* to shut up gcc */
82 static const char *pns_name_arr [] = {
83 "initial_exec", "global_store",
84 "frame_base", "globals", "args"
87 static const char *symconst_name_arr [] = {
88 "type_tag", "size", "linkage_ptr_info"
96 /* irnode constructor */
97 /* create a new irnode in irg, with an op, mode, arity and */
98 /* some incoming irnodes */
99 /* this constructor is used in every specified irnode constructor */
101 new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
102 int arity, ir_node **in)
105 int node_size = offsetof (ir_node, attr) + op->attr_size;
107 res = (ir_node *) obstack_alloc (irg->obst, node_size);
109 res->kind = k_ir_node;
115 res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
117 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
118 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
121 set_irn_dbg_info(res, db);
125 res->node_nr = get_irp_new_node_nr();
131 /* Copies all attributes stored in the old node to the new node.
132 Assumes both have the same opcode and sufficient size. */
134 copy_attrs (ir_node *old, ir_node *new) {
135 assert (get_irn_op(old) == get_irn_op(new));
136 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
139 /* IR-Nodes with attributes */
141 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
144 ir_node *np = XP_GETARG (ir_node *, 0);
147 XPS ("<null ir_node>");
151 XPF1 ("%I", get_irn_opident(np));
153 switch (get_irn_opcode (np)) { /* node label */
155 XPF1 ("%I", get_irn_mode(np)->name);
157 XPF1 ("%v", get_irn_const_attr);
160 if (get_irn_mode (np) == mode_b) {
162 XP (pnc_name_arr[get_irn_proj_attr(np)]);
163 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
165 XP (pns_name_arr[get_irn_proj_attr(np)]);
167 XPF1 ("%I", get_irn_mode(np)->name);
169 XPF1 ("%d", get_irn_proj_attr(np));
173 XPF1 ("%I", get_irn_mode(np)->name);
175 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
176 XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
178 case iro_Start: /* don't dump mode of these */
191 XPF1 ("%I", get_irn_mode(np)->name);
197 /** getting some parameters from ir_nodes **/
199 /* returns the number of predecessors without the block predecessor. */
201 get_irn_arity (const ir_node *node) {
203 if (interprocedural_view) { /* handle Filter and Block specially */
204 if (get_irn_opcode(node) == iro_Filter) {
205 assert(node->attr.filter.in_cg);
206 return ARR_LEN(node->attr.filter.in_cg) - 1;
207 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
208 return ARR_LEN(node->attr.block.in_cg) - 1;
210 /* else fall through */
212 return ARR_LEN(node->in) - 1;
215 /* Returns the array with ins. This array is shifted with respect to the
216 array accessed by get_irn_n: The block operand is at position 0 not -1.
217 (@@@ This should be changed.)
218 The order of the predecessors in this array is not guaranteed, except that
219 lists of operands as predecessors of Block or arguments of a Call are
222 get_irn_in (const ir_node *node) {
224 if (interprocedural_view) { /* handle Filter and Block specially */
225 if (get_irn_opcode(node) == iro_Filter) {
226 assert(node->attr.filter.in_cg);
227 return node->attr.filter.in_cg;
228 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
229 return node->attr.block.in_cg;
231 /* else fall through */
237 set_irn_in (ir_node *node, int arity, ir_node **in) {
240 if (interprocedural_view) { /* handle Filter and Block specially */
241 if (get_irn_opcode(node) == iro_Filter) {
242 assert(node->attr.filter.in_cg);
243 arr = &node->attr.filter.in_cg;
244 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
245 arr = &node->attr.block.in_cg;
252 if (arity != ARR_LEN(*arr) - 1) {
253 ir_node * block = (*arr)[0];
254 *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
257 fix_backedges(current_ir_graph->obst, node);
258 memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
261 /* to iterate through the predecessors without touching the array */
262 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
263 to iterate includind the Block predecessor iterate from i = -1 to
265 If it is a block, the entry -1 is NULL. */
267 get_irn_n (ir_node *node, int n) {
269 if (-1 > n || get_irn_arity(node) <= n) {
270 printf("pos: %d, arity: %d ", n, get_irn_arity(node));
273 assert(node); assert(-1 <= n && n < get_irn_arity(node));
274 if (interprocedural_view) { /* handle Filter and Block specially */
275 if (get_irn_opcode(node) == iro_Filter) {
276 assert(node->attr.filter.in_cg);
277 return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
278 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
279 return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
281 /* else fall through */
283 return (node->in[n + 1] = skip_nop(node->in[n + 1]));
287 set_irn_n (ir_node *node, int n, ir_node *in) {
288 assert(node && -1 <= n && n < get_irn_arity(node));
289 if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
290 /* Change block pred in both views! */
291 node->in[n + 1] = in;
292 assert(node->attr.filter.in_cg);
293 node->attr.filter.in_cg[n + 1] = in;
296 if (interprocedural_view) { /* handle Filter and Block specially */
297 if (get_irn_opcode(node) == iro_Filter) {
298 assert(node->attr.filter.in_cg);
299 node->attr.filter.in_cg[n + 1] = in;
301 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
302 node->attr.block.in_cg[n + 1] = in;
305 /* else fall through */
307 node->in[n + 1] = in;
311 get_irn_mode (const ir_node *node)
318 get_irn_modecode (const ir_node *node)
321 return node->mode->code;
326 get_irn_modeident (const ir_node *node)
329 return node->mode->name;
333 get_irn_op (const ir_node *node)
339 /* should be private to the library: */
341 set_irn_op (ir_node *node, ir_op *op)
348 get_irn_opcode (const ir_node *node)
351 assert (k_ir_node == get_kind(node));
353 return node->op->code;
357 get_irn_opname (const ir_node *node)
360 return id_to_str(node->op->name);
364 get_irn_opident (const ir_node *node)
367 return node->op->name;
371 get_irn_visited (const ir_node *node)
374 return node->visited;
378 set_irn_visited (ir_node *node, unsigned long visited)
381 node->visited = visited;
385 mark_irn_visited (ir_node *node) {
387 node->visited = current_ir_graph->visited;
391 irn_not_visited (const ir_node *node) {
393 return (node->visited < current_ir_graph->visited);
397 irn_visited (const ir_node *node) {
399 return (node->visited >= current_ir_graph->visited);
403 set_irn_link (ir_node *node, void *link) {
405 /* Link field is used for Phi construction and various optimizations
407 assert(get_irg_phase_state(current_ir_graph) != phase_building);
413 get_irn_link (const ir_node *node) {
418 /* Outputs a unique number for this node */
420 get_irn_node_nr(const ir_node *node) {
423 return node->node_nr;
430 get_irn_const_attr (ir_node *node)
432 assert (node->op == op_Const);
433 return node->attr.con;
437 get_irn_proj_attr (ir_node *node)
439 assert (node->op == op_Proj);
440 return node->attr.proj;
444 get_irn_alloc_attr (ir_node *node)
446 assert (node->op == op_Alloc);
451 get_irn_free_attr (ir_node *node)
453 assert (node->op == op_Free);
454 return node->attr.f = skip_tid(node->attr.f);
458 get_irn_symconst_attr (ir_node *node)
460 assert (node->op == op_SymConst);
465 get_irn_call_attr (ir_node *node)
467 assert (node->op == op_Call);
468 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
472 get_irn_sel_attr (ir_node *node)
474 assert (node->op == op_Sel);
479 get_irn_phi_attr (ir_node *node)
481 assert (node->op == op_Phi);
482 return node->attr.phi0_pos;
486 get_irn_block_attr (ir_node *node)
488 assert (node->op == op_Block);
489 return node->attr.block;
492 /** manipulate fields of individual nodes **/
494 /* this works for all except Block */
496 get_nodes_Block (ir_node *node) {
497 assert (!(node->op == op_Block));
498 return get_irn_n(node, -1);
502 set_nodes_Block (ir_node *node, ir_node *block) {
503 assert (!(node->op == op_Block));
504 set_irn_n(node, -1, block);
507 /* Returns an array with the predecessors of the Block. Depending on
508 the implementation of the graph datastructure this can be a copy of
509 the internal representation of predecessors as well as the internal
510 array itself. Therefore writing to this array might obstruct the ir. */
512 get_Block_cfgpred_arr (ir_node *node)
514 assert ((node->op == op_Block));
515 return (ir_node **)&(get_irn_in(node)[1]);
520 get_Block_n_cfgpreds (ir_node *node) {
521 assert ((node->op == op_Block));
522 return (get_irn_arity(node));
526 get_Block_cfgpred (ir_node *node, int pos) {
527 assert (node->op == op_Block);
529 if (-1 > pos || get_irn_arity(node) <= pos) {
530 dump_ir_block_graph(current_ir_graph);
531 printf("pos: %d, arity: %d ", pos, get_irn_arity(node));
534 assert(node); assert(-1 <= pos && pos < get_irn_arity(node));
535 return get_irn_n(node, pos);
539 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
540 assert (node->op == op_Block);
541 set_irn_n(node, pos, pred);
545 get_Block_matured (ir_node *node) {
546 assert (node->op == op_Block);
547 return node->attr.block.matured;
551 set_Block_matured (ir_node *node, bool matured) {
552 assert (node->op == op_Block);
553 node->attr.block.matured = matured;
556 get_Block_block_visited (ir_node *node) {
557 assert (node->op == op_Block);
558 return node->attr.block.block_visited;
562 set_Block_block_visited (ir_node *node, unsigned long visit) {
563 assert (node->op == op_Block);
564 node->attr.block.block_visited = visit;
567 /* For this current_ir_graph must be set. */
569 mark_Block_block_visited (ir_node *node) {
570 assert (node->op == op_Block);
571 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
575 Block_not_block_visited(ir_node *node) {
576 assert (node->op == op_Block);
577 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
581 get_Block_graph_arr (ir_node *node, int pos) {
582 assert (node->op == op_Block);
583 return node->attr.block.graph_arr[pos+1];
587 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
588 assert (node->op == op_Block);
589 node->attr.block.graph_arr[pos+1] = value;
592 /* handler handling for Blocks */
594 set_Block_handler (ir_node *block, ir_node *handler) {
595 assert ((block->op == op_Block));
596 assert ((handler->op == op_Block));
597 block->attr.block.handler_entry = handler;
601 get_Block_handler (ir_node *block) {
602 assert ((block->op == op_Block));
603 return (block->attr.block.handler_entry);
606 /* handler handling for Nodes */
608 set_Node_handler (ir_node *node, ir_node *handler) {
609 set_Block_handler (get_nodes_Block (node), handler);
613 get_Node_handler (ir_node *node) {
614 return (get_Block_handler (get_nodes_Block (node)));
617 /* exc_t handling for Blocks */
618 void set_Block_exc (ir_node *block, exc_t exc) {
619 assert ((block->op == op_Block));
620 block->attr.block.exc = exc;
623 exc_t get_Block_exc (ir_node *block) {
624 assert ((block->op == op_Block));
626 return (block->attr.block.exc);
629 /* exc_t handling for Nodes */
630 void set_Node_exc (ir_node *node, exc_t exc) {
631 set_Block_exc (get_nodes_Block (node), exc);
634 exc_t get_Node_exc (ir_node *node) {
635 return (get_Block_exc (get_nodes_Block (node)));
638 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
639 assert(node->op == op_Block);
640 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
641 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
642 node->attr.block.in_cg[0] = NULL;
643 node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
645 /* Fix backedge array. fix_backedges operates depending on
646 interprocedural_view. */
647 bool ipv = interprocedural_view;
648 interprocedural_view = true;
649 fix_backedges(current_ir_graph->obst, node);
650 interprocedural_view = ipv;
653 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
656 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
657 assert(node->op == op_Block &&
658 node->attr.block.in_cg &&
659 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
660 node->attr.block.in_cg[pos + 1] = pred;
663 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
664 assert(node->op == op_Block);
665 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
668 int get_Block_cg_n_cfgpreds(ir_node * node) {
669 assert(node->op == op_Block);
670 return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
673 ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
674 assert(node->op == op_Block && node->attr.block.in_cg);
675 return node->attr.block.in_cg[pos + 1];
678 void remove_Block_cg_cfgpred_arr(ir_node * node) {
679 assert(node->op == op_Block);
680 node->attr.block.in_cg = NULL;
684 get_End_n_keepalives(ir_node *end) {
685 assert (end->op == op_End);
686 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
690 get_End_keepalive(ir_node *end, int pos) {
691 assert (end->op == op_End);
692 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
696 add_End_keepalive (ir_node *end, ir_node *ka) {
697 assert (end->op == op_End);
698 ARR_APP1 (ir_node *, end->in, ka);
702 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
703 assert (end->op == op_End);
704 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
708 free_End (ir_node *end) {
709 assert (end->op == op_End);
710 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
711 end->in = NULL; /* @@@ make sure we get an error if we use the
712 in array afterwards ... */
715 ir_graph *get_EndReg_irg (const ir_node *end) {
716 assert (end->op == op_EndReg);
717 return end->attr.end.irg;
720 ir_graph *get_EndExcept_irg (const ir_node *end) {
721 assert (end->op == op_EndReg);
722 return end->attr.end.irg;
726 > Implementing the case construct (which is where the constant Proj node is
727 > important) involves far more than simply determining the constant values.
728 > We could argue that this is more properly a function of the translator from
729 > Firm to the target machine. That could be done if there was some way of
730 > projecting "default" out of the Cond node.
731 I know it's complicated.
732 Basically there are two proglems:
733 - determining the gaps between the projs
734 - determining the biggest case constant to konw the proj number for
736 I see several solutions:
737 1. Introduce a ProjDefault node. Solves both problems.
738 This means to extend all optimizations executed during construction.
739 2. Give the Cond node for switch two flavors:
740 a) there are no gaps in the projs (existing flavor)
741 b) gaps may exist, default proj is still the Proj with the largest
742 projection number. This covers also the gaps.
743 3. Fix the semantic of the Cond to that of 2b)
745 Solution 2 seems to be the best:
746 Computing the gaps in the Firm representation is not too hard, i.e.,
747 libfirm can implement a routine that transforms betweeen the two
748 flavours. This is also possible for 1) but 2) does not require to
749 change any existing optimization.
750 Further it should be far simpler to determine the biggest constant than
752 I don't want to choose 3) as 2a) seems to have advantages for
753 dataflow analysis and 3) does not allow to convert the representation to
757 get_Cond_selector (ir_node *node) {
758 assert (node->op == op_Cond);
759 return get_irn_n(node, 0);
763 set_Cond_selector (ir_node *node, ir_node *selector) {
764 assert (node->op == op_Cond);
765 set_irn_n(node, 0, selector);
769 get_Cond_kind (ir_node *node) {
770 assert (node->op == op_Cond);
771 return node->attr.c.kind;
775 set_Cond_kind (ir_node *node, cond_kind kind) {
776 assert (node->op == op_Cond);
777 node->attr.c.kind = kind;
781 get_Return_mem (ir_node *node) {
782 assert (node->op == op_Return);
783 return get_irn_n(node, 0);
787 set_Return_mem (ir_node *node, ir_node *mem) {
788 assert (node->op == op_Return);
789 set_irn_n(node, 0, mem);
793 get_Return_n_ress (ir_node *node) {
794 assert (node->op == op_Return);
795 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
799 get_Return_res_arr (ir_node *node)
801 assert ((node->op == op_Return));
802 if (get_Return_n_ress(node) > 0)
803 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
810 set_Return_n_res (ir_node *node, int results) {
811 assert (node->op == op_Return);
816 get_Return_res (ir_node *node, int pos) {
817 assert (node->op == op_Return);
818 assert (get_Return_n_ress(node) > pos);
819 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
823 set_Return_res (ir_node *node, int pos, ir_node *res){
824 assert (node->op == op_Return);
825 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
829 get_Raise_mem (ir_node *node) {
830 assert (node->op == op_Return);
831 return get_irn_n(node, 0);
835 set_Raise_mem (ir_node *node, ir_node *mem) {
836 assert (node->op == op_Raise);
837 set_irn_n(node, 0, mem);
841 get_Raise_exo_ptr (ir_node *node) {
842 assert (node->op == op_Raise);
843 return get_irn_n(node, 1);
847 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
848 assert (node->op == op_Raise);
849 set_irn_n(node, 1, exo_ptr);
852 INLINE tarval *get_Const_tarval (ir_node *node) {
853 assert (node->op == op_Const);
854 return get_irn_const_attr(node);
858 set_Const_tarval (ir_node *node, tarval *con) {
859 assert (node->op == op_Const);
860 node->attr.con = con;
864 get_SymConst_kind (const ir_node *node) {
865 assert (node->op == op_SymConst);
866 return node->attr.i.num;
870 set_SymConst_kind (ir_node *node, symconst_kind num) {
871 assert (node->op == op_SymConst);
872 node->attr.i.num = num;
876 get_SymConst_type (ir_node *node) {
877 assert ( (node->op == op_SymConst)
878 && ( get_SymConst_kind(node) == type_tag
879 || get_SymConst_kind(node) == size));
880 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
884 set_SymConst_type (ir_node *node, type *tp) {
885 assert ( (node->op == op_SymConst)
886 && ( get_SymConst_kind(node) == type_tag
887 || get_SymConst_kind(node) == size));
888 node->attr.i.tori.typ = tp;
892 get_SymConst_ptrinfo (ir_node *node) {
893 assert ( (node->op == op_SymConst)
894 && (get_SymConst_kind(node) == linkage_ptr_info));
895 return node->attr.i.tori.ptrinfo;
899 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
900 assert ( (node->op == op_SymConst)
901 && (get_SymConst_kind(node) == linkage_ptr_info));
902 node->attr.i.tori.ptrinfo = ptrinfo;
906 get_SymConst_type_or_id (ir_node *node) {
907 assert (node->op == op_SymConst);
908 return &(node->attr.i.tori);
912 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
913 assert (node->op == op_SymConst);
914 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
918 get_Sel_mem (ir_node *node) {
919 assert (node->op == op_Sel);
920 return get_irn_n(node, 0);
924 set_Sel_mem (ir_node *node, ir_node *mem) {
925 assert (node->op == op_Sel);
926 set_irn_n(node, 0, mem);
930 get_Sel_ptr (ir_node *node) {
931 assert (node->op == op_Sel);
932 return get_irn_n(node, 1);
936 set_Sel_ptr (ir_node *node, ir_node *ptr) {
937 assert (node->op == op_Sel);
938 set_irn_n(node, 1, ptr);
942 get_Sel_n_indexs (ir_node *node) {
943 assert (node->op == op_Sel);
944 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
948 get_Sel_index_arr (ir_node *node)
950 assert ((node->op == op_Sel));
951 if (get_Sel_n_indexs(node) > 0)
952 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
958 get_Sel_index (ir_node *node, int pos) {
959 assert (node->op == op_Sel);
960 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
964 set_Sel_index (ir_node *node, int pos, ir_node *index) {
965 assert (node->op == op_Sel);
966 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
970 get_Sel_entity (ir_node *node) {
971 assert (node->op == op_Sel);
972 return node->attr.s.ent;
976 set_Sel_entity (ir_node *node, entity *ent) {
977 assert (node->op == op_Sel);
978 node->attr.s.ent = ent;
982 get_InstOf_ent (ir_node *node) {
983 assert (node->op = op_InstOf);
984 return (node->attr.io.ent);
988 set_InstOf_ent (ir_node *node, type *ent) {
989 assert (node->op = op_InstOf);
990 node->attr.io.ent = ent;
994 get_InstOf_store (ir_node *node) {
995 assert (node->op = op_InstOf);
996 return (get_irn_n (node, 0));
1000 set_InstOf_store (ir_node *node, ir_node *obj) {
1001 assert (node->op = op_InstOf);
1002 set_irn_n (node, 0, obj);
1006 get_InstOf_obj (ir_node *node) {
1007 assert (node->op = op_InstOf);
1008 return (get_irn_n (node, 1));
1012 set_InstOf_obj (ir_node *node, ir_node *obj) {
1013 assert (node->op = op_InstOf);
1014 set_irn_n (node, 1, obj);
1018 /* For unary and binary arithmetic operations the access to the
1019 operands can be factored out. Left is the first, right the
1020 second arithmetic value as listed in tech report 0999-33.
1021 unops are: Minus, Abs, Not, Conv
1022 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1023 Shr, Shrs, Rotate, Cmp */
1027 get_Call_mem (ir_node *node) {
1028 assert (node->op == op_Call);
1029 return get_irn_n(node, 0);
1033 set_Call_mem (ir_node *node, ir_node *mem) {
1034 assert (node->op == op_Call);
1035 set_irn_n(node, 0, mem);
1039 get_Call_ptr (ir_node *node) {
1040 assert (node->op == op_Call);
1041 return get_irn_n(node, 1);
1045 set_Call_ptr (ir_node *node, ir_node *ptr) {
1046 assert (node->op == op_Call);
1047 set_irn_n(node, 1, ptr);
1051 get_Call_param_arr (ir_node *node) {
1052 assert (node->op == op_Call);
1053 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1057 get_Call_n_params (ir_node *node) {
1058 assert (node->op == op_Call);
1059 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1063 get_Call_arity (ir_node *node) {
1064 assert (node->op == op_Call);
1065 return get_Call_n_params(node);
1069 set_Call_arity (ir_node *node, ir_node *arity) {
1070 assert (node->op == op_Call);
1075 get_Call_param (ir_node *node, int pos) {
1076 assert (node->op == op_Call);
1077 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1081 set_Call_param (ir_node *node, int pos, ir_node *param) {
1082 assert (node->op == op_Call);
1083 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1087 get_Call_type (ir_node *node) {
1088 assert (node->op == op_Call);
1089 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1093 set_Call_type (ir_node *node, type *tp) {
1094 assert (node->op == op_Call);
1095 assert (is_method_type(tp));
1096 node->attr.call.cld_tp = tp;
1099 int get_Call_n_callees(ir_node * node) {
1100 assert(node->op == op_Call && node->attr.call.callee_arr);
1101 return ARR_LEN(node->attr.call.callee_arr);
1104 entity * get_Call_callee(ir_node * node, int pos) {
1105 assert(node->op == op_Call && node->attr.call.callee_arr);
1106 return node->attr.call.callee_arr[pos];
1109 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1110 assert(node->op == op_Call);
1111 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1112 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1114 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1117 void remove_Call_callee_arr(ir_node * node) {
1118 assert(node->op == op_Call);
1119 node->attr.call.callee_arr = NULL;
1122 ir_node * get_CallBegin_ptr (ir_node *node) {
1123 assert(node->op == op_CallBegin);
1124 return get_irn_n(node, 0);
1126 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1127 assert(node->op == op_CallBegin);
1128 set_irn_n(node, 0, ptr);
1130 ir_graph * get_CallBegin_irg (ir_node *node) {
1131 assert(node->op == op_CallBegin);
1132 return node->attr.callbegin.irg;
1134 ir_node * get_CallBegin_call (ir_node *node) {
1135 assert(node->op == op_CallBegin);
1136 return node->attr.callbegin.call;
1138 void set_CallBegin_call (ir_node *node, ir_node *call) {
1139 assert(node->op == op_CallBegin);
1140 node->attr.callbegin.call = call;
1144 get_Add_left (ir_node *node) {
1145 assert (node->op == op_Add);
1146 return get_irn_n(node, 0);
1150 set_Add_left (ir_node *node, ir_node *left) {
1151 assert (node->op == op_Add);
1152 set_irn_n(node, 0, left);
1156 get_Add_right (ir_node *node) {
1157 assert (node->op == op_Add);
1158 return get_irn_n(node, 1);
1162 set_Add_right (ir_node *node, ir_node *right) {
1163 assert (node->op == op_Add);
1164 set_irn_n(node, 1, right);
1168 get_Sub_left (ir_node *node) {
1169 assert (node->op == op_Sub);
1170 return get_irn_n(node, 0);
1174 set_Sub_left (ir_node *node, ir_node *left) {
1175 assert (node->op == op_Sub);
1176 set_irn_n(node, 0, left);
1180 get_Sub_right (ir_node *node) {
1181 assert (node->op == op_Sub);
1182 return get_irn_n(node, 1);
1186 set_Sub_right (ir_node *node, ir_node *right) {
1187 assert (node->op == op_Sub);
1188 set_irn_n(node, 1, right);
1193 get_Minus_op (ir_node *node) {
1194 assert (node->op == op_Minus);
1195 return get_irn_n(node, 0);
1199 set_Minus_op (ir_node *node, ir_node *op) {
1200 assert (node->op == op_Minus);
1201 set_irn_n(node, 0, op);
1206 get_Mul_left (ir_node *node) {
1207 assert (node->op == op_Mul);
1208 return get_irn_n(node, 0);
1212 set_Mul_left (ir_node *node, ir_node *left) {
1213 assert (node->op == op_Mul);
1214 set_irn_n(node, 0, left);
1218 get_Mul_right (ir_node *node) {
1219 assert (node->op == op_Mul);
1220 return get_irn_n(node, 1);
1224 set_Mul_right (ir_node *node, ir_node *right) {
1225 assert (node->op == op_Mul);
1226 set_irn_n(node, 1, right);
1230 get_Quot_left (ir_node *node) {
1231 assert (node->op == op_Quot);
1232 return get_irn_n(node, 1);
1236 set_Quot_left (ir_node *node, ir_node *left) {
1237 assert (node->op == op_Quot);
1238 set_irn_n(node, 1, left);
1242 get_Quot_right (ir_node *node) {
1243 assert (node->op == op_Quot);
1244 return get_irn_n(node, 2);
1248 set_Quot_right (ir_node *node, ir_node *right) {
1249 assert (node->op == op_Quot);
1250 set_irn_n(node, 2, right);
1254 get_Quot_mem (ir_node *node) {
1255 assert (node->op == op_Quot);
1256 return get_irn_n(node, 0);
1260 set_Quot_mem (ir_node *node, ir_node *mem) {
1261 assert (node->op == op_Quot);
1262 set_irn_n(node, 0, mem);
1266 get_DivMod_left (ir_node *node) {
1267 assert (node->op == op_DivMod);
1268 return get_irn_n(node, 1);
1272 set_DivMod_left (ir_node *node, ir_node *left) {
1273 assert (node->op == op_DivMod);
1274 set_irn_n(node, 1, left);
1278 get_DivMod_right (ir_node *node) {
1279 assert (node->op == op_DivMod);
1280 return get_irn_n(node, 2);
1284 set_DivMod_right (ir_node *node, ir_node *right) {
1285 assert (node->op == op_DivMod);
1286 set_irn_n(node, 2, right);
1290 get_DivMod_mem (ir_node *node) {
1291 assert (node->op == op_DivMod);
1292 return get_irn_n(node, 0);
1296 set_DivMod_mem (ir_node *node, ir_node *mem) {
1297 assert (node->op == op_DivMod);
1298 set_irn_n(node, 0, mem);
1302 get_Div_left (ir_node *node) {
1303 assert (node->op == op_Div);
1304 return get_irn_n(node, 1);
1308 set_Div_left (ir_node *node, ir_node *left) {
1309 assert (node->op == op_Div);
1310 set_irn_n(node, 1, left);
1314 get_Div_right (ir_node *node) {
1315 assert (node->op == op_Div);
1316 return get_irn_n(node, 2);
1320 set_Div_right (ir_node *node, ir_node *right) {
1321 assert (node->op == op_Div);
1322 set_irn_n(node, 2, right);
1326 get_Div_mem (ir_node *node) {
1327 assert (node->op == op_Div);
1328 return get_irn_n(node, 0);
1332 set_Div_mem (ir_node *node, ir_node *mem) {
1333 assert (node->op == op_Div);
1334 set_irn_n(node, 0, mem);
1338 get_Mod_left (ir_node *node) {
1339 assert (node->op == op_Mod);
1340 return get_irn_n(node, 1);
1344 set_Mod_left (ir_node *node, ir_node *left) {
1345 assert (node->op == op_Mod);
1346 set_irn_n(node, 1, left);
1350 get_Mod_right (ir_node *node) {
1351 assert (node->op == op_Mod);
1352 return get_irn_n(node, 2);
1356 set_Mod_right (ir_node *node, ir_node *right) {
1357 assert (node->op == op_Mod);
1358 set_irn_n(node, 2, right);
1362 get_Mod_mem (ir_node *node) {
1363 assert (node->op == op_Mod);
1364 return get_irn_n(node, 0);
1368 set_Mod_mem (ir_node *node, ir_node *mem) {
1369 assert (node->op == op_Mod);
1370 set_irn_n(node, 0, mem);
1374 get_Abs_op (ir_node *node) {
1375 assert (node->op == op_Abs);
1376 return get_irn_n(node, 0);
1380 set_Abs_op (ir_node *node, ir_node *op) {
1381 assert (node->op == op_Abs);
1382 set_irn_n(node, 0, op);
1386 get_And_left (ir_node *node) {
1387 assert (node->op == op_And);
1388 return get_irn_n(node, 0);
1392 set_And_left (ir_node *node, ir_node *left) {
1393 assert (node->op == op_And);
1394 set_irn_n(node, 0, left);
1398 get_And_right (ir_node *node) {
1399 assert (node->op == op_And);
1400 return get_irn_n(node, 1);
1404 set_And_right (ir_node *node, ir_node *right) {
1405 assert (node->op == op_And);
1406 set_irn_n(node, 1, right);
1410 get_Or_left (ir_node *node) {
1411 assert (node->op == op_Or);
1412 return get_irn_n(node, 0);
1416 set_Or_left (ir_node *node, ir_node *left) {
1417 assert (node->op == op_Or);
1418 set_irn_n(node, 0, left);
1422 get_Or_right (ir_node *node) {
1423 assert (node->op == op_Or);
1424 return get_irn_n(node, 1);
1428 set_Or_right (ir_node *node, ir_node *right) {
1429 assert (node->op == op_Or);
1430 set_irn_n(node, 1, right);
1434 get_Eor_left (ir_node *node) {
1435 assert (node->op == op_Eor);
1436 return get_irn_n(node, 0);
1440 set_Eor_left (ir_node *node, ir_node *left) {
1441 assert (node->op == op_Eor);
1442 set_irn_n(node, 0, left);
1446 get_Eor_right (ir_node *node) {
1447 assert (node->op == op_Eor);
1448 return get_irn_n(node, 1);
1452 set_Eor_right (ir_node *node, ir_node *right) {
1453 assert (node->op == op_Eor);
1454 set_irn_n(node, 1, right);
1459 get_Not_op (ir_node *node) {
1460 assert (node->op == op_Not);
1461 return get_irn_n(node, 0);
1465 set_Not_op (ir_node *node, ir_node *op) {
1466 assert (node->op == op_Not);
1467 set_irn_n(node, 0, op);
1472 get_Shl_left (ir_node *node) {
1473 assert (node->op == op_Shl);
1474 return get_irn_n(node, 0);
1478 set_Shl_left (ir_node *node, ir_node *left) {
1479 assert (node->op == op_Shl);
1480 set_irn_n(node, 0, left);
1484 get_Shl_right (ir_node *node) {
1485 assert (node->op == op_Shl);
1486 return get_irn_n(node, 1);
1490 set_Shl_right (ir_node *node, ir_node *right) {
1491 assert (node->op == op_Shl);
1492 set_irn_n(node, 1, right);
1496 get_Shr_left (ir_node *node) {
1497 assert (node->op == op_Shr);
1498 return get_irn_n(node, 0);
1502 set_Shr_left (ir_node *node, ir_node *left) {
1503 assert (node->op == op_Shr);
1504 set_irn_n(node, 0, left);
1508 get_Shr_right (ir_node *node) {
1509 assert (node->op == op_Shr);
1510 return get_irn_n(node, 1);
1514 set_Shr_right (ir_node *node, ir_node *right) {
1515 assert (node->op == op_Shr);
1516 set_irn_n(node, 1, right);
1520 get_Shrs_left (ir_node *node) {
1521 assert (node->op == op_Shrs);
1522 return get_irn_n(node, 0);
1526 set_Shrs_left (ir_node *node, ir_node *left) {
1527 assert (node->op == op_Shrs);
1528 set_irn_n(node, 0, left);
1532 get_Shrs_right (ir_node *node) {
1533 assert (node->op == op_Shrs);
1534 return get_irn_n(node, 1);
1538 set_Shrs_right (ir_node *node, ir_node *right) {
1539 assert (node->op == op_Shrs);
1540 set_irn_n(node, 1, right);
1544 get_Rot_left (ir_node *node) {
1545 assert (node->op == op_Rot);
1546 return get_irn_n(node, 0);
1550 set_Rot_left (ir_node *node, ir_node *left) {
1551 assert (node->op == op_Rot);
1552 set_irn_n(node, 0, left);
1556 get_Rot_right (ir_node *node) {
1557 assert (node->op == op_Rot);
1558 return get_irn_n(node, 1);
1562 set_Rot_right (ir_node *node, ir_node *right) {
1563 assert (node->op == op_Rot);
1564 set_irn_n(node, 1, right);
1568 get_Cmp_left (ir_node *node) {
1569 assert (node->op == op_Cmp);
1570 return get_irn_n(node, 0);
1574 set_Cmp_left (ir_node *node, ir_node *left) {
1575 assert (node->op == op_Cmp);
1576 set_irn_n(node, 0, left);
1580 get_Cmp_right (ir_node *node) {
1581 assert (node->op == op_Cmp);
1582 return get_irn_n(node, 1);
1586 set_Cmp_right (ir_node *node, ir_node *right) {
1587 assert (node->op == op_Cmp);
1588 set_irn_n(node, 1, right);
1592 get_Conv_op (ir_node *node) {
1593 assert (node->op == op_Conv);
1594 return get_irn_n(node, 0);
1598 set_Conv_op (ir_node *node, ir_node *op) {
1599 assert (node->op == op_Conv);
1600 set_irn_n(node, 0, op);
1606 is_unop (ir_node *node) {
1607 return ( node->op == op_Minus ||
1608 node->op == op_Abs ||
1609 node->op == op_Not ||
1610 node->op == op_Conv );
1614 get_unop_op (ir_node *node) {
1615 assert ( node->op == op_Minus ||
1616 node->op == op_Abs ||
1617 node->op == op_Not ||
1618 node->op == op_Conv );
1619 switch (get_irn_opcode (node)) {
1620 case iro_Minus: return get_Minus_op(node); break;
1621 case iro_Abs: return get_Abs_op(node); break;
1622 case iro_Not: return get_Not_op(node); break;
1623 case iro_Conv: return get_Conv_op(node); break;
1624 default: return NULL;
1629 set_unop_op (ir_node *node, ir_node *op) {
1630 assert (node->op == op_Minus ||
1631 node->op == op_Abs ||
1632 node->op == op_Not ||
1633 node->op == op_Conv );
1634 switch (get_irn_opcode (node)) {
1635 case iro_Minus: set_Minus_op(node, op); break;
1636 case iro_Abs: set_Abs_op(node, op); break;
1637 case iro_Not: set_Not_op(node, op); break;
1638 case iro_Conv: set_Conv_op(node, op); break;
1645 is_binop (ir_node *node) {
1646 return (node->op == op_Add ||
1647 node->op == op_Sub ||
1648 node->op == op_Mul ||
1649 node->op == op_Quot ||
1650 node->op == op_DivMod ||
1651 node->op == op_Div ||
1652 node->op == op_Mod ||
1653 node->op == op_And ||
1654 node->op == op_Or ||
1655 node->op == op_Eor ||
1656 node->op == op_Shl ||
1657 node->op == op_Shr ||
1658 node->op == op_Shrs ||
1659 node->op == op_Rot ||
1660 node->op == op_Cmp );
1664 get_binop_left (ir_node *node) {
1665 assert (node->op == op_Add ||
1666 node->op == op_Sub ||
1667 node->op == op_Mul ||
1668 node->op == op_Quot ||
1669 node->op == op_DivMod ||
1670 node->op == op_Div ||
1671 node->op == op_Mod ||
1672 node->op == op_And ||
1673 node->op == op_Or ||
1674 node->op == op_Eor ||
1675 node->op == op_Shl ||
1676 node->op == op_Shr ||
1677 node->op == op_Shrs ||
1678 node->op == op_Rot ||
1679 node->op == op_Cmp );
1681 switch (get_irn_opcode (node)) {
1682 case iro_Add : return get_Add_left(node); break;
1683 case iro_Sub : return get_Sub_left(node); break;
1684 case iro_Mul : return get_Mul_left(node); break;
1685 case iro_Quot : return get_Quot_left(node); break;
1686 case iro_DivMod: return get_DivMod_left(node); break;
1687 case iro_Div : return get_Div_left(node); break;
1688 case iro_Mod : return get_Mod_left(node); break;
1689 case iro_And : return get_And_left(node); break;
1690 case iro_Or : return get_Or_left(node); break;
1691 case iro_Eor : return get_Eor_left(node); break;
1692 case iro_Shl : return get_Shl_left(node); break;
1693 case iro_Shr : return get_Shr_left(node); break;
1694 case iro_Shrs : return get_Shrs_left(node); break;
1695 case iro_Rot : return get_Rot_left(node); break;
1696 case iro_Cmp : return get_Cmp_left(node); break;
1697 default: return NULL;
1702 set_binop_left (ir_node *node, ir_node *left) {
1703 assert (node->op == op_Add ||
1704 node->op == op_Sub ||
1705 node->op == op_Mul ||
1706 node->op == op_Quot ||
1707 node->op == op_DivMod ||
1708 node->op == op_Div ||
1709 node->op == op_Mod ||
1710 node->op == op_And ||
1711 node->op == op_Or ||
1712 node->op == op_Eor ||
1713 node->op == op_Shl ||
1714 node->op == op_Shr ||
1715 node->op == op_Shrs ||
1716 node->op == op_Rot ||
1717 node->op == op_Cmp );
1719 switch (get_irn_opcode (node)) {
1720 case iro_Add : set_Add_left(node, left); break;
1721 case iro_Sub : set_Sub_left(node, left); break;
1722 case iro_Mul : set_Mul_left(node, left); break;
1723 case iro_Quot : set_Quot_left(node, left); break;
1724 case iro_DivMod: set_DivMod_left(node, left); break;
1725 case iro_Div : set_Div_left(node, left); break;
1726 case iro_Mod : set_Mod_left(node, left); break;
1727 case iro_And : set_And_left(node, left); break;
1728 case iro_Or : set_Or_left(node, left); break;
1729 case iro_Eor : set_Eor_left(node, left); break;
1730 case iro_Shl : set_Shl_left(node, left); break;
1731 case iro_Shr : set_Shr_left(node, left); break;
1732 case iro_Shrs : set_Shrs_left(node, left); break;
1733 case iro_Rot : set_Rot_left(node, left); break;
1734 case iro_Cmp : set_Cmp_left(node, left); break;
1740 get_binop_right (ir_node *node) {
1741 assert (node->op == op_Add ||
1742 node->op == op_Sub ||
1743 node->op == op_Mul ||
1744 node->op == op_Quot ||
1745 node->op == op_DivMod ||
1746 node->op == op_Div ||
1747 node->op == op_Mod ||
1748 node->op == op_And ||
1749 node->op == op_Or ||
1750 node->op == op_Eor ||
1751 node->op == op_Shl ||
1752 node->op == op_Shr ||
1753 node->op == op_Shrs ||
1754 node->op == op_Rot ||
1755 node->op == op_Cmp );
1757 switch (get_irn_opcode (node)) {
1758 case iro_Add : return get_Add_right(node); break;
1759 case iro_Sub : return get_Sub_right(node); break;
1760 case iro_Mul : return get_Mul_right(node); break;
1761 case iro_Quot : return get_Quot_right(node); break;
1762 case iro_DivMod: return get_DivMod_right(node); break;
1763 case iro_Div : return get_Div_right(node); break;
1764 case iro_Mod : return get_Mod_right(node); break;
1765 case iro_And : return get_And_right(node); break;
1766 case iro_Or : return get_Or_right(node); break;
1767 case iro_Eor : return get_Eor_right(node); break;
1768 case iro_Shl : return get_Shl_right(node); break;
1769 case iro_Shr : return get_Shr_right(node); break;
1770 case iro_Shrs : return get_Shrs_right(node); break;
1771 case iro_Rot : return get_Rot_right(node); break;
1772 case iro_Cmp : return get_Cmp_right(node); break;
1773 default: return NULL;
1778 set_binop_right (ir_node *node, ir_node *right) {
1779 assert (node->op == op_Add ||
1780 node->op == op_Sub ||
1781 node->op == op_Mul ||
1782 node->op == op_Quot ||
1783 node->op == op_DivMod ||
1784 node->op == op_Div ||
1785 node->op == op_Mod ||
1786 node->op == op_And ||
1787 node->op == op_Or ||
1788 node->op == op_Eor ||
1789 node->op == op_Shl ||
1790 node->op == op_Shr ||
1791 node->op == op_Shrs ||
1792 node->op == op_Rot ||
1793 node->op == op_Cmp );
1795 switch (get_irn_opcode (node)) {
1796 case iro_Add : set_Add_right(node, right); break;
1797 case iro_Sub : set_Sub_right(node, right); break;
1798 case iro_Mul : set_Mul_right(node, right); break;
1799 case iro_Quot : set_Quot_right(node, right); break;
1800 case iro_DivMod: set_DivMod_right(node, right); break;
1801 case iro_Div : set_Div_right(node, right); break;
1802 case iro_Mod : set_Mod_right(node, right); break;
1803 case iro_And : set_And_right(node, right); break;
1804 case iro_Or : set_Or_right(node, right); break;
1805 case iro_Eor : set_Eor_right(node, right); break;
1806 case iro_Shl : set_Shl_right(node, right); break;
1807 case iro_Shr : set_Shr_right(node, right); break;
1808 case iro_Shrs : set_Shrs_right(node, right); break;
1809 case iro_Rot : set_Rot_right(node, right); break;
1810 case iro_Cmp : set_Cmp_right(node, right); break;
1817 get_Phi_preds_arr (ir_node *node) {
1818 assert (node->op == op_Phi);
1819 return (ir_node **)&(get_irn_in(node)[1]);
1823 get_Phi_n_preds (ir_node *node) {
1824 assert (node->op == op_Phi);
1825 return (get_irn_arity(node));
1829 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1830 assert (node->op == op_Phi);
1835 get_Phi_pred (ir_node *node, int pos) {
1836 assert (node->op == op_Phi);
1837 return get_irn_n(node, pos);
1841 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1842 assert (node->op == op_Phi);
1843 set_irn_n(node, pos, pred);
1847 get_Load_mem (ir_node *node) {
1848 assert (node->op == op_Load);
1849 return get_irn_n(node, 0);
1853 set_Load_mem (ir_node *node, ir_node *mem) {
1854 assert (node->op == op_Load);
1855 set_irn_n(node, 0, mem);
1859 get_Load_ptr (ir_node *node) {
1860 assert (node->op == op_Load);
1861 return get_irn_n(node, 1);
1865 set_Load_ptr (ir_node *node, ir_node *ptr) {
1866 assert (node->op == op_Load);
1867 set_irn_n(node, 1, ptr);
1872 get_Store_mem (ir_node *node) {
1873 assert (node->op == op_Store);
1874 return get_irn_n(node, 0);
1878 set_Store_mem (ir_node *node, ir_node *mem) {
1879 assert (node->op == op_Store);
1880 set_irn_n(node, 0, mem);
1884 get_Store_ptr (ir_node *node) {
1885 assert (node->op == op_Store);
1886 return get_irn_n(node, 1);
1890 set_Store_ptr (ir_node *node, ir_node *ptr) {
1891 assert (node->op == op_Store);
1892 set_irn_n(node, 1, ptr);
1896 get_Store_value (ir_node *node) {
1897 assert (node->op == op_Store);
1898 return get_irn_n(node, 2);
1902 set_Store_value (ir_node *node, ir_node *value) {
1903 assert (node->op == op_Store);
1904 set_irn_n(node, 2, value);
1908 get_Alloc_mem (ir_node *node) {
1909 assert (node->op == op_Alloc);
1910 return get_irn_n(node, 0);
1914 set_Alloc_mem (ir_node *node, ir_node *mem) {
1915 assert (node->op == op_Alloc);
1916 set_irn_n(node, 0, mem);
1920 get_Alloc_size (ir_node *node) {
1921 assert (node->op == op_Alloc);
1922 return get_irn_n(node, 1);
1926 set_Alloc_size (ir_node *node, ir_node *size) {
1927 assert (node->op == op_Alloc);
1928 set_irn_n(node, 1, size);
1932 get_Alloc_type (ir_node *node) {
1933 assert (node->op == op_Alloc);
1934 return node->attr.a.type = skip_tid(node->attr.a.type);
1938 set_Alloc_type (ir_node *node, type *tp) {
1939 assert (node->op == op_Alloc);
1940 node->attr.a.type = tp;
1944 get_Alloc_where (ir_node *node) {
1945 assert (node->op == op_Alloc);
1946 return node->attr.a.where;
1950 set_Alloc_where (ir_node *node, where_alloc where) {
1951 assert (node->op == op_Alloc);
1952 node->attr.a.where = where;
1957 get_Free_mem (ir_node *node) {
1958 assert (node->op == op_Free);
1959 return get_irn_n(node, 0);
1963 set_Free_mem (ir_node *node, ir_node *mem) {
1964 assert (node->op == op_Free);
1965 set_irn_n(node, 0, mem);
1969 get_Free_ptr (ir_node *node) {
1970 assert (node->op == op_Free);
1971 return get_irn_n(node, 1);
1975 set_Free_ptr (ir_node *node, ir_node *ptr) {
1976 assert (node->op == op_Free);
1977 set_irn_n(node, 1, ptr);
1981 get_Free_size (ir_node *node) {
1982 assert (node->op == op_Free);
1983 return get_irn_n(node, 2);
1987 set_Free_size (ir_node *node, ir_node *size) {
1988 assert (node->op == op_Free);
1989 set_irn_n(node, 2, size);
1993 get_Free_type (ir_node *node) {
1994 assert (node->op == op_Free);
1995 return node->attr.f = skip_tid(node->attr.f);
1999 set_Free_type (ir_node *node, type *tp) {
2000 assert (node->op == op_Free);
2005 get_Sync_preds_arr (ir_node *node) {
2006 assert (node->op == op_Sync);
2007 return (ir_node **)&(get_irn_in(node)[1]);
2011 get_Sync_n_preds (ir_node *node) {
2012 assert (node->op == op_Sync);
2013 return (get_irn_arity(node));
2018 set_Sync_n_preds (ir_node *node, int n_preds) {
2019 assert (node->op == op_Sync);
2024 get_Sync_pred (ir_node *node, int pos) {
2025 assert (node->op == op_Sync);
2026 return get_irn_n(node, pos);
2030 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
2031 assert (node->op == op_Sync);
2032 set_irn_n(node, pos, pred);
2036 get_Proj_pred (ir_node *node) {
2037 assert (is_Proj(node));
2038 return get_irn_n(node, 0);
2042 set_Proj_pred (ir_node *node, ir_node *pred) {
2043 assert (is_Proj(node));
2044 set_irn_n(node, 0, pred);
2048 get_Proj_proj (ir_node *node) {
2049 assert (is_Proj(node));
2050 if (get_irn_opcode(node) == iro_Proj) {
2051 return node->attr.proj;
2053 assert(get_irn_opcode(node) == iro_Filter);
2054 return node->attr.filter.proj;
2059 set_Proj_proj (ir_node *node, long proj) {
2060 assert (node->op == op_Proj);
2061 node->attr.proj = proj;
2065 get_Tuple_preds_arr (ir_node *node) {
2066 assert (node->op == op_Tuple);
2067 return (ir_node **)&(get_irn_in(node)[1]);
2071 get_Tuple_n_preds (ir_node *node) {
2072 assert (node->op == op_Tuple);
2073 return (get_irn_arity(node));
2078 set_Tuple_n_preds (ir_node *node, int n_preds) {
2079 assert (node->op == op_Tuple);
2084 get_Tuple_pred (ir_node *node, int pos) {
2085 assert (node->op == op_Tuple);
2086 return get_irn_n(node, pos);
2090 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2091 assert (node->op == op_Tuple);
2092 set_irn_n(node, pos, pred);
2096 get_Id_pred (ir_node *node) {
2097 assert (node->op == op_Id);
2098 return get_irn_n(node, 0);
2102 set_Id_pred (ir_node *node, ir_node *pred) {
2103 assert (node->op == op_Id);
2104 set_irn_n(node, 0, pred);
2109 get_Filter_pred (ir_node *node) {
2110 assert(node->op == op_Filter);
2114 set_Filter_pred (ir_node *node, ir_node *pred) {
2115 assert(node->op == op_Filter);
2119 get_Filter_proj(ir_node *node) {
2120 assert(node->op == op_Filter);
2121 return node->attr.filter.proj;
2124 set_Filter_proj (ir_node *node, long proj) {
2125 assert(node->op == op_Filter);
2126 node->attr.filter.proj = proj;
2129 /* Don't use get_irn_arity, get_irn_n in implementation as access
2130 shall work independent of view!!! */
2131 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2132 assert(node->op == op_Filter);
2133 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2134 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2135 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2136 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2137 node->attr.filter.in_cg[0] = node->in[0];
2139 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2142 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2143 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2144 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2145 node->attr.filter.in_cg[pos + 1] = pred;
2147 int get_Filter_n_cg_preds(ir_node *node) {
2148 assert(node->op == op_Filter && node->attr.filter.in_cg);
2149 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2151 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2153 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2155 arity = ARR_LEN(node->attr.filter.in_cg);
2156 assert(pos < arity - 1);
2157 return node->attr.filter.in_cg[pos + 1];
2162 get_irn_irg(ir_node *node) {
2163 if (get_irn_op(node) == op_CallBegin) {
2164 return node->attr.callbegin.irg;
2165 } else if (get_irn_op(node) == op_EndReg ||
2166 get_irn_op(node) == op_EndExcept) {
2167 return node->attr.end.irg;
2169 assert(0 && "no irg attr");
2174 /******************************************************************/
2175 /* Auxiliary routines */
2176 /******************************************************************/
2179 skip_Proj (ir_node *node) {
2180 /* don't assert node !!! */
2181 if (node && is_Proj(node)) {
2182 return get_Proj_pred(node);
2189 skip_Tuple (ir_node *node) {
2192 if (!get_opt_normalize()) return node;
2194 node = skip_nop(node);
2195 if (get_irn_op(node) == op_Proj) {
2196 pred = skip_nop(get_Proj_pred(node));
2197 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2198 pred = skip_nop(skip_Tuple(pred));
2199 if (get_irn_op(pred) == op_Tuple)
2200 return get_Tuple_pred(pred, get_Proj_proj(node));
2206 skip_nop (ir_node *node) {
2207 /* don't assert node !!! */
2209 if (!get_opt_normalize()) return node;
2211 /* Don't use get_Id_pred: We get into an endless loop for
2212 self-referencing Ids. */
2213 if (node && (node->op == op_Id) && (node != node->in[0+1])) {
2214 assert (get_irn_arity (node) > 0);
2215 return node->in[0+1];
2222 skip_Id (ir_node *node) {
2223 return skip_nop(node);
2227 is_Bad (ir_node *node) {
2229 if ((node) && get_irn_opcode(node) == iro_Bad)
2235 is_no_Block (ir_node *node) {
2237 return (get_irn_opcode(node) != iro_Block);
2241 is_Block (ir_node *node) {
2243 return (get_irn_opcode(node) == iro_Block);
2247 is_Proj (const ir_node *node) {
2249 return node->op == op_Proj
2250 || (!interprocedural_view && node->op == op_Filter);
2253 /* Returns true if the operation manipulates control flow. */
2255 is_cfop(ir_node *node) {
2256 return is_cfopcode(get_irn_op(node));
2259 /* Returns true if the operation manipulates interprocedural control flow:
2260 CallBegin, EndReg, EndExcept */
2261 INLINE int is_ip_cfop(ir_node *node) {
2262 return is_ip_cfopcode(get_irn_op(node));
2265 ir_graph *get_ip_cfop_irg(ir_node *n) {
2266 switch (get_irn_opcode(n)) {
2268 return get_EndReg_irg(n);
2270 return get_EndExcept_irg(n);
2272 return get_CallBegin_irg(n);
2274 assert(is_ip_cfop(n));
2276 return NULL; /* should never be reached */
2279 /* Returns true if the operation can change the control flow because
2282 is_fragile_op(ir_node *node) {
2283 return ( (get_irn_opcode(node) == iro_Call)
2284 || (get_irn_opcode(node) == iro_Quot)
2285 || (get_irn_opcode(node) == iro_DivMod)
2286 || (get_irn_opcode(node) == iro_Div)
2287 || (get_irn_opcode(node) == iro_Mod)
2288 || (get_irn_opcode(node) == iro_Load)
2289 || (get_irn_opcode(node) == iro_Store)
2290 || (get_irn_opcode(node) == iro_Alloc)
2291 || (get_irn_opcode(node) == iro_Bad)
2292 || (get_irn_opcode(node) == iro_Unknown));
2296 /* Returns the memory operand of fragile operations. */
2297 ir_node *get_fragile_op_mem(ir_node *node) {
2298 assert(node && is_fragile_op(node));
2300 switch (get_irn_opcode (node)) {
2309 return get_irn_n(node, 0);
2314 assert(0 && "not reached");