1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
4 * Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
16 #include "irgraph_t.h"
19 #include "typegmod_t.h"
21 #include "irbackedge_t.h"
28 /* some constants fixing the positions of nodes predecessors
30 #define CALL_PARAM_OFFSET 2
31 #define SEL_INDEX_OFFSET 2
32 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
33 #define END_KEEPALIVE_OFFSET 0
35 /* Declarations for inlineing */
36 INLINE ir_node ** get_irn_in (ir_node *node);
37 INLINE ir_mode *get_irn_mode (ir_node *node);
38 INLINE ir_op *get_irn_op (ir_node *node);
39 INLINE opcode get_irn_opcode (ir_node *node);
40 INLINE ident *get_irn_opident (ir_node *node);
41 INLINE type *get_SymConst_type (ir_node *node);
42 INLINE ir_node *skip_nop (ir_node *node);
43 INLINE ir_node *skip_nop (ir_node *node);
44 INLINE int is_Proj (ir_node *node);
47 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
48 "Gt", "Ge", "Lg", "Leg", "Uo",
49 "Ue", "Ul", "Ule", "Ug", "Uge",
52 INLINE char *get_pnc_string(int pnc) {
53 return pnc_name_arr[pnc];
58 get_negated_pnc(int pnc) {
60 case False: return True; break;
61 case Eq: return Ne; break;
62 case Lt: return Uge; break;
63 case Le: return Ug; break;
64 case Gt: return Ule; break;
65 case Ge: return Ul; break;
66 case Lg: return Ue; break;
67 case Leg: return Uo; break;
68 case Uo: return Leg; break;
69 case Ue: return Lg; break;
70 case Ul: return Ge; break;
71 case Ule: return Gt; break;
72 case Ug: return Le; break;
73 case Uge: return Lt; break;
74 case Ne: return Eq; break;
75 case True: return False; break;
77 return 99; /* to shut up gcc */
80 static char *pns_name_arr [] = {"initial_exec", "global_store",
81 "frame_base", "globals", "args"};
83 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
90 /* irnode constructor */
91 /* create a new irnode in irg, with an op, mode, arity and */
92 /* some incoming irnodes */
93 /* this constructor is used in every specified irnode constructor */
95 new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
96 int arity, ir_node **in)
99 int node_size = offsetof (ir_node, attr) + op->attr_size;
101 res = (ir_node *) obstack_alloc (irg->obst, node_size);
103 res->kind = k_ir_node;
109 res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
111 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
112 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
115 set_irn_dbg_info(res, db);
119 res->node_nr = get_irp_new_node_nr();
125 /* Copies all attributes stored in the old node to the new node.
126 Assumes both have the same opcode and sufficient size. */
128 copy_attrs (ir_node *old, ir_node *new) {
129 assert (get_irn_op(old) == get_irn_op(new));
130 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
133 /* IR-Nodes with attributes */
135 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
138 ir_node *np = XP_GETARG (ir_node *, 0);
141 XPS ("<null ir_node>");
145 XPF1 ("%I", get_irn_opident(np));
147 switch (get_irn_opcode (np)) { /* node label */
149 XPF1 ("%I", get_irn_mode(np)->name);
151 XPF1 ("%v", get_irn_const_attr);
154 if (get_irn_mode (np) == mode_b) {
156 XP (pnc_name_arr[get_irn_proj_attr(np)]);
157 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
159 XP (pns_name_arr[get_irn_proj_attr(np)]);
161 XPF1 ("%I", get_irn_mode(np)->name);
163 XPF1 ("%d", get_irn_proj_attr(np));
167 XPF1 ("%I", get_irn_mode(np)->name);
169 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
170 XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
172 case iro_Start: /* don't dump mode of these */
185 XPF1 ("%I", get_irn_mode(np)->name);
191 /** getting some parameters from ir_nodes **/
193 /* returns the number of predecessors without the block predecessor. */
195 get_irn_arity (ir_node *node) {
197 if (interprocedural_view) { /* handle Filter and Block specially */
198 if (get_irn_opcode(node) == iro_Filter) {
199 assert(node->attr.filter.in_cg);
200 return ARR_LEN(node->attr.filter.in_cg) - 1;
201 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
202 return ARR_LEN(node->attr.block.in_cg) - 1;
204 /* else fall through */
206 return ARR_LEN(node->in) - 1;
209 /* Returns the array with ins. This array is shifted with respect to the
210 array accessed by get_irn_n: The block operand is at position 0 not -1.
211 (@@@ This should be changed.)
212 The order of the predecessors in this array is not guaranteed, except that
213 lists of operands as predecessors of Block or arguments of a Call are
216 get_irn_in (ir_node *node) {
218 if (interprocedural_view) { /* handle Filter and Block specially */
219 if (get_irn_opcode(node) == iro_Filter) {
220 assert(node->attr.filter.in_cg);
221 return node->attr.filter.in_cg;
222 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
223 return node->attr.block.in_cg;
225 /* else fall through */
231 set_irn_in (ir_node *node, int arity, ir_node **in) {
234 if (interprocedural_view) { /* handle Filter and Block specially */
235 if (get_irn_opcode(node) == iro_Filter) {
236 assert(node->attr.filter.in_cg);
237 arr = &node->attr.filter.in_cg;
238 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
239 arr = &node->attr.block.in_cg;
246 if (arity != ARR_LEN(*arr) - 1) {
247 ir_node * block = (*arr)[0];
248 *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
251 fix_backedges(current_ir_graph->obst, node);
252 memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
255 /* to iterate through the predecessors without touching the array */
256 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
257 to iterate includind the Block predecessor iterate from i = -1 to
259 If it is a block, the entry -1 is NULL. */
261 get_irn_n (ir_node *node, int n) {
263 if (-1 > n || get_irn_arity(node) <= n) {
264 printf("pos: %d, arity: %d ", n, get_irn_arity(node));
267 assert(node); assert(-1 <= n && n < get_irn_arity(node));
268 if (interprocedural_view) { /* handle Filter and Block specially */
269 if (get_irn_opcode(node) == iro_Filter) {
270 assert(node->attr.filter.in_cg);
271 return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
272 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
273 return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
275 /* else fall through */
277 return (node->in[n + 1] = skip_nop(node->in[n + 1]));
281 set_irn_n (ir_node *node, int n, ir_node *in) {
282 assert(node && -1 <= n && n < get_irn_arity(node));
283 if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
284 /* Change block pred in both views! */
285 node->in[n + 1] = in;
286 assert(node->attr.filter.in_cg);
287 node->attr.filter.in_cg[n + 1] = in;
290 if (interprocedural_view) { /* handle Filter and Block specially */
291 if (get_irn_opcode(node) == iro_Filter) {
292 assert(node->attr.filter.in_cg);
293 node->attr.filter.in_cg[n + 1] = in;
295 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
296 node->attr.block.in_cg[n + 1] = in;
299 /* else fall through */
301 node->in[n + 1] = in;
305 get_irn_mode (ir_node *node)
312 get_irn_modecode (ir_node *node)
315 return node->mode->code;
320 get_irn_modeident (ir_node *node)
323 return node->mode->name;
327 get_irn_op (ir_node *node)
333 /* should be private to the library: */
335 set_irn_op (ir_node *node, ir_op *op)
342 get_irn_opcode (ir_node *node)
345 assert (k_ir_node == get_kind(node));
347 return node->op->code;
351 get_irn_opname (ir_node *node)
354 return id_to_str(node->op->name);
358 get_irn_opident (ir_node *node)
361 return node->op->name;
365 get_irn_visited (ir_node *node)
368 return node->visited;
372 set_irn_visited (ir_node *node, unsigned long visited)
375 node->visited = visited;
379 mark_irn_visited (ir_node *node) {
381 node->visited = current_ir_graph->visited;
385 irn_not_visited (ir_node *node) {
387 return (node->visited < current_ir_graph->visited);
391 irn_visited (ir_node *node) {
393 return (node->visited >= current_ir_graph->visited);
397 set_irn_link (ir_node *node, void *link) {
399 /* Link field is used for Phi construction and various optimizations
401 assert(get_irg_phase_state(current_ir_graph) != phase_building);
407 get_irn_link (ir_node *node) {
412 /* Outputs a unique number for this node */
414 get_irn_node_nr(ir_node *node) {
417 return node->node_nr;
424 get_irn_const_attr (ir_node *node)
426 assert (node->op == op_Const);
427 return node->attr.con;
431 get_irn_proj_attr (ir_node *node)
433 assert (node->op == op_Proj);
434 return node->attr.proj;
438 get_irn_alloc_attr (ir_node *node)
440 assert (node->op == op_Alloc);
445 get_irn_free_attr (ir_node *node)
447 assert (node->op == op_Free);
448 return node->attr.f = skip_tid(node->attr.f);
452 get_irn_symconst_attr (ir_node *node)
454 assert (node->op == op_SymConst);
459 get_irn_call_attr (ir_node *node)
461 assert (node->op == op_Call);
462 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
466 get_irn_sel_attr (ir_node *node)
468 assert (node->op == op_Sel);
473 get_irn_phi_attr (ir_node *node)
475 assert (node->op == op_Phi);
476 return node->attr.phi0_pos;
480 get_irn_block_attr (ir_node *node)
482 assert (node->op == op_Block);
483 return node->attr.block;
486 /** manipulate fields of individual nodes **/
488 /* this works for all except Block */
490 get_nodes_Block (ir_node *node) {
491 assert (!(node->op == op_Block));
492 return get_irn_n(node, -1);
496 set_nodes_Block (ir_node *node, ir_node *block) {
497 assert (!(node->op == op_Block));
498 set_irn_n(node, -1, block);
501 /* Returns an array with the predecessors of the Block. Depending on
502 the implementation of the graph datastructure this can be a copy of
503 the internal representation of predecessors as well as the internal
504 array itself. Therefore writing to this array might obstruct the ir. */
506 get_Block_cfgpred_arr (ir_node *node)
508 assert ((node->op == op_Block));
509 return (ir_node **)&(get_irn_in(node)[1]);
514 get_Block_n_cfgpreds (ir_node *node) {
515 assert ((node->op == op_Block));
516 return (get_irn_arity(node));
520 get_Block_cfgpred (ir_node *node, int pos) {
521 assert (node->op == op_Block);
523 if (-1 > pos || get_irn_arity(node) <= pos) {
524 dump_ir_block_graph(current_ir_graph);
525 printf("pos: %d, arity: %d ", pos, get_irn_arity(node));
528 assert(node); assert(-1 <= pos && pos < get_irn_arity(node));
529 return get_irn_n(node, pos);
533 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
534 assert (node->op == op_Block);
535 set_irn_n(node, pos, pred);
539 get_Block_matured (ir_node *node) {
540 assert (node->op == op_Block);
541 return node->attr.block.matured;
545 set_Block_matured (ir_node *node, bool matured) {
546 assert (node->op == op_Block);
547 node->attr.block.matured = matured;
550 get_Block_block_visited (ir_node *node) {
551 assert (node->op == op_Block);
552 return node->attr.block.block_visited;
556 set_Block_block_visited (ir_node *node, unsigned long visit) {
557 assert (node->op == op_Block);
558 node->attr.block.block_visited = visit;
561 /* For this current_ir_graph must be set. */
563 mark_Block_block_visited (ir_node *node) {
564 assert (node->op == op_Block);
565 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
569 Block_not_block_visited(ir_node *node) {
570 assert (node->op == op_Block);
571 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
575 get_Block_graph_arr (ir_node *node, int pos) {
576 assert (node->op == op_Block);
577 return node->attr.block.graph_arr[pos+1];
581 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
582 assert (node->op == op_Block);
583 node->attr.block.graph_arr[pos+1] = value;
586 /* handler handling for Blocks */
588 set_Block_handler (ir_node *block, ir_node *handler) {
589 assert ((block->op == op_Block));
590 assert ((handler->op == op_Block));
591 block->attr.block.handler_entry = handler;
595 get_Block_handler (ir_node *block) {
596 assert ((block->op == op_Block));
597 return (block->attr.block.handler_entry);
600 /* handler handling for Nodes */
602 set_Node_handler (ir_node *node, ir_node *handler) {
603 set_Block_handler (get_nodes_Block (node), handler);
607 get_Node_handler (ir_node *node) {
608 return (get_Block_handler (get_nodes_Block (node)));
611 /* exc_t handling for Blocks */
612 void set_Block_exc (ir_node *block, exc_t exc) {
613 assert ((block->op == op_Block));
614 block->attr.block.exc = exc;
617 exc_t get_Block_exc (ir_node *block) {
618 assert ((block->op == op_Block));
620 return (block->attr.block.exc);
623 /* exc_t handling for Nodes */
624 void set_Node_exc (ir_node *node, exc_t exc) {
625 set_Block_exc (get_nodes_Block (node), exc);
628 exc_t get_Node_exc (ir_node *node) {
629 return (get_Block_exc (get_nodes_Block (node)));
632 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
633 assert(node->op == op_Block);
634 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
635 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
636 node->attr.block.in_cg[0] = NULL;
637 node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
639 /* Fix backedge array. fix_backedges operates depending on
640 interprocedural_view. */
641 bool ipv = interprocedural_view;
642 interprocedural_view = true;
643 fix_backedges(current_ir_graph->obst, node);
644 interprocedural_view = ipv;
647 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
650 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
651 assert(node->op == op_Block &&
652 node->attr.block.in_cg &&
653 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
654 node->attr.block.in_cg[pos + 1] = pred;
657 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
658 assert(node->op == op_Block);
659 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
662 int get_Block_cg_n_cfgpreds(ir_node * node) {
663 assert(node->op == op_Block);
664 return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
667 ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
668 assert(node->op == op_Block && node->attr.block.in_cg);
669 return node->attr.block.in_cg[pos + 1];
672 void remove_Block_cg_cfgpred_arr(ir_node * node) {
673 assert(node->op == op_Block);
674 node->attr.block.in_cg = NULL;
678 get_End_n_keepalives(ir_node *end) {
679 assert (end->op == op_End);
680 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
684 get_End_keepalive(ir_node *end, int pos) {
685 assert (end->op == op_End);
686 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
690 add_End_keepalive (ir_node *end, ir_node *ka) {
691 assert (end->op == op_End);
692 ARR_APP1 (ir_node *, end->in, ka);
696 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
697 assert (end->op == op_End);
698 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
702 free_End (ir_node *end) {
703 assert (end->op == op_End);
704 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
705 end->in = NULL; /* @@@ make sure we get an error if we use the
706 in array afterwards ... */
709 ir_graph *get_EndReg_irg (ir_node *end) {
710 assert (end->op == op_EndReg);
711 return end->attr.end.irg;
714 ir_graph *get_EndExcept_irg (ir_node *end) {
715 assert (end->op == op_EndReg);
716 return end->attr.end.irg;
720 > Implementing the case construct (which is where the constant Proj node is
721 > important) involves far more than simply determining the constant values.
722 > We could argue that this is more properly a function of the translator from
723 > Firm to the target machine. That could be done if there was some way of
724 > projecting "default" out of the Cond node.
725 I know it's complicated.
726 Basically there are two proglems:
727 - determining the gaps between the projs
728 - determining the biggest case constant to konw the proj number for
730 I see several solutions:
731 1. Introduce a ProjDefault node. Solves both problems.
732 This means to extend all optimizations executed during construction.
733 2. Give the Cond node for switch two flavors:
734 a) there are no gaps in the projs (existing flavor)
735 b) gaps may exist, default proj is still the Proj with the largest
736 projection number. This covers also the gaps.
737 3. Fix the semantic of the Cond to that of 2b)
739 Solution 2 seems to be the best:
740 Computing the gaps in the Firm representation is not too hard, i.e.,
741 libfirm can implement a routine that transforms betweeen the two
742 flavours. This is also possible for 1) but 2) does not require to
743 change any existing optimization.
744 Further it should be far simpler to determine the biggest constant than
746 I don't want to choose 3) as 2a) seems to have advantages for
747 dataflow analysis and 3) does not allow to convert the representation to
751 get_Cond_selector (ir_node *node) {
752 assert (node->op == op_Cond);
753 return get_irn_n(node, 0);
757 set_Cond_selector (ir_node *node, ir_node *selector) {
758 assert (node->op == op_Cond);
759 set_irn_n(node, 0, selector);
763 get_Cond_kind (ir_node *node) {
764 assert (node->op == op_Cond);
765 return node->attr.c.kind;
769 set_Cond_kind (ir_node *node, cond_kind kind) {
770 assert (node->op == op_Cond);
771 node->attr.c.kind = kind;
775 get_Return_mem (ir_node *node) {
776 assert (node->op == op_Return);
777 return get_irn_n(node, 0);
781 set_Return_mem (ir_node *node, ir_node *mem) {
782 assert (node->op == op_Return);
783 set_irn_n(node, 0, mem);
787 get_Return_n_ress (ir_node *node) {
788 assert (node->op == op_Return);
789 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
793 get_Return_res_arr (ir_node *node)
795 assert ((node->op == op_Return));
796 if (get_Return_n_ress(node) > 0)
797 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
804 set_Return_n_res (ir_node *node, int results) {
805 assert (node->op == op_Return);
810 get_Return_res (ir_node *node, int pos) {
811 assert (node->op == op_Return);
812 assert (get_Return_n_ress(node) > pos);
813 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
817 set_Return_res (ir_node *node, int pos, ir_node *res){
818 assert (node->op == op_Return);
819 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
823 get_Raise_mem (ir_node *node) {
824 assert (node->op == op_Return);
825 return get_irn_n(node, 0);
829 set_Raise_mem (ir_node *node, ir_node *mem) {
830 assert (node->op == op_Raise);
831 set_irn_n(node, 0, mem);
835 get_Raise_exo_ptr (ir_node *node) {
836 assert (node->op == op_Raise);
837 return get_irn_n(node, 1);
841 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
842 assert (node->op == op_Raise);
843 set_irn_n(node, 1, exo_ptr);
846 INLINE tarval *get_Const_tarval (ir_node *node) {
847 assert (node->op == op_Const);
848 return get_irn_const_attr(node);
852 set_Const_tarval (ir_node *node, tarval *con) {
853 assert (node->op == op_Const);
854 node->attr.con = con;
858 get_SymConst_kind (ir_node *node) {
859 assert (node->op == op_SymConst);
860 return node->attr.i.num;
864 set_SymConst_kind (ir_node *node, symconst_kind num) {
865 assert (node->op == op_SymConst);
866 node->attr.i.num = num;
870 get_SymConst_type (ir_node *node) {
871 assert ( (node->op == op_SymConst)
872 && ( get_SymConst_kind(node) == type_tag
873 || get_SymConst_kind(node) == size));
874 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
878 set_SymConst_type (ir_node *node, type *tp) {
879 assert ( (node->op == op_SymConst)
880 && ( get_SymConst_kind(node) == type_tag
881 || get_SymConst_kind(node) == size));
882 node->attr.i.tori.typ = tp;
886 get_SymConst_ptrinfo (ir_node *node) {
887 assert ( (node->op == op_SymConst)
888 && (get_SymConst_kind(node) == linkage_ptr_info));
889 return node->attr.i.tori.ptrinfo;
893 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
894 assert ( (node->op == op_SymConst)
895 && (get_SymConst_kind(node) == linkage_ptr_info));
896 node->attr.i.tori.ptrinfo = ptrinfo;
900 get_SymConst_type_or_id (ir_node *node) {
901 assert (node->op == op_SymConst);
902 return &(node->attr.i.tori);
906 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
907 assert (node->op == op_SymConst);
908 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
912 get_Sel_mem (ir_node *node) {
913 assert (node->op == op_Sel);
914 return get_irn_n(node, 0);
918 set_Sel_mem (ir_node *node, ir_node *mem) {
919 assert (node->op == op_Sel);
920 set_irn_n(node, 0, mem);
924 get_Sel_ptr (ir_node *node) {
925 assert (node->op == op_Sel);
926 return get_irn_n(node, 1);
930 set_Sel_ptr (ir_node *node, ir_node *ptr) {
931 assert (node->op == op_Sel);
932 set_irn_n(node, 1, ptr);
936 get_Sel_n_indexs (ir_node *node) {
937 assert (node->op == op_Sel);
938 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
942 get_Sel_index_arr (ir_node *node)
944 assert ((node->op == op_Sel));
945 if (get_Sel_n_indexs(node) > 0)
946 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
952 get_Sel_index (ir_node *node, int pos) {
953 assert (node->op == op_Sel);
954 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
958 set_Sel_index (ir_node *node, int pos, ir_node *index) {
959 assert (node->op == op_Sel);
960 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
964 get_Sel_entity (ir_node *node) {
965 assert (node->op == op_Sel);
966 return node->attr.s.ent;
970 set_Sel_entity (ir_node *node, entity *ent) {
971 assert (node->op == op_Sel);
972 node->attr.s.ent = ent;
976 get_InstOf_ent (ir_node *node) {
977 assert (node->op = op_InstOf);
978 return (node->attr.io.ent);
982 set_InstOf_ent (ir_node *node, type *ent) {
983 assert (node->op = op_InstOf);
984 node->attr.io.ent = ent;
988 get_InstOf_store (ir_node *node) {
989 assert (node->op = op_InstOf);
990 return (get_irn_n (node, 0));
994 set_InstOf_store (ir_node *node, ir_node *obj) {
995 assert (node->op = op_InstOf);
996 set_irn_n (node, 0, obj);
1000 get_InstOf_obj (ir_node *node) {
1001 assert (node->op = op_InstOf);
1002 return (get_irn_n (node, 1));
1006 set_InstOf_obj (ir_node *node, ir_node *obj) {
1007 assert (node->op = op_InstOf);
1008 set_irn_n (node, 1, obj);
1012 /* For unary and binary arithmetic operations the access to the
1013 operands can be factored out. Left is the first, right the
1014 second arithmetic value as listed in tech report 0999-33.
1015 unops are: Minus, Abs, Not, Conv
1016 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1017 Shr, Shrs, Rotate, Cmp */
1021 get_Call_mem (ir_node *node) {
1022 assert (node->op == op_Call);
1023 return get_irn_n(node, 0);
1027 set_Call_mem (ir_node *node, ir_node *mem) {
1028 assert (node->op == op_Call);
1029 set_irn_n(node, 0, mem);
1033 get_Call_ptr (ir_node *node) {
1034 assert (node->op == op_Call);
1035 return get_irn_n(node, 1);
1039 set_Call_ptr (ir_node *node, ir_node *ptr) {
1040 assert (node->op == op_Call);
1041 set_irn_n(node, 1, ptr);
1045 get_Call_param_arr (ir_node *node) {
1046 assert (node->op == op_Call);
1047 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1051 get_Call_n_params (ir_node *node) {
1052 assert (node->op == op_Call);
1053 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1057 get_Call_arity (ir_node *node) {
1058 assert (node->op == op_Call);
1059 return get_Call_n_params(node);
1063 set_Call_arity (ir_node *node, ir_node *arity) {
1064 assert (node->op == op_Call);
1069 get_Call_param (ir_node *node, int pos) {
1070 assert (node->op == op_Call);
1071 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1075 set_Call_param (ir_node *node, int pos, ir_node *param) {
1076 assert (node->op == op_Call);
1077 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1081 get_Call_type (ir_node *node) {
1082 assert (node->op == op_Call);
1083 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1087 set_Call_type (ir_node *node, type *tp) {
1088 assert (node->op == op_Call);
1089 assert (is_method_type(tp));
1090 node->attr.call.cld_tp = tp;
1093 int get_Call_n_callees(ir_node * node) {
1094 assert(node->op == op_Call && node->attr.call.callee_arr);
1095 return ARR_LEN(node->attr.call.callee_arr);
1098 entity * get_Call_callee(ir_node * node, int pos) {
1099 assert(node->op == op_Call && node->attr.call.callee_arr);
1100 return node->attr.call.callee_arr[pos];
1103 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1104 assert(node->op == op_Call);
1105 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1106 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1108 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1111 void remove_Call_callee_arr(ir_node * node) {
1112 assert(node->op == op_Call);
1113 node->attr.call.callee_arr = NULL;
1116 ir_node * get_CallBegin_ptr (ir_node *node) {
1117 assert(node->op == op_CallBegin);
1118 return get_irn_n(node, 0);
1120 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1121 assert(node->op == op_CallBegin);
1122 set_irn_n(node, 0, ptr);
1124 ir_graph * get_CallBegin_irg (ir_node *node) {
1125 assert(node->op == op_CallBegin);
1126 return node->attr.callbegin.irg;
1128 ir_node * get_CallBegin_call (ir_node *node) {
1129 assert(node->op == op_CallBegin);
1130 return node->attr.callbegin.call;
1132 void set_CallBegin_call (ir_node *node, ir_node *call) {
1133 assert(node->op == op_CallBegin);
1134 node->attr.callbegin.call = call;
1138 get_Add_left (ir_node *node) {
1139 assert (node->op == op_Add);
1140 return get_irn_n(node, 0);
1144 set_Add_left (ir_node *node, ir_node *left) {
1145 assert (node->op == op_Add);
1146 set_irn_n(node, 0, left);
1150 get_Add_right (ir_node *node) {
1151 assert (node->op == op_Add);
1152 return get_irn_n(node, 1);
1156 set_Add_right (ir_node *node, ir_node *right) {
1157 assert (node->op == op_Add);
1158 set_irn_n(node, 1, right);
1162 get_Sub_left (ir_node *node) {
1163 assert (node->op == op_Sub);
1164 return get_irn_n(node, 0);
1168 set_Sub_left (ir_node *node, ir_node *left) {
1169 assert (node->op == op_Sub);
1170 set_irn_n(node, 0, left);
1174 get_Sub_right (ir_node *node) {
1175 assert (node->op == op_Sub);
1176 return get_irn_n(node, 1);
1180 set_Sub_right (ir_node *node, ir_node *right) {
1181 assert (node->op == op_Sub);
1182 set_irn_n(node, 1, right);
1187 get_Minus_op (ir_node *node) {
1188 assert (node->op == op_Minus);
1189 return get_irn_n(node, 0);
1193 set_Minus_op (ir_node *node, ir_node *op) {
1194 assert (node->op == op_Minus);
1195 set_irn_n(node, 0, op);
1200 get_Mul_left (ir_node *node) {
1201 assert (node->op == op_Mul);
1202 return get_irn_n(node, 0);
1206 set_Mul_left (ir_node *node, ir_node *left) {
1207 assert (node->op == op_Mul);
1208 set_irn_n(node, 0, left);
1212 get_Mul_right (ir_node *node) {
1213 assert (node->op == op_Mul);
1214 return get_irn_n(node, 1);
1218 set_Mul_right (ir_node *node, ir_node *right) {
1219 assert (node->op == op_Mul);
1220 set_irn_n(node, 1, right);
1224 get_Quot_left (ir_node *node) {
1225 assert (node->op == op_Quot);
1226 return get_irn_n(node, 1);
1230 set_Quot_left (ir_node *node, ir_node *left) {
1231 assert (node->op == op_Quot);
1232 set_irn_n(node, 1, left);
1236 get_Quot_right (ir_node *node) {
1237 assert (node->op == op_Quot);
1238 return get_irn_n(node, 2);
1242 set_Quot_right (ir_node *node, ir_node *right) {
1243 assert (node->op == op_Quot);
1244 set_irn_n(node, 2, right);
1248 get_Quot_mem (ir_node *node) {
1249 assert (node->op == op_Quot);
1250 return get_irn_n(node, 0);
1254 set_Quot_mem (ir_node *node, ir_node *mem) {
1255 assert (node->op == op_Quot);
1256 set_irn_n(node, 0, mem);
1260 get_DivMod_left (ir_node *node) {
1261 assert (node->op == op_DivMod);
1262 return get_irn_n(node, 1);
1266 set_DivMod_left (ir_node *node, ir_node *left) {
1267 assert (node->op == op_DivMod);
1268 set_irn_n(node, 1, left);
1272 get_DivMod_right (ir_node *node) {
1273 assert (node->op == op_DivMod);
1274 return get_irn_n(node, 2);
1278 set_DivMod_right (ir_node *node, ir_node *right) {
1279 assert (node->op == op_DivMod);
1280 set_irn_n(node, 2, right);
1284 get_DivMod_mem (ir_node *node) {
1285 assert (node->op == op_DivMod);
1286 return get_irn_n(node, 0);
1290 set_DivMod_mem (ir_node *node, ir_node *mem) {
1291 assert (node->op == op_DivMod);
1292 set_irn_n(node, 0, mem);
1296 get_Div_left (ir_node *node) {
1297 assert (node->op == op_Div);
1298 return get_irn_n(node, 1);
1302 set_Div_left (ir_node *node, ir_node *left) {
1303 assert (node->op == op_Div);
1304 set_irn_n(node, 1, left);
1308 get_Div_right (ir_node *node) {
1309 assert (node->op == op_Div);
1310 return get_irn_n(node, 2);
1314 set_Div_right (ir_node *node, ir_node *right) {
1315 assert (node->op == op_Div);
1316 set_irn_n(node, 2, right);
1320 get_Div_mem (ir_node *node) {
1321 assert (node->op == op_Div);
1322 return get_irn_n(node, 0);
1326 set_Div_mem (ir_node *node, ir_node *mem) {
1327 assert (node->op == op_Div);
1328 set_irn_n(node, 0, mem);
1332 get_Mod_left (ir_node *node) {
1333 assert (node->op == op_Mod);
1334 return get_irn_n(node, 1);
1338 set_Mod_left (ir_node *node, ir_node *left) {
1339 assert (node->op == op_Mod);
1340 set_irn_n(node, 1, left);
1344 get_Mod_right (ir_node *node) {
1345 assert (node->op == op_Mod);
1346 return get_irn_n(node, 2);
1350 set_Mod_right (ir_node *node, ir_node *right) {
1351 assert (node->op == op_Mod);
1352 set_irn_n(node, 2, right);
1356 get_Mod_mem (ir_node *node) {
1357 assert (node->op == op_Mod);
1358 return get_irn_n(node, 0);
1362 set_Mod_mem (ir_node *node, ir_node *mem) {
1363 assert (node->op == op_Mod);
1364 set_irn_n(node, 0, mem);
1368 get_Abs_op (ir_node *node) {
1369 assert (node->op == op_Abs);
1370 return get_irn_n(node, 0);
1374 set_Abs_op (ir_node *node, ir_node *op) {
1375 assert (node->op == op_Abs);
1376 set_irn_n(node, 0, op);
1380 get_And_left (ir_node *node) {
1381 assert (node->op == op_And);
1382 return get_irn_n(node, 0);
1386 set_And_left (ir_node *node, ir_node *left) {
1387 assert (node->op == op_And);
1388 set_irn_n(node, 0, left);
1392 get_And_right (ir_node *node) {
1393 assert (node->op == op_And);
1394 return get_irn_n(node, 1);
1398 set_And_right (ir_node *node, ir_node *right) {
1399 assert (node->op == op_And);
1400 set_irn_n(node, 1, right);
1404 get_Or_left (ir_node *node) {
1405 assert (node->op == op_Or);
1406 return get_irn_n(node, 0);
1410 set_Or_left (ir_node *node, ir_node *left) {
1411 assert (node->op == op_Or);
1412 set_irn_n(node, 0, left);
1416 get_Or_right (ir_node *node) {
1417 assert (node->op == op_Or);
1418 return get_irn_n(node, 1);
1422 set_Or_right (ir_node *node, ir_node *right) {
1423 assert (node->op == op_Or);
1424 set_irn_n(node, 1, right);
1428 get_Eor_left (ir_node *node) {
1429 assert (node->op == op_Eor);
1430 return get_irn_n(node, 0);
1434 set_Eor_left (ir_node *node, ir_node *left) {
1435 assert (node->op == op_Eor);
1436 set_irn_n(node, 0, left);
1440 get_Eor_right (ir_node *node) {
1441 assert (node->op == op_Eor);
1442 return get_irn_n(node, 1);
1446 set_Eor_right (ir_node *node, ir_node *right) {
1447 assert (node->op == op_Eor);
1448 set_irn_n(node, 1, right);
1453 get_Not_op (ir_node *node) {
1454 assert (node->op == op_Not);
1455 return get_irn_n(node, 0);
1459 set_Not_op (ir_node *node, ir_node *op) {
1460 assert (node->op == op_Not);
1461 set_irn_n(node, 0, op);
1466 get_Shl_left (ir_node *node) {
1467 assert (node->op == op_Shl);
1468 return get_irn_n(node, 0);
1472 set_Shl_left (ir_node *node, ir_node *left) {
1473 assert (node->op == op_Shl);
1474 set_irn_n(node, 0, left);
1478 get_Shl_right (ir_node *node) {
1479 assert (node->op == op_Shl);
1480 return get_irn_n(node, 1);
1484 set_Shl_right (ir_node *node, ir_node *right) {
1485 assert (node->op == op_Shl);
1486 set_irn_n(node, 1, right);
1490 get_Shr_left (ir_node *node) {
1491 assert (node->op == op_Shr);
1492 return get_irn_n(node, 0);
1496 set_Shr_left (ir_node *node, ir_node *left) {
1497 assert (node->op == op_Shr);
1498 set_irn_n(node, 0, left);
1502 get_Shr_right (ir_node *node) {
1503 assert (node->op == op_Shr);
1504 return get_irn_n(node, 1);
1508 set_Shr_right (ir_node *node, ir_node *right) {
1509 assert (node->op == op_Shr);
1510 set_irn_n(node, 1, right);
1514 get_Shrs_left (ir_node *node) {
1515 assert (node->op == op_Shrs);
1516 return get_irn_n(node, 0);
1520 set_Shrs_left (ir_node *node, ir_node *left) {
1521 assert (node->op == op_Shrs);
1522 set_irn_n(node, 0, left);
1526 get_Shrs_right (ir_node *node) {
1527 assert (node->op == op_Shrs);
1528 return get_irn_n(node, 1);
1532 set_Shrs_right (ir_node *node, ir_node *right) {
1533 assert (node->op == op_Shrs);
1534 set_irn_n(node, 1, right);
1538 get_Rot_left (ir_node *node) {
1539 assert (node->op == op_Rot);
1540 return get_irn_n(node, 0);
1544 set_Rot_left (ir_node *node, ir_node *left) {
1545 assert (node->op == op_Rot);
1546 set_irn_n(node, 0, left);
1550 get_Rot_right (ir_node *node) {
1551 assert (node->op == op_Rot);
1552 return get_irn_n(node, 1);
1556 set_Rot_right (ir_node *node, ir_node *right) {
1557 assert (node->op == op_Rot);
1558 set_irn_n(node, 1, right);
1562 get_Cmp_left (ir_node *node) {
1563 assert (node->op == op_Cmp);
1564 return get_irn_n(node, 0);
1568 set_Cmp_left (ir_node *node, ir_node *left) {
1569 assert (node->op == op_Cmp);
1570 set_irn_n(node, 0, left);
1574 get_Cmp_right (ir_node *node) {
1575 assert (node->op == op_Cmp);
1576 return get_irn_n(node, 1);
1580 set_Cmp_right (ir_node *node, ir_node *right) {
1581 assert (node->op == op_Cmp);
1582 set_irn_n(node, 1, right);
1586 get_Conv_op (ir_node *node) {
1587 assert (node->op == op_Conv);
1588 return get_irn_n(node, 0);
1592 set_Conv_op (ir_node *node, ir_node *op) {
1593 assert (node->op == op_Conv);
1594 set_irn_n(node, 0, op);
1600 is_unop (ir_node *node) {
1601 return ( node->op == op_Minus ||
1602 node->op == op_Abs ||
1603 node->op == op_Not ||
1604 node->op == op_Conv );
1608 get_unop_op (ir_node *node) {
1609 assert ( node->op == op_Minus ||
1610 node->op == op_Abs ||
1611 node->op == op_Not ||
1612 node->op == op_Conv );
1613 switch (get_irn_opcode (node)) {
1614 case iro_Minus: return get_Minus_op(node); break;
1615 case iro_Abs: return get_Abs_op(node); break;
1616 case iro_Not: return get_Not_op(node); break;
1617 case iro_Conv: return get_Conv_op(node); break;
1618 default: return NULL;
1623 set_unop_op (ir_node *node, ir_node *op) {
1624 assert (node->op == op_Minus ||
1625 node->op == op_Abs ||
1626 node->op == op_Not ||
1627 node->op == op_Conv );
1628 switch (get_irn_opcode (node)) {
1629 case iro_Minus: set_Minus_op(node, op); break;
1630 case iro_Abs: set_Abs_op(node, op); break;
1631 case iro_Not: set_Not_op(node, op); break;
1632 case iro_Conv: set_Conv_op(node, op); break;
1639 is_binop (ir_node *node) {
1640 return (node->op == op_Add ||
1641 node->op == op_Sub ||
1642 node->op == op_Mul ||
1643 node->op == op_Quot ||
1644 node->op == op_DivMod ||
1645 node->op == op_Div ||
1646 node->op == op_Mod ||
1647 node->op == op_And ||
1648 node->op == op_Or ||
1649 node->op == op_Eor ||
1650 node->op == op_Shl ||
1651 node->op == op_Shr ||
1652 node->op == op_Shrs ||
1653 node->op == op_Rot ||
1654 node->op == op_Cmp );
1658 get_binop_left (ir_node *node) {
1659 assert (node->op == op_Add ||
1660 node->op == op_Sub ||
1661 node->op == op_Mul ||
1662 node->op == op_Quot ||
1663 node->op == op_DivMod ||
1664 node->op == op_Div ||
1665 node->op == op_Mod ||
1666 node->op == op_And ||
1667 node->op == op_Or ||
1668 node->op == op_Eor ||
1669 node->op == op_Shl ||
1670 node->op == op_Shr ||
1671 node->op == op_Shrs ||
1672 node->op == op_Rot ||
1673 node->op == op_Cmp );
1675 switch (get_irn_opcode (node)) {
1676 case iro_Add : return get_Add_left(node); break;
1677 case iro_Sub : return get_Sub_left(node); break;
1678 case iro_Mul : return get_Mul_left(node); break;
1679 case iro_Quot : return get_Quot_left(node); break;
1680 case iro_DivMod: return get_DivMod_left(node); break;
1681 case iro_Div : return get_Div_left(node); break;
1682 case iro_Mod : return get_Mod_left(node); break;
1683 case iro_And : return get_And_left(node); break;
1684 case iro_Or : return get_Or_left(node); break;
1685 case iro_Eor : return get_Eor_left(node); break;
1686 case iro_Shl : return get_Shl_left(node); break;
1687 case iro_Shr : return get_Shr_left(node); break;
1688 case iro_Shrs : return get_Shrs_left(node); break;
1689 case iro_Rot : return get_Rot_left(node); break;
1690 case iro_Cmp : return get_Cmp_left(node); break;
1691 default: return NULL;
1696 set_binop_left (ir_node *node, ir_node *left) {
1697 assert (node->op == op_Add ||
1698 node->op == op_Sub ||
1699 node->op == op_Mul ||
1700 node->op == op_Quot ||
1701 node->op == op_DivMod ||
1702 node->op == op_Div ||
1703 node->op == op_Mod ||
1704 node->op == op_And ||
1705 node->op == op_Or ||
1706 node->op == op_Eor ||
1707 node->op == op_Shl ||
1708 node->op == op_Shr ||
1709 node->op == op_Shrs ||
1710 node->op == op_Rot ||
1711 node->op == op_Cmp );
1713 switch (get_irn_opcode (node)) {
1714 case iro_Add : set_Add_left(node, left); break;
1715 case iro_Sub : set_Sub_left(node, left); break;
1716 case iro_Mul : set_Mul_left(node, left); break;
1717 case iro_Quot : set_Quot_left(node, left); break;
1718 case iro_DivMod: set_DivMod_left(node, left); break;
1719 case iro_Div : set_Div_left(node, left); break;
1720 case iro_Mod : set_Mod_left(node, left); break;
1721 case iro_And : set_And_left(node, left); break;
1722 case iro_Or : set_Or_left(node, left); break;
1723 case iro_Eor : set_Eor_left(node, left); break;
1724 case iro_Shl : set_Shl_left(node, left); break;
1725 case iro_Shr : set_Shr_left(node, left); break;
1726 case iro_Shrs : set_Shrs_left(node, left); break;
1727 case iro_Rot : set_Rot_left(node, left); break;
1728 case iro_Cmp : set_Cmp_left(node, left); break;
1734 get_binop_right (ir_node *node) {
1735 assert (node->op == op_Add ||
1736 node->op == op_Sub ||
1737 node->op == op_Mul ||
1738 node->op == op_Quot ||
1739 node->op == op_DivMod ||
1740 node->op == op_Div ||
1741 node->op == op_Mod ||
1742 node->op == op_And ||
1743 node->op == op_Or ||
1744 node->op == op_Eor ||
1745 node->op == op_Shl ||
1746 node->op == op_Shr ||
1747 node->op == op_Shrs ||
1748 node->op == op_Rot ||
1749 node->op == op_Cmp );
1751 switch (get_irn_opcode (node)) {
1752 case iro_Add : return get_Add_right(node); break;
1753 case iro_Sub : return get_Sub_right(node); break;
1754 case iro_Mul : return get_Mul_right(node); break;
1755 case iro_Quot : return get_Quot_right(node); break;
1756 case iro_DivMod: return get_DivMod_right(node); break;
1757 case iro_Div : return get_Div_right(node); break;
1758 case iro_Mod : return get_Mod_right(node); break;
1759 case iro_And : return get_And_right(node); break;
1760 case iro_Or : return get_Or_right(node); break;
1761 case iro_Eor : return get_Eor_right(node); break;
1762 case iro_Shl : return get_Shl_right(node); break;
1763 case iro_Shr : return get_Shr_right(node); break;
1764 case iro_Shrs : return get_Shrs_right(node); break;
1765 case iro_Rot : return get_Rot_right(node); break;
1766 case iro_Cmp : return get_Cmp_right(node); break;
1767 default: return NULL;
1772 set_binop_right (ir_node *node, ir_node *right) {
1773 assert (node->op == op_Add ||
1774 node->op == op_Sub ||
1775 node->op == op_Mul ||
1776 node->op == op_Quot ||
1777 node->op == op_DivMod ||
1778 node->op == op_Div ||
1779 node->op == op_Mod ||
1780 node->op == op_And ||
1781 node->op == op_Or ||
1782 node->op == op_Eor ||
1783 node->op == op_Shl ||
1784 node->op == op_Shr ||
1785 node->op == op_Shrs ||
1786 node->op == op_Rot ||
1787 node->op == op_Cmp );
1789 switch (get_irn_opcode (node)) {
1790 case iro_Add : set_Add_right(node, right); break;
1791 case iro_Sub : set_Sub_right(node, right); break;
1792 case iro_Mul : set_Mul_right(node, right); break;
1793 case iro_Quot : set_Quot_right(node, right); break;
1794 case iro_DivMod: set_DivMod_right(node, right); break;
1795 case iro_Div : set_Div_right(node, right); break;
1796 case iro_Mod : set_Mod_right(node, right); break;
1797 case iro_And : set_And_right(node, right); break;
1798 case iro_Or : set_Or_right(node, right); break;
1799 case iro_Eor : set_Eor_right(node, right); break;
1800 case iro_Shl : set_Shl_right(node, right); break;
1801 case iro_Shr : set_Shr_right(node, right); break;
1802 case iro_Shrs : set_Shrs_right(node, right); break;
1803 case iro_Rot : set_Rot_right(node, right); break;
1804 case iro_Cmp : set_Cmp_right(node, right); break;
1811 get_Phi_preds_arr (ir_node *node) {
1812 assert (node->op == op_Phi);
1813 return (ir_node **)&(get_irn_in(node)[1]);
1817 get_Phi_n_preds (ir_node *node) {
1818 assert (node->op == op_Phi);
1819 return (get_irn_arity(node));
1823 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1824 assert (node->op == op_Phi);
1829 get_Phi_pred (ir_node *node, int pos) {
1830 assert (node->op == op_Phi);
1831 return get_irn_n(node, pos);
1835 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1836 assert (node->op == op_Phi);
1837 set_irn_n(node, pos, pred);
1841 get_Load_mem (ir_node *node) {
1842 assert (node->op == op_Load);
1843 return get_irn_n(node, 0);
1847 set_Load_mem (ir_node *node, ir_node *mem) {
1848 assert (node->op == op_Load);
1849 set_irn_n(node, 0, mem);
1853 get_Load_ptr (ir_node *node) {
1854 assert (node->op == op_Load);
1855 return get_irn_n(node, 1);
1859 set_Load_ptr (ir_node *node, ir_node *ptr) {
1860 assert (node->op == op_Load);
1861 set_irn_n(node, 1, ptr);
1866 get_Store_mem (ir_node *node) {
1867 assert (node->op == op_Store);
1868 return get_irn_n(node, 0);
1872 set_Store_mem (ir_node *node, ir_node *mem) {
1873 assert (node->op == op_Store);
1874 set_irn_n(node, 0, mem);
1878 get_Store_ptr (ir_node *node) {
1879 assert (node->op == op_Store);
1880 return get_irn_n(node, 1);
1884 set_Store_ptr (ir_node *node, ir_node *ptr) {
1885 assert (node->op == op_Store);
1886 set_irn_n(node, 1, ptr);
1890 get_Store_value (ir_node *node) {
1891 assert (node->op == op_Store);
1892 return get_irn_n(node, 2);
1896 set_Store_value (ir_node *node, ir_node *value) {
1897 assert (node->op == op_Store);
1898 set_irn_n(node, 2, value);
1902 get_Alloc_mem (ir_node *node) {
1903 assert (node->op == op_Alloc);
1904 return get_irn_n(node, 0);
1908 set_Alloc_mem (ir_node *node, ir_node *mem) {
1909 assert (node->op == op_Alloc);
1910 set_irn_n(node, 0, mem);
1914 get_Alloc_size (ir_node *node) {
1915 assert (node->op == op_Alloc);
1916 return get_irn_n(node, 1);
1920 set_Alloc_size (ir_node *node, ir_node *size) {
1921 assert (node->op == op_Alloc);
1922 set_irn_n(node, 1, size);
1926 get_Alloc_type (ir_node *node) {
1927 assert (node->op == op_Alloc);
1928 return node->attr.a.type = skip_tid(node->attr.a.type);
1932 set_Alloc_type (ir_node *node, type *tp) {
1933 assert (node->op == op_Alloc);
1934 node->attr.a.type = tp;
1938 get_Alloc_where (ir_node *node) {
1939 assert (node->op == op_Alloc);
1940 return node->attr.a.where;
1944 set_Alloc_where (ir_node *node, where_alloc where) {
1945 assert (node->op == op_Alloc);
1946 node->attr.a.where = where;
1951 get_Free_mem (ir_node *node) {
1952 assert (node->op == op_Free);
1953 return get_irn_n(node, 0);
1957 set_Free_mem (ir_node *node, ir_node *mem) {
1958 assert (node->op == op_Free);
1959 set_irn_n(node, 0, mem);
1963 get_Free_ptr (ir_node *node) {
1964 assert (node->op == op_Free);
1965 return get_irn_n(node, 1);
1969 set_Free_ptr (ir_node *node, ir_node *ptr) {
1970 assert (node->op == op_Free);
1971 set_irn_n(node, 1, ptr);
1975 get_Free_size (ir_node *node) {
1976 assert (node->op == op_Free);
1977 return get_irn_n(node, 2);
1981 set_Free_size (ir_node *node, ir_node *size) {
1982 assert (node->op == op_Free);
1983 set_irn_n(node, 2, size);
1987 get_Free_type (ir_node *node) {
1988 assert (node->op == op_Free);
1989 return node->attr.f = skip_tid(node->attr.f);
1993 set_Free_type (ir_node *node, type *tp) {
1994 assert (node->op == op_Free);
1999 get_Sync_preds_arr (ir_node *node) {
2000 assert (node->op == op_Sync);
2001 return (ir_node **)&(get_irn_in(node)[1]);
2005 get_Sync_n_preds (ir_node *node) {
2006 assert (node->op == op_Sync);
2007 return (get_irn_arity(node));
2012 set_Sync_n_preds (ir_node *node, int n_preds) {
2013 assert (node->op == op_Sync);
2018 get_Sync_pred (ir_node *node, int pos) {
2019 assert (node->op == op_Sync);
2020 return get_irn_n(node, pos);
2024 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
2025 assert (node->op == op_Sync);
2026 set_irn_n(node, pos, pred);
2030 get_Proj_pred (ir_node *node) {
2031 assert (is_Proj(node));
2032 return get_irn_n(node, 0);
2036 set_Proj_pred (ir_node *node, ir_node *pred) {
2037 assert (is_Proj(node));
2038 set_irn_n(node, 0, pred);
2042 get_Proj_proj (ir_node *node) {
2043 assert (is_Proj(node));
2044 if (get_irn_opcode(node) == iro_Proj) {
2045 return node->attr.proj;
2047 assert(get_irn_opcode(node) == iro_Filter);
2048 return node->attr.filter.proj;
2053 set_Proj_proj (ir_node *node, long proj) {
2054 assert (node->op == op_Proj);
2055 node->attr.proj = proj;
2059 get_Tuple_preds_arr (ir_node *node) {
2060 assert (node->op == op_Tuple);
2061 return (ir_node **)&(get_irn_in(node)[1]);
2065 get_Tuple_n_preds (ir_node *node) {
2066 assert (node->op == op_Tuple);
2067 return (get_irn_arity(node));
2072 set_Tuple_n_preds (ir_node *node, int n_preds) {
2073 assert (node->op == op_Tuple);
2078 get_Tuple_pred (ir_node *node, int pos) {
2079 assert (node->op == op_Tuple);
2080 return get_irn_n(node, pos);
2084 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2085 assert (node->op == op_Tuple);
2086 set_irn_n(node, pos, pred);
2090 get_Id_pred (ir_node *node) {
2091 assert (node->op == op_Id);
2092 return get_irn_n(node, 0);
2096 set_Id_pred (ir_node *node, ir_node *pred) {
2097 assert (node->op == op_Id);
2098 set_irn_n(node, 0, pred);
2103 get_Filter_pred (ir_node *node) {
2104 assert(node->op == op_Filter);
2108 set_Filter_pred (ir_node *node, ir_node *pred) {
2109 assert(node->op == op_Filter);
2113 get_Filter_proj(ir_node *node) {
2114 assert(node->op == op_Filter);
2115 return node->attr.filter.proj;
2118 set_Filter_proj (ir_node *node, long proj) {
2119 assert(node->op == op_Filter);
2120 node->attr.filter.proj = proj;
2123 /* Don't use get_irn_arity, get_irn_n in implementation as access
2124 shall work independent of view!!! */
2125 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2126 assert(node->op == op_Filter);
2127 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2128 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2129 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2130 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2131 node->attr.filter.in_cg[0] = node->in[0];
2133 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2136 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2137 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2138 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2139 node->attr.filter.in_cg[pos + 1] = pred;
2141 int get_Filter_n_cg_preds(ir_node *node) {
2142 assert(node->op == op_Filter && node->attr.filter.in_cg);
2143 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2145 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2147 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2149 arity = ARR_LEN(node->attr.filter.in_cg);
2150 assert(pos < arity - 1);
2151 return node->attr.filter.in_cg[pos + 1];
2156 get_irn_irg(ir_node *node) {
2157 if (get_irn_op(node) == op_CallBegin) {
2158 return node->attr.callbegin.irg;
2159 } else if (get_irn_op(node) == op_EndReg ||
2160 get_irn_op(node) == op_EndExcept) {
2161 return node->attr.end.irg;
2163 assert(0 && "no irg attr");
2168 /******************************************************************/
2169 /* Auxiliary routines */
2170 /******************************************************************/
2173 skip_Proj (ir_node *node) {
2174 /* don't assert node !!! */
2175 if (node && is_Proj(node)) {
2176 return get_Proj_pred(node);
2183 skip_Tuple (ir_node *node) {
2186 node = skip_nop(node);
2187 if (get_irn_op(node) == op_Proj) {
2188 pred = skip_nop(get_Proj_pred(node));
2189 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2190 pred = skip_nop(skip_Tuple(pred));
2191 if (get_irn_op(pred) == op_Tuple)
2192 return get_Tuple_pred(pred, get_Proj_proj(node));
2198 skip_nop (ir_node *node) {
2199 /* don't assert node !!! */
2201 /* Don't use get_Id_pred: We get into an endless loop for
2202 self-referencing Ids. */
2203 if (node && (node->op == op_Id) && (node != node->in[0+1])) {
2204 assert (get_irn_arity (node) > 0);
2205 return node->in[0+1];
2212 skip_Id (ir_node *node) {
2213 return skip_nop(node);
2217 is_Bad (ir_node *node) {
2219 if ((node) && get_irn_opcode(node) == iro_Bad)
2225 is_no_Block (ir_node *node) {
2227 return (get_irn_opcode(node) != iro_Block);
2231 is_Block (ir_node *node) {
2233 return (get_irn_opcode(node) == iro_Block);
2237 is_Proj (ir_node *node) {
2239 return node->op == op_Proj
2240 || (!interprocedural_view && node->op == op_Filter);
2243 /* Returns true if the operation manipulates control flow. */
2245 is_cfop(ir_node *node) {
2246 return is_cfopcode(get_irn_op(node));
2249 /* Returns true if the operation manipulates interprocedural control flow:
2250 CallBegin, EndReg, EndExcept */
2251 INLINE int is_ip_cfop(ir_node *node) {
2252 return is_ip_cfopcode(get_irn_op(node));
2255 ir_graph *get_ip_cfop_irg(ir_node *n) {
2256 switch (get_irn_opcode(n)) {
2258 return get_EndReg_irg(n);
2260 return get_EndExcept_irg(n);
2262 return get_CallBegin_irg(n);
2264 assert(is_ip_cfop(n));
2266 return NULL; /* should never be reached */
2269 /* Returns true if the operation can change the control flow because
2272 is_fragile_op(ir_node *node) {
2273 return ( (get_irn_opcode(node) == iro_Call)
2274 || (get_irn_opcode(node) == iro_Quot)
2275 || (get_irn_opcode(node) == iro_DivMod)
2276 || (get_irn_opcode(node) == iro_Div)
2277 || (get_irn_opcode(node) == iro_Mod)
2278 || (get_irn_opcode(node) == iro_Load)
2279 || (get_irn_opcode(node) == iro_Store)
2280 || (get_irn_opcode(node) == iro_Alloc)
2281 || (get_irn_opcode(node) == iro_Bad)
2282 || (get_irn_opcode(node) == iro_Unknown));
2286 /* Returns the memory operand of fragile operations. */
2287 ir_node *get_fragile_op_mem(ir_node *node) {
2288 assert(node && is_fragile_op(node));
2290 switch (get_irn_opcode (node)) {
2299 return get_irn_n(node, 0);
2304 assert(0 && "not reached");