1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
15 #include "irgraph_t.h"
18 #include "typegmod_t.h"
25 /* some constants fixing the positions of nodes predecessors
27 #define CALL_PARAM_OFFSET 2
28 #define SEL_INDEX_OFFSET 2
29 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
30 #define END_KEEPALIVE_OFFSET 0
32 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
33 "Gt", "Ge", "Lg", "Leg", "Uo",
34 "Ue", "Ul", "Ule", "Ug", "Uge",
37 inline char *get_pnc_string(int pnc) {
38 return pnc_name_arr[pnc];
43 get_negated_pnc(int pnc) {
45 case False: return True; break;
46 case Eq: return Ne; break;
47 case Lt: return Uge; break;
48 case Le: return Ug; break;
49 case Gt: return Ule; break;
50 case Ge: return Ul; break;
51 case Lg: return Ue; break;
52 case Leg: return Uo; break;
53 case Uo: return Leg; break;
54 case Ue: return Lg; break;
55 case Ul: return Ge; break;
56 case Ule: return Gt; break;
57 case Ug: return Le; break;
58 case Uge: return Lt; break;
59 case Ne: return Eq; break;
60 case True: return False; break;
62 return 99; /* to shut up gcc */
65 static char *pns_name_arr [] = {"initial_exec", "global_store",
66 "frame_base", "globals", "args"};
68 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
75 /* irnode constructor */
76 /* create a new irnode in irg, with an op, mode, arity and */
77 /* some incoming irnodes */
78 /* this constructor is used in every specified irnode constructor */
80 new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
81 int arity, ir_node **in)
84 int node_size = offsetof (ir_node, attr) + op->attr_size;
86 res = (ir_node *) obstack_alloc (irg->obst, node_size);
88 res->kind = k_ir_node;
94 res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
96 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
97 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
100 set_irn_dbg_info(res, db);
104 res->node_nr = get_irp_new_node_nr();
110 /* Copies all attributes stored in the old node to the new node.
111 Assumes both have the same opcode and sufficient size. */
113 copy_attrs (ir_node *old, ir_node *new) {
114 assert (get_irn_opcode(old) == get_irn_opcode(new));
115 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
118 /* IR-Nodes with attributes */
120 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
123 ir_node *np = XP_GETARG (ir_node *, 0);
126 XPS ("<null ir_node>");
130 XPF1 ("%I", get_irn_opident(np));
132 switch (get_irn_opcode (np)) { /* node label */
134 XPF1 ("%I", get_irn_mode(np)->name);
136 XPF1 ("%v", get_irn_const_attr);
139 if (get_irn_modecode (np) == irm_b) {
141 XP (pnc_name_arr[get_irn_proj_attr(np)]);
142 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
144 XP (pns_name_arr[get_irn_proj_attr(np)]);
146 XPF1 ("%I", get_irn_mode(np)->name);
148 XPF1 ("%d", get_irn_proj_attr(np));
152 XPF1 ("%I", get_irn_mode(np)->name);
154 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
155 XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
157 case iro_Start: /* don't dump mode of these */
170 XPF1 ("%I", get_irn_mode(np)->name);
176 /** getting some parameters from ir_nodes **/
178 /* returns the number of predecessors without the block predecessor. */
180 get_irn_arity (ir_node *node) {
182 if (interprocedural_view) { /* handle Filter and Block specially */
183 if (get_irn_opcode(node) == iro_Filter) {
184 assert(node->attr.filter.in_cg);
185 return ARR_LEN(node->attr.filter.in_cg) - 1;
186 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
187 return ARR_LEN(node->attr.block.in_cg) - 1;
189 /* else fall through */
191 return ARR_LEN(node->in) - 1;
194 /* Returns the array with ins. This array is shifted with respect to the
195 array accessed by get_irn_n: The block operand is at position 0 not -1.
196 (@@@ This should be changed.)
197 The order of the predecessors in this array is not guaranteed, except that
198 lists of operands as predecessors of Block or arguments of a Call are
201 get_irn_in (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 node->attr.filter.in_cg;
207 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
208 return node->attr.block.in_cg;
210 /* else fall through */
216 set_irn_in (ir_node *node, int arity, ir_node **in) {
219 if (interprocedural_view) { /* handle Filter and Block specially */
220 if (get_irn_opcode(node) == iro_Filter) {
221 assert(node->attr.filter.in_cg);
222 arr = &node->attr.filter.in_cg;
223 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
224 arr = &node->attr.block.in_cg;
231 if (arity != ARR_LEN(*arr) - 1) {
232 ir_node * block = (*arr)[0];
233 *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
236 memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
239 /* to iterate through the predecessors without touching the array */
240 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
241 to iterate includind the Block predecessor iterate from i = -1 to
243 If it is a block, the entry -1 is NULL. */
245 get_irn_n (ir_node *node, int n) {
246 assert(node && -1 <= n && n < get_irn_arity(node));
247 if (interprocedural_view) { /* handle Filter and Block specially */
248 if (get_irn_opcode(node) == iro_Filter) {
249 assert(node->attr.filter.in_cg);
250 return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
251 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
252 return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
254 /* else fall through */
256 return (node->in[n + 1] = skip_nop(node->in[n + 1]));
260 set_irn_n (ir_node *node, int n, ir_node *in) {
261 assert(node && -1 <= n && n < get_irn_arity(node));
262 if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
263 /* Change block pred in both views! */
264 node->in[n + 1] = in;
265 assert(node->attr.filter.in_cg);
266 node->attr.filter.in_cg[n + 1] = in;
269 if (interprocedural_view) { /* handle Filter and Block specially */
270 if (get_irn_opcode(node) == iro_Filter) {
271 assert(node->attr.filter.in_cg);
272 node->attr.filter.in_cg[n + 1] = in;
274 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
275 node->attr.block.in_cg[n + 1] = in;
278 /* else fall through */
280 node->in[n + 1] = in;
284 get_irn_mode (ir_node *node)
291 get_irn_modecode (ir_node *node)
294 return node->mode->code;
299 get_irn_modeident (ir_node *node)
302 return node->mode->name;
306 get_irn_op (ir_node *node)
312 /* should be private to the library: */
314 set_irn_op (ir_node *node, ir_op *op)
321 get_irn_opcode (ir_node *node)
324 return node->op->code;
328 get_irn_opname (ir_node *node)
331 return id_to_str(node->op->name);
335 get_irn_opident (ir_node *node)
338 return node->op->name;
342 get_irn_visited (ir_node *node)
345 return node->visited;
349 set_irn_visited (ir_node *node, unsigned long visited)
352 node->visited = visited;
356 mark_irn_visited (ir_node *node) {
358 node->visited = current_ir_graph->visited;
362 irn_not_visited (ir_node *node) {
364 return (node->visited < current_ir_graph->visited);
368 set_irn_link (ir_node *node, ir_node *link) {
374 get_irn_link (ir_node *node) {
379 /* Outputs a unique number for this node */
381 get_irn_node_nr(ir_node *node) {
384 return node->node_nr;
391 get_irn_const_attr (ir_node *node)
393 assert (node->op == op_Const);
394 return node->attr.con;
398 get_irn_proj_attr (ir_node *node)
400 assert (node->op == op_Proj);
401 return node->attr.proj;
405 get_irn_alloc_attr (ir_node *node)
407 assert (node->op == op_Alloc);
412 get_irn_free_attr (ir_node *node)
414 assert (node->op == op_Free);
415 return node->attr.f = skip_tid(node->attr.f);
419 get_irn_symconst_attr (ir_node *node)
421 assert (node->op == op_SymConst);
426 get_irn_call_attr (ir_node *node)
428 assert (node->op == op_Call);
429 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
433 get_irn_sel_attr (ir_node *node)
435 assert (node->op == op_Sel);
440 get_irn_phi_attr (ir_node *node)
442 assert (node->op == op_Phi);
443 return node->attr.phi0_pos;
447 get_irn_block_attr (ir_node *node)
449 assert (node->op == op_Block);
450 return node->attr.block;
453 /** manipulate fields of individual nodes **/
455 /* this works for all except Block */
457 get_nodes_Block (ir_node *node) {
458 assert (!(node->op == op_Block));
459 return get_irn_n(node, -1);
463 set_nodes_Block (ir_node *node, ir_node *block) {
464 assert (!(node->op == op_Block));
465 set_irn_n(node, -1, block);
468 /* Returns an array with the predecessors of the Block. Depending on
469 the implementation of the graph datastructure this can be a copy of
470 the internal representation of predecessors as well as the internal
471 array itself. Therefore writing to this array might obstruct the ir. */
473 get_Block_cfgpred_arr (ir_node *node)
475 assert ((node->op == op_Block));
476 return (ir_node **)&(get_irn_in(node)[1]);
481 get_Block_n_cfgpreds (ir_node *node) {
482 assert ((node->op == op_Block));
483 return (get_irn_arity(node));
488 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
489 assert ((node->op == op_Block));
494 get_Block_cfgpred (ir_node *node, int pos) {
495 assert (node->op == op_Block);
496 return get_irn_n(node, pos);
500 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
501 assert (node->op == op_Block);
502 set_irn_n(node, pos, pred);
506 get_Block_matured (ir_node *node) {
507 assert (node->op == op_Block);
508 return node->attr.block.matured;
512 set_Block_matured (ir_node *node, bool matured) {
513 assert (node->op == op_Block);
514 node->attr.block.matured = matured;
517 get_Block_block_visited (ir_node *node) {
518 assert (node->op == op_Block);
519 return node->attr.block.block_visited;
523 set_Block_block_visited (ir_node *node, unsigned long visit) {
524 assert (node->op == op_Block);
525 node->attr.block.block_visited = visit;
528 /* For this current_ir_graph must be set. */
529 inline void mark_Block_block_visited (ir_node *node) {
530 assert (node->op == op_Block);
531 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
534 inline int Block_not_block_visited(ir_node *node) {
535 assert (node->op == op_Block);
536 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
540 get_Block_graph_arr (ir_node *node, int pos) {
541 assert (node->op == op_Block);
542 return node->attr.block.graph_arr[pos+1];
546 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
547 assert (node->op == op_Block);
548 node->attr.block.graph_arr[pos+1] = value;
551 void set_Block_exc (ir_node *block, exc_t exc)
553 block->attr.block.exc = exc;
556 exc_t get_Block_exc (ir_node *block)
558 return (block->attr.block.exc);
561 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
562 assert(node->op == op_Block);
563 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
564 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
565 node->attr.block.in_cg[0] = NULL;
567 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
570 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
571 assert(node->op == op_Block && node->attr.block.in_cg && 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
572 node->attr.block.in_cg[pos + 1] = pred;
575 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
576 assert(node->op == op_Block);
577 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
580 int get_Block_cg_n_cfgpreds(ir_node * node) {
581 assert(node->op == op_Block && node->attr.block.in_cg);
582 return ARR_LEN(node->attr.block.in_cg) - 1;
585 void remove_Block_cg_cfgpred_arr(ir_node * node) {
586 assert(node->op == op_Block);
587 node->attr.block.in_cg = NULL;
591 get_End_n_keepalives(ir_node *end) {
592 assert (end->op == op_End);
593 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
597 get_End_keepalive(ir_node *end, int pos) {
598 assert (end->op == op_End);
599 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
603 add_End_keepalive (ir_node *end, ir_node *ka) {
604 assert (end->op == op_End);
605 ARR_APP1 (ir_node *, end->in, ka);
609 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
610 assert (end->op == op_End);
611 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
615 free_End (ir_node *end) {
616 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
617 end->in = NULL; /* @@@ make sure we get an error if we use the in array afterwards ... */
621 > Implementing the case construct (which is where the constant Proj node is
622 > important) involves far more than simply determining the constant values.
623 > We could argue that this is more properly a function of the translator from
624 > Firm to the target machine. That could be done if there was some way of
625 > projecting "default" out of the Cond node.
626 I know it's complicated.
627 Basically there are two proglems:
628 - determining the gaps between the projs
629 - determining the biggest case constant to konw the proj number for
631 I see several solutions:
632 1. Introduce a ProjDefault node. Solves both problems.
633 This means to extend all optimizations executed during construction.
634 2. Give the Cond node for switch two flavors:
635 a) there are no gaps in the projs (existing flavor)
636 b) gaps may exist, default proj is still the Proj with the largest
637 projection number. This covers also the gaps.
638 3. Fix the semantic of the Cond to that of 2b)
640 Solution 2 seems to be the best:
641 Computing the gaps in the Firm representation is not too hard, i.e.,
642 libfirm can implement a routine that transforms betweeen the two
643 flavours. This is also possible for 1) but 2) does not require to
644 change any existing optimization.
645 Further it should be far simpler to determine the biggest constant than
647 I don't want to choose 3) as 2a) seems to have advantages for
648 dataflow analysis and 3) does not allow to convert the representation to
652 get_Cond_selector (ir_node *node) {
653 assert (node->op == op_Cond);
654 return get_irn_n(node, 0);
658 set_Cond_selector (ir_node *node, ir_node *selector) {
659 assert (node->op == op_Cond);
660 set_irn_n(node, 0, selector);
664 get_Cond_kind (ir_node *node) {
665 assert (node->op == op_Cond);
666 return node->attr.c.kind;
670 set_Cond_kind (ir_node *node, cond_kind kind) {
671 assert (node->op == op_Cond);
672 node->attr.c.kind = kind;
676 get_Return_mem (ir_node *node) {
677 assert (node->op == op_Return);
678 return get_irn_n(node, 0);
682 set_Return_mem (ir_node *node, ir_node *mem) {
683 assert (node->op == op_Return);
684 set_irn_n(node, 0, mem);
688 get_Return_res_arr (ir_node *node)
690 assert ((node->op == op_Return));
691 if (get_Return_n_res(node) > 0)
692 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
698 get_Return_n_res (ir_node *node) {
699 assert (node->op == op_Return);
700 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
705 set_Return_n_res (ir_node *node, int results) {
706 assert (node->op == op_Return);
711 get_Return_res (ir_node *node, int pos) {
712 assert (node->op == op_Return);
713 assert (get_Return_n_res(node) > pos);
714 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
718 set_Return_res (ir_node *node, int pos, ir_node *res){
719 assert (node->op == op_Return);
720 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
724 get_Raise_mem (ir_node *node) {
725 assert (node->op == op_Return);
726 return get_irn_n(node, 0);
730 set_Raise_mem (ir_node *node, ir_node *mem) {
731 assert (node->op == op_Raise);
732 set_irn_n(node, 0, mem);
736 get_Raise_exo_ptr (ir_node *node) {
737 assert (node->op == op_Raise);
738 return get_irn_n(node, 1);
742 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
743 assert (node->op == op_Raise);
744 set_irn_n(node, 1, exo_ptr);
747 inline tarval *get_Const_tarval (ir_node *node) {
748 assert (node->op == op_Const);
749 return get_irn_const_attr(node);
753 set_Const_tarval (ir_node *node, tarval *con) {
754 assert (node->op == op_Const);
755 node->attr.con = con;
759 get_SymConst_kind (ir_node *node) {
760 assert (node->op == op_SymConst);
761 return node->attr.i.num;
765 set_SymConst_kind (ir_node *node, symconst_kind num) {
766 assert (node->op == op_SymConst);
767 node->attr.i.num = num;
771 get_SymConst_type (ir_node *node) {
772 assert ( (node->op == op_SymConst)
773 && ( get_SymConst_kind(node) == type_tag
774 || get_SymConst_kind(node) == size));
775 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
779 set_SymConst_type (ir_node *node, type *type) {
780 assert ( (node->op == op_SymConst)
781 && ( get_SymConst_kind(node) == type_tag
782 || get_SymConst_kind(node) == size));
783 node->attr.i.tori.typ = type;
787 get_SymConst_ptrinfo (ir_node *node) {
788 assert ( (node->op == op_SymConst)
789 && (get_SymConst_kind(node) == linkage_ptr_info));
790 return node->attr.i.tori.ptrinfo;
794 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
795 assert ( (node->op == op_SymConst)
796 && (get_SymConst_kind(node) == linkage_ptr_info));
797 node->attr.i.tori.ptrinfo = ptrinfo;
801 get_SymConst_type_or_id (ir_node *node) {
802 assert (node->op == op_SymConst);
803 return &(node->attr.i.tori);
807 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
808 assert (node->op == op_SymConst);
809 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
813 get_Sel_mem (ir_node *node) {
814 assert (node->op == op_Sel);
815 return get_irn_n(node, 0);
819 set_Sel_mem (ir_node *node, ir_node *mem) {
820 assert (node->op == op_Sel);
821 set_irn_n(node, 0, mem);
825 get_Sel_ptr (ir_node *node) {
826 assert (node->op == op_Sel);
827 return get_irn_n(node, 1);
831 set_Sel_ptr (ir_node *node, ir_node *ptr) {
832 assert (node->op == op_Sel);
833 set_irn_n(node, 1, ptr);
837 get_Sel_index_arr (ir_node *node)
839 assert ((node->op == op_Sel));
840 if (get_Sel_n_index(node) > 0)
841 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
847 get_Sel_n_index (ir_node *node) {
848 assert (node->op == op_Sel);
849 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
854 set_Sel_n_index (ir_node *node, int n_index) {
855 assert (node->op == op_Sel);
860 get_Sel_index (ir_node *node, int pos) {
861 assert (node->op == op_Sel);
862 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
866 set_Sel_index (ir_node *node, int pos, ir_node *index) {
867 assert (node->op == op_Sel);
868 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
872 get_Sel_entity (ir_node *node) {
873 assert (node->op == op_Sel);
874 return node->attr.s.ent;
878 set_Sel_entity (ir_node *node, entity *ent) {
879 assert (node->op == op_Sel);
880 node->attr.s.ent = ent;
884 get_Sel_linkage_type (ir_node *node) {
885 assert (node->op == op_Sel);
886 return node->attr.s.ltyp;
890 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
891 assert (node->op == op_Sel);
892 node->attr.s.ltyp = lt;
896 get_Call_mem (ir_node *node) {
897 assert (node->op == op_Call);
898 return get_irn_n(node, 0);
902 set_Call_mem (ir_node *node, ir_node *mem) {
903 assert (node->op == op_Call);
904 set_irn_n(node, 0, mem);
908 get_Call_ptr (ir_node *node) {
909 assert (node->op == op_Call);
910 return get_irn_n(node, 1);
914 set_Call_ptr (ir_node *node, ir_node *ptr) {
915 assert (node->op == op_Call);
916 set_irn_n(node, 1, ptr);
920 get_Call_param_arr (ir_node *node) {
921 assert (node->op == op_Call);
922 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
926 get_Call_n_params (ir_node *node) {
927 assert (node->op == op_Call);
928 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
932 get_Call_arity (ir_node *node) {
933 assert (node->op == op_Call);
934 return get_Call_n_params(node);
938 set_Call_arity (ir_node *node, ir_node *arity) {
939 assert (node->op == op_Call);
944 get_Call_param (ir_node *node, int pos) {
945 assert (node->op == op_Call);
946 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
950 set_Call_param (ir_node *node, int pos, ir_node *param) {
951 assert (node->op == op_Call);
952 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
956 get_Call_type (ir_node *node) {
957 assert (node->op == op_Call);
958 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
962 set_Call_type (ir_node *node, type *type) {
963 assert (node->op == op_Call);
964 assert (is_method_type(type));
965 node->attr.call.cld_tp = type;
968 int get_Call_n_callees(ir_node * node) {
969 assert(node->op == op_Call && node->attr.call.callee_arr);
970 return ARR_LEN(node->attr.call.callee_arr);
973 entity * get_Call_callee(ir_node * node, int pos) {
974 assert(node->op == op_Call && node->attr.call.callee_arr);
975 return node->attr.call.callee_arr[pos];
978 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
979 assert(node->op == op_Call);
980 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
981 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
983 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
986 void remove_Call_callee_arr(ir_node * node) {
987 assert(node->op == op_Call);
988 node->attr.call.callee_arr = NULL;
991 /* For unary and binary arithmetic operations the access to the
992 operands can be factored out. Left is the first, right the
993 second arithmetic value as listed in tech report 0999-33.
994 unops are: Minus, Abs, Not, Conv
995 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
996 Shr, Shrs, Rotate, Cmp */
999 is_unop (ir_node *node) {
1000 return ( node->op == op_Minus ||
1001 node->op == op_Abs ||
1002 node->op == op_Not ||
1003 node->op == op_Conv );
1007 get_unop_op (ir_node *node) {
1008 assert ( node->op == op_Minus ||
1009 node->op == op_Abs ||
1010 node->op == op_Not ||
1011 node->op == op_Conv );
1012 switch (get_irn_opcode (node)) {
1013 case iro_Minus: return get_Minus_op(node); break;
1014 case iro_Abs: return get_Abs_op(node); break;
1015 case iro_Not: return get_Not_op(node); break;
1016 case iro_Conv: return get_Conv_op(node); break;
1017 default: return NULL;
1022 set_unop_op (ir_node *node, ir_node *op) {
1023 assert (node->op == op_Minus ||
1024 node->op == op_Abs ||
1025 node->op == op_Not ||
1026 node->op == op_Conv );
1027 switch (get_irn_opcode (node)) {
1028 case iro_Minus: set_Minus_op(node, op); break;
1029 case iro_Abs: set_Abs_op(node, op); break;
1030 case iro_Not: set_Not_op(node, op); break;
1031 case iro_Conv: set_Conv_op(node, op); break;
1038 is_binop (ir_node *node) {
1039 return (node->op == op_Add ||
1040 node->op == op_Sub ||
1041 node->op == op_Mul ||
1042 node->op == op_Quot ||
1043 node->op == op_DivMod ||
1044 node->op == op_Div ||
1045 node->op == op_Mod ||
1046 node->op == op_And ||
1047 node->op == op_Or ||
1048 node->op == op_Eor ||
1049 node->op == op_Shl ||
1050 node->op == op_Shr ||
1051 node->op == op_Shrs ||
1052 node->op == op_Rot ||
1053 node->op == op_Cmp );
1057 get_binop_left (ir_node *node) {
1058 assert (node->op == op_Add ||
1059 node->op == op_Sub ||
1060 node->op == op_Mul ||
1061 node->op == op_Quot ||
1062 node->op == op_DivMod ||
1063 node->op == op_Div ||
1064 node->op == op_Mod ||
1065 node->op == op_And ||
1066 node->op == op_Or ||
1067 node->op == op_Eor ||
1068 node->op == op_Shl ||
1069 node->op == op_Shr ||
1070 node->op == op_Shrs ||
1071 node->op == op_Rot ||
1072 node->op == op_Cmp );
1074 switch (get_irn_opcode (node)) {
1075 case iro_Add : return get_Add_left(node); break;
1076 case iro_Sub : return get_Sub_left(node); break;
1077 case iro_Mul : return get_Mul_left(node); break;
1078 case iro_Quot : return get_Quot_left(node); break;
1079 case iro_DivMod: return get_DivMod_left(node); break;
1080 case iro_Div : return get_Div_left(node); break;
1081 case iro_Mod : return get_Mod_left(node); break;
1082 case iro_And : return get_And_left(node); break;
1083 case iro_Or : return get_Or_left(node); break;
1084 case iro_Eor : return get_Eor_left(node); break;
1085 case iro_Shl : return get_Shl_left(node); break;
1086 case iro_Shr : return get_Shr_left(node); break;
1087 case iro_Shrs : return get_Shrs_left(node); break;
1088 case iro_Rot : return get_Rot_left(node); break;
1089 case iro_Cmp : return get_Cmp_left(node); break;
1090 default: return NULL;
1095 set_binop_left (ir_node *node, ir_node *left) {
1096 assert (node->op == op_Add ||
1097 node->op == op_Sub ||
1098 node->op == op_Mul ||
1099 node->op == op_Quot ||
1100 node->op == op_DivMod ||
1101 node->op == op_Div ||
1102 node->op == op_Mod ||
1103 node->op == op_And ||
1104 node->op == op_Or ||
1105 node->op == op_Eor ||
1106 node->op == op_Shl ||
1107 node->op == op_Shr ||
1108 node->op == op_Shrs ||
1109 node->op == op_Rot ||
1110 node->op == op_Cmp );
1112 switch (get_irn_opcode (node)) {
1113 case iro_Add : set_Add_left(node, left); break;
1114 case iro_Sub : set_Sub_left(node, left); break;
1115 case iro_Mul : set_Mul_left(node, left); break;
1116 case iro_Quot : set_Quot_left(node, left); break;
1117 case iro_DivMod: set_DivMod_left(node, left); break;
1118 case iro_Div : set_Div_left(node, left); break;
1119 case iro_Mod : set_Mod_left(node, left); break;
1120 case iro_And : set_And_left(node, left); break;
1121 case iro_Or : set_Or_left(node, left); break;
1122 case iro_Eor : set_Eor_left(node, left); break;
1123 case iro_Shl : set_Shl_left(node, left); break;
1124 case iro_Shr : set_Shr_left(node, left); break;
1125 case iro_Shrs : set_Shrs_left(node, left); break;
1126 case iro_Rot : set_Rot_left(node, left); break;
1127 case iro_Cmp : set_Cmp_left(node, left); break;
1133 get_binop_right (ir_node *node) {
1134 assert (node->op == op_Add ||
1135 node->op == op_Sub ||
1136 node->op == op_Mul ||
1137 node->op == op_Quot ||
1138 node->op == op_DivMod ||
1139 node->op == op_Div ||
1140 node->op == op_Mod ||
1141 node->op == op_And ||
1142 node->op == op_Or ||
1143 node->op == op_Eor ||
1144 node->op == op_Shl ||
1145 node->op == op_Shr ||
1146 node->op == op_Shrs ||
1147 node->op == op_Rot ||
1148 node->op == op_Cmp );
1150 switch (get_irn_opcode (node)) {
1151 case iro_Add : return get_Add_right(node); break;
1152 case iro_Sub : return get_Sub_right(node); break;
1153 case iro_Mul : return get_Mul_right(node); break;
1154 case iro_Quot : return get_Quot_right(node); break;
1155 case iro_DivMod: return get_DivMod_right(node); break;
1156 case iro_Div : return get_Div_right(node); break;
1157 case iro_Mod : return get_Mod_right(node); break;
1158 case iro_And : return get_And_right(node); break;
1159 case iro_Or : return get_Or_right(node); break;
1160 case iro_Eor : return get_Eor_right(node); break;
1161 case iro_Shl : return get_Shl_right(node); break;
1162 case iro_Shr : return get_Shr_right(node); break;
1163 case iro_Shrs : return get_Shrs_right(node); break;
1164 case iro_Rot : return get_Rot_right(node); break;
1165 case iro_Cmp : return get_Cmp_right(node); break;
1166 default: return NULL;
1171 set_binop_right (ir_node *node, ir_node *right) {
1172 assert (node->op == op_Add ||
1173 node->op == op_Sub ||
1174 node->op == op_Mul ||
1175 node->op == op_Quot ||
1176 node->op == op_DivMod ||
1177 node->op == op_Div ||
1178 node->op == op_Mod ||
1179 node->op == op_And ||
1180 node->op == op_Or ||
1181 node->op == op_Eor ||
1182 node->op == op_Shl ||
1183 node->op == op_Shr ||
1184 node->op == op_Shrs ||
1185 node->op == op_Rot ||
1186 node->op == op_Cmp );
1188 switch (get_irn_opcode (node)) {
1189 case iro_Add : set_Add_right(node, right); break;
1190 case iro_Sub : set_Sub_right(node, right); break;
1191 case iro_Mul : set_Mul_right(node, right); break;
1192 case iro_Quot : set_Quot_right(node, right); break;
1193 case iro_DivMod: set_DivMod_right(node, right); break;
1194 case iro_Div : set_Div_right(node, right); break;
1195 case iro_Mod : set_Mod_right(node, right); break;
1196 case iro_And : set_And_right(node, right); break;
1197 case iro_Or : set_Or_right(node, right); break;
1198 case iro_Eor : set_Eor_right(node, right); break;
1199 case iro_Shl : set_Shl_right(node, right); break;
1200 case iro_Shr : set_Shr_right(node, right); break;
1201 case iro_Shrs : set_Shrs_right(node, right); break;
1202 case iro_Rot : set_Rot_right(node, right); break;
1203 case iro_Cmp : set_Cmp_right(node, right); break;
1209 get_Add_left (ir_node *node) {
1210 assert (node->op == op_Add);
1211 return get_irn_n(node, 0);
1215 set_Add_left (ir_node *node, ir_node *left) {
1216 assert (node->op == op_Add);
1217 set_irn_n(node, 0, left);
1221 get_Add_right (ir_node *node) {
1222 assert (node->op == op_Add);
1223 return get_irn_n(node, 1);
1227 set_Add_right (ir_node *node, ir_node *right) {
1228 assert (node->op == op_Add);
1229 set_irn_n(node, 1, right);
1233 get_Sub_left (ir_node *node) {
1234 assert (node->op == op_Sub);
1235 return get_irn_n(node, 0);
1239 set_Sub_left (ir_node *node, ir_node *left) {
1240 assert (node->op == op_Sub);
1241 set_irn_n(node, 0, left);
1245 get_Sub_right (ir_node *node) {
1246 assert (node->op == op_Sub);
1247 return get_irn_n(node, 1);
1251 set_Sub_right (ir_node *node, ir_node *right) {
1252 assert (node->op == op_Sub);
1253 set_irn_n(node, 1, right);
1258 get_Minus_op (ir_node *node) {
1259 assert (node->op == op_Minus);
1260 return get_irn_n(node, 0);
1264 set_Minus_op (ir_node *node, ir_node *op) {
1265 assert (node->op == op_Minus);
1266 set_irn_n(node, 0, op);
1271 get_Mul_left (ir_node *node) {
1272 assert (node->op == op_Mul);
1273 return get_irn_n(node, 0);
1277 set_Mul_left (ir_node *node, ir_node *left) {
1278 assert (node->op == op_Mul);
1279 set_irn_n(node, 0, left);
1283 get_Mul_right (ir_node *node) {
1284 assert (node->op == op_Mul);
1285 return get_irn_n(node, 1);
1289 set_Mul_right (ir_node *node, ir_node *right) {
1290 assert (node->op == op_Mul);
1291 set_irn_n(node, 1, right);
1295 get_Quot_left (ir_node *node) {
1296 assert (node->op == op_Quot);
1297 return get_irn_n(node, 1);
1301 set_Quot_left (ir_node *node, ir_node *left) {
1302 assert (node->op == op_Quot);
1303 set_irn_n(node, 1, left);
1307 get_Quot_right (ir_node *node) {
1308 assert (node->op == op_Quot);
1309 return get_irn_n(node, 2);
1313 set_Quot_right (ir_node *node, ir_node *right) {
1314 assert (node->op == op_Quot);
1315 set_irn_n(node, 2, right);
1319 get_Quot_mem (ir_node *node) {
1320 assert (node->op == op_Quot);
1321 return get_irn_n(node, 0);
1325 set_Quot_mem (ir_node *node, ir_node *mem) {
1326 assert (node->op == op_Quot);
1327 set_irn_n(node, 0, mem);
1331 get_DivMod_left (ir_node *node) {
1332 assert (node->op == op_DivMod);
1333 return get_irn_n(node, 1);
1337 set_DivMod_left (ir_node *node, ir_node *left) {
1338 assert (node->op == op_DivMod);
1339 set_irn_n(node, 1, left);
1343 get_DivMod_right (ir_node *node) {
1344 assert (node->op == op_DivMod);
1345 return get_irn_n(node, 2);
1349 set_DivMod_right (ir_node *node, ir_node *right) {
1350 assert (node->op == op_DivMod);
1351 set_irn_n(node, 2, right);
1355 get_DivMod_mem (ir_node *node) {
1356 assert (node->op == op_DivMod);
1357 return get_irn_n(node, 0);
1361 set_DivMod_mem (ir_node *node, ir_node *mem) {
1362 assert (node->op == op_DivMod);
1363 set_irn_n(node, 0, mem);
1367 get_Div_left (ir_node *node) {
1368 assert (node->op == op_Div);
1369 return get_irn_n(node, 1);
1373 set_Div_left (ir_node *node, ir_node *left) {
1374 assert (node->op == op_Div);
1375 set_irn_n(node, 1, left);
1379 get_Div_right (ir_node *node) {
1380 assert (node->op == op_Div);
1381 return get_irn_n(node, 2);
1385 set_Div_right (ir_node *node, ir_node *right) {
1386 assert (node->op == op_Div);
1387 set_irn_n(node, 2, right);
1391 get_Div_mem (ir_node *node) {
1392 assert (node->op == op_Div);
1393 return get_irn_n(node, 0);
1397 set_Div_mem (ir_node *node, ir_node *mem) {
1398 assert (node->op == op_Div);
1399 set_irn_n(node, 0, mem);
1403 get_Mod_left (ir_node *node) {
1404 assert (node->op == op_Mod);
1405 return get_irn_n(node, 1);
1409 set_Mod_left (ir_node *node, ir_node *left) {
1410 assert (node->op == op_Mod);
1411 set_irn_n(node, 1, left);
1415 get_Mod_right (ir_node *node) {
1416 assert (node->op == op_Mod);
1417 return get_irn_n(node, 2);
1421 set_Mod_right (ir_node *node, ir_node *right) {
1422 assert (node->op == op_Mod);
1423 set_irn_n(node, 2, right);
1427 get_Mod_mem (ir_node *node) {
1428 assert (node->op == op_Mod);
1429 return get_irn_n(node, 0);
1433 set_Mod_mem (ir_node *node, ir_node *mem) {
1434 assert (node->op == op_Mod);
1435 set_irn_n(node, 0, mem);
1439 get_Abs_op (ir_node *node) {
1440 assert (node->op == op_Abs);
1441 return get_irn_n(node, 0);
1445 set_Abs_op (ir_node *node, ir_node *op) {
1446 assert (node->op == op_Abs);
1447 set_irn_n(node, 0, op);
1451 get_And_left (ir_node *node) {
1452 assert (node->op == op_And);
1453 return get_irn_n(node, 0);
1457 set_And_left (ir_node *node, ir_node *left) {
1458 assert (node->op == op_And);
1459 set_irn_n(node, 0, left);
1463 get_And_right (ir_node *node) {
1464 assert (node->op == op_And);
1465 return get_irn_n(node, 1);
1469 set_And_right (ir_node *node, ir_node *right) {
1470 assert (node->op == op_And);
1471 set_irn_n(node, 1, right);
1475 get_Or_left (ir_node *node) {
1476 assert (node->op == op_Or);
1477 return get_irn_n(node, 0);
1481 set_Or_left (ir_node *node, ir_node *left) {
1482 assert (node->op == op_Or);
1483 set_irn_n(node, 0, left);
1487 get_Or_right (ir_node *node) {
1488 assert (node->op == op_Or);
1489 return get_irn_n(node, 1);
1493 set_Or_right (ir_node *node, ir_node *right) {
1494 assert (node->op == op_Or);
1495 set_irn_n(node, 1, right);
1499 get_Eor_left (ir_node *node) {
1500 assert (node->op == op_Eor);
1501 return get_irn_n(node, 0);
1505 set_Eor_left (ir_node *node, ir_node *left) {
1506 assert (node->op == op_Eor);
1507 set_irn_n(node, 0, left);
1511 get_Eor_right (ir_node *node) {
1512 assert (node->op == op_Eor);
1513 return get_irn_n(node, 1);
1517 set_Eor_right (ir_node *node, ir_node *right) {
1518 assert (node->op == op_Eor);
1519 set_irn_n(node, 1, right);
1524 get_Not_op (ir_node *node) {
1525 assert (node->op == op_Not);
1526 return get_irn_n(node, 0);
1530 set_Not_op (ir_node *node, ir_node *op) {
1531 assert (node->op == op_Not);
1532 set_irn_n(node, 0, op);
1537 get_Shl_left (ir_node *node) {
1538 assert (node->op == op_Shl);
1539 return get_irn_n(node, 0);
1543 set_Shl_left (ir_node *node, ir_node *left) {
1544 assert (node->op == op_Shl);
1545 set_irn_n(node, 0, left);
1549 get_Shl_right (ir_node *node) {
1550 assert (node->op == op_Shl);
1551 return get_irn_n(node, 1);
1555 set_Shl_right (ir_node *node, ir_node *right) {
1556 assert (node->op == op_Shl);
1557 set_irn_n(node, 1, right);
1561 get_Shr_left (ir_node *node) {
1562 assert (node->op == op_Shr);
1563 return get_irn_n(node, 0);
1567 set_Shr_left (ir_node *node, ir_node *left) {
1568 assert (node->op == op_Shr);
1569 set_irn_n(node, 0, left);
1573 get_Shr_right (ir_node *node) {
1574 assert (node->op == op_Shr);
1575 return get_irn_n(node, 1);
1579 set_Shr_right (ir_node *node, ir_node *right) {
1580 assert (node->op == op_Shr);
1581 set_irn_n(node, 1, right);
1585 get_Shrs_left (ir_node *node) {
1586 assert (node->op == op_Shrs);
1587 return get_irn_n(node, 0);
1591 set_Shrs_left (ir_node *node, ir_node *left) {
1592 assert (node->op == op_Shrs);
1593 set_irn_n(node, 0, left);
1597 get_Shrs_right (ir_node *node) {
1598 assert (node->op == op_Shrs);
1599 return get_irn_n(node, 1);
1603 set_Shrs_right (ir_node *node, ir_node *right) {
1604 assert (node->op == op_Shrs);
1605 set_irn_n(node, 1, right);
1609 get_Rot_left (ir_node *node) {
1610 assert (node->op == op_Rot);
1611 return get_irn_n(node, 0);
1615 set_Rot_left (ir_node *node, ir_node *left) {
1616 assert (node->op == op_Rot);
1617 set_irn_n(node, 0, left);
1621 get_Rot_right (ir_node *node) {
1622 assert (node->op == op_Rot);
1623 return get_irn_n(node, 1);
1627 set_Rot_right (ir_node *node, ir_node *right) {
1628 assert (node->op == op_Rot);
1629 set_irn_n(node, 1, right);
1633 get_Cmp_left (ir_node *node) {
1634 assert (node->op == op_Cmp);
1635 return get_irn_n(node, 0);
1639 set_Cmp_left (ir_node *node, ir_node *left) {
1640 assert (node->op == op_Cmp);
1641 set_irn_n(node, 0, left);
1645 get_Cmp_right (ir_node *node) {
1646 assert (node->op == op_Cmp);
1647 return get_irn_n(node, 1);
1651 set_Cmp_right (ir_node *node, ir_node *right) {
1652 assert (node->op == op_Cmp);
1653 set_irn_n(node, 1, right);
1657 get_Conv_op (ir_node *node) {
1658 assert (node->op == op_Conv);
1659 return get_irn_n(node, 0);
1663 set_Conv_op (ir_node *node, ir_node *op) {
1664 assert (node->op == op_Conv);
1665 set_irn_n(node, 0, op);
1669 get_Phi_preds_arr (ir_node *node) {
1670 assert (node->op == op_Phi);
1671 return (ir_node **)&(get_irn_in(node)[1]);
1675 get_Phi_n_preds (ir_node *node) {
1676 assert (node->op == op_Phi);
1677 return (get_irn_arity(node));
1681 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1682 assert (node->op == op_Phi);
1687 get_Phi_pred (ir_node *node, int pos) {
1688 assert (node->op == op_Phi);
1689 return get_irn_n(node, pos);
1693 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1694 assert (node->op == op_Phi);
1695 set_irn_n(node, pos, pred);
1699 get_Load_mem (ir_node *node) {
1700 assert (node->op == op_Load);
1701 return get_irn_n(node, 0);
1705 set_Load_mem (ir_node *node, ir_node *mem) {
1706 assert (node->op == op_Load);
1707 set_irn_n(node, 0, mem);
1711 get_Load_ptr (ir_node *node) {
1712 assert (node->op == op_Load);
1713 return get_irn_n(node, 1);
1717 set_Load_ptr (ir_node *node, ir_node *ptr) {
1718 assert (node->op == op_Load);
1719 set_irn_n(node, 1, ptr);
1724 get_Store_mem (ir_node *node) {
1725 assert (node->op == op_Store);
1726 return get_irn_n(node, 0);
1730 set_Store_mem (ir_node *node, ir_node *mem) {
1731 assert (node->op == op_Store);
1732 set_irn_n(node, 0, mem);
1736 get_Store_ptr (ir_node *node) {
1737 assert (node->op == op_Store);
1738 return get_irn_n(node, 1);
1742 set_Store_ptr (ir_node *node, ir_node *ptr) {
1743 assert (node->op == op_Store);
1744 set_irn_n(node, 1, ptr);
1748 get_Store_value (ir_node *node) {
1749 assert (node->op == op_Store);
1750 return get_irn_n(node, 2);
1754 set_Store_value (ir_node *node, ir_node *value) {
1755 assert (node->op == op_Store);
1756 set_irn_n(node, 2, value);
1760 get_Alloc_mem (ir_node *node) {
1761 assert (node->op == op_Alloc);
1762 return get_irn_n(node, 0);
1766 set_Alloc_mem (ir_node *node, ir_node *mem) {
1767 assert (node->op == op_Alloc);
1768 set_irn_n(node, 0, mem);
1772 get_Alloc_size (ir_node *node) {
1773 assert (node->op == op_Alloc);
1774 return get_irn_n(node, 1);
1778 set_Alloc_size (ir_node *node, ir_node *size) {
1779 assert (node->op == op_Alloc);
1780 set_irn_n(node, 1, size);
1784 get_Alloc_type (ir_node *node) {
1785 assert (node->op == op_Alloc);
1786 return node->attr.a.type = skip_tid(node->attr.a.type);
1790 set_Alloc_type (ir_node *node, type *type) {
1791 assert (node->op == op_Alloc);
1792 node->attr.a.type = type;
1796 get_Alloc_where (ir_node *node) {
1797 assert (node->op == op_Alloc);
1798 return node->attr.a.where;
1802 set_Alloc_where (ir_node *node, where_alloc where) {
1803 assert (node->op == op_Alloc);
1804 node->attr.a.where = where;
1809 get_Free_mem (ir_node *node) {
1810 assert (node->op == op_Free);
1811 return get_irn_n(node, 0);
1815 set_Free_mem (ir_node *node, ir_node *mem) {
1816 assert (node->op == op_Free);
1817 set_irn_n(node, 0, mem);
1821 get_Free_ptr (ir_node *node) {
1822 assert (node->op == op_Free);
1823 return get_irn_n(node, 1);
1827 set_Free_ptr (ir_node *node, ir_node *ptr) {
1828 assert (node->op == op_Free);
1829 set_irn_n(node, 1, ptr);
1833 get_Free_size (ir_node *node) {
1834 assert (node->op == op_Free);
1835 return get_irn_n(node, 2);
1839 set_Free_size (ir_node *node, ir_node *size) {
1840 assert (node->op == op_Free);
1841 set_irn_n(node, 2, size);
1845 get_Free_type (ir_node *node) {
1846 assert (node->op == op_Free);
1847 return node->attr.f = skip_tid(node->attr.f);
1851 set_Free_type (ir_node *node, type *type) {
1852 assert (node->op == op_Free);
1853 node->attr.f = type;
1857 get_Sync_preds_arr (ir_node *node) {
1858 assert (node->op == op_Sync);
1859 return (ir_node **)&(get_irn_in(node)[1]);
1863 get_Sync_n_preds (ir_node *node) {
1864 assert (node->op == op_Sync);
1865 return (get_irn_arity(node));
1870 set_Sync_n_preds (ir_node *node, int n_preds) {
1871 assert (node->op == op_Sync);
1876 get_Sync_pred (ir_node *node, int pos) {
1877 assert (node->op == op_Sync);
1878 return get_irn_n(node, pos);
1882 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1883 assert (node->op == op_Sync);
1884 set_irn_n(node, pos, pred);
1888 get_Proj_pred (ir_node *node) {
1889 assert (is_Proj(node));
1890 return get_irn_n(node, 0);
1894 set_Proj_pred (ir_node *node, ir_node *pred) {
1895 assert (is_Proj(node));
1896 set_irn_n(node, 0, pred);
1900 get_Proj_proj (ir_node *node) {
1901 assert (is_Proj(node));
1902 if (get_irn_opcode(node) == iro_Proj) {
1903 return node->attr.proj;
1905 assert(get_irn_opcode(node) == iro_Filter);
1906 return node->attr.filter.proj;
1911 set_Proj_proj (ir_node *node, long proj) {
1912 assert (node->op == op_Proj);
1913 node->attr.proj = proj;
1917 get_Tuple_preds_arr (ir_node *node) {
1918 assert (node->op == op_Tuple);
1919 return (ir_node **)&(get_irn_in(node)[1]);
1923 get_Tuple_n_preds (ir_node *node) {
1924 assert (node->op == op_Tuple);
1925 return (get_irn_arity(node));
1930 set_Tuple_n_preds (ir_node *node, int n_preds) {
1931 assert (node->op == op_Tuple);
1936 get_Tuple_pred (ir_node *node, int pos) {
1937 assert (node->op == op_Tuple);
1938 return get_irn_n(node, pos);
1942 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1943 assert (node->op == op_Tuple);
1944 set_irn_n(node, pos, pred);
1948 get_Id_pred (ir_node *node) {
1949 assert (node->op == op_Id);
1950 return get_irn_n(node, 0);
1954 set_Id_pred (ir_node *node, ir_node *pred) {
1955 assert (node->op == op_Id);
1956 set_irn_n(node, 0, pred);
1961 get_Filter_pred(ir_node *node) {
1962 assert(node->op == op_Filter);
1967 get_Filter_proj(ir_node *node) {
1968 assert(node->op == op_Filter);
1969 return node->attr.filter.proj;
1972 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
1973 assert(node->op == op_Filter);
1974 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
1975 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
1976 node->attr.filter.in_cg[0] = node->in[0];
1978 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
1981 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
1982 assert(node->op == op_Filter && node->attr.filter.in_cg && 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
1983 node->attr.filter.in_cg[pos + 1] = pred;
1988 get_irn_irg(ir_node *node) {
1989 if (get_irn_op(node) == op_CallBegin) {
1990 return node->attr.callbegin.irg;
1991 } else if (get_irn_op(node) == op_EndReg || get_irn_op(node) == op_EndExcept) {
1992 return node->attr.end.irg;
1994 assert(0 && "no irg attr");
1999 /******************************************************************/
2000 /* Auxiliary routines */
2001 /******************************************************************/
2004 skip_Proj (ir_node *node) {
2005 /* don't assert node !!! */
2006 if (node && is_Proj(node)) {
2007 return get_Proj_pred(node);
2014 skip_Tuple (ir_node *node) {
2017 node = skip_nop(node);
2018 if (get_irn_op(node) == op_Proj) {
2019 pred = skip_nop(get_Proj_pred(node));
2020 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2021 pred = skip_nop(skip_Tuple(pred));
2022 if (get_irn_op(pred) == op_Tuple)
2023 return get_Tuple_pred(pred, get_Proj_proj(node));
2029 skip_nop (ir_node *node) {
2030 /* don't assert node !!! */
2032 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
2033 /* Don't use get_Id_pred: We get into an endless loop for
2034 self-referencing Ids. */
2035 assert (get_irn_arity (node) > 0);
2036 return node->in[0+1];
2043 skip_Id (ir_node *node) {
2044 return skip_nop(node);
2048 is_Bad (ir_node *node) {
2050 if ((node) && get_irn_opcode(node) == iro_Bad)
2056 is_no_Block (ir_node *node) {
2058 return (get_irn_opcode(node) != iro_Block);
2062 is_Proj (ir_node *node) {
2064 return node->op == op_Proj
2065 || (!interprocedural_view && node->op == op_Filter);
2068 /* Returns true if the operation manipulates control flow. */
2070 is_cfop(ir_node *node) {
2071 return is_cfopcode(get_irn_op(node));
2074 /* Returns true if the operation can change the control flow because
2077 is_fragile_op(ir_node *node) {
2078 return ( (get_irn_opcode(node) == iro_Call)
2079 || (get_irn_opcode(node) == iro_Quot)
2080 || (get_irn_opcode(node) == iro_DivMod)
2081 || (get_irn_opcode(node) == iro_Div)
2082 || (get_irn_opcode(node) == iro_Mod)
2083 || (get_irn_opcode(node) == iro_Load)
2084 || (get_irn_opcode(node) == iro_Store)
2085 || (get_irn_opcode(node) == iro_Alloc)
2086 || (get_irn_opcode(node) == iro_Bad)
2087 || (get_irn_opcode(node) == iro_Unknown));
2091 /* Returns the memory operand of fragile operations. */
2092 ir_node *get_fragile_op_mem(ir_node *node) {
2093 assert(node && is_fragile_op(node));
2095 switch (get_irn_opcode (node)) {
2104 return get_irn_n(node, 0);
2109 assert(0 && "not reached");