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"
27 /* some constants fixing the positions of nodes predecessors
29 #define CALL_PARAM_OFFSET 2
30 #define SEL_INDEX_OFFSET 2
31 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
32 #define END_KEEPALIVE_OFFSET 0
34 /* Declarations for inlineing */
35 INLINE ir_node ** get_irn_in (ir_node *node);
36 INLINE ir_mode *get_irn_mode (ir_node *node);
37 INLINE ir_op *get_irn_op (ir_node *node);
38 INLINE opcode get_irn_opcode (ir_node *node);
39 INLINE ident *get_irn_opident (ir_node *node);
40 INLINE type *get_SymConst_type (ir_node *node);
41 INLINE ir_node *skip_nop (ir_node *node);
42 INLINE ir_node *skip_nop (ir_node *node);
43 INLINE int is_Proj (ir_node *node);
46 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
47 "Gt", "Ge", "Lg", "Leg", "Uo",
48 "Ue", "Ul", "Ule", "Ug", "Uge",
51 INLINE char *get_pnc_string(int pnc) {
52 return pnc_name_arr[pnc];
57 get_negated_pnc(int pnc) {
59 case False: return True; break;
60 case Eq: return Ne; break;
61 case Lt: return Uge; break;
62 case Le: return Ug; break;
63 case Gt: return Ule; break;
64 case Ge: return Ul; break;
65 case Lg: return Ue; break;
66 case Leg: return Uo; break;
67 case Uo: return Leg; break;
68 case Ue: return Lg; break;
69 case Ul: return Ge; break;
70 case Ule: return Gt; break;
71 case Ug: return Le; break;
72 case Uge: return Lt; break;
73 case Ne: return Eq; break;
74 case True: return False; break;
76 return 99; /* to shut up gcc */
79 static char *pns_name_arr [] = {"initial_exec", "global_store",
80 "frame_base", "globals", "args"};
82 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
89 /* irnode constructor */
90 /* create a new irnode in irg, with an op, mode, arity and */
91 /* some incoming irnodes */
92 /* this constructor is used in every specified irnode constructor */
94 new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
95 int arity, ir_node **in)
98 int node_size = offsetof (ir_node, attr) + op->attr_size;
100 res = (ir_node *) obstack_alloc (irg->obst, node_size);
102 res->kind = k_ir_node;
108 res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
110 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
111 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
114 set_irn_dbg_info(res, db);
118 res->node_nr = get_irp_new_node_nr();
124 /* Copies all attributes stored in the old node to the new node.
125 Assumes both have the same opcode and sufficient size. */
127 copy_attrs (ir_node *old, ir_node *new) {
128 assert (get_irn_op(old) == get_irn_op(new));
129 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
132 /* IR-Nodes with attributes */
134 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
137 ir_node *np = XP_GETARG (ir_node *, 0);
140 XPS ("<null ir_node>");
144 XPF1 ("%I", get_irn_opident(np));
146 switch (get_irn_opcode (np)) { /* node label */
148 XPF1 ("%I", get_irn_mode(np)->name);
150 XPF1 ("%v", get_irn_const_attr);
153 if (get_irn_mode (np) == mode_b) {
155 XP (pnc_name_arr[get_irn_proj_attr(np)]);
156 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
158 XP (pns_name_arr[get_irn_proj_attr(np)]);
160 XPF1 ("%I", get_irn_mode(np)->name);
162 XPF1 ("%d", get_irn_proj_attr(np));
166 XPF1 ("%I", get_irn_mode(np)->name);
168 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
169 XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
171 case iro_Start: /* don't dump mode of these */
184 XPF1 ("%I", get_irn_mode(np)->name);
190 /** getting some parameters from ir_nodes **/
192 /* returns the number of predecessors without the block predecessor. */
194 get_irn_arity (ir_node *node) {
196 if (interprocedural_view) { /* handle Filter and Block specially */
197 if (get_irn_opcode(node) == iro_Filter) {
198 assert(node->attr.filter.in_cg);
199 return ARR_LEN(node->attr.filter.in_cg) - 1;
200 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
201 return ARR_LEN(node->attr.block.in_cg) - 1;
203 /* else fall through */
205 return ARR_LEN(node->in) - 1;
208 /* Returns the array with ins. This array is shifted with respect to the
209 array accessed by get_irn_n: The block operand is at position 0 not -1.
210 (@@@ This should be changed.)
211 The order of the predecessors in this array is not guaranteed, except that
212 lists of operands as predecessors of Block or arguments of a Call are
215 get_irn_in (ir_node *node) {
217 if (interprocedural_view) { /* handle Filter and Block specially */
218 if (get_irn_opcode(node) == iro_Filter) {
219 assert(node->attr.filter.in_cg);
220 return node->attr.filter.in_cg;
221 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
222 return node->attr.block.in_cg;
224 /* else fall through */
230 set_irn_in (ir_node *node, int arity, ir_node **in) {
233 if (interprocedural_view) { /* handle Filter and Block specially */
234 if (get_irn_opcode(node) == iro_Filter) {
235 assert(node->attr.filter.in_cg);
236 arr = &node->attr.filter.in_cg;
237 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
238 arr = &node->attr.block.in_cg;
245 if (arity != ARR_LEN(*arr) - 1) {
246 ir_node * block = (*arr)[0];
247 *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
250 memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
253 /* to iterate through the predecessors without touching the array */
254 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
255 to iterate includind the Block predecessor iterate from i = -1 to
257 If it is a block, the entry -1 is NULL. */
259 get_irn_n (ir_node *node, int n) {
261 if (-1 > n || get_irn_arity(node) <= n) {
262 printf("pos: %d, arity: %d ", n, get_irn_arity(node));
265 assert(node); assert(-1 <= n && n < get_irn_arity(node));
266 if (interprocedural_view) { /* handle Filter and Block specially */
267 if (get_irn_opcode(node) == iro_Filter) {
268 assert(node->attr.filter.in_cg);
269 return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
270 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
271 return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
273 /* else fall through */
275 return (node->in[n + 1] = skip_nop(node->in[n + 1]));
279 set_irn_n (ir_node *node, int n, ir_node *in) {
280 assert(node && -1 <= n && n < get_irn_arity(node));
281 if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
282 /* Change block pred in both views! */
283 node->in[n + 1] = in;
284 assert(node->attr.filter.in_cg);
285 node->attr.filter.in_cg[n + 1] = in;
288 if (interprocedural_view) { /* handle Filter and Block specially */
289 if (get_irn_opcode(node) == iro_Filter) {
290 assert(node->attr.filter.in_cg);
291 node->attr.filter.in_cg[n + 1] = in;
293 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
294 node->attr.block.in_cg[n + 1] = in;
297 /* else fall through */
299 node->in[n + 1] = in;
303 get_irn_mode (ir_node *node)
310 get_irn_modecode (ir_node *node)
313 return node->mode->code;
318 get_irn_modeident (ir_node *node)
321 return node->mode->name;
325 get_irn_op (ir_node *node)
331 /* should be private to the library: */
333 set_irn_op (ir_node *node, ir_op *op)
340 get_irn_opcode (ir_node *node)
343 return node->op->code;
347 get_irn_opname (ir_node *node)
350 return id_to_str(node->op->name);
354 get_irn_opident (ir_node *node)
357 return node->op->name;
361 get_irn_visited (ir_node *node)
364 return node->visited;
368 set_irn_visited (ir_node *node, unsigned long visited)
371 node->visited = visited;
375 mark_irn_visited (ir_node *node) {
377 node->visited = current_ir_graph->visited;
381 irn_not_visited (ir_node *node) {
383 return (node->visited < current_ir_graph->visited);
387 irn_visited (ir_node *node) {
389 return (node->visited >= current_ir_graph->visited);
393 set_irn_link (ir_node *node, void *link) {
399 get_irn_link (ir_node *node) {
404 /* Outputs a unique number for this node */
406 get_irn_node_nr(ir_node *node) {
409 return node->node_nr;
416 get_irn_const_attr (ir_node *node)
418 assert (node->op == op_Const);
419 return node->attr.con;
423 get_irn_proj_attr (ir_node *node)
425 assert (node->op == op_Proj);
426 return node->attr.proj;
430 get_irn_alloc_attr (ir_node *node)
432 assert (node->op == op_Alloc);
437 get_irn_free_attr (ir_node *node)
439 assert (node->op == op_Free);
440 return node->attr.f = skip_tid(node->attr.f);
444 get_irn_symconst_attr (ir_node *node)
446 assert (node->op == op_SymConst);
451 get_irn_call_attr (ir_node *node)
453 assert (node->op == op_Call);
454 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
458 get_irn_sel_attr (ir_node *node)
460 assert (node->op == op_Sel);
465 get_irn_phi_attr (ir_node *node)
467 assert (node->op == op_Phi);
468 return node->attr.phi0_pos;
472 get_irn_block_attr (ir_node *node)
474 assert (node->op == op_Block);
475 return node->attr.block;
478 /** manipulate fields of individual nodes **/
480 /* this works for all except Block */
482 get_nodes_Block (ir_node *node) {
483 assert (!(node->op == op_Block));
484 return get_irn_n(node, -1);
488 set_nodes_Block (ir_node *node, ir_node *block) {
489 assert (!(node->op == op_Block));
490 set_irn_n(node, -1, block);
493 /* Returns an array with the predecessors of the Block. Depending on
494 the implementation of the graph datastructure this can be a copy of
495 the internal representation of predecessors as well as the internal
496 array itself. Therefore writing to this array might obstruct the ir. */
498 get_Block_cfgpred_arr (ir_node *node)
500 assert ((node->op == op_Block));
501 return (ir_node **)&(get_irn_in(node)[1]);
506 get_Block_n_cfgpreds (ir_node *node) {
507 assert ((node->op == op_Block));
508 return (get_irn_arity(node));
512 get_Block_cfgpred (ir_node *node, int pos) {
514 assert (node->op == op_Block);
515 if (-1 > pos || get_irn_arity(node) <= pos) {
516 dump_ir_block_graph(current_ir_graph);
517 printf("pos: %d, arity: %d ", pos, get_irn_arity(node));
520 assert(node); assert(-1 <= pos && pos < get_irn_arity(node));
521 return get_irn_n(node, pos);
525 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
526 assert (node->op == op_Block);
527 set_irn_n(node, pos, pred);
531 get_Block_matured (ir_node *node) {
532 assert (node->op == op_Block);
533 return node->attr.block.matured;
537 set_Block_matured (ir_node *node, bool matured) {
538 assert (node->op == op_Block);
539 node->attr.block.matured = matured;
542 get_Block_block_visited (ir_node *node) {
543 assert (node->op == op_Block);
544 return node->attr.block.block_visited;
548 set_Block_block_visited (ir_node *node, unsigned long visit) {
549 assert (node->op == op_Block);
550 node->attr.block.block_visited = visit;
553 /* For this current_ir_graph must be set. */
555 mark_Block_block_visited (ir_node *node) {
556 assert (node->op == op_Block);
557 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
561 Block_not_block_visited(ir_node *node) {
562 assert (node->op == op_Block);
563 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
567 get_Block_graph_arr (ir_node *node, int pos) {
568 assert (node->op == op_Block);
569 return node->attr.block.graph_arr[pos+1];
573 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
574 assert (node->op == op_Block);
575 node->attr.block.graph_arr[pos+1] = value;
578 /* handler handling for Blocks */
580 set_Block_handler (ir_node *block, ir_node *handler) {
581 assert ((block->op == op_Block));
582 assert ((handler->op == op_Block));
583 block->attr.block.handler_entry = handler;
587 get_Block_handler (ir_node *block) {
588 assert ((block->op == op_Block));
589 return (block->attr.block.handler_entry);
592 /* handler handling for Nodes */
594 set_Node_handler (ir_node *node, ir_node *handler) {
595 set_Block_handler (get_nodes_Block (node), handler);
599 get_Node_handler (ir_node *node) {
600 return (get_Block_handler (get_nodes_Block (node)));
603 /* exc_t handling for Blocks */
604 void set_Block_exc (ir_node *block, exc_t exc) {
605 assert ((block->op == op_Block));
606 block->attr.block.exc = exc;
609 exc_t get_Block_exc (ir_node *block) {
610 assert ((block->op == op_Block));
612 return (block->attr.block.exc);
615 /* exc_t handling for Nodes */
616 void set_Node_exc (ir_node *node, exc_t exc) {
617 set_Block_exc (get_nodes_Block (node), exc);
620 exc_t get_Node_exc (ir_node *node) {
621 return (get_Block_exc (get_nodes_Block (node)));
624 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
625 assert(node->op == op_Block);
626 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
627 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
628 node->attr.block.in_cg[0] = NULL;
629 node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
631 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
634 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
635 assert(node->op == op_Block &&
636 node->attr.block.in_cg &&
637 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
638 node->attr.block.in_cg[pos + 1] = pred;
641 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
642 assert(node->op == op_Block);
643 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
646 int get_Block_cg_n_cfgpreds(ir_node * node) {
647 assert(node->op == op_Block && node->attr.block.in_cg);
648 return ARR_LEN(node->attr.block.in_cg) - 1;
651 ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
652 assert(node->op == op_Block && node->attr.block.in_cg);
653 return node->attr.block.in_cg[pos + 1];
656 void remove_Block_cg_cfgpred_arr(ir_node * node) {
657 assert(node->op == op_Block);
658 node->attr.block.in_cg = NULL;
662 get_End_n_keepalives(ir_node *end) {
663 assert (end->op == op_End);
664 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
668 get_End_keepalive(ir_node *end, int pos) {
669 assert (end->op == op_End);
670 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
674 add_End_keepalive (ir_node *end, ir_node *ka) {
675 assert (end->op == op_End);
676 ARR_APP1 (ir_node *, end->in, ka);
680 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
681 assert (end->op == op_End);
682 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
686 free_End (ir_node *end) {
687 assert (end->op == op_End);
688 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
689 end->in = NULL; /* @@@ make sure we get an error if we use the
690 in array afterwards ... */
693 ir_graph *get_EndReg_irg (ir_node *end) {
694 assert (end->op == op_EndReg);
695 return end->attr.end.irg;
698 ir_graph *get_EndExcept_irg (ir_node *end) {
699 assert (end->op == op_EndReg);
700 return end->attr.end.irg;
704 > Implementing the case construct (which is where the constant Proj node is
705 > important) involves far more than simply determining the constant values.
706 > We could argue that this is more properly a function of the translator from
707 > Firm to the target machine. That could be done if there was some way of
708 > projecting "default" out of the Cond node.
709 I know it's complicated.
710 Basically there are two proglems:
711 - determining the gaps between the projs
712 - determining the biggest case constant to konw the proj number for
714 I see several solutions:
715 1. Introduce a ProjDefault node. Solves both problems.
716 This means to extend all optimizations executed during construction.
717 2. Give the Cond node for switch two flavors:
718 a) there are no gaps in the projs (existing flavor)
719 b) gaps may exist, default proj is still the Proj with the largest
720 projection number. This covers also the gaps.
721 3. Fix the semantic of the Cond to that of 2b)
723 Solution 2 seems to be the best:
724 Computing the gaps in the Firm representation is not too hard, i.e.,
725 libfirm can implement a routine that transforms betweeen the two
726 flavours. This is also possible for 1) but 2) does not require to
727 change any existing optimization.
728 Further it should be far simpler to determine the biggest constant than
730 I don't want to choose 3) as 2a) seems to have advantages for
731 dataflow analysis and 3) does not allow to convert the representation to
735 get_Cond_selector (ir_node *node) {
736 assert (node->op == op_Cond);
737 return get_irn_n(node, 0);
741 set_Cond_selector (ir_node *node, ir_node *selector) {
742 assert (node->op == op_Cond);
743 set_irn_n(node, 0, selector);
747 get_Cond_kind (ir_node *node) {
748 assert (node->op == op_Cond);
749 return node->attr.c.kind;
753 set_Cond_kind (ir_node *node, cond_kind kind) {
754 assert (node->op == op_Cond);
755 node->attr.c.kind = kind;
759 get_Return_mem (ir_node *node) {
760 assert (node->op == op_Return);
761 return get_irn_n(node, 0);
765 set_Return_mem (ir_node *node, ir_node *mem) {
766 assert (node->op == op_Return);
767 set_irn_n(node, 0, mem);
771 get_Return_n_ress (ir_node *node) {
772 assert (node->op == op_Return);
773 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
777 get_Return_res_arr (ir_node *node)
779 assert ((node->op == op_Return));
780 if (get_Return_n_ress(node) > 0)
781 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
788 set_Return_n_res (ir_node *node, int results) {
789 assert (node->op == op_Return);
794 get_Return_res (ir_node *node, int pos) {
795 assert (node->op == op_Return);
796 assert (get_Return_n_ress(node) > pos);
797 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
801 set_Return_res (ir_node *node, int pos, ir_node *res){
802 assert (node->op == op_Return);
803 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
807 get_Raise_mem (ir_node *node) {
808 assert (node->op == op_Return);
809 return get_irn_n(node, 0);
813 set_Raise_mem (ir_node *node, ir_node *mem) {
814 assert (node->op == op_Raise);
815 set_irn_n(node, 0, mem);
819 get_Raise_exo_ptr (ir_node *node) {
820 assert (node->op == op_Raise);
821 return get_irn_n(node, 1);
825 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
826 assert (node->op == op_Raise);
827 set_irn_n(node, 1, exo_ptr);
830 INLINE tarval *get_Const_tarval (ir_node *node) {
831 assert (node->op == op_Const);
832 return get_irn_const_attr(node);
836 set_Const_tarval (ir_node *node, tarval *con) {
837 assert (node->op == op_Const);
838 node->attr.con = con;
842 get_SymConst_kind (ir_node *node) {
843 assert (node->op == op_SymConst);
844 return node->attr.i.num;
848 set_SymConst_kind (ir_node *node, symconst_kind num) {
849 assert (node->op == op_SymConst);
850 node->attr.i.num = num;
854 get_SymConst_type (ir_node *node) {
855 assert ( (node->op == op_SymConst)
856 && ( get_SymConst_kind(node) == type_tag
857 || get_SymConst_kind(node) == size));
858 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
862 set_SymConst_type (ir_node *node, type *type) {
863 assert ( (node->op == op_SymConst)
864 && ( get_SymConst_kind(node) == type_tag
865 || get_SymConst_kind(node) == size));
866 node->attr.i.tori.typ = type;
870 get_SymConst_ptrinfo (ir_node *node) {
871 assert ( (node->op == op_SymConst)
872 && (get_SymConst_kind(node) == linkage_ptr_info));
873 return node->attr.i.tori.ptrinfo;
877 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
878 assert ( (node->op == op_SymConst)
879 && (get_SymConst_kind(node) == linkage_ptr_info));
880 node->attr.i.tori.ptrinfo = ptrinfo;
884 get_SymConst_type_or_id (ir_node *node) {
885 assert (node->op == op_SymConst);
886 return &(node->attr.i.tori);
890 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
891 assert (node->op == op_SymConst);
892 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
896 get_Sel_mem (ir_node *node) {
897 assert (node->op == op_Sel);
898 return get_irn_n(node, 0);
902 set_Sel_mem (ir_node *node, ir_node *mem) {
903 assert (node->op == op_Sel);
904 set_irn_n(node, 0, mem);
908 get_Sel_ptr (ir_node *node) {
909 assert (node->op == op_Sel);
910 return get_irn_n(node, 1);
914 set_Sel_ptr (ir_node *node, ir_node *ptr) {
915 assert (node->op == op_Sel);
916 set_irn_n(node, 1, ptr);
920 get_Sel_n_indexs (ir_node *node) {
921 assert (node->op == op_Sel);
922 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
926 get_Sel_index_arr (ir_node *node)
928 assert ((node->op == op_Sel));
929 if (get_Sel_n_indexs(node) > 0)
930 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
936 get_Sel_index (ir_node *node, int pos) {
937 assert (node->op == op_Sel);
938 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
942 set_Sel_index (ir_node *node, int pos, ir_node *index) {
943 assert (node->op == op_Sel);
944 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
948 get_Sel_entity (ir_node *node) {
949 assert (node->op == op_Sel);
950 return node->attr.s.ent;
954 set_Sel_entity (ir_node *node, entity *ent) {
955 assert (node->op == op_Sel);
956 node->attr.s.ent = ent;
960 get_InstOf_ent (ir_node *node) {
961 assert (node->op = op_InstOf);
962 return (node->attr.io.ent);
966 set_InstOf_ent (ir_node *node, type *ent) {
967 assert (node->op = op_InstOf);
968 node->attr.io.ent = ent;
972 get_InstOf_store (ir_node *node) {
973 assert (node->op = op_InstOf);
974 return (get_irn_n (node, 0));
978 set_InstOf_store (ir_node *node, ir_node *obj) {
979 assert (node->op = op_InstOf);
980 set_irn_n (node, 0, obj);
984 get_InstOf_obj (ir_node *node) {
985 assert (node->op = op_InstOf);
986 return (get_irn_n (node, 1));
990 set_InstOf_obj (ir_node *node, ir_node *obj) {
991 assert (node->op = op_InstOf);
992 set_irn_n (node, 1, obj);
996 /* For unary and binary arithmetic operations the access to the
997 operands can be factored out. Left is the first, right the
998 second arithmetic value as listed in tech report 0999-33.
999 unops are: Minus, Abs, Not, Conv
1000 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1001 Shr, Shrs, Rotate, Cmp */
1005 get_Call_mem (ir_node *node) {
1006 assert (node->op == op_Call);
1007 return get_irn_n(node, 0);
1011 set_Call_mem (ir_node *node, ir_node *mem) {
1012 assert (node->op == op_Call);
1013 set_irn_n(node, 0, mem);
1017 get_Call_ptr (ir_node *node) {
1018 assert (node->op == op_Call);
1019 return get_irn_n(node, 1);
1023 set_Call_ptr (ir_node *node, ir_node *ptr) {
1024 assert (node->op == op_Call);
1025 set_irn_n(node, 1, ptr);
1029 get_Call_param_arr (ir_node *node) {
1030 assert (node->op == op_Call);
1031 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1035 get_Call_n_params (ir_node *node) {
1036 assert (node->op == op_Call);
1037 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1041 get_Call_arity (ir_node *node) {
1042 assert (node->op == op_Call);
1043 return get_Call_n_params(node);
1047 set_Call_arity (ir_node *node, ir_node *arity) {
1048 assert (node->op == op_Call);
1053 get_Call_param (ir_node *node, int pos) {
1054 assert (node->op == op_Call);
1055 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1059 set_Call_param (ir_node *node, int pos, ir_node *param) {
1060 assert (node->op == op_Call);
1061 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1065 get_Call_type (ir_node *node) {
1066 assert (node->op == op_Call);
1067 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1071 set_Call_type (ir_node *node, type *type) {
1072 assert (node->op == op_Call);
1073 assert (is_method_type(type));
1074 node->attr.call.cld_tp = type;
1077 int get_Call_n_callees(ir_node * node) {
1078 assert(node->op == op_Call && node->attr.call.callee_arr);
1079 return ARR_LEN(node->attr.call.callee_arr);
1082 entity * get_Call_callee(ir_node * node, int pos) {
1083 assert(node->op == op_Call && node->attr.call.callee_arr);
1084 return node->attr.call.callee_arr[pos];
1087 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1088 assert(node->op == op_Call);
1089 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1090 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1092 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1095 void remove_Call_callee_arr(ir_node * node) {
1096 assert(node->op == op_Call);
1097 node->attr.call.callee_arr = NULL;
1100 ir_node * get_CallBegin_ptr (ir_node *node) {
1101 assert(node->op == op_CallBegin);
1102 return get_irn_n(node, 0);
1104 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1105 assert(node->op == op_CallBegin);
1106 set_irn_n(node, 0, ptr);
1108 ir_graph * get_CallBegin_irg (ir_node *node) {
1109 assert(node->op == op_CallBegin);
1110 return node->attr.callbegin.irg;
1112 ir_node * get_CallBegin_call (ir_node *node) {
1113 assert(node->op == op_CallBegin);
1114 return node->attr.callbegin.call;
1116 void set_CallBegin_call (ir_node *node, ir_node *call) {
1117 assert(node->op == op_CallBegin);
1118 node->attr.callbegin.call = call;
1122 get_Add_left (ir_node *node) {
1123 assert (node->op == op_Add);
1124 return get_irn_n(node, 0);
1128 set_Add_left (ir_node *node, ir_node *left) {
1129 assert (node->op == op_Add);
1130 set_irn_n(node, 0, left);
1134 get_Add_right (ir_node *node) {
1135 assert (node->op == op_Add);
1136 return get_irn_n(node, 1);
1140 set_Add_right (ir_node *node, ir_node *right) {
1141 assert (node->op == op_Add);
1142 set_irn_n(node, 1, right);
1146 get_Sub_left (ir_node *node) {
1147 assert (node->op == op_Sub);
1148 return get_irn_n(node, 0);
1152 set_Sub_left (ir_node *node, ir_node *left) {
1153 assert (node->op == op_Sub);
1154 set_irn_n(node, 0, left);
1158 get_Sub_right (ir_node *node) {
1159 assert (node->op == op_Sub);
1160 return get_irn_n(node, 1);
1164 set_Sub_right (ir_node *node, ir_node *right) {
1165 assert (node->op == op_Sub);
1166 set_irn_n(node, 1, right);
1171 get_Minus_op (ir_node *node) {
1172 assert (node->op == op_Minus);
1173 return get_irn_n(node, 0);
1177 set_Minus_op (ir_node *node, ir_node *op) {
1178 assert (node->op == op_Minus);
1179 set_irn_n(node, 0, op);
1184 get_Mul_left (ir_node *node) {
1185 assert (node->op == op_Mul);
1186 return get_irn_n(node, 0);
1190 set_Mul_left (ir_node *node, ir_node *left) {
1191 assert (node->op == op_Mul);
1192 set_irn_n(node, 0, left);
1196 get_Mul_right (ir_node *node) {
1197 assert (node->op == op_Mul);
1198 return get_irn_n(node, 1);
1202 set_Mul_right (ir_node *node, ir_node *right) {
1203 assert (node->op == op_Mul);
1204 set_irn_n(node, 1, right);
1208 get_Quot_left (ir_node *node) {
1209 assert (node->op == op_Quot);
1210 return get_irn_n(node, 1);
1214 set_Quot_left (ir_node *node, ir_node *left) {
1215 assert (node->op == op_Quot);
1216 set_irn_n(node, 1, left);
1220 get_Quot_right (ir_node *node) {
1221 assert (node->op == op_Quot);
1222 return get_irn_n(node, 2);
1226 set_Quot_right (ir_node *node, ir_node *right) {
1227 assert (node->op == op_Quot);
1228 set_irn_n(node, 2, right);
1232 get_Quot_mem (ir_node *node) {
1233 assert (node->op == op_Quot);
1234 return get_irn_n(node, 0);
1238 set_Quot_mem (ir_node *node, ir_node *mem) {
1239 assert (node->op == op_Quot);
1240 set_irn_n(node, 0, mem);
1244 get_DivMod_left (ir_node *node) {
1245 assert (node->op == op_DivMod);
1246 return get_irn_n(node, 1);
1250 set_DivMod_left (ir_node *node, ir_node *left) {
1251 assert (node->op == op_DivMod);
1252 set_irn_n(node, 1, left);
1256 get_DivMod_right (ir_node *node) {
1257 assert (node->op == op_DivMod);
1258 return get_irn_n(node, 2);
1262 set_DivMod_right (ir_node *node, ir_node *right) {
1263 assert (node->op == op_DivMod);
1264 set_irn_n(node, 2, right);
1268 get_DivMod_mem (ir_node *node) {
1269 assert (node->op == op_DivMod);
1270 return get_irn_n(node, 0);
1274 set_DivMod_mem (ir_node *node, ir_node *mem) {
1275 assert (node->op == op_DivMod);
1276 set_irn_n(node, 0, mem);
1280 get_Div_left (ir_node *node) {
1281 assert (node->op == op_Div);
1282 return get_irn_n(node, 1);
1286 set_Div_left (ir_node *node, ir_node *left) {
1287 assert (node->op == op_Div);
1288 set_irn_n(node, 1, left);
1292 get_Div_right (ir_node *node) {
1293 assert (node->op == op_Div);
1294 return get_irn_n(node, 2);
1298 set_Div_right (ir_node *node, ir_node *right) {
1299 assert (node->op == op_Div);
1300 set_irn_n(node, 2, right);
1304 get_Div_mem (ir_node *node) {
1305 assert (node->op == op_Div);
1306 return get_irn_n(node, 0);
1310 set_Div_mem (ir_node *node, ir_node *mem) {
1311 assert (node->op == op_Div);
1312 set_irn_n(node, 0, mem);
1316 get_Mod_left (ir_node *node) {
1317 assert (node->op == op_Mod);
1318 return get_irn_n(node, 1);
1322 set_Mod_left (ir_node *node, ir_node *left) {
1323 assert (node->op == op_Mod);
1324 set_irn_n(node, 1, left);
1328 get_Mod_right (ir_node *node) {
1329 assert (node->op == op_Mod);
1330 return get_irn_n(node, 2);
1334 set_Mod_right (ir_node *node, ir_node *right) {
1335 assert (node->op == op_Mod);
1336 set_irn_n(node, 2, right);
1340 get_Mod_mem (ir_node *node) {
1341 assert (node->op == op_Mod);
1342 return get_irn_n(node, 0);
1346 set_Mod_mem (ir_node *node, ir_node *mem) {
1347 assert (node->op == op_Mod);
1348 set_irn_n(node, 0, mem);
1352 get_Abs_op (ir_node *node) {
1353 assert (node->op == op_Abs);
1354 return get_irn_n(node, 0);
1358 set_Abs_op (ir_node *node, ir_node *op) {
1359 assert (node->op == op_Abs);
1360 set_irn_n(node, 0, op);
1364 get_And_left (ir_node *node) {
1365 assert (node->op == op_And);
1366 return get_irn_n(node, 0);
1370 set_And_left (ir_node *node, ir_node *left) {
1371 assert (node->op == op_And);
1372 set_irn_n(node, 0, left);
1376 get_And_right (ir_node *node) {
1377 assert (node->op == op_And);
1378 return get_irn_n(node, 1);
1382 set_And_right (ir_node *node, ir_node *right) {
1383 assert (node->op == op_And);
1384 set_irn_n(node, 1, right);
1388 get_Or_left (ir_node *node) {
1389 assert (node->op == op_Or);
1390 return get_irn_n(node, 0);
1394 set_Or_left (ir_node *node, ir_node *left) {
1395 assert (node->op == op_Or);
1396 set_irn_n(node, 0, left);
1400 get_Or_right (ir_node *node) {
1401 assert (node->op == op_Or);
1402 return get_irn_n(node, 1);
1406 set_Or_right (ir_node *node, ir_node *right) {
1407 assert (node->op == op_Or);
1408 set_irn_n(node, 1, right);
1412 get_Eor_left (ir_node *node) {
1413 assert (node->op == op_Eor);
1414 return get_irn_n(node, 0);
1418 set_Eor_left (ir_node *node, ir_node *left) {
1419 assert (node->op == op_Eor);
1420 set_irn_n(node, 0, left);
1424 get_Eor_right (ir_node *node) {
1425 assert (node->op == op_Eor);
1426 return get_irn_n(node, 1);
1430 set_Eor_right (ir_node *node, ir_node *right) {
1431 assert (node->op == op_Eor);
1432 set_irn_n(node, 1, right);
1437 get_Not_op (ir_node *node) {
1438 assert (node->op == op_Not);
1439 return get_irn_n(node, 0);
1443 set_Not_op (ir_node *node, ir_node *op) {
1444 assert (node->op == op_Not);
1445 set_irn_n(node, 0, op);
1450 get_Shl_left (ir_node *node) {
1451 assert (node->op == op_Shl);
1452 return get_irn_n(node, 0);
1456 set_Shl_left (ir_node *node, ir_node *left) {
1457 assert (node->op == op_Shl);
1458 set_irn_n(node, 0, left);
1462 get_Shl_right (ir_node *node) {
1463 assert (node->op == op_Shl);
1464 return get_irn_n(node, 1);
1468 set_Shl_right (ir_node *node, ir_node *right) {
1469 assert (node->op == op_Shl);
1470 set_irn_n(node, 1, right);
1474 get_Shr_left (ir_node *node) {
1475 assert (node->op == op_Shr);
1476 return get_irn_n(node, 0);
1480 set_Shr_left (ir_node *node, ir_node *left) {
1481 assert (node->op == op_Shr);
1482 set_irn_n(node, 0, left);
1486 get_Shr_right (ir_node *node) {
1487 assert (node->op == op_Shr);
1488 return get_irn_n(node, 1);
1492 set_Shr_right (ir_node *node, ir_node *right) {
1493 assert (node->op == op_Shr);
1494 set_irn_n(node, 1, right);
1498 get_Shrs_left (ir_node *node) {
1499 assert (node->op == op_Shrs);
1500 return get_irn_n(node, 0);
1504 set_Shrs_left (ir_node *node, ir_node *left) {
1505 assert (node->op == op_Shrs);
1506 set_irn_n(node, 0, left);
1510 get_Shrs_right (ir_node *node) {
1511 assert (node->op == op_Shrs);
1512 return get_irn_n(node, 1);
1516 set_Shrs_right (ir_node *node, ir_node *right) {
1517 assert (node->op == op_Shrs);
1518 set_irn_n(node, 1, right);
1522 get_Rot_left (ir_node *node) {
1523 assert (node->op == op_Rot);
1524 return get_irn_n(node, 0);
1528 set_Rot_left (ir_node *node, ir_node *left) {
1529 assert (node->op == op_Rot);
1530 set_irn_n(node, 0, left);
1534 get_Rot_right (ir_node *node) {
1535 assert (node->op == op_Rot);
1536 return get_irn_n(node, 1);
1540 set_Rot_right (ir_node *node, ir_node *right) {
1541 assert (node->op == op_Rot);
1542 set_irn_n(node, 1, right);
1546 get_Cmp_left (ir_node *node) {
1547 assert (node->op == op_Cmp);
1548 return get_irn_n(node, 0);
1552 set_Cmp_left (ir_node *node, ir_node *left) {
1553 assert (node->op == op_Cmp);
1554 set_irn_n(node, 0, left);
1558 get_Cmp_right (ir_node *node) {
1559 assert (node->op == op_Cmp);
1560 return get_irn_n(node, 1);
1564 set_Cmp_right (ir_node *node, ir_node *right) {
1565 assert (node->op == op_Cmp);
1566 set_irn_n(node, 1, right);
1570 get_Conv_op (ir_node *node) {
1571 assert (node->op == op_Conv);
1572 return get_irn_n(node, 0);
1576 set_Conv_op (ir_node *node, ir_node *op) {
1577 assert (node->op == op_Conv);
1578 set_irn_n(node, 0, op);
1584 is_unop (ir_node *node) {
1585 return ( node->op == op_Minus ||
1586 node->op == op_Abs ||
1587 node->op == op_Not ||
1588 node->op == op_Conv );
1592 get_unop_op (ir_node *node) {
1593 assert ( node->op == op_Minus ||
1594 node->op == op_Abs ||
1595 node->op == op_Not ||
1596 node->op == op_Conv );
1597 switch (get_irn_opcode (node)) {
1598 case iro_Minus: return get_Minus_op(node); break;
1599 case iro_Abs: return get_Abs_op(node); break;
1600 case iro_Not: return get_Not_op(node); break;
1601 case iro_Conv: return get_Conv_op(node); break;
1602 default: return NULL;
1607 set_unop_op (ir_node *node, ir_node *op) {
1608 assert (node->op == op_Minus ||
1609 node->op == op_Abs ||
1610 node->op == op_Not ||
1611 node->op == op_Conv );
1612 switch (get_irn_opcode (node)) {
1613 case iro_Minus: set_Minus_op(node, op); break;
1614 case iro_Abs: set_Abs_op(node, op); break;
1615 case iro_Not: set_Not_op(node, op); break;
1616 case iro_Conv: set_Conv_op(node, op); break;
1623 is_binop (ir_node *node) {
1624 return (node->op == op_Add ||
1625 node->op == op_Sub ||
1626 node->op == op_Mul ||
1627 node->op == op_Quot ||
1628 node->op == op_DivMod ||
1629 node->op == op_Div ||
1630 node->op == op_Mod ||
1631 node->op == op_And ||
1632 node->op == op_Or ||
1633 node->op == op_Eor ||
1634 node->op == op_Shl ||
1635 node->op == op_Shr ||
1636 node->op == op_Shrs ||
1637 node->op == op_Rot ||
1638 node->op == op_Cmp );
1642 get_binop_left (ir_node *node) {
1643 assert (node->op == op_Add ||
1644 node->op == op_Sub ||
1645 node->op == op_Mul ||
1646 node->op == op_Quot ||
1647 node->op == op_DivMod ||
1648 node->op == op_Div ||
1649 node->op == op_Mod ||
1650 node->op == op_And ||
1651 node->op == op_Or ||
1652 node->op == op_Eor ||
1653 node->op == op_Shl ||
1654 node->op == op_Shr ||
1655 node->op == op_Shrs ||
1656 node->op == op_Rot ||
1657 node->op == op_Cmp );
1659 switch (get_irn_opcode (node)) {
1660 case iro_Add : return get_Add_left(node); break;
1661 case iro_Sub : return get_Sub_left(node); break;
1662 case iro_Mul : return get_Mul_left(node); break;
1663 case iro_Quot : return get_Quot_left(node); break;
1664 case iro_DivMod: return get_DivMod_left(node); break;
1665 case iro_Div : return get_Div_left(node); break;
1666 case iro_Mod : return get_Mod_left(node); break;
1667 case iro_And : return get_And_left(node); break;
1668 case iro_Or : return get_Or_left(node); break;
1669 case iro_Eor : return get_Eor_left(node); break;
1670 case iro_Shl : return get_Shl_left(node); break;
1671 case iro_Shr : return get_Shr_left(node); break;
1672 case iro_Shrs : return get_Shrs_left(node); break;
1673 case iro_Rot : return get_Rot_left(node); break;
1674 case iro_Cmp : return get_Cmp_left(node); break;
1675 default: return NULL;
1680 set_binop_left (ir_node *node, ir_node *left) {
1681 assert (node->op == op_Add ||
1682 node->op == op_Sub ||
1683 node->op == op_Mul ||
1684 node->op == op_Quot ||
1685 node->op == op_DivMod ||
1686 node->op == op_Div ||
1687 node->op == op_Mod ||
1688 node->op == op_And ||
1689 node->op == op_Or ||
1690 node->op == op_Eor ||
1691 node->op == op_Shl ||
1692 node->op == op_Shr ||
1693 node->op == op_Shrs ||
1694 node->op == op_Rot ||
1695 node->op == op_Cmp );
1697 switch (get_irn_opcode (node)) {
1698 case iro_Add : set_Add_left(node, left); break;
1699 case iro_Sub : set_Sub_left(node, left); break;
1700 case iro_Mul : set_Mul_left(node, left); break;
1701 case iro_Quot : set_Quot_left(node, left); break;
1702 case iro_DivMod: set_DivMod_left(node, left); break;
1703 case iro_Div : set_Div_left(node, left); break;
1704 case iro_Mod : set_Mod_left(node, left); break;
1705 case iro_And : set_And_left(node, left); break;
1706 case iro_Or : set_Or_left(node, left); break;
1707 case iro_Eor : set_Eor_left(node, left); break;
1708 case iro_Shl : set_Shl_left(node, left); break;
1709 case iro_Shr : set_Shr_left(node, left); break;
1710 case iro_Shrs : set_Shrs_left(node, left); break;
1711 case iro_Rot : set_Rot_left(node, left); break;
1712 case iro_Cmp : set_Cmp_left(node, left); break;
1718 get_binop_right (ir_node *node) {
1719 assert (node->op == op_Add ||
1720 node->op == op_Sub ||
1721 node->op == op_Mul ||
1722 node->op == op_Quot ||
1723 node->op == op_DivMod ||
1724 node->op == op_Div ||
1725 node->op == op_Mod ||
1726 node->op == op_And ||
1727 node->op == op_Or ||
1728 node->op == op_Eor ||
1729 node->op == op_Shl ||
1730 node->op == op_Shr ||
1731 node->op == op_Shrs ||
1732 node->op == op_Rot ||
1733 node->op == op_Cmp );
1735 switch (get_irn_opcode (node)) {
1736 case iro_Add : return get_Add_right(node); break;
1737 case iro_Sub : return get_Sub_right(node); break;
1738 case iro_Mul : return get_Mul_right(node); break;
1739 case iro_Quot : return get_Quot_right(node); break;
1740 case iro_DivMod: return get_DivMod_right(node); break;
1741 case iro_Div : return get_Div_right(node); break;
1742 case iro_Mod : return get_Mod_right(node); break;
1743 case iro_And : return get_And_right(node); break;
1744 case iro_Or : return get_Or_right(node); break;
1745 case iro_Eor : return get_Eor_right(node); break;
1746 case iro_Shl : return get_Shl_right(node); break;
1747 case iro_Shr : return get_Shr_right(node); break;
1748 case iro_Shrs : return get_Shrs_right(node); break;
1749 case iro_Rot : return get_Rot_right(node); break;
1750 case iro_Cmp : return get_Cmp_right(node); break;
1751 default: return NULL;
1756 set_binop_right (ir_node *node, ir_node *right) {
1757 assert (node->op == op_Add ||
1758 node->op == op_Sub ||
1759 node->op == op_Mul ||
1760 node->op == op_Quot ||
1761 node->op == op_DivMod ||
1762 node->op == op_Div ||
1763 node->op == op_Mod ||
1764 node->op == op_And ||
1765 node->op == op_Or ||
1766 node->op == op_Eor ||
1767 node->op == op_Shl ||
1768 node->op == op_Shr ||
1769 node->op == op_Shrs ||
1770 node->op == op_Rot ||
1771 node->op == op_Cmp );
1773 switch (get_irn_opcode (node)) {
1774 case iro_Add : set_Add_right(node, right); break;
1775 case iro_Sub : set_Sub_right(node, right); break;
1776 case iro_Mul : set_Mul_right(node, right); break;
1777 case iro_Quot : set_Quot_right(node, right); break;
1778 case iro_DivMod: set_DivMod_right(node, right); break;
1779 case iro_Div : set_Div_right(node, right); break;
1780 case iro_Mod : set_Mod_right(node, right); break;
1781 case iro_And : set_And_right(node, right); break;
1782 case iro_Or : set_Or_right(node, right); break;
1783 case iro_Eor : set_Eor_right(node, right); break;
1784 case iro_Shl : set_Shl_right(node, right); break;
1785 case iro_Shr : set_Shr_right(node, right); break;
1786 case iro_Shrs : set_Shrs_right(node, right); break;
1787 case iro_Rot : set_Rot_right(node, right); break;
1788 case iro_Cmp : set_Cmp_right(node, right); break;
1795 get_Phi_preds_arr (ir_node *node) {
1796 assert (node->op == op_Phi);
1797 return (ir_node **)&(get_irn_in(node)[1]);
1801 get_Phi_n_preds (ir_node *node) {
1802 assert (node->op == op_Phi);
1803 return (get_irn_arity(node));
1807 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1808 assert (node->op == op_Phi);
1813 get_Phi_pred (ir_node *node, int pos) {
1814 assert (node->op == op_Phi);
1815 return get_irn_n(node, pos);
1819 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1820 assert (node->op == op_Phi);
1821 set_irn_n(node, pos, pred);
1825 get_Load_mem (ir_node *node) {
1826 assert (node->op == op_Load);
1827 return get_irn_n(node, 0);
1831 set_Load_mem (ir_node *node, ir_node *mem) {
1832 assert (node->op == op_Load);
1833 set_irn_n(node, 0, mem);
1837 get_Load_ptr (ir_node *node) {
1838 assert (node->op == op_Load);
1839 return get_irn_n(node, 1);
1843 set_Load_ptr (ir_node *node, ir_node *ptr) {
1844 assert (node->op == op_Load);
1845 set_irn_n(node, 1, ptr);
1850 get_Store_mem (ir_node *node) {
1851 assert (node->op == op_Store);
1852 return get_irn_n(node, 0);
1856 set_Store_mem (ir_node *node, ir_node *mem) {
1857 assert (node->op == op_Store);
1858 set_irn_n(node, 0, mem);
1862 get_Store_ptr (ir_node *node) {
1863 assert (node->op == op_Store);
1864 return get_irn_n(node, 1);
1868 set_Store_ptr (ir_node *node, ir_node *ptr) {
1869 assert (node->op == op_Store);
1870 set_irn_n(node, 1, ptr);
1874 get_Store_value (ir_node *node) {
1875 assert (node->op == op_Store);
1876 return get_irn_n(node, 2);
1880 set_Store_value (ir_node *node, ir_node *value) {
1881 assert (node->op == op_Store);
1882 set_irn_n(node, 2, value);
1886 get_Alloc_mem (ir_node *node) {
1887 assert (node->op == op_Alloc);
1888 return get_irn_n(node, 0);
1892 set_Alloc_mem (ir_node *node, ir_node *mem) {
1893 assert (node->op == op_Alloc);
1894 set_irn_n(node, 0, mem);
1898 get_Alloc_size (ir_node *node) {
1899 assert (node->op == op_Alloc);
1900 return get_irn_n(node, 1);
1904 set_Alloc_size (ir_node *node, ir_node *size) {
1905 assert (node->op == op_Alloc);
1906 set_irn_n(node, 1, size);
1910 get_Alloc_type (ir_node *node) {
1911 assert (node->op == op_Alloc);
1912 return node->attr.a.type = skip_tid(node->attr.a.type);
1916 set_Alloc_type (ir_node *node, type *type) {
1917 assert (node->op == op_Alloc);
1918 node->attr.a.type = type;
1922 get_Alloc_where (ir_node *node) {
1923 assert (node->op == op_Alloc);
1924 return node->attr.a.where;
1928 set_Alloc_where (ir_node *node, where_alloc where) {
1929 assert (node->op == op_Alloc);
1930 node->attr.a.where = where;
1935 get_Free_mem (ir_node *node) {
1936 assert (node->op == op_Free);
1937 return get_irn_n(node, 0);
1941 set_Free_mem (ir_node *node, ir_node *mem) {
1942 assert (node->op == op_Free);
1943 set_irn_n(node, 0, mem);
1947 get_Free_ptr (ir_node *node) {
1948 assert (node->op == op_Free);
1949 return get_irn_n(node, 1);
1953 set_Free_ptr (ir_node *node, ir_node *ptr) {
1954 assert (node->op == op_Free);
1955 set_irn_n(node, 1, ptr);
1959 get_Free_size (ir_node *node) {
1960 assert (node->op == op_Free);
1961 return get_irn_n(node, 2);
1965 set_Free_size (ir_node *node, ir_node *size) {
1966 assert (node->op == op_Free);
1967 set_irn_n(node, 2, size);
1971 get_Free_type (ir_node *node) {
1972 assert (node->op == op_Free);
1973 return node->attr.f = skip_tid(node->attr.f);
1977 set_Free_type (ir_node *node, type *type) {
1978 assert (node->op == op_Free);
1979 node->attr.f = type;
1983 get_Sync_preds_arr (ir_node *node) {
1984 assert (node->op == op_Sync);
1985 return (ir_node **)&(get_irn_in(node)[1]);
1989 get_Sync_n_preds (ir_node *node) {
1990 assert (node->op == op_Sync);
1991 return (get_irn_arity(node));
1996 set_Sync_n_preds (ir_node *node, int n_preds) {
1997 assert (node->op == op_Sync);
2002 get_Sync_pred (ir_node *node, int pos) {
2003 assert (node->op == op_Sync);
2004 return get_irn_n(node, pos);
2008 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
2009 assert (node->op == op_Sync);
2010 set_irn_n(node, pos, pred);
2014 get_Proj_pred (ir_node *node) {
2015 assert (is_Proj(node));
2016 return get_irn_n(node, 0);
2020 set_Proj_pred (ir_node *node, ir_node *pred) {
2021 assert (is_Proj(node));
2022 set_irn_n(node, 0, pred);
2026 get_Proj_proj (ir_node *node) {
2027 assert (is_Proj(node));
2028 if (get_irn_opcode(node) == iro_Proj) {
2029 return node->attr.proj;
2031 assert(get_irn_opcode(node) == iro_Filter);
2032 return node->attr.filter.proj;
2037 set_Proj_proj (ir_node *node, long proj) {
2038 assert (node->op == op_Proj);
2039 node->attr.proj = proj;
2043 get_Tuple_preds_arr (ir_node *node) {
2044 assert (node->op == op_Tuple);
2045 return (ir_node **)&(get_irn_in(node)[1]);
2049 get_Tuple_n_preds (ir_node *node) {
2050 assert (node->op == op_Tuple);
2051 return (get_irn_arity(node));
2056 set_Tuple_n_preds (ir_node *node, int n_preds) {
2057 assert (node->op == op_Tuple);
2062 get_Tuple_pred (ir_node *node, int pos) {
2063 assert (node->op == op_Tuple);
2064 return get_irn_n(node, pos);
2068 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2069 assert (node->op == op_Tuple);
2070 set_irn_n(node, pos, pred);
2074 get_Id_pred (ir_node *node) {
2075 assert (node->op == op_Id);
2076 return get_irn_n(node, 0);
2080 set_Id_pred (ir_node *node, ir_node *pred) {
2081 assert (node->op == op_Id);
2082 set_irn_n(node, 0, pred);
2087 get_Filter_pred (ir_node *node) {
2088 assert(node->op == op_Filter);
2092 set_Filter_pred (ir_node *node, ir_node *pred) {
2093 assert(node->op == op_Filter);
2097 get_Filter_proj(ir_node *node) {
2098 assert(node->op == op_Filter);
2099 return node->attr.filter.proj;
2102 set_Filter_proj (ir_node *node, long proj) {
2103 assert(node->op == op_Filter);
2104 node->attr.filter.proj = proj;
2107 /* Don't use get_irn_arity, get_irn_n in implementation as access
2108 shall work independent of view!!! */
2109 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2110 assert(node->op == op_Filter);
2111 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2112 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2113 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2114 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2115 node->attr.filter.in_cg[0] = node->in[0];
2117 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2120 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2121 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2122 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2123 node->attr.filter.in_cg[pos + 1] = pred;
2125 int get_Filter_n_cg_preds(ir_node *node) {
2126 assert(node->op == op_Filter && node->attr.filter.in_cg);
2127 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2129 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2131 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2133 arity = ARR_LEN(node->attr.filter.in_cg);
2134 assert(pos < arity - 1);
2135 return node->attr.filter.in_cg[pos + 1];
2140 get_irn_irg(ir_node *node) {
2141 if (get_irn_op(node) == op_CallBegin) {
2142 return node->attr.callbegin.irg;
2143 } else if (get_irn_op(node) == op_EndReg ||
2144 get_irn_op(node) == op_EndExcept) {
2145 return node->attr.end.irg;
2147 assert(0 && "no irg attr");
2152 /******************************************************************/
2153 /* Auxiliary routines */
2154 /******************************************************************/
2157 skip_Proj (ir_node *node) {
2158 /* don't assert node !!! */
2159 if (node && is_Proj(node)) {
2160 return get_Proj_pred(node);
2167 skip_Tuple (ir_node *node) {
2170 node = skip_nop(node);
2171 if (get_irn_op(node) == op_Proj) {
2172 pred = skip_nop(get_Proj_pred(node));
2173 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2174 pred = skip_nop(skip_Tuple(pred));
2175 if (get_irn_op(pred) == op_Tuple)
2176 return get_Tuple_pred(pred, get_Proj_proj(node));
2182 skip_nop (ir_node *node) {
2183 /* don't assert node !!! */
2185 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
2186 /* Don't use get_Id_pred: We get into an endless loop for
2187 self-referencing Ids. */
2188 assert (get_irn_arity (node) > 0);
2189 return node->in[0+1];
2196 skip_Id (ir_node *node) {
2197 return skip_nop(node);
2201 is_Bad (ir_node *node) {
2203 if ((node) && get_irn_opcode(node) == iro_Bad)
2209 is_no_Block (ir_node *node) {
2211 return (get_irn_opcode(node) != iro_Block);
2215 is_Proj (ir_node *node) {
2217 return node->op == op_Proj
2218 || (!interprocedural_view && node->op == op_Filter);
2221 /* Returns true if the operation manipulates control flow. */
2223 is_cfop(ir_node *node) {
2224 return is_cfopcode(get_irn_op(node));
2227 /* Returns true if the operation manipulates interprocedural control flow:
2228 CallBegin, EndReg, EndExcept */
2229 int is_ip_cfop(ir_node *node) {
2230 return is_ip_cfopcode(get_irn_op(node));
2233 /* Returns true if the operation can change the control flow because
2236 is_fragile_op(ir_node *node) {
2237 return ( (get_irn_opcode(node) == iro_Call)
2238 || (get_irn_opcode(node) == iro_Quot)
2239 || (get_irn_opcode(node) == iro_DivMod)
2240 || (get_irn_opcode(node) == iro_Div)
2241 || (get_irn_opcode(node) == iro_Mod)
2242 || (get_irn_opcode(node) == iro_Load)
2243 || (get_irn_opcode(node) == iro_Store)
2244 || (get_irn_opcode(node) == iro_Alloc)
2245 || (get_irn_opcode(node) == iro_Bad)
2246 || (get_irn_opcode(node) == iro_Unknown));
2250 /* Returns the memory operand of fragile operations. */
2251 ir_node *get_fragile_op_mem(ir_node *node) {
2252 assert(node && is_fragile_op(node));
2254 switch (get_irn_opcode (node)) {
2263 return get_irn_n(node, 0);
2268 assert(0 && "not reached");