1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
16 #include "irgraph_t.h"
19 #include "typegmod_t.h"
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 memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
254 /* to iterate through the predecessors without touching the array */
255 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
256 to iterate includind the Block predecessor iterate from i = -1 to
258 If it is a block, the entry -1 is NULL. */
260 get_irn_n (ir_node *node, int n) {
262 if (-1 > n || get_irn_arity(node) <= n) {
263 printf("pos: %d, arity: %d ", n, get_irn_arity(node));
266 assert(node); assert(-1 <= n && n < get_irn_arity(node));
267 if (interprocedural_view) { /* handle Filter and Block specially */
268 if (get_irn_opcode(node) == iro_Filter) {
269 assert(node->attr.filter.in_cg);
270 return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
271 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
272 return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
274 /* else fall through */
276 return (node->in[n + 1] = skip_nop(node->in[n + 1]));
280 set_irn_n (ir_node *node, int n, ir_node *in) {
281 assert(node && -1 <= n && n < get_irn_arity(node));
282 if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
283 /* Change block pred in both views! */
284 node->in[n + 1] = in;
285 assert(node->attr.filter.in_cg);
286 node->attr.filter.in_cg[n + 1] = in;
289 if (interprocedural_view) { /* handle Filter and Block specially */
290 if (get_irn_opcode(node) == iro_Filter) {
291 assert(node->attr.filter.in_cg);
292 node->attr.filter.in_cg[n + 1] = in;
294 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
295 node->attr.block.in_cg[n + 1] = in;
298 /* else fall through */
300 node->in[n + 1] = in;
304 get_irn_mode (ir_node *node)
311 get_irn_modecode (ir_node *node)
314 return node->mode->code;
319 get_irn_modeident (ir_node *node)
322 return node->mode->name;
326 get_irn_op (ir_node *node)
332 /* should be private to the library: */
334 set_irn_op (ir_node *node, ir_op *op)
341 get_irn_opcode (ir_node *node)
344 return node->op->code;
348 get_irn_opname (ir_node *node)
351 return id_to_str(node->op->name);
355 get_irn_opident (ir_node *node)
358 return node->op->name;
362 get_irn_visited (ir_node *node)
365 return node->visited;
369 set_irn_visited (ir_node *node, unsigned long visited)
372 node->visited = visited;
376 mark_irn_visited (ir_node *node) {
378 node->visited = current_ir_graph->visited;
382 irn_not_visited (ir_node *node) {
384 return (node->visited < current_ir_graph->visited);
388 irn_visited (ir_node *node) {
390 return (node->visited >= current_ir_graph->visited);
394 set_irn_link (ir_node *node, void *link) {
396 /* Link field is used for Phi construction and various optimizations
398 assert(get_irg_phase_state(current_ir_graph) != phase_building);
404 get_irn_link (ir_node *node) {
409 /* Outputs a unique number for this node */
411 get_irn_node_nr(ir_node *node) {
414 return node->node_nr;
421 get_irn_const_attr (ir_node *node)
423 assert (node->op == op_Const);
424 return node->attr.con;
428 get_irn_proj_attr (ir_node *node)
430 assert (node->op == op_Proj);
431 return node->attr.proj;
435 get_irn_alloc_attr (ir_node *node)
437 assert (node->op == op_Alloc);
442 get_irn_free_attr (ir_node *node)
444 assert (node->op == op_Free);
445 return node->attr.f = skip_tid(node->attr.f);
449 get_irn_symconst_attr (ir_node *node)
451 assert (node->op == op_SymConst);
456 get_irn_call_attr (ir_node *node)
458 assert (node->op == op_Call);
459 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
463 get_irn_sel_attr (ir_node *node)
465 assert (node->op == op_Sel);
470 get_irn_phi_attr (ir_node *node)
472 assert (node->op == op_Phi);
473 return node->attr.phi0_pos;
477 get_irn_block_attr (ir_node *node)
479 assert (node->op == op_Block);
480 return node->attr.block;
483 /** manipulate fields of individual nodes **/
485 /* this works for all except Block */
487 get_nodes_Block (ir_node *node) {
488 assert (!(node->op == op_Block));
489 return get_irn_n(node, -1);
493 set_nodes_Block (ir_node *node, ir_node *block) {
494 assert (!(node->op == op_Block));
495 set_irn_n(node, -1, block);
498 /* Returns an array with the predecessors of the Block. Depending on
499 the implementation of the graph datastructure this can be a copy of
500 the internal representation of predecessors as well as the internal
501 array itself. Therefore writing to this array might obstruct the ir. */
503 get_Block_cfgpred_arr (ir_node *node)
505 assert ((node->op == op_Block));
506 return (ir_node **)&(get_irn_in(node)[1]);
511 get_Block_n_cfgpreds (ir_node *node) {
512 assert ((node->op == op_Block));
513 return (get_irn_arity(node));
517 get_Block_cfgpred (ir_node *node, int pos) {
518 assert (node->op == op_Block);
520 if (-1 > pos || get_irn_arity(node) <= pos) {
521 dump_ir_block_graph(current_ir_graph);
522 printf("pos: %d, arity: %d ", pos, get_irn_arity(node));
525 assert(node); assert(-1 <= pos && pos < get_irn_arity(node));
526 return get_irn_n(node, pos);
530 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
531 assert (node->op == op_Block);
532 set_irn_n(node, pos, pred);
536 get_Block_matured (ir_node *node) {
537 assert (node->op == op_Block);
538 return node->attr.block.matured;
542 set_Block_matured (ir_node *node, bool matured) {
543 assert (node->op == op_Block);
544 node->attr.block.matured = matured;
547 get_Block_block_visited (ir_node *node) {
548 assert (node->op == op_Block);
549 return node->attr.block.block_visited;
553 set_Block_block_visited (ir_node *node, unsigned long visit) {
554 assert (node->op == op_Block);
555 node->attr.block.block_visited = visit;
558 /* For this current_ir_graph must be set. */
560 mark_Block_block_visited (ir_node *node) {
561 assert (node->op == op_Block);
562 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
566 Block_not_block_visited(ir_node *node) {
567 assert (node->op == op_Block);
568 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
572 get_Block_graph_arr (ir_node *node, int pos) {
573 assert (node->op == op_Block);
574 return node->attr.block.graph_arr[pos+1];
578 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
579 assert (node->op == op_Block);
580 node->attr.block.graph_arr[pos+1] = value;
583 /* handler handling for Blocks */
585 set_Block_handler (ir_node *block, ir_node *handler) {
586 assert ((block->op == op_Block));
587 assert ((handler->op == op_Block));
588 block->attr.block.handler_entry = handler;
592 get_Block_handler (ir_node *block) {
593 assert ((block->op == op_Block));
594 return (block->attr.block.handler_entry);
597 /* handler handling for Nodes */
599 set_Node_handler (ir_node *node, ir_node *handler) {
600 set_Block_handler (get_nodes_Block (node), handler);
604 get_Node_handler (ir_node *node) {
605 return (get_Block_handler (get_nodes_Block (node)));
608 /* exc_t handling for Blocks */
609 void set_Block_exc (ir_node *block, exc_t exc) {
610 assert ((block->op == op_Block));
611 block->attr.block.exc = exc;
614 exc_t get_Block_exc (ir_node *block) {
615 assert ((block->op == op_Block));
617 return (block->attr.block.exc);
620 /* exc_t handling for Nodes */
621 void set_Node_exc (ir_node *node, exc_t exc) {
622 set_Block_exc (get_nodes_Block (node), exc);
625 exc_t get_Node_exc (ir_node *node) {
626 return (get_Block_exc (get_nodes_Block (node)));
629 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
630 assert(node->op == op_Block);
631 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
632 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
633 node->attr.block.in_cg[0] = NULL;
634 node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
636 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
639 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
640 assert(node->op == op_Block &&
641 node->attr.block.in_cg &&
642 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
643 node->attr.block.in_cg[pos + 1] = pred;
646 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
647 assert(node->op == op_Block);
648 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
651 int get_Block_cg_n_cfgpreds(ir_node * node) {
652 assert(node->op == op_Block);
653 return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
656 ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
657 assert(node->op == op_Block && node->attr.block.in_cg);
658 return node->attr.block.in_cg[pos + 1];
661 void remove_Block_cg_cfgpred_arr(ir_node * node) {
662 assert(node->op == op_Block);
663 node->attr.block.in_cg = NULL;
667 get_End_n_keepalives(ir_node *end) {
668 assert (end->op == op_End);
669 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
673 get_End_keepalive(ir_node *end, int pos) {
674 assert (end->op == op_End);
675 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
679 add_End_keepalive (ir_node *end, ir_node *ka) {
680 assert (end->op == op_End);
681 ARR_APP1 (ir_node *, end->in, ka);
685 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
686 assert (end->op == op_End);
687 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
691 free_End (ir_node *end) {
692 assert (end->op == op_End);
693 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
694 end->in = NULL; /* @@@ make sure we get an error if we use the
695 in array afterwards ... */
698 ir_graph *get_EndReg_irg (ir_node *end) {
699 assert (end->op == op_EndReg);
700 return end->attr.end.irg;
703 ir_graph *get_EndExcept_irg (ir_node *end) {
704 assert (end->op == op_EndReg);
705 return end->attr.end.irg;
709 > Implementing the case construct (which is where the constant Proj node is
710 > important) involves far more than simply determining the constant values.
711 > We could argue that this is more properly a function of the translator from
712 > Firm to the target machine. That could be done if there was some way of
713 > projecting "default" out of the Cond node.
714 I know it's complicated.
715 Basically there are two proglems:
716 - determining the gaps between the projs
717 - determining the biggest case constant to konw the proj number for
719 I see several solutions:
720 1. Introduce a ProjDefault node. Solves both problems.
721 This means to extend all optimizations executed during construction.
722 2. Give the Cond node for switch two flavors:
723 a) there are no gaps in the projs (existing flavor)
724 b) gaps may exist, default proj is still the Proj with the largest
725 projection number. This covers also the gaps.
726 3. Fix the semantic of the Cond to that of 2b)
728 Solution 2 seems to be the best:
729 Computing the gaps in the Firm representation is not too hard, i.e.,
730 libfirm can implement a routine that transforms betweeen the two
731 flavours. This is also possible for 1) but 2) does not require to
732 change any existing optimization.
733 Further it should be far simpler to determine the biggest constant than
735 I don't want to choose 3) as 2a) seems to have advantages for
736 dataflow analysis and 3) does not allow to convert the representation to
740 get_Cond_selector (ir_node *node) {
741 assert (node->op == op_Cond);
742 return get_irn_n(node, 0);
746 set_Cond_selector (ir_node *node, ir_node *selector) {
747 assert (node->op == op_Cond);
748 set_irn_n(node, 0, selector);
752 get_Cond_kind (ir_node *node) {
753 assert (node->op == op_Cond);
754 return node->attr.c.kind;
758 set_Cond_kind (ir_node *node, cond_kind kind) {
759 assert (node->op == op_Cond);
760 node->attr.c.kind = kind;
764 get_Return_mem (ir_node *node) {
765 assert (node->op == op_Return);
766 return get_irn_n(node, 0);
770 set_Return_mem (ir_node *node, ir_node *mem) {
771 assert (node->op == op_Return);
772 set_irn_n(node, 0, mem);
776 get_Return_n_ress (ir_node *node) {
777 assert (node->op == op_Return);
778 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
782 get_Return_res_arr (ir_node *node)
784 assert ((node->op == op_Return));
785 if (get_Return_n_ress(node) > 0)
786 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
793 set_Return_n_res (ir_node *node, int results) {
794 assert (node->op == op_Return);
799 get_Return_res (ir_node *node, int pos) {
800 assert (node->op == op_Return);
801 assert (get_Return_n_ress(node) > pos);
802 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
806 set_Return_res (ir_node *node, int pos, ir_node *res){
807 assert (node->op == op_Return);
808 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
812 get_Raise_mem (ir_node *node) {
813 assert (node->op == op_Return);
814 return get_irn_n(node, 0);
818 set_Raise_mem (ir_node *node, ir_node *mem) {
819 assert (node->op == op_Raise);
820 set_irn_n(node, 0, mem);
824 get_Raise_exo_ptr (ir_node *node) {
825 assert (node->op == op_Raise);
826 return get_irn_n(node, 1);
830 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
831 assert (node->op == op_Raise);
832 set_irn_n(node, 1, exo_ptr);
835 INLINE tarval *get_Const_tarval (ir_node *node) {
836 assert (node->op == op_Const);
837 return get_irn_const_attr(node);
841 set_Const_tarval (ir_node *node, tarval *con) {
842 assert (node->op == op_Const);
843 node->attr.con = con;
847 get_SymConst_kind (ir_node *node) {
848 assert (node->op == op_SymConst);
849 return node->attr.i.num;
853 set_SymConst_kind (ir_node *node, symconst_kind num) {
854 assert (node->op == op_SymConst);
855 node->attr.i.num = num;
859 get_SymConst_type (ir_node *node) {
860 assert ( (node->op == op_SymConst)
861 && ( get_SymConst_kind(node) == type_tag
862 || get_SymConst_kind(node) == size));
863 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
867 set_SymConst_type (ir_node *node, type *type) {
868 assert ( (node->op == op_SymConst)
869 && ( get_SymConst_kind(node) == type_tag
870 || get_SymConst_kind(node) == size));
871 node->attr.i.tori.typ = type;
875 get_SymConst_ptrinfo (ir_node *node) {
876 assert ( (node->op == op_SymConst)
877 && (get_SymConst_kind(node) == linkage_ptr_info));
878 return node->attr.i.tori.ptrinfo;
882 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
883 assert ( (node->op == op_SymConst)
884 && (get_SymConst_kind(node) == linkage_ptr_info));
885 node->attr.i.tori.ptrinfo = ptrinfo;
889 get_SymConst_type_or_id (ir_node *node) {
890 assert (node->op == op_SymConst);
891 return &(node->attr.i.tori);
895 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
896 assert (node->op == op_SymConst);
897 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
901 get_Sel_mem (ir_node *node) {
902 assert (node->op == op_Sel);
903 return get_irn_n(node, 0);
907 set_Sel_mem (ir_node *node, ir_node *mem) {
908 assert (node->op == op_Sel);
909 set_irn_n(node, 0, mem);
913 get_Sel_ptr (ir_node *node) {
914 assert (node->op == op_Sel);
915 return get_irn_n(node, 1);
919 set_Sel_ptr (ir_node *node, ir_node *ptr) {
920 assert (node->op == op_Sel);
921 set_irn_n(node, 1, ptr);
925 get_Sel_n_indexs (ir_node *node) {
926 assert (node->op == op_Sel);
927 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
931 get_Sel_index_arr (ir_node *node)
933 assert ((node->op == op_Sel));
934 if (get_Sel_n_indexs(node) > 0)
935 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
941 get_Sel_index (ir_node *node, int pos) {
942 assert (node->op == op_Sel);
943 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
947 set_Sel_index (ir_node *node, int pos, ir_node *index) {
948 assert (node->op == op_Sel);
949 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
953 get_Sel_entity (ir_node *node) {
954 assert (node->op == op_Sel);
955 return node->attr.s.ent;
959 set_Sel_entity (ir_node *node, entity *ent) {
960 assert (node->op == op_Sel);
961 node->attr.s.ent = ent;
965 get_InstOf_ent (ir_node *node) {
966 assert (node->op = op_InstOf);
967 return (node->attr.io.ent);
971 set_InstOf_ent (ir_node *node, type *ent) {
972 assert (node->op = op_InstOf);
973 node->attr.io.ent = ent;
977 get_InstOf_store (ir_node *node) {
978 assert (node->op = op_InstOf);
979 return (get_irn_n (node, 0));
983 set_InstOf_store (ir_node *node, ir_node *obj) {
984 assert (node->op = op_InstOf);
985 set_irn_n (node, 0, obj);
989 get_InstOf_obj (ir_node *node) {
990 assert (node->op = op_InstOf);
991 return (get_irn_n (node, 1));
995 set_InstOf_obj (ir_node *node, ir_node *obj) {
996 assert (node->op = op_InstOf);
997 set_irn_n (node, 1, obj);
1001 /* For unary and binary arithmetic operations the access to the
1002 operands can be factored out. Left is the first, right the
1003 second arithmetic value as listed in tech report 0999-33.
1004 unops are: Minus, Abs, Not, Conv
1005 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1006 Shr, Shrs, Rotate, Cmp */
1010 get_Call_mem (ir_node *node) {
1011 assert (node->op == op_Call);
1012 return get_irn_n(node, 0);
1016 set_Call_mem (ir_node *node, ir_node *mem) {
1017 assert (node->op == op_Call);
1018 set_irn_n(node, 0, mem);
1022 get_Call_ptr (ir_node *node) {
1023 assert (node->op == op_Call);
1024 return get_irn_n(node, 1);
1028 set_Call_ptr (ir_node *node, ir_node *ptr) {
1029 assert (node->op == op_Call);
1030 set_irn_n(node, 1, ptr);
1034 get_Call_param_arr (ir_node *node) {
1035 assert (node->op == op_Call);
1036 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1040 get_Call_n_params (ir_node *node) {
1041 assert (node->op == op_Call);
1042 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1046 get_Call_arity (ir_node *node) {
1047 assert (node->op == op_Call);
1048 return get_Call_n_params(node);
1052 set_Call_arity (ir_node *node, ir_node *arity) {
1053 assert (node->op == op_Call);
1058 get_Call_param (ir_node *node, int pos) {
1059 assert (node->op == op_Call);
1060 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1064 set_Call_param (ir_node *node, int pos, ir_node *param) {
1065 assert (node->op == op_Call);
1066 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1070 get_Call_type (ir_node *node) {
1071 assert (node->op == op_Call);
1072 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1076 set_Call_type (ir_node *node, type *type) {
1077 assert (node->op == op_Call);
1078 assert (is_method_type(type));
1079 node->attr.call.cld_tp = type;
1082 int get_Call_n_callees(ir_node * node) {
1083 assert(node->op == op_Call && node->attr.call.callee_arr);
1084 return ARR_LEN(node->attr.call.callee_arr);
1087 entity * get_Call_callee(ir_node * node, int pos) {
1088 assert(node->op == op_Call && node->attr.call.callee_arr);
1089 return node->attr.call.callee_arr[pos];
1092 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1093 assert(node->op == op_Call);
1094 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1095 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1097 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1100 void remove_Call_callee_arr(ir_node * node) {
1101 assert(node->op == op_Call);
1102 node->attr.call.callee_arr = NULL;
1105 ir_node * get_CallBegin_ptr (ir_node *node) {
1106 assert(node->op == op_CallBegin);
1107 return get_irn_n(node, 0);
1109 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1110 assert(node->op == op_CallBegin);
1111 set_irn_n(node, 0, ptr);
1113 ir_graph * get_CallBegin_irg (ir_node *node) {
1114 assert(node->op == op_CallBegin);
1115 return node->attr.callbegin.irg;
1117 ir_node * get_CallBegin_call (ir_node *node) {
1118 assert(node->op == op_CallBegin);
1119 return node->attr.callbegin.call;
1121 void set_CallBegin_call (ir_node *node, ir_node *call) {
1122 assert(node->op == op_CallBegin);
1123 node->attr.callbegin.call = call;
1127 get_Add_left (ir_node *node) {
1128 assert (node->op == op_Add);
1129 return get_irn_n(node, 0);
1133 set_Add_left (ir_node *node, ir_node *left) {
1134 assert (node->op == op_Add);
1135 set_irn_n(node, 0, left);
1139 get_Add_right (ir_node *node) {
1140 assert (node->op == op_Add);
1141 return get_irn_n(node, 1);
1145 set_Add_right (ir_node *node, ir_node *right) {
1146 assert (node->op == op_Add);
1147 set_irn_n(node, 1, right);
1151 get_Sub_left (ir_node *node) {
1152 assert (node->op == op_Sub);
1153 return get_irn_n(node, 0);
1157 set_Sub_left (ir_node *node, ir_node *left) {
1158 assert (node->op == op_Sub);
1159 set_irn_n(node, 0, left);
1163 get_Sub_right (ir_node *node) {
1164 assert (node->op == op_Sub);
1165 return get_irn_n(node, 1);
1169 set_Sub_right (ir_node *node, ir_node *right) {
1170 assert (node->op == op_Sub);
1171 set_irn_n(node, 1, right);
1176 get_Minus_op (ir_node *node) {
1177 assert (node->op == op_Minus);
1178 return get_irn_n(node, 0);
1182 set_Minus_op (ir_node *node, ir_node *op) {
1183 assert (node->op == op_Minus);
1184 set_irn_n(node, 0, op);
1189 get_Mul_left (ir_node *node) {
1190 assert (node->op == op_Mul);
1191 return get_irn_n(node, 0);
1195 set_Mul_left (ir_node *node, ir_node *left) {
1196 assert (node->op == op_Mul);
1197 set_irn_n(node, 0, left);
1201 get_Mul_right (ir_node *node) {
1202 assert (node->op == op_Mul);
1203 return get_irn_n(node, 1);
1207 set_Mul_right (ir_node *node, ir_node *right) {
1208 assert (node->op == op_Mul);
1209 set_irn_n(node, 1, right);
1213 get_Quot_left (ir_node *node) {
1214 assert (node->op == op_Quot);
1215 return get_irn_n(node, 1);
1219 set_Quot_left (ir_node *node, ir_node *left) {
1220 assert (node->op == op_Quot);
1221 set_irn_n(node, 1, left);
1225 get_Quot_right (ir_node *node) {
1226 assert (node->op == op_Quot);
1227 return get_irn_n(node, 2);
1231 set_Quot_right (ir_node *node, ir_node *right) {
1232 assert (node->op == op_Quot);
1233 set_irn_n(node, 2, right);
1237 get_Quot_mem (ir_node *node) {
1238 assert (node->op == op_Quot);
1239 return get_irn_n(node, 0);
1243 set_Quot_mem (ir_node *node, ir_node *mem) {
1244 assert (node->op == op_Quot);
1245 set_irn_n(node, 0, mem);
1249 get_DivMod_left (ir_node *node) {
1250 assert (node->op == op_DivMod);
1251 return get_irn_n(node, 1);
1255 set_DivMod_left (ir_node *node, ir_node *left) {
1256 assert (node->op == op_DivMod);
1257 set_irn_n(node, 1, left);
1261 get_DivMod_right (ir_node *node) {
1262 assert (node->op == op_DivMod);
1263 return get_irn_n(node, 2);
1267 set_DivMod_right (ir_node *node, ir_node *right) {
1268 assert (node->op == op_DivMod);
1269 set_irn_n(node, 2, right);
1273 get_DivMod_mem (ir_node *node) {
1274 assert (node->op == op_DivMod);
1275 return get_irn_n(node, 0);
1279 set_DivMod_mem (ir_node *node, ir_node *mem) {
1280 assert (node->op == op_DivMod);
1281 set_irn_n(node, 0, mem);
1285 get_Div_left (ir_node *node) {
1286 assert (node->op == op_Div);
1287 return get_irn_n(node, 1);
1291 set_Div_left (ir_node *node, ir_node *left) {
1292 assert (node->op == op_Div);
1293 set_irn_n(node, 1, left);
1297 get_Div_right (ir_node *node) {
1298 assert (node->op == op_Div);
1299 return get_irn_n(node, 2);
1303 set_Div_right (ir_node *node, ir_node *right) {
1304 assert (node->op == op_Div);
1305 set_irn_n(node, 2, right);
1309 get_Div_mem (ir_node *node) {
1310 assert (node->op == op_Div);
1311 return get_irn_n(node, 0);
1315 set_Div_mem (ir_node *node, ir_node *mem) {
1316 assert (node->op == op_Div);
1317 set_irn_n(node, 0, mem);
1321 get_Mod_left (ir_node *node) {
1322 assert (node->op == op_Mod);
1323 return get_irn_n(node, 1);
1327 set_Mod_left (ir_node *node, ir_node *left) {
1328 assert (node->op == op_Mod);
1329 set_irn_n(node, 1, left);
1333 get_Mod_right (ir_node *node) {
1334 assert (node->op == op_Mod);
1335 return get_irn_n(node, 2);
1339 set_Mod_right (ir_node *node, ir_node *right) {
1340 assert (node->op == op_Mod);
1341 set_irn_n(node, 2, right);
1345 get_Mod_mem (ir_node *node) {
1346 assert (node->op == op_Mod);
1347 return get_irn_n(node, 0);
1351 set_Mod_mem (ir_node *node, ir_node *mem) {
1352 assert (node->op == op_Mod);
1353 set_irn_n(node, 0, mem);
1357 get_Abs_op (ir_node *node) {
1358 assert (node->op == op_Abs);
1359 return get_irn_n(node, 0);
1363 set_Abs_op (ir_node *node, ir_node *op) {
1364 assert (node->op == op_Abs);
1365 set_irn_n(node, 0, op);
1369 get_And_left (ir_node *node) {
1370 assert (node->op == op_And);
1371 return get_irn_n(node, 0);
1375 set_And_left (ir_node *node, ir_node *left) {
1376 assert (node->op == op_And);
1377 set_irn_n(node, 0, left);
1381 get_And_right (ir_node *node) {
1382 assert (node->op == op_And);
1383 return get_irn_n(node, 1);
1387 set_And_right (ir_node *node, ir_node *right) {
1388 assert (node->op == op_And);
1389 set_irn_n(node, 1, right);
1393 get_Or_left (ir_node *node) {
1394 assert (node->op == op_Or);
1395 return get_irn_n(node, 0);
1399 set_Or_left (ir_node *node, ir_node *left) {
1400 assert (node->op == op_Or);
1401 set_irn_n(node, 0, left);
1405 get_Or_right (ir_node *node) {
1406 assert (node->op == op_Or);
1407 return get_irn_n(node, 1);
1411 set_Or_right (ir_node *node, ir_node *right) {
1412 assert (node->op == op_Or);
1413 set_irn_n(node, 1, right);
1417 get_Eor_left (ir_node *node) {
1418 assert (node->op == op_Eor);
1419 return get_irn_n(node, 0);
1423 set_Eor_left (ir_node *node, ir_node *left) {
1424 assert (node->op == op_Eor);
1425 set_irn_n(node, 0, left);
1429 get_Eor_right (ir_node *node) {
1430 assert (node->op == op_Eor);
1431 return get_irn_n(node, 1);
1435 set_Eor_right (ir_node *node, ir_node *right) {
1436 assert (node->op == op_Eor);
1437 set_irn_n(node, 1, right);
1442 get_Not_op (ir_node *node) {
1443 assert (node->op == op_Not);
1444 return get_irn_n(node, 0);
1448 set_Not_op (ir_node *node, ir_node *op) {
1449 assert (node->op == op_Not);
1450 set_irn_n(node, 0, op);
1455 get_Shl_left (ir_node *node) {
1456 assert (node->op == op_Shl);
1457 return get_irn_n(node, 0);
1461 set_Shl_left (ir_node *node, ir_node *left) {
1462 assert (node->op == op_Shl);
1463 set_irn_n(node, 0, left);
1467 get_Shl_right (ir_node *node) {
1468 assert (node->op == op_Shl);
1469 return get_irn_n(node, 1);
1473 set_Shl_right (ir_node *node, ir_node *right) {
1474 assert (node->op == op_Shl);
1475 set_irn_n(node, 1, right);
1479 get_Shr_left (ir_node *node) {
1480 assert (node->op == op_Shr);
1481 return get_irn_n(node, 0);
1485 set_Shr_left (ir_node *node, ir_node *left) {
1486 assert (node->op == op_Shr);
1487 set_irn_n(node, 0, left);
1491 get_Shr_right (ir_node *node) {
1492 assert (node->op == op_Shr);
1493 return get_irn_n(node, 1);
1497 set_Shr_right (ir_node *node, ir_node *right) {
1498 assert (node->op == op_Shr);
1499 set_irn_n(node, 1, right);
1503 get_Shrs_left (ir_node *node) {
1504 assert (node->op == op_Shrs);
1505 return get_irn_n(node, 0);
1509 set_Shrs_left (ir_node *node, ir_node *left) {
1510 assert (node->op == op_Shrs);
1511 set_irn_n(node, 0, left);
1515 get_Shrs_right (ir_node *node) {
1516 assert (node->op == op_Shrs);
1517 return get_irn_n(node, 1);
1521 set_Shrs_right (ir_node *node, ir_node *right) {
1522 assert (node->op == op_Shrs);
1523 set_irn_n(node, 1, right);
1527 get_Rot_left (ir_node *node) {
1528 assert (node->op == op_Rot);
1529 return get_irn_n(node, 0);
1533 set_Rot_left (ir_node *node, ir_node *left) {
1534 assert (node->op == op_Rot);
1535 set_irn_n(node, 0, left);
1539 get_Rot_right (ir_node *node) {
1540 assert (node->op == op_Rot);
1541 return get_irn_n(node, 1);
1545 set_Rot_right (ir_node *node, ir_node *right) {
1546 assert (node->op == op_Rot);
1547 set_irn_n(node, 1, right);
1551 get_Cmp_left (ir_node *node) {
1552 assert (node->op == op_Cmp);
1553 return get_irn_n(node, 0);
1557 set_Cmp_left (ir_node *node, ir_node *left) {
1558 assert (node->op == op_Cmp);
1559 set_irn_n(node, 0, left);
1563 get_Cmp_right (ir_node *node) {
1564 assert (node->op == op_Cmp);
1565 return get_irn_n(node, 1);
1569 set_Cmp_right (ir_node *node, ir_node *right) {
1570 assert (node->op == op_Cmp);
1571 set_irn_n(node, 1, right);
1575 get_Conv_op (ir_node *node) {
1576 assert (node->op == op_Conv);
1577 return get_irn_n(node, 0);
1581 set_Conv_op (ir_node *node, ir_node *op) {
1582 assert (node->op == op_Conv);
1583 set_irn_n(node, 0, op);
1589 is_unop (ir_node *node) {
1590 return ( node->op == op_Minus ||
1591 node->op == op_Abs ||
1592 node->op == op_Not ||
1593 node->op == op_Conv );
1597 get_unop_op (ir_node *node) {
1598 assert ( node->op == op_Minus ||
1599 node->op == op_Abs ||
1600 node->op == op_Not ||
1601 node->op == op_Conv );
1602 switch (get_irn_opcode (node)) {
1603 case iro_Minus: return get_Minus_op(node); break;
1604 case iro_Abs: return get_Abs_op(node); break;
1605 case iro_Not: return get_Not_op(node); break;
1606 case iro_Conv: return get_Conv_op(node); break;
1607 default: return NULL;
1612 set_unop_op (ir_node *node, ir_node *op) {
1613 assert (node->op == op_Minus ||
1614 node->op == op_Abs ||
1615 node->op == op_Not ||
1616 node->op == op_Conv );
1617 switch (get_irn_opcode (node)) {
1618 case iro_Minus: set_Minus_op(node, op); break;
1619 case iro_Abs: set_Abs_op(node, op); break;
1620 case iro_Not: set_Not_op(node, op); break;
1621 case iro_Conv: set_Conv_op(node, op); break;
1628 is_binop (ir_node *node) {
1629 return (node->op == op_Add ||
1630 node->op == op_Sub ||
1631 node->op == op_Mul ||
1632 node->op == op_Quot ||
1633 node->op == op_DivMod ||
1634 node->op == op_Div ||
1635 node->op == op_Mod ||
1636 node->op == op_And ||
1637 node->op == op_Or ||
1638 node->op == op_Eor ||
1639 node->op == op_Shl ||
1640 node->op == op_Shr ||
1641 node->op == op_Shrs ||
1642 node->op == op_Rot ||
1643 node->op == op_Cmp );
1647 get_binop_left (ir_node *node) {
1648 assert (node->op == op_Add ||
1649 node->op == op_Sub ||
1650 node->op == op_Mul ||
1651 node->op == op_Quot ||
1652 node->op == op_DivMod ||
1653 node->op == op_Div ||
1654 node->op == op_Mod ||
1655 node->op == op_And ||
1656 node->op == op_Or ||
1657 node->op == op_Eor ||
1658 node->op == op_Shl ||
1659 node->op == op_Shr ||
1660 node->op == op_Shrs ||
1661 node->op == op_Rot ||
1662 node->op == op_Cmp );
1664 switch (get_irn_opcode (node)) {
1665 case iro_Add : return get_Add_left(node); break;
1666 case iro_Sub : return get_Sub_left(node); break;
1667 case iro_Mul : return get_Mul_left(node); break;
1668 case iro_Quot : return get_Quot_left(node); break;
1669 case iro_DivMod: return get_DivMod_left(node); break;
1670 case iro_Div : return get_Div_left(node); break;
1671 case iro_Mod : return get_Mod_left(node); break;
1672 case iro_And : return get_And_left(node); break;
1673 case iro_Or : return get_Or_left(node); break;
1674 case iro_Eor : return get_Eor_left(node); break;
1675 case iro_Shl : return get_Shl_left(node); break;
1676 case iro_Shr : return get_Shr_left(node); break;
1677 case iro_Shrs : return get_Shrs_left(node); break;
1678 case iro_Rot : return get_Rot_left(node); break;
1679 case iro_Cmp : return get_Cmp_left(node); break;
1680 default: return NULL;
1685 set_binop_left (ir_node *node, ir_node *left) {
1686 assert (node->op == op_Add ||
1687 node->op == op_Sub ||
1688 node->op == op_Mul ||
1689 node->op == op_Quot ||
1690 node->op == op_DivMod ||
1691 node->op == op_Div ||
1692 node->op == op_Mod ||
1693 node->op == op_And ||
1694 node->op == op_Or ||
1695 node->op == op_Eor ||
1696 node->op == op_Shl ||
1697 node->op == op_Shr ||
1698 node->op == op_Shrs ||
1699 node->op == op_Rot ||
1700 node->op == op_Cmp );
1702 switch (get_irn_opcode (node)) {
1703 case iro_Add : set_Add_left(node, left); break;
1704 case iro_Sub : set_Sub_left(node, left); break;
1705 case iro_Mul : set_Mul_left(node, left); break;
1706 case iro_Quot : set_Quot_left(node, left); break;
1707 case iro_DivMod: set_DivMod_left(node, left); break;
1708 case iro_Div : set_Div_left(node, left); break;
1709 case iro_Mod : set_Mod_left(node, left); break;
1710 case iro_And : set_And_left(node, left); break;
1711 case iro_Or : set_Or_left(node, left); break;
1712 case iro_Eor : set_Eor_left(node, left); break;
1713 case iro_Shl : set_Shl_left(node, left); break;
1714 case iro_Shr : set_Shr_left(node, left); break;
1715 case iro_Shrs : set_Shrs_left(node, left); break;
1716 case iro_Rot : set_Rot_left(node, left); break;
1717 case iro_Cmp : set_Cmp_left(node, left); break;
1723 get_binop_right (ir_node *node) {
1724 assert (node->op == op_Add ||
1725 node->op == op_Sub ||
1726 node->op == op_Mul ||
1727 node->op == op_Quot ||
1728 node->op == op_DivMod ||
1729 node->op == op_Div ||
1730 node->op == op_Mod ||
1731 node->op == op_And ||
1732 node->op == op_Or ||
1733 node->op == op_Eor ||
1734 node->op == op_Shl ||
1735 node->op == op_Shr ||
1736 node->op == op_Shrs ||
1737 node->op == op_Rot ||
1738 node->op == op_Cmp );
1740 switch (get_irn_opcode (node)) {
1741 case iro_Add : return get_Add_right(node); break;
1742 case iro_Sub : return get_Sub_right(node); break;
1743 case iro_Mul : return get_Mul_right(node); break;
1744 case iro_Quot : return get_Quot_right(node); break;
1745 case iro_DivMod: return get_DivMod_right(node); break;
1746 case iro_Div : return get_Div_right(node); break;
1747 case iro_Mod : return get_Mod_right(node); break;
1748 case iro_And : return get_And_right(node); break;
1749 case iro_Or : return get_Or_right(node); break;
1750 case iro_Eor : return get_Eor_right(node); break;
1751 case iro_Shl : return get_Shl_right(node); break;
1752 case iro_Shr : return get_Shr_right(node); break;
1753 case iro_Shrs : return get_Shrs_right(node); break;
1754 case iro_Rot : return get_Rot_right(node); break;
1755 case iro_Cmp : return get_Cmp_right(node); break;
1756 default: return NULL;
1761 set_binop_right (ir_node *node, ir_node *right) {
1762 assert (node->op == op_Add ||
1763 node->op == op_Sub ||
1764 node->op == op_Mul ||
1765 node->op == op_Quot ||
1766 node->op == op_DivMod ||
1767 node->op == op_Div ||
1768 node->op == op_Mod ||
1769 node->op == op_And ||
1770 node->op == op_Or ||
1771 node->op == op_Eor ||
1772 node->op == op_Shl ||
1773 node->op == op_Shr ||
1774 node->op == op_Shrs ||
1775 node->op == op_Rot ||
1776 node->op == op_Cmp );
1778 switch (get_irn_opcode (node)) {
1779 case iro_Add : set_Add_right(node, right); break;
1780 case iro_Sub : set_Sub_right(node, right); break;
1781 case iro_Mul : set_Mul_right(node, right); break;
1782 case iro_Quot : set_Quot_right(node, right); break;
1783 case iro_DivMod: set_DivMod_right(node, right); break;
1784 case iro_Div : set_Div_right(node, right); break;
1785 case iro_Mod : set_Mod_right(node, right); break;
1786 case iro_And : set_And_right(node, right); break;
1787 case iro_Or : set_Or_right(node, right); break;
1788 case iro_Eor : set_Eor_right(node, right); break;
1789 case iro_Shl : set_Shl_right(node, right); break;
1790 case iro_Shr : set_Shr_right(node, right); break;
1791 case iro_Shrs : set_Shrs_right(node, right); break;
1792 case iro_Rot : set_Rot_right(node, right); break;
1793 case iro_Cmp : set_Cmp_right(node, right); break;
1800 get_Phi_preds_arr (ir_node *node) {
1801 assert (node->op == op_Phi);
1802 return (ir_node **)&(get_irn_in(node)[1]);
1806 get_Phi_n_preds (ir_node *node) {
1807 assert (node->op == op_Phi);
1808 return (get_irn_arity(node));
1812 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1813 assert (node->op == op_Phi);
1818 get_Phi_pred (ir_node *node, int pos) {
1819 assert (node->op == op_Phi);
1820 return get_irn_n(node, pos);
1824 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1825 assert (node->op == op_Phi);
1826 set_irn_n(node, pos, pred);
1830 get_Load_mem (ir_node *node) {
1831 assert (node->op == op_Load);
1832 return get_irn_n(node, 0);
1836 set_Load_mem (ir_node *node, ir_node *mem) {
1837 assert (node->op == op_Load);
1838 set_irn_n(node, 0, mem);
1842 get_Load_ptr (ir_node *node) {
1843 assert (node->op == op_Load);
1844 return get_irn_n(node, 1);
1848 set_Load_ptr (ir_node *node, ir_node *ptr) {
1849 assert (node->op == op_Load);
1850 set_irn_n(node, 1, ptr);
1855 get_Store_mem (ir_node *node) {
1856 assert (node->op == op_Store);
1857 return get_irn_n(node, 0);
1861 set_Store_mem (ir_node *node, ir_node *mem) {
1862 assert (node->op == op_Store);
1863 set_irn_n(node, 0, mem);
1867 get_Store_ptr (ir_node *node) {
1868 assert (node->op == op_Store);
1869 return get_irn_n(node, 1);
1873 set_Store_ptr (ir_node *node, ir_node *ptr) {
1874 assert (node->op == op_Store);
1875 set_irn_n(node, 1, ptr);
1879 get_Store_value (ir_node *node) {
1880 assert (node->op == op_Store);
1881 return get_irn_n(node, 2);
1885 set_Store_value (ir_node *node, ir_node *value) {
1886 assert (node->op == op_Store);
1887 set_irn_n(node, 2, value);
1891 get_Alloc_mem (ir_node *node) {
1892 assert (node->op == op_Alloc);
1893 return get_irn_n(node, 0);
1897 set_Alloc_mem (ir_node *node, ir_node *mem) {
1898 assert (node->op == op_Alloc);
1899 set_irn_n(node, 0, mem);
1903 get_Alloc_size (ir_node *node) {
1904 assert (node->op == op_Alloc);
1905 return get_irn_n(node, 1);
1909 set_Alloc_size (ir_node *node, ir_node *size) {
1910 assert (node->op == op_Alloc);
1911 set_irn_n(node, 1, size);
1915 get_Alloc_type (ir_node *node) {
1916 assert (node->op == op_Alloc);
1917 return node->attr.a.type = skip_tid(node->attr.a.type);
1921 set_Alloc_type (ir_node *node, type *type) {
1922 assert (node->op == op_Alloc);
1923 node->attr.a.type = type;
1927 get_Alloc_where (ir_node *node) {
1928 assert (node->op == op_Alloc);
1929 return node->attr.a.where;
1933 set_Alloc_where (ir_node *node, where_alloc where) {
1934 assert (node->op == op_Alloc);
1935 node->attr.a.where = where;
1940 get_Free_mem (ir_node *node) {
1941 assert (node->op == op_Free);
1942 return get_irn_n(node, 0);
1946 set_Free_mem (ir_node *node, ir_node *mem) {
1947 assert (node->op == op_Free);
1948 set_irn_n(node, 0, mem);
1952 get_Free_ptr (ir_node *node) {
1953 assert (node->op == op_Free);
1954 return get_irn_n(node, 1);
1958 set_Free_ptr (ir_node *node, ir_node *ptr) {
1959 assert (node->op == op_Free);
1960 set_irn_n(node, 1, ptr);
1964 get_Free_size (ir_node *node) {
1965 assert (node->op == op_Free);
1966 return get_irn_n(node, 2);
1970 set_Free_size (ir_node *node, ir_node *size) {
1971 assert (node->op == op_Free);
1972 set_irn_n(node, 2, size);
1976 get_Free_type (ir_node *node) {
1977 assert (node->op == op_Free);
1978 return node->attr.f = skip_tid(node->attr.f);
1982 set_Free_type (ir_node *node, type *type) {
1983 assert (node->op == op_Free);
1984 node->attr.f = type;
1988 get_Sync_preds_arr (ir_node *node) {
1989 assert (node->op == op_Sync);
1990 return (ir_node **)&(get_irn_in(node)[1]);
1994 get_Sync_n_preds (ir_node *node) {
1995 assert (node->op == op_Sync);
1996 return (get_irn_arity(node));
2001 set_Sync_n_preds (ir_node *node, int n_preds) {
2002 assert (node->op == op_Sync);
2007 get_Sync_pred (ir_node *node, int pos) {
2008 assert (node->op == op_Sync);
2009 return get_irn_n(node, pos);
2013 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
2014 assert (node->op == op_Sync);
2015 set_irn_n(node, pos, pred);
2019 get_Proj_pred (ir_node *node) {
2020 assert (is_Proj(node));
2021 return get_irn_n(node, 0);
2025 set_Proj_pred (ir_node *node, ir_node *pred) {
2026 assert (is_Proj(node));
2027 set_irn_n(node, 0, pred);
2031 get_Proj_proj (ir_node *node) {
2032 assert (is_Proj(node));
2033 if (get_irn_opcode(node) == iro_Proj) {
2034 return node->attr.proj;
2036 assert(get_irn_opcode(node) == iro_Filter);
2037 return node->attr.filter.proj;
2042 set_Proj_proj (ir_node *node, long proj) {
2043 assert (node->op == op_Proj);
2044 node->attr.proj = proj;
2048 get_Tuple_preds_arr (ir_node *node) {
2049 assert (node->op == op_Tuple);
2050 return (ir_node **)&(get_irn_in(node)[1]);
2054 get_Tuple_n_preds (ir_node *node) {
2055 assert (node->op == op_Tuple);
2056 return (get_irn_arity(node));
2061 set_Tuple_n_preds (ir_node *node, int n_preds) {
2062 assert (node->op == op_Tuple);
2067 get_Tuple_pred (ir_node *node, int pos) {
2068 assert (node->op == op_Tuple);
2069 return get_irn_n(node, pos);
2073 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2074 assert (node->op == op_Tuple);
2075 set_irn_n(node, pos, pred);
2079 get_Id_pred (ir_node *node) {
2080 assert (node->op == op_Id);
2081 return get_irn_n(node, 0);
2085 set_Id_pred (ir_node *node, ir_node *pred) {
2086 assert (node->op == op_Id);
2087 set_irn_n(node, 0, pred);
2092 get_Filter_pred (ir_node *node) {
2093 assert(node->op == op_Filter);
2097 set_Filter_pred (ir_node *node, ir_node *pred) {
2098 assert(node->op == op_Filter);
2102 get_Filter_proj(ir_node *node) {
2103 assert(node->op == op_Filter);
2104 return node->attr.filter.proj;
2107 set_Filter_proj (ir_node *node, long proj) {
2108 assert(node->op == op_Filter);
2109 node->attr.filter.proj = proj;
2112 /* Don't use get_irn_arity, get_irn_n in implementation as access
2113 shall work independent of view!!! */
2114 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2115 assert(node->op == op_Filter);
2116 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2117 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2118 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2119 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2120 node->attr.filter.in_cg[0] = node->in[0];
2122 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2125 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2126 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2127 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2128 node->attr.filter.in_cg[pos + 1] = pred;
2130 int get_Filter_n_cg_preds(ir_node *node) {
2131 assert(node->op == op_Filter && node->attr.filter.in_cg);
2132 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2134 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2136 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2138 arity = ARR_LEN(node->attr.filter.in_cg);
2139 assert(pos < arity - 1);
2140 return node->attr.filter.in_cg[pos + 1];
2145 get_irn_irg(ir_node *node) {
2146 if (get_irn_op(node) == op_CallBegin) {
2147 return node->attr.callbegin.irg;
2148 } else if (get_irn_op(node) == op_EndReg ||
2149 get_irn_op(node) == op_EndExcept) {
2150 return node->attr.end.irg;
2152 assert(0 && "no irg attr");
2157 /******************************************************************/
2158 /* Auxiliary routines */
2159 /******************************************************************/
2162 skip_Proj (ir_node *node) {
2163 /* don't assert node !!! */
2164 if (node && is_Proj(node)) {
2165 return get_Proj_pred(node);
2172 skip_Tuple (ir_node *node) {
2175 node = skip_nop(node);
2176 if (get_irn_op(node) == op_Proj) {
2177 pred = skip_nop(get_Proj_pred(node));
2178 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2179 pred = skip_nop(skip_Tuple(pred));
2180 if (get_irn_op(pred) == op_Tuple)
2181 return get_Tuple_pred(pred, get_Proj_proj(node));
2187 skip_nop (ir_node *node) {
2188 /* don't assert node !!! */
2190 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
2191 /* Don't use get_Id_pred: We get into an endless loop for
2192 self-referencing Ids. */
2193 assert (get_irn_arity (node) > 0);
2194 return node->in[0+1];
2201 skip_Id (ir_node *node) {
2202 return skip_nop(node);
2206 is_Bad (ir_node *node) {
2208 if ((node) && get_irn_opcode(node) == iro_Bad)
2214 is_no_Block (ir_node *node) {
2216 return (get_irn_opcode(node) != iro_Block);
2220 is_Block (ir_node *node) {
2222 return (get_irn_opcode(node) == iro_Block);
2226 is_Proj (ir_node *node) {
2228 return node->op == op_Proj
2229 || (!interprocedural_view && node->op == op_Filter);
2232 /* Returns true if the operation manipulates control flow. */
2234 is_cfop(ir_node *node) {
2235 return is_cfopcode(get_irn_op(node));
2238 /* Returns true if the operation manipulates interprocedural control flow:
2239 CallBegin, EndReg, EndExcept */
2240 INLINE int is_ip_cfop(ir_node *node) {
2241 return is_ip_cfopcode(get_irn_op(node));
2244 ir_graph *get_ip_cfop_irg(ir_node *n) {
2245 switch (get_irn_opcode(n)) {
2247 return get_EndReg_irg(n);
2249 return get_EndExcept_irg(n);
2251 return get_CallBegin_irg(n);
2253 assert(is_ip_cfop(n));
2255 return NULL; /* should never be reached */
2258 /* Returns true if the operation can change the control flow because
2261 is_fragile_op(ir_node *node) {
2262 return ( (get_irn_opcode(node) == iro_Call)
2263 || (get_irn_opcode(node) == iro_Quot)
2264 || (get_irn_opcode(node) == iro_DivMod)
2265 || (get_irn_opcode(node) == iro_Div)
2266 || (get_irn_opcode(node) == iro_Mod)
2267 || (get_irn_opcode(node) == iro_Load)
2268 || (get_irn_opcode(node) == iro_Store)
2269 || (get_irn_opcode(node) == iro_Alloc)
2270 || (get_irn_opcode(node) == iro_Bad)
2271 || (get_irn_opcode(node) == iro_Unknown));
2275 /* Returns the memory operand of fragile operations. */
2276 ir_node *get_fragile_op_mem(ir_node *node) {
2277 assert(node && is_fragile_op(node));
2279 switch (get_irn_opcode (node)) {
2288 return get_irn_n(node, 0);
2293 assert(0 && "not reached");