1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
4 * Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
17 #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 const char *pns_name_arr [] = {
83 "initial_exec", "global_store",
84 "frame_base", "globals", "args"
87 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 /** getting some parameters from ir_nodes **/
142 is_ir_node (void *thing) {
144 if (get_kind(thing) == k_ir_node)
150 /* returns the number of predecessors without the block predecessor. */
152 get_irn_arity (const ir_node *node) {
154 if (interprocedural_view) { /* handle Filter and Block specially */
155 if (get_irn_opcode(node) == iro_Filter) {
156 assert(node->attr.filter.in_cg);
157 return ARR_LEN(node->attr.filter.in_cg) - 1;
158 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
159 return ARR_LEN(node->attr.block.in_cg) - 1;
161 /* else fall through */
163 return ARR_LEN(node->in) - 1;
166 /* Returns the array with ins. This array is shifted with respect to the
167 array accessed by get_irn_n: The block operand is at position 0 not -1.
168 (@@@ This should be changed.)
169 The order of the predecessors in this array is not guaranteed, except that
170 lists of operands as predecessors of Block or arguments of a Call are
173 get_irn_in (const ir_node *node) {
175 if (interprocedural_view) { /* handle Filter and Block specially */
176 if (get_irn_opcode(node) == iro_Filter) {
177 assert(node->attr.filter.in_cg);
178 return node->attr.filter.in_cg;
179 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
180 return node->attr.block.in_cg;
182 /* else fall through */
188 set_irn_in (ir_node *node, int arity, ir_node **in) {
191 if (interprocedural_view) { /* handle Filter and Block specially */
192 if (get_irn_opcode(node) == iro_Filter) {
193 assert(node->attr.filter.in_cg);
194 arr = &node->attr.filter.in_cg;
195 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
196 arr = &node->attr.block.in_cg;
203 if (arity != ARR_LEN(*arr) - 1) {
204 ir_node * block = (*arr)[0];
205 *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
208 fix_backedges(current_ir_graph->obst, node);
209 memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
212 /* to iterate through the predecessors without touching the array */
213 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
214 to iterate includind the Block predecessor iterate from i = -1 to
216 If it is a block, the entry -1 is NULL. */
218 get_irn_n (ir_node *node, int n) {
220 if (-1 > n || get_irn_arity(node) <= n) {
221 printf("pos: %d, arity: %d ", n, get_irn_arity(node));
224 assert(node); assert(-1 <= n && n < get_irn_arity(node));
225 if (interprocedural_view) { /* handle Filter and Block specially */
226 if (get_irn_opcode(node) == iro_Filter) {
227 assert(node->attr.filter.in_cg);
228 return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
229 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
230 return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
232 /* else fall through */
234 return (node->in[n + 1] = skip_nop(node->in[n + 1]));
238 set_irn_n (ir_node *node, int n, ir_node *in) {
239 assert(node && -1 <= n && n < get_irn_arity(node));
240 if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
241 /* Change block pred in both views! */
242 node->in[n + 1] = in;
243 assert(node->attr.filter.in_cg);
244 node->attr.filter.in_cg[n + 1] = in;
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 node->attr.filter.in_cg[n + 1] = in;
252 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
253 node->attr.block.in_cg[n + 1] = in;
256 /* else fall through */
258 node->in[n + 1] = in;
262 get_irn_mode (const ir_node *node)
269 set_irn_mode (ir_node *node, ir_mode *mode)
277 get_irn_modecode (const ir_node *node)
280 return node->mode->code;
285 get_irn_modeident (const ir_node *node)
288 return get_mode_ident(node->mode);
292 get_irn_op (const ir_node *node)
298 /* should be private to the library: */
300 set_irn_op (ir_node *node, ir_op *op)
307 get_irn_opcode (const ir_node *node)
310 assert (k_ir_node == get_kind(node));
312 return node->op->code;
316 get_irn_opname (const ir_node *node)
319 return get_id_str(node->op->name);
323 get_irn_opident (const ir_node *node)
326 return node->op->name;
330 get_irn_visited (const ir_node *node)
333 return node->visited;
337 set_irn_visited (ir_node *node, unsigned long visited)
340 node->visited = visited;
344 mark_irn_visited (ir_node *node) {
346 node->visited = current_ir_graph->visited;
350 irn_not_visited (const ir_node *node) {
352 return (node->visited < current_ir_graph->visited);
356 irn_visited (const ir_node *node) {
358 return (node->visited >= current_ir_graph->visited);
362 set_irn_link (ir_node *node, void *link) {
364 /* Link field is used for Phi construction and various optimizations
366 assert(get_irg_phase_state(current_ir_graph) != phase_building);
372 get_irn_link (const ir_node *node) {
377 /* Outputs a unique number for this node */
379 get_irn_node_nr(const ir_node *node) {
382 return node->node_nr;
389 get_irn_const_attr (ir_node *node)
391 assert (node->op == op_Const);
392 return node->attr.con;
396 get_irn_proj_attr (ir_node *node)
398 assert (node->op == op_Proj);
399 return node->attr.proj;
403 get_irn_alloc_attr (ir_node *node)
405 assert (node->op == op_Alloc);
410 get_irn_free_attr (ir_node *node)
412 assert (node->op == op_Free);
413 return node->attr.f = skip_tid(node->attr.f);
417 get_irn_symconst_attr (ir_node *node)
419 assert (node->op == op_SymConst);
424 get_irn_call_attr (ir_node *node)
426 assert (node->op == op_Call);
427 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
431 get_irn_sel_attr (ir_node *node)
433 assert (node->op == op_Sel);
438 get_irn_phi_attr (ir_node *node)
440 assert (node->op == op_Phi);
441 return node->attr.phi0_pos;
445 get_irn_block_attr (ir_node *node)
447 assert (node->op == op_Block);
448 return node->attr.block;
451 /** manipulate fields of individual nodes **/
453 /* this works for all except Block */
455 get_nodes_Block (ir_node *node) {
456 assert (!(node->op == op_Block));
457 return get_irn_n(node, -1);
461 set_nodes_Block (ir_node *node, ir_node *block) {
462 assert (!(node->op == op_Block));
463 set_irn_n(node, -1, block);
466 /* Returns an array with the predecessors of the Block. Depending on
467 the implementation of the graph datastructure this can be a copy of
468 the internal representation of predecessors as well as the internal
469 array itself. Therefore writing to this array might obstruct the ir. */
471 get_Block_cfgpred_arr (ir_node *node)
473 assert ((node->op == op_Block));
474 return (ir_node **)&(get_irn_in(node)[1]);
479 get_Block_n_cfgpreds (ir_node *node) {
480 assert ((node->op == op_Block));
481 return (get_irn_arity(node));
485 get_Block_cfgpred (ir_node *node, int pos) {
486 assert (node->op == op_Block);
488 if (-1 > pos || get_irn_arity(node) <= pos) {
489 dump_ir_block_graph(current_ir_graph);
490 printf("pos: %d, arity: %d ", pos, get_irn_arity(node));
493 assert(node); assert(-1 <= pos && pos < get_irn_arity(node));
494 return get_irn_n(node, pos);
498 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
499 assert (node->op == op_Block);
500 set_irn_n(node, pos, pred);
504 get_Block_matured (ir_node *node) {
505 assert (node->op == op_Block);
506 return node->attr.block.matured;
510 set_Block_matured (ir_node *node, bool matured) {
511 assert (node->op == op_Block);
512 node->attr.block.matured = matured;
515 get_Block_block_visited (ir_node *node) {
516 assert (node->op == op_Block);
517 return node->attr.block.block_visited;
521 set_Block_block_visited (ir_node *node, unsigned long visit) {
522 assert (node->op == op_Block);
523 node->attr.block.block_visited = visit;
526 /* For this current_ir_graph must be set. */
528 mark_Block_block_visited (ir_node *node) {
529 assert (node->op == op_Block);
530 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
534 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 /* handler handling for Blocks */
553 set_Block_handler (ir_node *block, ir_node *handler) {
554 assert ((block->op == op_Block));
555 assert ((handler->op == op_Block));
556 block->attr.block.handler_entry = handler;
560 get_Block_handler (ir_node *block) {
561 assert ((block->op == op_Block));
562 return (block->attr.block.handler_entry);
565 /* handler handling for Nodes */
567 set_Node_handler (ir_node *node, ir_node *handler) {
568 set_Block_handler (get_nodes_Block (node), handler);
572 get_Node_handler (ir_node *node) {
573 return (get_Block_handler (get_nodes_Block (node)));
576 /* exc_t handling for Blocks */
577 void set_Block_exc (ir_node *block, exc_t exc) {
578 assert ((block->op == op_Block));
579 block->attr.block.exc = exc;
582 exc_t get_Block_exc (ir_node *block) {
583 assert ((block->op == op_Block));
585 return (block->attr.block.exc);
588 /* exc_t handling for Nodes */
589 void set_Node_exc (ir_node *node, exc_t exc) {
590 set_Block_exc (get_nodes_Block (node), exc);
593 exc_t get_Node_exc (ir_node *node) {
594 return (get_Block_exc (get_nodes_Block (node)));
597 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
598 assert(node->op == op_Block);
599 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
600 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
601 node->attr.block.in_cg[0] = NULL;
602 node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
604 /* Fix backedge array. fix_backedges operates depending on
605 interprocedural_view. */
606 bool ipv = interprocedural_view;
607 interprocedural_view = true;
608 fix_backedges(current_ir_graph->obst, node);
609 interprocedural_view = ipv;
612 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
615 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
616 assert(node->op == op_Block &&
617 node->attr.block.in_cg &&
618 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
619 node->attr.block.in_cg[pos + 1] = pred;
622 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
623 assert(node->op == op_Block);
624 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
627 int get_Block_cg_n_cfgpreds(ir_node * node) {
628 assert(node->op == op_Block);
629 return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
632 ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
633 assert(node->op == op_Block && node->attr.block.in_cg);
634 return node->attr.block.in_cg[pos + 1];
637 void remove_Block_cg_cfgpred_arr(ir_node * node) {
638 assert(node->op == op_Block);
639 node->attr.block.in_cg = NULL;
642 /* Start references the irg it is in. */
644 get_Start_irg(ir_node *node) {
645 assert(node->op == op_Start);
646 return node->attr.start.irg;
650 set_Start_irg(ir_node *node, ir_graph *irg) {
651 assert(node->op == op_Start);
652 assert(is_ir_graph(irg));
653 node->attr.start.irg = irg;
657 get_End_n_keepalives(ir_node *end) {
658 assert (end->op == op_End);
659 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
663 get_End_keepalive(ir_node *end, int pos) {
664 assert (end->op == op_End);
665 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
669 add_End_keepalive (ir_node *end, ir_node *ka) {
670 assert (end->op == op_End);
671 ARR_APP1 (ir_node *, end->in, ka);
675 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
676 assert (end->op == op_End);
677 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
681 free_End (ir_node *end) {
682 assert (end->op == op_End);
683 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
684 end->in = NULL; /* @@@ make sure we get an error if we use the
685 in array afterwards ... */
688 ir_graph *get_EndReg_irg (const ir_node *end) {
689 assert (end->op == op_EndReg);
690 return end->attr.end.irg;
693 ir_graph *get_EndExcept_irg (const ir_node *end) {
694 assert (end->op == op_EndReg);
695 return end->attr.end.irg;
699 > Implementing the case construct (which is where the constant Proj node is
700 > important) involves far more than simply determining the constant values.
701 > We could argue that this is more properly a function of the translator from
702 > Firm to the target machine. That could be done if there was some way of
703 > projecting "default" out of the Cond node.
704 I know it's complicated.
705 Basically there are two proglems:
706 - determining the gaps between the projs
707 - determining the biggest case constant to konw the proj number for
709 I see several solutions:
710 1. Introduce a ProjDefault node. Solves both problems.
711 This means to extend all optimizations executed during construction.
712 2. Give the Cond node for switch two flavors:
713 a) there are no gaps in the projs (existing flavor)
714 b) gaps may exist, default proj is still the Proj with the largest
715 projection number. This covers also the gaps.
716 3. Fix the semantic of the Cond to that of 2b)
718 Solution 2 seems to be the best:
719 Computing the gaps in the Firm representation is not too hard, i.e.,
720 libfirm can implement a routine that transforms betweeen the two
721 flavours. This is also possible for 1) but 2) does not require to
722 change any existing optimization.
723 Further it should be far simpler to determine the biggest constant than
725 I don't want to choose 3) as 2a) seems to have advantages for
726 dataflow analysis and 3) does not allow to convert the representation to
730 get_Cond_selector (ir_node *node) {
731 assert (node->op == op_Cond);
732 return get_irn_n(node, 0);
736 set_Cond_selector (ir_node *node, ir_node *selector) {
737 assert (node->op == op_Cond);
738 set_irn_n(node, 0, selector);
742 get_Cond_kind (ir_node *node) {
743 assert (node->op == op_Cond);
744 return node->attr.c.kind;
748 set_Cond_kind (ir_node *node, cond_kind kind) {
749 assert (node->op == op_Cond);
750 node->attr.c.kind = kind;
754 get_Return_mem (ir_node *node) {
755 assert (node->op == op_Return);
756 return get_irn_n(node, 0);
760 set_Return_mem (ir_node *node, ir_node *mem) {
761 assert (node->op == op_Return);
762 set_irn_n(node, 0, mem);
766 get_Return_n_ress (ir_node *node) {
767 assert (node->op == op_Return);
768 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
772 get_Return_res_arr (ir_node *node)
774 assert ((node->op == op_Return));
775 if (get_Return_n_ress(node) > 0)
776 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
783 set_Return_n_res (ir_node *node, int results) {
784 assert (node->op == op_Return);
789 get_Return_res (ir_node *node, int pos) {
790 assert (node->op == op_Return);
791 assert (get_Return_n_ress(node) > pos);
792 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
796 set_Return_res (ir_node *node, int pos, ir_node *res){
797 assert (node->op == op_Return);
798 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
802 get_Raise_mem (ir_node *node) {
803 assert (node->op == op_Raise);
804 return get_irn_n(node, 0);
808 set_Raise_mem (ir_node *node, ir_node *mem) {
809 assert (node->op == op_Raise);
810 set_irn_n(node, 0, mem);
814 get_Raise_exo_ptr (ir_node *node) {
815 assert (node->op == op_Raise);
816 return get_irn_n(node, 1);
820 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
821 assert (node->op == op_Raise);
822 set_irn_n(node, 1, exo_ptr);
825 INLINE tarval *get_Const_tarval (ir_node *node) {
826 assert (node->op == op_Const);
827 return get_irn_const_attr(node);
831 set_Const_tarval (ir_node *node, tarval *con) {
832 assert (node->op == op_Const);
833 node->attr.con = con;
837 get_SymConst_kind (const ir_node *node) {
838 assert (node->op == op_SymConst);
839 return node->attr.i.num;
843 set_SymConst_kind (ir_node *node, symconst_kind num) {
844 assert (node->op == op_SymConst);
845 node->attr.i.num = num;
849 get_SymConst_type (ir_node *node) {
850 assert ( (node->op == op_SymConst)
851 && ( get_SymConst_kind(node) == type_tag
852 || get_SymConst_kind(node) == size));
853 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
857 set_SymConst_type (ir_node *node, type *tp) {
858 assert ( (node->op == op_SymConst)
859 && ( get_SymConst_kind(node) == type_tag
860 || get_SymConst_kind(node) == size));
861 node->attr.i.tori.typ = tp;
865 get_SymConst_ptrinfo (ir_node *node) {
866 assert ( (node->op == op_SymConst)
867 && (get_SymConst_kind(node) == linkage_ptr_info));
868 return node->attr.i.tori.ptrinfo;
872 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
873 assert ( (node->op == op_SymConst)
874 && (get_SymConst_kind(node) == linkage_ptr_info));
875 node->attr.i.tori.ptrinfo = ptrinfo;
879 get_SymConst_type_or_id (ir_node *node) {
880 assert (node->op == op_SymConst);
881 return &(node->attr.i.tori);
885 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
886 assert (node->op == op_SymConst);
887 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
891 get_Sel_mem (ir_node *node) {
892 assert (node->op == op_Sel);
893 return get_irn_n(node, 0);
897 set_Sel_mem (ir_node *node, ir_node *mem) {
898 assert (node->op == op_Sel);
899 set_irn_n(node, 0, mem);
903 get_Sel_ptr (ir_node *node) {
904 assert (node->op == op_Sel);
905 return get_irn_n(node, 1);
909 set_Sel_ptr (ir_node *node, ir_node *ptr) {
910 assert (node->op == op_Sel);
911 set_irn_n(node, 1, ptr);
915 get_Sel_n_indexs (ir_node *node) {
916 assert (node->op == op_Sel);
917 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
921 get_Sel_index_arr (ir_node *node)
923 assert ((node->op == op_Sel));
924 if (get_Sel_n_indexs(node) > 0)
925 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
931 get_Sel_index (ir_node *node, int pos) {
932 assert (node->op == op_Sel);
933 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
937 set_Sel_index (ir_node *node, int pos, ir_node *index) {
938 assert (node->op == op_Sel);
939 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
943 get_Sel_entity (ir_node *node) {
944 assert (node->op == op_Sel);
945 return node->attr.s.ent;
949 set_Sel_entity (ir_node *node, entity *ent) {
950 assert (node->op == op_Sel);
951 node->attr.s.ent = ent;
955 get_InstOf_ent (ir_node *node) {
956 assert (node->op = op_InstOf);
957 return (node->attr.io.ent);
961 set_InstOf_ent (ir_node *node, type *ent) {
962 assert (node->op = op_InstOf);
963 node->attr.io.ent = ent;
967 get_InstOf_store (ir_node *node) {
968 assert (node->op = op_InstOf);
969 return (get_irn_n (node, 0));
973 set_InstOf_store (ir_node *node, ir_node *obj) {
974 assert (node->op = op_InstOf);
975 set_irn_n (node, 0, obj);
979 get_InstOf_obj (ir_node *node) {
980 assert (node->op = op_InstOf);
981 return (get_irn_n (node, 1));
985 set_InstOf_obj (ir_node *node, ir_node *obj) {
986 assert (node->op = op_InstOf);
987 set_irn_n (node, 1, obj);
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, Cast
995 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
996 Shr, Shrs, Rotate, Cmp */
1000 get_Call_mem (ir_node *node) {
1001 assert (node->op == op_Call);
1002 return get_irn_n(node, 0);
1006 set_Call_mem (ir_node *node, ir_node *mem) {
1007 assert (node->op == op_Call);
1008 set_irn_n(node, 0, mem);
1012 get_Call_ptr (ir_node *node) {
1013 assert (node->op == op_Call);
1014 return get_irn_n(node, 1);
1018 set_Call_ptr (ir_node *node, ir_node *ptr) {
1019 assert (node->op == op_Call);
1020 set_irn_n(node, 1, ptr);
1024 get_Call_param_arr (ir_node *node) {
1025 assert (node->op == op_Call);
1026 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1030 get_Call_n_params (ir_node *node) {
1031 assert (node->op == op_Call);
1032 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1036 get_Call_arity (ir_node *node) {
1037 assert (node->op == op_Call);
1038 return get_Call_n_params(node);
1042 set_Call_arity (ir_node *node, ir_node *arity) {
1043 assert (node->op == op_Call);
1048 get_Call_param (ir_node *node, int pos) {
1049 assert (node->op == op_Call);
1050 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1054 set_Call_param (ir_node *node, int pos, ir_node *param) {
1055 assert (node->op == op_Call);
1056 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1060 get_Call_type (ir_node *node) {
1061 assert (node->op == op_Call);
1062 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1066 set_Call_type (ir_node *node, type *tp) {
1067 assert (node->op == op_Call);
1068 assert (is_method_type(tp));
1069 node->attr.call.cld_tp = tp;
1072 int get_Call_n_callees(ir_node * node) {
1073 assert(node->op == op_Call && node->attr.call.callee_arr);
1074 return ARR_LEN(node->attr.call.callee_arr);
1077 entity * get_Call_callee(ir_node * node, int pos) {
1078 assert(node->op == op_Call && node->attr.call.callee_arr);
1079 return node->attr.call.callee_arr[pos];
1082 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1083 assert(node->op == op_Call);
1084 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1085 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1087 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1090 void remove_Call_callee_arr(ir_node * node) {
1091 assert(node->op == op_Call);
1092 node->attr.call.callee_arr = NULL;
1095 ir_node * get_CallBegin_ptr (ir_node *node) {
1096 assert(node->op == op_CallBegin);
1097 return get_irn_n(node, 0);
1099 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1100 assert(node->op == op_CallBegin);
1101 set_irn_n(node, 0, ptr);
1103 ir_graph * get_CallBegin_irg (ir_node *node) {
1104 assert(node->op == op_CallBegin);
1105 return node->attr.callbegin.irg;
1107 ir_node * get_CallBegin_call (ir_node *node) {
1108 assert(node->op == op_CallBegin);
1109 return node->attr.callbegin.call;
1111 void set_CallBegin_call (ir_node *node, ir_node *call) {
1112 assert(node->op == op_CallBegin);
1113 node->attr.callbegin.call = call;
1117 get_Add_left (ir_node *node) {
1118 assert (node->op == op_Add);
1119 return get_irn_n(node, 0);
1123 set_Add_left (ir_node *node, ir_node *left) {
1124 assert (node->op == op_Add);
1125 set_irn_n(node, 0, left);
1129 get_Add_right (ir_node *node) {
1130 assert (node->op == op_Add);
1131 return get_irn_n(node, 1);
1135 set_Add_right (ir_node *node, ir_node *right) {
1136 assert (node->op == op_Add);
1137 set_irn_n(node, 1, right);
1141 get_Sub_left (ir_node *node) {
1142 assert (node->op == op_Sub);
1143 return get_irn_n(node, 0);
1147 set_Sub_left (ir_node *node, ir_node *left) {
1148 assert (node->op == op_Sub);
1149 set_irn_n(node, 0, left);
1153 get_Sub_right (ir_node *node) {
1154 assert (node->op == op_Sub);
1155 return get_irn_n(node, 1);
1159 set_Sub_right (ir_node *node, ir_node *right) {
1160 assert (node->op == op_Sub);
1161 set_irn_n(node, 1, right);
1166 get_Minus_op (ir_node *node) {
1167 assert (node->op == op_Minus);
1168 return get_irn_n(node, 0);
1172 set_Minus_op (ir_node *node, ir_node *op) {
1173 assert (node->op == op_Minus);
1174 set_irn_n(node, 0, op);
1179 get_Mul_left (ir_node *node) {
1180 assert (node->op == op_Mul);
1181 return get_irn_n(node, 0);
1185 set_Mul_left (ir_node *node, ir_node *left) {
1186 assert (node->op == op_Mul);
1187 set_irn_n(node, 0, left);
1191 get_Mul_right (ir_node *node) {
1192 assert (node->op == op_Mul);
1193 return get_irn_n(node, 1);
1197 set_Mul_right (ir_node *node, ir_node *right) {
1198 assert (node->op == op_Mul);
1199 set_irn_n(node, 1, right);
1203 get_Quot_left (ir_node *node) {
1204 assert (node->op == op_Quot);
1205 return get_irn_n(node, 1);
1209 set_Quot_left (ir_node *node, ir_node *left) {
1210 assert (node->op == op_Quot);
1211 set_irn_n(node, 1, left);
1215 get_Quot_right (ir_node *node) {
1216 assert (node->op == op_Quot);
1217 return get_irn_n(node, 2);
1221 set_Quot_right (ir_node *node, ir_node *right) {
1222 assert (node->op == op_Quot);
1223 set_irn_n(node, 2, right);
1227 get_Quot_mem (ir_node *node) {
1228 assert (node->op == op_Quot);
1229 return get_irn_n(node, 0);
1233 set_Quot_mem (ir_node *node, ir_node *mem) {
1234 assert (node->op == op_Quot);
1235 set_irn_n(node, 0, mem);
1239 get_DivMod_left (ir_node *node) {
1240 assert (node->op == op_DivMod);
1241 return get_irn_n(node, 1);
1245 set_DivMod_left (ir_node *node, ir_node *left) {
1246 assert (node->op == op_DivMod);
1247 set_irn_n(node, 1, left);
1251 get_DivMod_right (ir_node *node) {
1252 assert (node->op == op_DivMod);
1253 return get_irn_n(node, 2);
1257 set_DivMod_right (ir_node *node, ir_node *right) {
1258 assert (node->op == op_DivMod);
1259 set_irn_n(node, 2, right);
1263 get_DivMod_mem (ir_node *node) {
1264 assert (node->op == op_DivMod);
1265 return get_irn_n(node, 0);
1269 set_DivMod_mem (ir_node *node, ir_node *mem) {
1270 assert (node->op == op_DivMod);
1271 set_irn_n(node, 0, mem);
1275 get_Div_left (ir_node *node) {
1276 assert (node->op == op_Div);
1277 return get_irn_n(node, 1);
1281 set_Div_left (ir_node *node, ir_node *left) {
1282 assert (node->op == op_Div);
1283 set_irn_n(node, 1, left);
1287 get_Div_right (ir_node *node) {
1288 assert (node->op == op_Div);
1289 return get_irn_n(node, 2);
1293 set_Div_right (ir_node *node, ir_node *right) {
1294 assert (node->op == op_Div);
1295 set_irn_n(node, 2, right);
1299 get_Div_mem (ir_node *node) {
1300 assert (node->op == op_Div);
1301 return get_irn_n(node, 0);
1305 set_Div_mem (ir_node *node, ir_node *mem) {
1306 assert (node->op == op_Div);
1307 set_irn_n(node, 0, mem);
1311 get_Mod_left (ir_node *node) {
1312 assert (node->op == op_Mod);
1313 return get_irn_n(node, 1);
1317 set_Mod_left (ir_node *node, ir_node *left) {
1318 assert (node->op == op_Mod);
1319 set_irn_n(node, 1, left);
1323 get_Mod_right (ir_node *node) {
1324 assert (node->op == op_Mod);
1325 return get_irn_n(node, 2);
1329 set_Mod_right (ir_node *node, ir_node *right) {
1330 assert (node->op == op_Mod);
1331 set_irn_n(node, 2, right);
1335 get_Mod_mem (ir_node *node) {
1336 assert (node->op == op_Mod);
1337 return get_irn_n(node, 0);
1341 set_Mod_mem (ir_node *node, ir_node *mem) {
1342 assert (node->op == op_Mod);
1343 set_irn_n(node, 0, mem);
1347 get_Abs_op (ir_node *node) {
1348 assert (node->op == op_Abs);
1349 return get_irn_n(node, 0);
1353 set_Abs_op (ir_node *node, ir_node *op) {
1354 assert (node->op == op_Abs);
1355 set_irn_n(node, 0, op);
1359 get_And_left (ir_node *node) {
1360 assert (node->op == op_And);
1361 return get_irn_n(node, 0);
1365 set_And_left (ir_node *node, ir_node *left) {
1366 assert (node->op == op_And);
1367 set_irn_n(node, 0, left);
1371 get_And_right (ir_node *node) {
1372 assert (node->op == op_And);
1373 return get_irn_n(node, 1);
1377 set_And_right (ir_node *node, ir_node *right) {
1378 assert (node->op == op_And);
1379 set_irn_n(node, 1, right);
1383 get_Or_left (ir_node *node) {
1384 assert (node->op == op_Or);
1385 return get_irn_n(node, 0);
1389 set_Or_left (ir_node *node, ir_node *left) {
1390 assert (node->op == op_Or);
1391 set_irn_n(node, 0, left);
1395 get_Or_right (ir_node *node) {
1396 assert (node->op == op_Or);
1397 return get_irn_n(node, 1);
1401 set_Or_right (ir_node *node, ir_node *right) {
1402 assert (node->op == op_Or);
1403 set_irn_n(node, 1, right);
1407 get_Eor_left (ir_node *node) {
1408 assert (node->op == op_Eor);
1409 return get_irn_n(node, 0);
1413 set_Eor_left (ir_node *node, ir_node *left) {
1414 assert (node->op == op_Eor);
1415 set_irn_n(node, 0, left);
1419 get_Eor_right (ir_node *node) {
1420 assert (node->op == op_Eor);
1421 return get_irn_n(node, 1);
1425 set_Eor_right (ir_node *node, ir_node *right) {
1426 assert (node->op == op_Eor);
1427 set_irn_n(node, 1, right);
1432 get_Not_op (ir_node *node) {
1433 assert (node->op == op_Not);
1434 return get_irn_n(node, 0);
1438 set_Not_op (ir_node *node, ir_node *op) {
1439 assert (node->op == op_Not);
1440 set_irn_n(node, 0, op);
1445 get_Shl_left (ir_node *node) {
1446 assert (node->op == op_Shl);
1447 return get_irn_n(node, 0);
1451 set_Shl_left (ir_node *node, ir_node *left) {
1452 assert (node->op == op_Shl);
1453 set_irn_n(node, 0, left);
1457 get_Shl_right (ir_node *node) {
1458 assert (node->op == op_Shl);
1459 return get_irn_n(node, 1);
1463 set_Shl_right (ir_node *node, ir_node *right) {
1464 assert (node->op == op_Shl);
1465 set_irn_n(node, 1, right);
1469 get_Shr_left (ir_node *node) {
1470 assert (node->op == op_Shr);
1471 return get_irn_n(node, 0);
1475 set_Shr_left (ir_node *node, ir_node *left) {
1476 assert (node->op == op_Shr);
1477 set_irn_n(node, 0, left);
1481 get_Shr_right (ir_node *node) {
1482 assert (node->op == op_Shr);
1483 return get_irn_n(node, 1);
1487 set_Shr_right (ir_node *node, ir_node *right) {
1488 assert (node->op == op_Shr);
1489 set_irn_n(node, 1, right);
1493 get_Shrs_left (ir_node *node) {
1494 assert (node->op == op_Shrs);
1495 return get_irn_n(node, 0);
1499 set_Shrs_left (ir_node *node, ir_node *left) {
1500 assert (node->op == op_Shrs);
1501 set_irn_n(node, 0, left);
1505 get_Shrs_right (ir_node *node) {
1506 assert (node->op == op_Shrs);
1507 return get_irn_n(node, 1);
1511 set_Shrs_right (ir_node *node, ir_node *right) {
1512 assert (node->op == op_Shrs);
1513 set_irn_n(node, 1, right);
1517 get_Rot_left (ir_node *node) {
1518 assert (node->op == op_Rot);
1519 return get_irn_n(node, 0);
1523 set_Rot_left (ir_node *node, ir_node *left) {
1524 assert (node->op == op_Rot);
1525 set_irn_n(node, 0, left);
1529 get_Rot_right (ir_node *node) {
1530 assert (node->op == op_Rot);
1531 return get_irn_n(node, 1);
1535 set_Rot_right (ir_node *node, ir_node *right) {
1536 assert (node->op == op_Rot);
1537 set_irn_n(node, 1, right);
1541 get_Cmp_left (ir_node *node) {
1542 assert (node->op == op_Cmp);
1543 return get_irn_n(node, 0);
1547 set_Cmp_left (ir_node *node, ir_node *left) {
1548 assert (node->op == op_Cmp);
1549 set_irn_n(node, 0, left);
1553 get_Cmp_right (ir_node *node) {
1554 assert (node->op == op_Cmp);
1555 return get_irn_n(node, 1);
1559 set_Cmp_right (ir_node *node, ir_node *right) {
1560 assert (node->op == op_Cmp);
1561 set_irn_n(node, 1, right);
1565 get_Conv_op (ir_node *node) {
1566 assert (node->op == op_Conv);
1567 return get_irn_n(node, 0);
1571 set_Conv_op (ir_node *node, ir_node *op) {
1572 assert (node->op == op_Conv);
1573 set_irn_n(node, 0, op);
1577 get_Cast_op (ir_node *node) {
1578 assert (node->op == op_Cast);
1579 return get_irn_n(node, 0);
1583 set_Cast_op (ir_node *node, ir_node *op) {
1584 assert (node->op == op_Cast);
1585 set_irn_n(node, 0, op);
1589 get_Cast_type (ir_node *node) {
1590 assert (node->op == op_Cast);
1591 return node->attr.cast.totype;
1595 set_Cast_type (ir_node *node, type *to_tp) {
1596 assert (node->op == op_Cast);
1597 node->attr.cast.totype = to_tp;
1601 is_unop (ir_node *node) {
1602 return ( node->op == op_Minus ||
1603 node->op == op_Abs ||
1604 node->op == op_Not ||
1605 node->op == op_Conv ||
1606 node->op == op_Cast );
1610 get_unop_op (ir_node *node) {
1611 assert (is_unop(node));
1612 switch (get_irn_opcode (node)) {
1613 case iro_Minus: return get_Minus_op(node); break;
1614 case iro_Abs: return get_Abs_op(node); break;
1615 case iro_Not: return get_Not_op(node); break;
1616 case iro_Conv: return get_Conv_op(node); break;
1617 case iro_Cast: return get_Cast_op(node); break;
1618 default: return NULL;
1623 set_unop_op (ir_node *node, ir_node *op) {
1624 assert (is_unop(node));
1625 switch (get_irn_opcode (node)) {
1626 case iro_Minus: set_Minus_op(node, op); break;
1627 case iro_Abs: set_Abs_op(node, op); break;
1628 case iro_Not: set_Not_op(node, op); break;
1629 case iro_Conv: set_Conv_op(node, op); break;
1630 case iro_Cast: set_Cast_op(node, op); break;
1637 is_binop (ir_node *node) {
1638 return (node->op == op_Add ||
1639 node->op == op_Sub ||
1640 node->op == op_Mul ||
1641 node->op == op_Quot ||
1642 node->op == op_DivMod ||
1643 node->op == op_Div ||
1644 node->op == op_Mod ||
1645 node->op == op_And ||
1646 node->op == op_Or ||
1647 node->op == op_Eor ||
1648 node->op == op_Shl ||
1649 node->op == op_Shr ||
1650 node->op == op_Shrs ||
1651 node->op == op_Rot ||
1652 node->op == op_Cmp );
1656 get_binop_left (ir_node *node) {
1657 assert (node->op == op_Add ||
1658 node->op == op_Sub ||
1659 node->op == op_Mul ||
1660 node->op == op_Quot ||
1661 node->op == op_DivMod ||
1662 node->op == op_Div ||
1663 node->op == op_Mod ||
1664 node->op == op_And ||
1665 node->op == op_Or ||
1666 node->op == op_Eor ||
1667 node->op == op_Shl ||
1668 node->op == op_Shr ||
1669 node->op == op_Shrs ||
1670 node->op == op_Rot ||
1671 node->op == op_Cmp );
1673 switch (get_irn_opcode (node)) {
1674 case iro_Add : return get_Add_left(node); break;
1675 case iro_Sub : return get_Sub_left(node); break;
1676 case iro_Mul : return get_Mul_left(node); break;
1677 case iro_Quot : return get_Quot_left(node); break;
1678 case iro_DivMod: return get_DivMod_left(node); break;
1679 case iro_Div : return get_Div_left(node); break;
1680 case iro_Mod : return get_Mod_left(node); break;
1681 case iro_And : return get_And_left(node); break;
1682 case iro_Or : return get_Or_left(node); break;
1683 case iro_Eor : return get_Eor_left(node); break;
1684 case iro_Shl : return get_Shl_left(node); break;
1685 case iro_Shr : return get_Shr_left(node); break;
1686 case iro_Shrs : return get_Shrs_left(node); break;
1687 case iro_Rot : return get_Rot_left(node); break;
1688 case iro_Cmp : return get_Cmp_left(node); break;
1689 default: return NULL;
1694 set_binop_left (ir_node *node, ir_node *left) {
1695 assert (node->op == op_Add ||
1696 node->op == op_Sub ||
1697 node->op == op_Mul ||
1698 node->op == op_Quot ||
1699 node->op == op_DivMod ||
1700 node->op == op_Div ||
1701 node->op == op_Mod ||
1702 node->op == op_And ||
1703 node->op == op_Or ||
1704 node->op == op_Eor ||
1705 node->op == op_Shl ||
1706 node->op == op_Shr ||
1707 node->op == op_Shrs ||
1708 node->op == op_Rot ||
1709 node->op == op_Cmp );
1711 switch (get_irn_opcode (node)) {
1712 case iro_Add : set_Add_left(node, left); break;
1713 case iro_Sub : set_Sub_left(node, left); break;
1714 case iro_Mul : set_Mul_left(node, left); break;
1715 case iro_Quot : set_Quot_left(node, left); break;
1716 case iro_DivMod: set_DivMod_left(node, left); break;
1717 case iro_Div : set_Div_left(node, left); break;
1718 case iro_Mod : set_Mod_left(node, left); break;
1719 case iro_And : set_And_left(node, left); break;
1720 case iro_Or : set_Or_left(node, left); break;
1721 case iro_Eor : set_Eor_left(node, left); break;
1722 case iro_Shl : set_Shl_left(node, left); break;
1723 case iro_Shr : set_Shr_left(node, left); break;
1724 case iro_Shrs : set_Shrs_left(node, left); break;
1725 case iro_Rot : set_Rot_left(node, left); break;
1726 case iro_Cmp : set_Cmp_left(node, left); break;
1732 get_binop_right (ir_node *node) {
1733 assert (node->op == op_Add ||
1734 node->op == op_Sub ||
1735 node->op == op_Mul ||
1736 node->op == op_Quot ||
1737 node->op == op_DivMod ||
1738 node->op == op_Div ||
1739 node->op == op_Mod ||
1740 node->op == op_And ||
1741 node->op == op_Or ||
1742 node->op == op_Eor ||
1743 node->op == op_Shl ||
1744 node->op == op_Shr ||
1745 node->op == op_Shrs ||
1746 node->op == op_Rot ||
1747 node->op == op_Cmp );
1749 switch (get_irn_opcode (node)) {
1750 case iro_Add : return get_Add_right(node); break;
1751 case iro_Sub : return get_Sub_right(node); break;
1752 case iro_Mul : return get_Mul_right(node); break;
1753 case iro_Quot : return get_Quot_right(node); break;
1754 case iro_DivMod: return get_DivMod_right(node); break;
1755 case iro_Div : return get_Div_right(node); break;
1756 case iro_Mod : return get_Mod_right(node); break;
1757 case iro_And : return get_And_right(node); break;
1758 case iro_Or : return get_Or_right(node); break;
1759 case iro_Eor : return get_Eor_right(node); break;
1760 case iro_Shl : return get_Shl_right(node); break;
1761 case iro_Shr : return get_Shr_right(node); break;
1762 case iro_Shrs : return get_Shrs_right(node); break;
1763 case iro_Rot : return get_Rot_right(node); break;
1764 case iro_Cmp : return get_Cmp_right(node); break;
1765 default: return NULL;
1770 set_binop_right (ir_node *node, ir_node *right) {
1771 assert (node->op == op_Add ||
1772 node->op == op_Sub ||
1773 node->op == op_Mul ||
1774 node->op == op_Quot ||
1775 node->op == op_DivMod ||
1776 node->op == op_Div ||
1777 node->op == op_Mod ||
1778 node->op == op_And ||
1779 node->op == op_Or ||
1780 node->op == op_Eor ||
1781 node->op == op_Shl ||
1782 node->op == op_Shr ||
1783 node->op == op_Shrs ||
1784 node->op == op_Rot ||
1785 node->op == op_Cmp );
1787 switch (get_irn_opcode (node)) {
1788 case iro_Add : set_Add_right(node, right); break;
1789 case iro_Sub : set_Sub_right(node, right); break;
1790 case iro_Mul : set_Mul_right(node, right); break;
1791 case iro_Quot : set_Quot_right(node, right); break;
1792 case iro_DivMod: set_DivMod_right(node, right); break;
1793 case iro_Div : set_Div_right(node, right); break;
1794 case iro_Mod : set_Mod_right(node, right); break;
1795 case iro_And : set_And_right(node, right); break;
1796 case iro_Or : set_Or_right(node, right); break;
1797 case iro_Eor : set_Eor_right(node, right); break;
1798 case iro_Shl : set_Shl_right(node, right); break;
1799 case iro_Shr : set_Shr_right(node, right); break;
1800 case iro_Shrs : set_Shrs_right(node, right); break;
1801 case iro_Rot : set_Rot_right(node, right); break;
1802 case iro_Cmp : set_Cmp_right(node, right); break;
1809 get_Phi_preds_arr (ir_node *node) {
1810 assert (node->op == op_Phi);
1811 return (ir_node **)&(get_irn_in(node)[1]);
1815 get_Phi_n_preds (ir_node *node) {
1816 assert (node->op == op_Phi);
1817 return (get_irn_arity(node));
1821 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1822 assert (node->op == op_Phi);
1827 get_Phi_pred (ir_node *node, int pos) {
1828 assert (node->op == op_Phi);
1829 return get_irn_n(node, pos);
1833 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1834 assert (node->op == op_Phi);
1835 set_irn_n(node, pos, pred);
1839 get_Load_mem (ir_node *node) {
1840 assert (node->op == op_Load);
1841 return get_irn_n(node, 0);
1845 set_Load_mem (ir_node *node, ir_node *mem) {
1846 assert (node->op == op_Load);
1847 set_irn_n(node, 0, mem);
1851 get_Load_ptr (ir_node *node) {
1852 assert (node->op == op_Load);
1853 return get_irn_n(node, 1);
1857 set_Load_ptr (ir_node *node, ir_node *ptr) {
1858 assert (node->op == op_Load);
1859 set_irn_n(node, 1, ptr);
1864 get_Store_mem (ir_node *node) {
1865 assert (node->op == op_Store);
1866 return get_irn_n(node, 0);
1870 set_Store_mem (ir_node *node, ir_node *mem) {
1871 assert (node->op == op_Store);
1872 set_irn_n(node, 0, mem);
1876 get_Store_ptr (ir_node *node) {
1877 assert (node->op == op_Store);
1878 return get_irn_n(node, 1);
1882 set_Store_ptr (ir_node *node, ir_node *ptr) {
1883 assert (node->op == op_Store);
1884 set_irn_n(node, 1, ptr);
1888 get_Store_value (ir_node *node) {
1889 assert (node->op == op_Store);
1890 return get_irn_n(node, 2);
1894 set_Store_value (ir_node *node, ir_node *value) {
1895 assert (node->op == op_Store);
1896 set_irn_n(node, 2, value);
1900 get_Alloc_mem (ir_node *node) {
1901 assert (node->op == op_Alloc);
1902 return get_irn_n(node, 0);
1906 set_Alloc_mem (ir_node *node, ir_node *mem) {
1907 assert (node->op == op_Alloc);
1908 set_irn_n(node, 0, mem);
1912 get_Alloc_size (ir_node *node) {
1913 assert (node->op == op_Alloc);
1914 return get_irn_n(node, 1);
1918 set_Alloc_size (ir_node *node, ir_node *size) {
1919 assert (node->op == op_Alloc);
1920 set_irn_n(node, 1, size);
1924 get_Alloc_type (ir_node *node) {
1925 assert (node->op == op_Alloc);
1926 return node->attr.a.type = skip_tid(node->attr.a.type);
1930 set_Alloc_type (ir_node *node, type *tp) {
1931 assert (node->op == op_Alloc);
1932 node->attr.a.type = tp;
1936 get_Alloc_where (ir_node *node) {
1937 assert (node->op == op_Alloc);
1938 return node->attr.a.where;
1942 set_Alloc_where (ir_node *node, where_alloc where) {
1943 assert (node->op == op_Alloc);
1944 node->attr.a.where = where;
1949 get_Free_mem (ir_node *node) {
1950 assert (node->op == op_Free);
1951 return get_irn_n(node, 0);
1955 set_Free_mem (ir_node *node, ir_node *mem) {
1956 assert (node->op == op_Free);
1957 set_irn_n(node, 0, mem);
1961 get_Free_ptr (ir_node *node) {
1962 assert (node->op == op_Free);
1963 return get_irn_n(node, 1);
1967 set_Free_ptr (ir_node *node, ir_node *ptr) {
1968 assert (node->op == op_Free);
1969 set_irn_n(node, 1, ptr);
1973 get_Free_size (ir_node *node) {
1974 assert (node->op == op_Free);
1975 return get_irn_n(node, 2);
1979 set_Free_size (ir_node *node, ir_node *size) {
1980 assert (node->op == op_Free);
1981 set_irn_n(node, 2, size);
1985 get_Free_type (ir_node *node) {
1986 assert (node->op == op_Free);
1987 return node->attr.f = skip_tid(node->attr.f);
1991 set_Free_type (ir_node *node, type *tp) {
1992 assert (node->op == op_Free);
1997 get_Sync_preds_arr (ir_node *node) {
1998 assert (node->op == op_Sync);
1999 return (ir_node **)&(get_irn_in(node)[1]);
2003 get_Sync_n_preds (ir_node *node) {
2004 assert (node->op == op_Sync);
2005 return (get_irn_arity(node));
2010 set_Sync_n_preds (ir_node *node, int n_preds) {
2011 assert (node->op == op_Sync);
2016 get_Sync_pred (ir_node *node, int pos) {
2017 assert (node->op == op_Sync);
2018 return get_irn_n(node, pos);
2022 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
2023 assert (node->op == op_Sync);
2024 set_irn_n(node, pos, pred);
2028 get_Proj_pred (ir_node *node) {
2029 assert (is_Proj(node));
2030 return get_irn_n(node, 0);
2034 set_Proj_pred (ir_node *node, ir_node *pred) {
2035 assert (is_Proj(node));
2036 set_irn_n(node, 0, pred);
2040 get_Proj_proj (ir_node *node) {
2041 assert (is_Proj(node));
2042 if (get_irn_opcode(node) == iro_Proj) {
2043 return node->attr.proj;
2045 assert(get_irn_opcode(node) == iro_Filter);
2046 return node->attr.filter.proj;
2051 set_Proj_proj (ir_node *node, long proj) {
2052 assert (node->op == op_Proj);
2053 node->attr.proj = proj;
2057 get_Tuple_preds_arr (ir_node *node) {
2058 assert (node->op == op_Tuple);
2059 return (ir_node **)&(get_irn_in(node)[1]);
2063 get_Tuple_n_preds (ir_node *node) {
2064 assert (node->op == op_Tuple);
2065 return (get_irn_arity(node));
2070 set_Tuple_n_preds (ir_node *node, int n_preds) {
2071 assert (node->op == op_Tuple);
2076 get_Tuple_pred (ir_node *node, int pos) {
2077 assert (node->op == op_Tuple);
2078 return get_irn_n(node, pos);
2082 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2083 assert (node->op == op_Tuple);
2084 set_irn_n(node, pos, pred);
2088 get_Id_pred (ir_node *node) {
2089 assert (node->op == op_Id);
2090 return get_irn_n(node, 0);
2094 set_Id_pred (ir_node *node, ir_node *pred) {
2095 assert (node->op == op_Id);
2096 set_irn_n(node, 0, pred);
2101 get_Filter_pred (ir_node *node) {
2102 assert(node->op == op_Filter);
2106 set_Filter_pred (ir_node *node, ir_node *pred) {
2107 assert(node->op == op_Filter);
2111 get_Filter_proj(ir_node *node) {
2112 assert(node->op == op_Filter);
2113 return node->attr.filter.proj;
2116 set_Filter_proj (ir_node *node, long proj) {
2117 assert(node->op == op_Filter);
2118 node->attr.filter.proj = proj;
2121 /* Don't use get_irn_arity, get_irn_n in implementation as access
2122 shall work independent of view!!! */
2123 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2124 assert(node->op == op_Filter);
2125 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2126 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2127 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2128 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2129 node->attr.filter.in_cg[0] = node->in[0];
2131 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2134 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2135 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2136 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2137 node->attr.filter.in_cg[pos + 1] = pred;
2139 int get_Filter_n_cg_preds(ir_node *node) {
2140 assert(node->op == op_Filter && node->attr.filter.in_cg);
2141 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2143 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2145 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2147 arity = ARR_LEN(node->attr.filter.in_cg);
2148 assert(pos < arity - 1);
2149 return node->attr.filter.in_cg[pos + 1];
2154 get_irn_irg(ir_node *node) {
2155 if (get_irn_op(node) == op_CallBegin) {
2156 return node->attr.callbegin.irg;
2157 } else if (get_irn_op(node) == op_EndReg ||
2158 get_irn_op(node) == op_EndExcept) {
2159 return node->attr.end.irg;
2160 } else if (get_irn_op(node) == op_Start) {
2161 return node->attr.start.irg;
2163 assert(0 && "no irg attr");
2169 /******************************************************************/
2170 /* Auxiliary routines */
2171 /******************************************************************/
2174 skip_Proj (ir_node *node) {
2175 /* don't assert node !!! */
2176 if (node && is_Proj(node)) {
2177 return get_Proj_pred(node);
2184 skip_Tuple (ir_node *node) {
2187 if (!get_opt_normalize()) return node;
2189 node = skip_nop(node);
2190 if (get_irn_op(node) == op_Proj) {
2191 pred = skip_nop(get_Proj_pred(node));
2192 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2193 pred = skip_nop(skip_Tuple(pred));
2194 if (get_irn_op(pred) == op_Tuple)
2195 return get_Tuple_pred(pred, get_Proj_proj(node));
2200 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2201 than any other approach, as Id chains are resolved and all point to the real node, or
2202 all id's are self loops. */
2204 skip_nop (ir_node *node) {
2205 /* don't assert node !!! */
2207 if (!get_opt_normalize()) return node;
2209 /* Don't use get_Id_pred: We get into an endless loop for
2210 self-referencing Ids. */
2211 if (node && (node->op == op_Id) && (node != node->in[0+1])) {
2212 ir_node *rem_pred = node->in[0+1];
2215 assert (get_irn_arity (node) > 0);
2217 node->in[0+1] = node;
2218 res = skip_nop(rem_pred);
2219 if (res->op == op_Id) /* self-loop */ return node;
2221 node->in[0+1] = res;
2229 skip_Id (ir_node *node) {
2230 return skip_nop(node);
2234 is_Bad (ir_node *node) {
2236 if ((node) && get_irn_opcode(node) == iro_Bad)
2242 is_no_Block (ir_node *node) {
2244 return (get_irn_opcode(node) != iro_Block);
2248 is_Block (ir_node *node) {
2250 return (get_irn_opcode(node) == iro_Block);
2254 is_Proj (const ir_node *node) {
2256 return node->op == op_Proj
2257 || (!interprocedural_view && node->op == op_Filter);
2260 /* Returns true if the operation manipulates control flow. */
2262 is_cfop(ir_node *node) {
2263 return is_cfopcode(get_irn_op(node));
2266 /* Returns true if the operation manipulates interprocedural control flow:
2267 CallBegin, EndReg, EndExcept */
2268 INLINE int is_ip_cfop(ir_node *node) {
2269 return is_ip_cfopcode(get_irn_op(node));
2272 ir_graph *get_ip_cfop_irg(ir_node *n) {
2273 switch (get_irn_opcode(n)) {
2275 return get_EndReg_irg(n);
2277 return get_EndExcept_irg(n);
2279 return get_CallBegin_irg(n);
2281 assert(is_ip_cfop(n));
2283 return NULL; /* should never be reached */
2286 /* Returns true if the operation can change the control flow because
2289 is_fragile_op(ir_node *node) {
2290 return ( (get_irn_opcode(node) == iro_Call)
2291 || (get_irn_opcode(node) == iro_Quot)
2292 || (get_irn_opcode(node) == iro_DivMod)
2293 || (get_irn_opcode(node) == iro_Div)
2294 || (get_irn_opcode(node) == iro_Mod)
2295 || (get_irn_opcode(node) == iro_Load)
2296 || (get_irn_opcode(node) == iro_Store)
2297 || (get_irn_opcode(node) == iro_Alloc)
2298 || (get_irn_opcode(node) == iro_Bad)
2299 || (get_irn_opcode(node) == iro_Unknown));
2303 /* Returns the memory operand of fragile operations. */
2304 ir_node *get_fragile_op_mem(ir_node *node) {
2305 assert(node && is_fragile_op(node));
2307 switch (get_irn_opcode (node)) {
2316 return get_irn_n(node, 0);
2321 assert(0 && "not reached");