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) {
400 get_irn_link (ir_node *node) {
405 /* Outputs a unique number for this node */
407 get_irn_node_nr(ir_node *node) {
410 return node->node_nr;
417 get_irn_const_attr (ir_node *node)
419 assert (node->op == op_Const);
420 return node->attr.con;
424 get_irn_proj_attr (ir_node *node)
426 assert (node->op == op_Proj);
427 return node->attr.proj;
431 get_irn_alloc_attr (ir_node *node)
433 assert (node->op == op_Alloc);
438 get_irn_free_attr (ir_node *node)
440 assert (node->op == op_Free);
441 return node->attr.f = skip_tid(node->attr.f);
445 get_irn_symconst_attr (ir_node *node)
447 assert (node->op == op_SymConst);
452 get_irn_call_attr (ir_node *node)
454 assert (node->op == op_Call);
455 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
459 get_irn_sel_attr (ir_node *node)
461 assert (node->op == op_Sel);
466 get_irn_phi_attr (ir_node *node)
468 assert (node->op == op_Phi);
469 return node->attr.phi0_pos;
473 get_irn_block_attr (ir_node *node)
475 assert (node->op == op_Block);
476 return node->attr.block;
479 /** manipulate fields of individual nodes **/
481 /* this works for all except Block */
483 get_nodes_Block (ir_node *node) {
484 assert (!(node->op == op_Block));
485 return get_irn_n(node, -1);
489 set_nodes_Block (ir_node *node, ir_node *block) {
490 assert (!(node->op == op_Block));
491 set_irn_n(node, -1, block);
494 /* Returns an array with the predecessors of the Block. Depending on
495 the implementation of the graph datastructure this can be a copy of
496 the internal representation of predecessors as well as the internal
497 array itself. Therefore writing to this array might obstruct the ir. */
499 get_Block_cfgpred_arr (ir_node *node)
501 assert ((node->op == op_Block));
502 return (ir_node **)&(get_irn_in(node)[1]);
507 get_Block_n_cfgpreds (ir_node *node) {
508 assert ((node->op == op_Block));
509 return (get_irn_arity(node));
513 get_Block_cfgpred (ir_node *node, int pos) {
515 assert (node->op == op_Block);
516 if (-1 > pos || get_irn_arity(node) <= pos) {
517 dump_ir_block_graph(current_ir_graph);
518 printf("pos: %d, arity: %d ", pos, get_irn_arity(node));
521 assert(node); assert(-1 <= pos && pos < get_irn_arity(node));
522 return get_irn_n(node, pos);
526 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
527 assert (node->op == op_Block);
528 set_irn_n(node, pos, pred);
532 get_Block_matured (ir_node *node) {
533 assert (node->op == op_Block);
534 return node->attr.block.matured;
538 set_Block_matured (ir_node *node, bool matured) {
539 assert (node->op == op_Block);
540 node->attr.block.matured = matured;
543 get_Block_block_visited (ir_node *node) {
544 assert (node->op == op_Block);
545 return node->attr.block.block_visited;
549 set_Block_block_visited (ir_node *node, unsigned long visit) {
550 assert (node->op == op_Block);
551 node->attr.block.block_visited = visit;
554 /* For this current_ir_graph must be set. */
556 mark_Block_block_visited (ir_node *node) {
557 assert (node->op == op_Block);
558 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
562 Block_not_block_visited(ir_node *node) {
563 assert (node->op == op_Block);
564 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
568 get_Block_graph_arr (ir_node *node, int pos) {
569 assert (node->op == op_Block);
570 return node->attr.block.graph_arr[pos+1];
574 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
575 assert (node->op == op_Block);
576 node->attr.block.graph_arr[pos+1] = value;
579 /* handler handling for Blocks */
581 set_Block_handler (ir_node *block, ir_node *handler) {
582 assert ((block->op == op_Block));
583 assert ((handler->op == op_Block));
584 block->attr.block.handler_entry = handler;
588 get_Block_handler (ir_node *block) {
589 assert ((block->op == op_Block));
590 return (block->attr.block.handler_entry);
593 /* handler handling for Nodes */
595 set_Node_handler (ir_node *node, ir_node *handler) {
596 set_Block_handler (get_nodes_Block (node), handler);
600 get_Node_handler (ir_node *node) {
601 return (get_Block_handler (get_nodes_Block (node)));
604 /* exc_t handling for Blocks */
605 void set_Block_exc (ir_node *block, exc_t exc) {
606 assert ((block->op == op_Block));
607 block->attr.block.exc = exc;
610 exc_t get_Block_exc (ir_node *block) {
611 assert ((block->op == op_Block));
613 return (block->attr.block.exc);
616 /* exc_t handling for Nodes */
617 void set_Node_exc (ir_node *node, exc_t exc) {
618 set_Block_exc (get_nodes_Block (node), exc);
621 exc_t get_Node_exc (ir_node *node) {
622 return (get_Block_exc (get_nodes_Block (node)));
625 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
626 assert(node->op == op_Block);
627 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
628 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
629 node->attr.block.in_cg[0] = NULL;
630 node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
632 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
635 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
636 assert(node->op == op_Block &&
637 node->attr.block.in_cg &&
638 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
639 node->attr.block.in_cg[pos + 1] = pred;
642 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
643 assert(node->op == op_Block);
644 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
647 int get_Block_cg_n_cfgpreds(ir_node * node) {
648 assert(node->op == op_Block && node->attr.block.in_cg);
649 return ARR_LEN(node->attr.block.in_cg) - 1;
652 ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
653 assert(node->op == op_Block && node->attr.block.in_cg);
654 return node->attr.block.in_cg[pos + 1];
657 void remove_Block_cg_cfgpred_arr(ir_node * node) {
658 assert(node->op == op_Block);
659 node->attr.block.in_cg = NULL;
663 get_End_n_keepalives(ir_node *end) {
664 assert (end->op == op_End);
665 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
669 get_End_keepalive(ir_node *end, int pos) {
670 assert (end->op == op_End);
671 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
675 add_End_keepalive (ir_node *end, ir_node *ka) {
676 assert (end->op == op_End);
677 ARR_APP1 (ir_node *, end->in, ka);
681 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
682 assert (end->op == op_End);
683 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
687 free_End (ir_node *end) {
688 assert (end->op == op_End);
689 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
690 end->in = NULL; /* @@@ make sure we get an error if we use the
691 in array afterwards ... */
694 ir_graph *get_EndReg_irg (ir_node *end) {
695 assert (end->op == op_EndReg);
696 return end->attr.end.irg;
699 ir_graph *get_EndExcept_irg (ir_node *end) {
700 assert (end->op == op_EndReg);
701 return end->attr.end.irg;
705 > Implementing the case construct (which is where the constant Proj node is
706 > important) involves far more than simply determining the constant values.
707 > We could argue that this is more properly a function of the translator from
708 > Firm to the target machine. That could be done if there was some way of
709 > projecting "default" out of the Cond node.
710 I know it's complicated.
711 Basically there are two proglems:
712 - determining the gaps between the projs
713 - determining the biggest case constant to konw the proj number for
715 I see several solutions:
716 1. Introduce a ProjDefault node. Solves both problems.
717 This means to extend all optimizations executed during construction.
718 2. Give the Cond node for switch two flavors:
719 a) there are no gaps in the projs (existing flavor)
720 b) gaps may exist, default proj is still the Proj with the largest
721 projection number. This covers also the gaps.
722 3. Fix the semantic of the Cond to that of 2b)
724 Solution 2 seems to be the best:
725 Computing the gaps in the Firm representation is not too hard, i.e.,
726 libfirm can implement a routine that transforms betweeen the two
727 flavours. This is also possible for 1) but 2) does not require to
728 change any existing optimization.
729 Further it should be far simpler to determine the biggest constant than
731 I don't want to choose 3) as 2a) seems to have advantages for
732 dataflow analysis and 3) does not allow to convert the representation to
736 get_Cond_selector (ir_node *node) {
737 assert (node->op == op_Cond);
738 return get_irn_n(node, 0);
742 set_Cond_selector (ir_node *node, ir_node *selector) {
743 assert (node->op == op_Cond);
744 set_irn_n(node, 0, selector);
748 get_Cond_kind (ir_node *node) {
749 assert (node->op == op_Cond);
750 return node->attr.c.kind;
754 set_Cond_kind (ir_node *node, cond_kind kind) {
755 assert (node->op == op_Cond);
756 node->attr.c.kind = kind;
760 get_Return_mem (ir_node *node) {
761 assert (node->op == op_Return);
762 return get_irn_n(node, 0);
766 set_Return_mem (ir_node *node, ir_node *mem) {
767 assert (node->op == op_Return);
768 set_irn_n(node, 0, mem);
772 get_Return_n_ress (ir_node *node) {
773 assert (node->op == op_Return);
774 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
778 get_Return_res_arr (ir_node *node)
780 assert ((node->op == op_Return));
781 if (get_Return_n_ress(node) > 0)
782 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
789 set_Return_n_res (ir_node *node, int results) {
790 assert (node->op == op_Return);
795 get_Return_res (ir_node *node, int pos) {
796 assert (node->op == op_Return);
797 assert (get_Return_n_ress(node) > pos);
798 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
802 set_Return_res (ir_node *node, int pos, ir_node *res){
803 assert (node->op == op_Return);
804 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
808 get_Raise_mem (ir_node *node) {
809 assert (node->op == op_Return);
810 return get_irn_n(node, 0);
814 set_Raise_mem (ir_node *node, ir_node *mem) {
815 assert (node->op == op_Raise);
816 set_irn_n(node, 0, mem);
820 get_Raise_exo_ptr (ir_node *node) {
821 assert (node->op == op_Raise);
822 return get_irn_n(node, 1);
826 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
827 assert (node->op == op_Raise);
828 set_irn_n(node, 1, exo_ptr);
831 INLINE tarval *get_Const_tarval (ir_node *node) {
832 assert (node->op == op_Const);
833 return get_irn_const_attr(node);
837 set_Const_tarval (ir_node *node, tarval *con) {
838 assert (node->op == op_Const);
839 node->attr.con = con;
843 get_SymConst_kind (ir_node *node) {
844 assert (node->op == op_SymConst);
845 return node->attr.i.num;
849 set_SymConst_kind (ir_node *node, symconst_kind num) {
850 assert (node->op == op_SymConst);
851 node->attr.i.num = num;
855 get_SymConst_type (ir_node *node) {
856 assert ( (node->op == op_SymConst)
857 && ( get_SymConst_kind(node) == type_tag
858 || get_SymConst_kind(node) == size));
859 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
863 set_SymConst_type (ir_node *node, type *type) {
864 assert ( (node->op == op_SymConst)
865 && ( get_SymConst_kind(node) == type_tag
866 || get_SymConst_kind(node) == size));
867 node->attr.i.tori.typ = type;
871 get_SymConst_ptrinfo (ir_node *node) {
872 assert ( (node->op == op_SymConst)
873 && (get_SymConst_kind(node) == linkage_ptr_info));
874 return node->attr.i.tori.ptrinfo;
878 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
879 assert ( (node->op == op_SymConst)
880 && (get_SymConst_kind(node) == linkage_ptr_info));
881 node->attr.i.tori.ptrinfo = ptrinfo;
885 get_SymConst_type_or_id (ir_node *node) {
886 assert (node->op == op_SymConst);
887 return &(node->attr.i.tori);
891 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
892 assert (node->op == op_SymConst);
893 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
897 get_Sel_mem (ir_node *node) {
898 assert (node->op == op_Sel);
899 return get_irn_n(node, 0);
903 set_Sel_mem (ir_node *node, ir_node *mem) {
904 assert (node->op == op_Sel);
905 set_irn_n(node, 0, mem);
909 get_Sel_ptr (ir_node *node) {
910 assert (node->op == op_Sel);
911 return get_irn_n(node, 1);
915 set_Sel_ptr (ir_node *node, ir_node *ptr) {
916 assert (node->op == op_Sel);
917 set_irn_n(node, 1, ptr);
921 get_Sel_n_indexs (ir_node *node) {
922 assert (node->op == op_Sel);
923 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
927 get_Sel_index_arr (ir_node *node)
929 assert ((node->op == op_Sel));
930 if (get_Sel_n_indexs(node) > 0)
931 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
937 get_Sel_index (ir_node *node, int pos) {
938 assert (node->op == op_Sel);
939 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
943 set_Sel_index (ir_node *node, int pos, ir_node *index) {
944 assert (node->op == op_Sel);
945 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
949 get_Sel_entity (ir_node *node) {
950 assert (node->op == op_Sel);
951 return node->attr.s.ent;
955 set_Sel_entity (ir_node *node, entity *ent) {
956 assert (node->op == op_Sel);
957 node->attr.s.ent = ent;
961 get_InstOf_ent (ir_node *node) {
962 assert (node->op = op_InstOf);
963 return (node->attr.io.ent);
967 set_InstOf_ent (ir_node *node, type *ent) {
968 assert (node->op = op_InstOf);
969 node->attr.io.ent = ent;
973 get_InstOf_store (ir_node *node) {
974 assert (node->op = op_InstOf);
975 return (get_irn_n (node, 0));
979 set_InstOf_store (ir_node *node, ir_node *obj) {
980 assert (node->op = op_InstOf);
981 set_irn_n (node, 0, obj);
985 get_InstOf_obj (ir_node *node) {
986 assert (node->op = op_InstOf);
987 return (get_irn_n (node, 1));
991 set_InstOf_obj (ir_node *node, ir_node *obj) {
992 assert (node->op = op_InstOf);
993 set_irn_n (node, 1, obj);
997 /* For unary and binary arithmetic operations the access to the
998 operands can be factored out. Left is the first, right the
999 second arithmetic value as listed in tech report 0999-33.
1000 unops are: Minus, Abs, Not, Conv
1001 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1002 Shr, Shrs, Rotate, Cmp */
1006 get_Call_mem (ir_node *node) {
1007 assert (node->op == op_Call);
1008 return get_irn_n(node, 0);
1012 set_Call_mem (ir_node *node, ir_node *mem) {
1013 assert (node->op == op_Call);
1014 set_irn_n(node, 0, mem);
1018 get_Call_ptr (ir_node *node) {
1019 assert (node->op == op_Call);
1020 return get_irn_n(node, 1);
1024 set_Call_ptr (ir_node *node, ir_node *ptr) {
1025 assert (node->op == op_Call);
1026 set_irn_n(node, 1, ptr);
1030 get_Call_param_arr (ir_node *node) {
1031 assert (node->op == op_Call);
1032 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1036 get_Call_n_params (ir_node *node) {
1037 assert (node->op == op_Call);
1038 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1042 get_Call_arity (ir_node *node) {
1043 assert (node->op == op_Call);
1044 return get_Call_n_params(node);
1048 set_Call_arity (ir_node *node, ir_node *arity) {
1049 assert (node->op == op_Call);
1054 get_Call_param (ir_node *node, int pos) {
1055 assert (node->op == op_Call);
1056 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1060 set_Call_param (ir_node *node, int pos, ir_node *param) {
1061 assert (node->op == op_Call);
1062 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1066 get_Call_type (ir_node *node) {
1067 assert (node->op == op_Call);
1068 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1072 set_Call_type (ir_node *node, type *type) {
1073 assert (node->op == op_Call);
1074 assert (is_method_type(type));
1075 node->attr.call.cld_tp = type;
1078 int get_Call_n_callees(ir_node * node) {
1079 assert(node->op == op_Call && node->attr.call.callee_arr);
1080 return ARR_LEN(node->attr.call.callee_arr);
1083 entity * get_Call_callee(ir_node * node, int pos) {
1084 assert(node->op == op_Call && node->attr.call.callee_arr);
1085 return node->attr.call.callee_arr[pos];
1088 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1089 assert(node->op == op_Call);
1090 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1091 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1093 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1096 void remove_Call_callee_arr(ir_node * node) {
1097 assert(node->op == op_Call);
1098 node->attr.call.callee_arr = NULL;
1101 ir_node * get_CallBegin_ptr (ir_node *node) {
1102 assert(node->op == op_CallBegin);
1103 return get_irn_n(node, 0);
1105 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1106 assert(node->op == op_CallBegin);
1107 set_irn_n(node, 0, ptr);
1109 ir_graph * get_CallBegin_irg (ir_node *node) {
1110 assert(node->op == op_CallBegin);
1111 return node->attr.callbegin.irg;
1113 ir_node * get_CallBegin_call (ir_node *node) {
1114 assert(node->op == op_CallBegin);
1115 return node->attr.callbegin.call;
1117 void set_CallBegin_call (ir_node *node, ir_node *call) {
1118 assert(node->op == op_CallBegin);
1119 node->attr.callbegin.call = call;
1123 get_Add_left (ir_node *node) {
1124 assert (node->op == op_Add);
1125 return get_irn_n(node, 0);
1129 set_Add_left (ir_node *node, ir_node *left) {
1130 assert (node->op == op_Add);
1131 set_irn_n(node, 0, left);
1135 get_Add_right (ir_node *node) {
1136 assert (node->op == op_Add);
1137 return get_irn_n(node, 1);
1141 set_Add_right (ir_node *node, ir_node *right) {
1142 assert (node->op == op_Add);
1143 set_irn_n(node, 1, right);
1147 get_Sub_left (ir_node *node) {
1148 assert (node->op == op_Sub);
1149 return get_irn_n(node, 0);
1153 set_Sub_left (ir_node *node, ir_node *left) {
1154 assert (node->op == op_Sub);
1155 set_irn_n(node, 0, left);
1159 get_Sub_right (ir_node *node) {
1160 assert (node->op == op_Sub);
1161 return get_irn_n(node, 1);
1165 set_Sub_right (ir_node *node, ir_node *right) {
1166 assert (node->op == op_Sub);
1167 set_irn_n(node, 1, right);
1172 get_Minus_op (ir_node *node) {
1173 assert (node->op == op_Minus);
1174 return get_irn_n(node, 0);
1178 set_Minus_op (ir_node *node, ir_node *op) {
1179 assert (node->op == op_Minus);
1180 set_irn_n(node, 0, op);
1185 get_Mul_left (ir_node *node) {
1186 assert (node->op == op_Mul);
1187 return get_irn_n(node, 0);
1191 set_Mul_left (ir_node *node, ir_node *left) {
1192 assert (node->op == op_Mul);
1193 set_irn_n(node, 0, left);
1197 get_Mul_right (ir_node *node) {
1198 assert (node->op == op_Mul);
1199 return get_irn_n(node, 1);
1203 set_Mul_right (ir_node *node, ir_node *right) {
1204 assert (node->op == op_Mul);
1205 set_irn_n(node, 1, right);
1209 get_Quot_left (ir_node *node) {
1210 assert (node->op == op_Quot);
1211 return get_irn_n(node, 1);
1215 set_Quot_left (ir_node *node, ir_node *left) {
1216 assert (node->op == op_Quot);
1217 set_irn_n(node, 1, left);
1221 get_Quot_right (ir_node *node) {
1222 assert (node->op == op_Quot);
1223 return get_irn_n(node, 2);
1227 set_Quot_right (ir_node *node, ir_node *right) {
1228 assert (node->op == op_Quot);
1229 set_irn_n(node, 2, right);
1233 get_Quot_mem (ir_node *node) {
1234 assert (node->op == op_Quot);
1235 return get_irn_n(node, 0);
1239 set_Quot_mem (ir_node *node, ir_node *mem) {
1240 assert (node->op == op_Quot);
1241 set_irn_n(node, 0, mem);
1245 get_DivMod_left (ir_node *node) {
1246 assert (node->op == op_DivMod);
1247 return get_irn_n(node, 1);
1251 set_DivMod_left (ir_node *node, ir_node *left) {
1252 assert (node->op == op_DivMod);
1253 set_irn_n(node, 1, left);
1257 get_DivMod_right (ir_node *node) {
1258 assert (node->op == op_DivMod);
1259 return get_irn_n(node, 2);
1263 set_DivMod_right (ir_node *node, ir_node *right) {
1264 assert (node->op == op_DivMod);
1265 set_irn_n(node, 2, right);
1269 get_DivMod_mem (ir_node *node) {
1270 assert (node->op == op_DivMod);
1271 return get_irn_n(node, 0);
1275 set_DivMod_mem (ir_node *node, ir_node *mem) {
1276 assert (node->op == op_DivMod);
1277 set_irn_n(node, 0, mem);
1281 get_Div_left (ir_node *node) {
1282 assert (node->op == op_Div);
1283 return get_irn_n(node, 1);
1287 set_Div_left (ir_node *node, ir_node *left) {
1288 assert (node->op == op_Div);
1289 set_irn_n(node, 1, left);
1293 get_Div_right (ir_node *node) {
1294 assert (node->op == op_Div);
1295 return get_irn_n(node, 2);
1299 set_Div_right (ir_node *node, ir_node *right) {
1300 assert (node->op == op_Div);
1301 set_irn_n(node, 2, right);
1305 get_Div_mem (ir_node *node) {
1306 assert (node->op == op_Div);
1307 return get_irn_n(node, 0);
1311 set_Div_mem (ir_node *node, ir_node *mem) {
1312 assert (node->op == op_Div);
1313 set_irn_n(node, 0, mem);
1317 get_Mod_left (ir_node *node) {
1318 assert (node->op == op_Mod);
1319 return get_irn_n(node, 1);
1323 set_Mod_left (ir_node *node, ir_node *left) {
1324 assert (node->op == op_Mod);
1325 set_irn_n(node, 1, left);
1329 get_Mod_right (ir_node *node) {
1330 assert (node->op == op_Mod);
1331 return get_irn_n(node, 2);
1335 set_Mod_right (ir_node *node, ir_node *right) {
1336 assert (node->op == op_Mod);
1337 set_irn_n(node, 2, right);
1341 get_Mod_mem (ir_node *node) {
1342 assert (node->op == op_Mod);
1343 return get_irn_n(node, 0);
1347 set_Mod_mem (ir_node *node, ir_node *mem) {
1348 assert (node->op == op_Mod);
1349 set_irn_n(node, 0, mem);
1353 get_Abs_op (ir_node *node) {
1354 assert (node->op == op_Abs);
1355 return get_irn_n(node, 0);
1359 set_Abs_op (ir_node *node, ir_node *op) {
1360 assert (node->op == op_Abs);
1361 set_irn_n(node, 0, op);
1365 get_And_left (ir_node *node) {
1366 assert (node->op == op_And);
1367 return get_irn_n(node, 0);
1371 set_And_left (ir_node *node, ir_node *left) {
1372 assert (node->op == op_And);
1373 set_irn_n(node, 0, left);
1377 get_And_right (ir_node *node) {
1378 assert (node->op == op_And);
1379 return get_irn_n(node, 1);
1383 set_And_right (ir_node *node, ir_node *right) {
1384 assert (node->op == op_And);
1385 set_irn_n(node, 1, right);
1389 get_Or_left (ir_node *node) {
1390 assert (node->op == op_Or);
1391 return get_irn_n(node, 0);
1395 set_Or_left (ir_node *node, ir_node *left) {
1396 assert (node->op == op_Or);
1397 set_irn_n(node, 0, left);
1401 get_Or_right (ir_node *node) {
1402 assert (node->op == op_Or);
1403 return get_irn_n(node, 1);
1407 set_Or_right (ir_node *node, ir_node *right) {
1408 assert (node->op == op_Or);
1409 set_irn_n(node, 1, right);
1413 get_Eor_left (ir_node *node) {
1414 assert (node->op == op_Eor);
1415 return get_irn_n(node, 0);
1419 set_Eor_left (ir_node *node, ir_node *left) {
1420 assert (node->op == op_Eor);
1421 set_irn_n(node, 0, left);
1425 get_Eor_right (ir_node *node) {
1426 assert (node->op == op_Eor);
1427 return get_irn_n(node, 1);
1431 set_Eor_right (ir_node *node, ir_node *right) {
1432 assert (node->op == op_Eor);
1433 set_irn_n(node, 1, right);
1438 get_Not_op (ir_node *node) {
1439 assert (node->op == op_Not);
1440 return get_irn_n(node, 0);
1444 set_Not_op (ir_node *node, ir_node *op) {
1445 assert (node->op == op_Not);
1446 set_irn_n(node, 0, op);
1451 get_Shl_left (ir_node *node) {
1452 assert (node->op == op_Shl);
1453 return get_irn_n(node, 0);
1457 set_Shl_left (ir_node *node, ir_node *left) {
1458 assert (node->op == op_Shl);
1459 set_irn_n(node, 0, left);
1463 get_Shl_right (ir_node *node) {
1464 assert (node->op == op_Shl);
1465 return get_irn_n(node, 1);
1469 set_Shl_right (ir_node *node, ir_node *right) {
1470 assert (node->op == op_Shl);
1471 set_irn_n(node, 1, right);
1475 get_Shr_left (ir_node *node) {
1476 assert (node->op == op_Shr);
1477 return get_irn_n(node, 0);
1481 set_Shr_left (ir_node *node, ir_node *left) {
1482 assert (node->op == op_Shr);
1483 set_irn_n(node, 0, left);
1487 get_Shr_right (ir_node *node) {
1488 assert (node->op == op_Shr);
1489 return get_irn_n(node, 1);
1493 set_Shr_right (ir_node *node, ir_node *right) {
1494 assert (node->op == op_Shr);
1495 set_irn_n(node, 1, right);
1499 get_Shrs_left (ir_node *node) {
1500 assert (node->op == op_Shrs);
1501 return get_irn_n(node, 0);
1505 set_Shrs_left (ir_node *node, ir_node *left) {
1506 assert (node->op == op_Shrs);
1507 set_irn_n(node, 0, left);
1511 get_Shrs_right (ir_node *node) {
1512 assert (node->op == op_Shrs);
1513 return get_irn_n(node, 1);
1517 set_Shrs_right (ir_node *node, ir_node *right) {
1518 assert (node->op == op_Shrs);
1519 set_irn_n(node, 1, right);
1523 get_Rot_left (ir_node *node) {
1524 assert (node->op == op_Rot);
1525 return get_irn_n(node, 0);
1529 set_Rot_left (ir_node *node, ir_node *left) {
1530 assert (node->op == op_Rot);
1531 set_irn_n(node, 0, left);
1535 get_Rot_right (ir_node *node) {
1536 assert (node->op == op_Rot);
1537 return get_irn_n(node, 1);
1541 set_Rot_right (ir_node *node, ir_node *right) {
1542 assert (node->op == op_Rot);
1543 set_irn_n(node, 1, right);
1547 get_Cmp_left (ir_node *node) {
1548 assert (node->op == op_Cmp);
1549 return get_irn_n(node, 0);
1553 set_Cmp_left (ir_node *node, ir_node *left) {
1554 assert (node->op == op_Cmp);
1555 set_irn_n(node, 0, left);
1559 get_Cmp_right (ir_node *node) {
1560 assert (node->op == op_Cmp);
1561 return get_irn_n(node, 1);
1565 set_Cmp_right (ir_node *node, ir_node *right) {
1566 assert (node->op == op_Cmp);
1567 set_irn_n(node, 1, right);
1571 get_Conv_op (ir_node *node) {
1572 assert (node->op == op_Conv);
1573 return get_irn_n(node, 0);
1577 set_Conv_op (ir_node *node, ir_node *op) {
1578 assert (node->op == op_Conv);
1579 set_irn_n(node, 0, op);
1585 is_unop (ir_node *node) {
1586 return ( node->op == op_Minus ||
1587 node->op == op_Abs ||
1588 node->op == op_Not ||
1589 node->op == op_Conv );
1593 get_unop_op (ir_node *node) {
1594 assert ( node->op == op_Minus ||
1595 node->op == op_Abs ||
1596 node->op == op_Not ||
1597 node->op == op_Conv );
1598 switch (get_irn_opcode (node)) {
1599 case iro_Minus: return get_Minus_op(node); break;
1600 case iro_Abs: return get_Abs_op(node); break;
1601 case iro_Not: return get_Not_op(node); break;
1602 case iro_Conv: return get_Conv_op(node); break;
1603 default: return NULL;
1608 set_unop_op (ir_node *node, ir_node *op) {
1609 assert (node->op == op_Minus ||
1610 node->op == op_Abs ||
1611 node->op == op_Not ||
1612 node->op == op_Conv );
1613 switch (get_irn_opcode (node)) {
1614 case iro_Minus: set_Minus_op(node, op); break;
1615 case iro_Abs: set_Abs_op(node, op); break;
1616 case iro_Not: set_Not_op(node, op); break;
1617 case iro_Conv: set_Conv_op(node, op); break;
1624 is_binop (ir_node *node) {
1625 return (node->op == op_Add ||
1626 node->op == op_Sub ||
1627 node->op == op_Mul ||
1628 node->op == op_Quot ||
1629 node->op == op_DivMod ||
1630 node->op == op_Div ||
1631 node->op == op_Mod ||
1632 node->op == op_And ||
1633 node->op == op_Or ||
1634 node->op == op_Eor ||
1635 node->op == op_Shl ||
1636 node->op == op_Shr ||
1637 node->op == op_Shrs ||
1638 node->op == op_Rot ||
1639 node->op == op_Cmp );
1643 get_binop_left (ir_node *node) {
1644 assert (node->op == op_Add ||
1645 node->op == op_Sub ||
1646 node->op == op_Mul ||
1647 node->op == op_Quot ||
1648 node->op == op_DivMod ||
1649 node->op == op_Div ||
1650 node->op == op_Mod ||
1651 node->op == op_And ||
1652 node->op == op_Or ||
1653 node->op == op_Eor ||
1654 node->op == op_Shl ||
1655 node->op == op_Shr ||
1656 node->op == op_Shrs ||
1657 node->op == op_Rot ||
1658 node->op == op_Cmp );
1660 switch (get_irn_opcode (node)) {
1661 case iro_Add : return get_Add_left(node); break;
1662 case iro_Sub : return get_Sub_left(node); break;
1663 case iro_Mul : return get_Mul_left(node); break;
1664 case iro_Quot : return get_Quot_left(node); break;
1665 case iro_DivMod: return get_DivMod_left(node); break;
1666 case iro_Div : return get_Div_left(node); break;
1667 case iro_Mod : return get_Mod_left(node); break;
1668 case iro_And : return get_And_left(node); break;
1669 case iro_Or : return get_Or_left(node); break;
1670 case iro_Eor : return get_Eor_left(node); break;
1671 case iro_Shl : return get_Shl_left(node); break;
1672 case iro_Shr : return get_Shr_left(node); break;
1673 case iro_Shrs : return get_Shrs_left(node); break;
1674 case iro_Rot : return get_Rot_left(node); break;
1675 case iro_Cmp : return get_Cmp_left(node); break;
1676 default: return NULL;
1681 set_binop_left (ir_node *node, ir_node *left) {
1682 assert (node->op == op_Add ||
1683 node->op == op_Sub ||
1684 node->op == op_Mul ||
1685 node->op == op_Quot ||
1686 node->op == op_DivMod ||
1687 node->op == op_Div ||
1688 node->op == op_Mod ||
1689 node->op == op_And ||
1690 node->op == op_Or ||
1691 node->op == op_Eor ||
1692 node->op == op_Shl ||
1693 node->op == op_Shr ||
1694 node->op == op_Shrs ||
1695 node->op == op_Rot ||
1696 node->op == op_Cmp );
1698 switch (get_irn_opcode (node)) {
1699 case iro_Add : set_Add_left(node, left); break;
1700 case iro_Sub : set_Sub_left(node, left); break;
1701 case iro_Mul : set_Mul_left(node, left); break;
1702 case iro_Quot : set_Quot_left(node, left); break;
1703 case iro_DivMod: set_DivMod_left(node, left); break;
1704 case iro_Div : set_Div_left(node, left); break;
1705 case iro_Mod : set_Mod_left(node, left); break;
1706 case iro_And : set_And_left(node, left); break;
1707 case iro_Or : set_Or_left(node, left); break;
1708 case iro_Eor : set_Eor_left(node, left); break;
1709 case iro_Shl : set_Shl_left(node, left); break;
1710 case iro_Shr : set_Shr_left(node, left); break;
1711 case iro_Shrs : set_Shrs_left(node, left); break;
1712 case iro_Rot : set_Rot_left(node, left); break;
1713 case iro_Cmp : set_Cmp_left(node, left); break;
1719 get_binop_right (ir_node *node) {
1720 assert (node->op == op_Add ||
1721 node->op == op_Sub ||
1722 node->op == op_Mul ||
1723 node->op == op_Quot ||
1724 node->op == op_DivMod ||
1725 node->op == op_Div ||
1726 node->op == op_Mod ||
1727 node->op == op_And ||
1728 node->op == op_Or ||
1729 node->op == op_Eor ||
1730 node->op == op_Shl ||
1731 node->op == op_Shr ||
1732 node->op == op_Shrs ||
1733 node->op == op_Rot ||
1734 node->op == op_Cmp );
1736 switch (get_irn_opcode (node)) {
1737 case iro_Add : return get_Add_right(node); break;
1738 case iro_Sub : return get_Sub_right(node); break;
1739 case iro_Mul : return get_Mul_right(node); break;
1740 case iro_Quot : return get_Quot_right(node); break;
1741 case iro_DivMod: return get_DivMod_right(node); break;
1742 case iro_Div : return get_Div_right(node); break;
1743 case iro_Mod : return get_Mod_right(node); break;
1744 case iro_And : return get_And_right(node); break;
1745 case iro_Or : return get_Or_right(node); break;
1746 case iro_Eor : return get_Eor_right(node); break;
1747 case iro_Shl : return get_Shl_right(node); break;
1748 case iro_Shr : return get_Shr_right(node); break;
1749 case iro_Shrs : return get_Shrs_right(node); break;
1750 case iro_Rot : return get_Rot_right(node); break;
1751 case iro_Cmp : return get_Cmp_right(node); break;
1752 default: return NULL;
1757 set_binop_right (ir_node *node, ir_node *right) {
1758 assert (node->op == op_Add ||
1759 node->op == op_Sub ||
1760 node->op == op_Mul ||
1761 node->op == op_Quot ||
1762 node->op == op_DivMod ||
1763 node->op == op_Div ||
1764 node->op == op_Mod ||
1765 node->op == op_And ||
1766 node->op == op_Or ||
1767 node->op == op_Eor ||
1768 node->op == op_Shl ||
1769 node->op == op_Shr ||
1770 node->op == op_Shrs ||
1771 node->op == op_Rot ||
1772 node->op == op_Cmp );
1774 switch (get_irn_opcode (node)) {
1775 case iro_Add : set_Add_right(node, right); break;
1776 case iro_Sub : set_Sub_right(node, right); break;
1777 case iro_Mul : set_Mul_right(node, right); break;
1778 case iro_Quot : set_Quot_right(node, right); break;
1779 case iro_DivMod: set_DivMod_right(node, right); break;
1780 case iro_Div : set_Div_right(node, right); break;
1781 case iro_Mod : set_Mod_right(node, right); break;
1782 case iro_And : set_And_right(node, right); break;
1783 case iro_Or : set_Or_right(node, right); break;
1784 case iro_Eor : set_Eor_right(node, right); break;
1785 case iro_Shl : set_Shl_right(node, right); break;
1786 case iro_Shr : set_Shr_right(node, right); break;
1787 case iro_Shrs : set_Shrs_right(node, right); break;
1788 case iro_Rot : set_Rot_right(node, right); break;
1789 case iro_Cmp : set_Cmp_right(node, right); break;
1796 get_Phi_preds_arr (ir_node *node) {
1797 assert (node->op == op_Phi);
1798 return (ir_node **)&(get_irn_in(node)[1]);
1802 get_Phi_n_preds (ir_node *node) {
1803 assert (node->op == op_Phi);
1804 return (get_irn_arity(node));
1808 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1809 assert (node->op == op_Phi);
1814 get_Phi_pred (ir_node *node, int pos) {
1815 assert (node->op == op_Phi);
1816 return get_irn_n(node, pos);
1820 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1821 assert (node->op == op_Phi);
1822 set_irn_n(node, pos, pred);
1826 get_Load_mem (ir_node *node) {
1827 assert (node->op == op_Load);
1828 return get_irn_n(node, 0);
1832 set_Load_mem (ir_node *node, ir_node *mem) {
1833 assert (node->op == op_Load);
1834 set_irn_n(node, 0, mem);
1838 get_Load_ptr (ir_node *node) {
1839 assert (node->op == op_Load);
1840 return get_irn_n(node, 1);
1844 set_Load_ptr (ir_node *node, ir_node *ptr) {
1845 assert (node->op == op_Load);
1846 set_irn_n(node, 1, ptr);
1851 get_Store_mem (ir_node *node) {
1852 assert (node->op == op_Store);
1853 return get_irn_n(node, 0);
1857 set_Store_mem (ir_node *node, ir_node *mem) {
1858 assert (node->op == op_Store);
1859 set_irn_n(node, 0, mem);
1863 get_Store_ptr (ir_node *node) {
1864 assert (node->op == op_Store);
1865 return get_irn_n(node, 1);
1869 set_Store_ptr (ir_node *node, ir_node *ptr) {
1870 assert (node->op == op_Store);
1871 set_irn_n(node, 1, ptr);
1875 get_Store_value (ir_node *node) {
1876 assert (node->op == op_Store);
1877 return get_irn_n(node, 2);
1881 set_Store_value (ir_node *node, ir_node *value) {
1882 assert (node->op == op_Store);
1883 set_irn_n(node, 2, value);
1887 get_Alloc_mem (ir_node *node) {
1888 assert (node->op == op_Alloc);
1889 return get_irn_n(node, 0);
1893 set_Alloc_mem (ir_node *node, ir_node *mem) {
1894 assert (node->op == op_Alloc);
1895 set_irn_n(node, 0, mem);
1899 get_Alloc_size (ir_node *node) {
1900 assert (node->op == op_Alloc);
1901 return get_irn_n(node, 1);
1905 set_Alloc_size (ir_node *node, ir_node *size) {
1906 assert (node->op == op_Alloc);
1907 set_irn_n(node, 1, size);
1911 get_Alloc_type (ir_node *node) {
1912 assert (node->op == op_Alloc);
1913 return node->attr.a.type = skip_tid(node->attr.a.type);
1917 set_Alloc_type (ir_node *node, type *type) {
1918 assert (node->op == op_Alloc);
1919 node->attr.a.type = type;
1923 get_Alloc_where (ir_node *node) {
1924 assert (node->op == op_Alloc);
1925 return node->attr.a.where;
1929 set_Alloc_where (ir_node *node, where_alloc where) {
1930 assert (node->op == op_Alloc);
1931 node->attr.a.where = where;
1936 get_Free_mem (ir_node *node) {
1937 assert (node->op == op_Free);
1938 return get_irn_n(node, 0);
1942 set_Free_mem (ir_node *node, ir_node *mem) {
1943 assert (node->op == op_Free);
1944 set_irn_n(node, 0, mem);
1948 get_Free_ptr (ir_node *node) {
1949 assert (node->op == op_Free);
1950 return get_irn_n(node, 1);
1954 set_Free_ptr (ir_node *node, ir_node *ptr) {
1955 assert (node->op == op_Free);
1956 set_irn_n(node, 1, ptr);
1960 get_Free_size (ir_node *node) {
1961 assert (node->op == op_Free);
1962 return get_irn_n(node, 2);
1966 set_Free_size (ir_node *node, ir_node *size) {
1967 assert (node->op == op_Free);
1968 set_irn_n(node, 2, size);
1972 get_Free_type (ir_node *node) {
1973 assert (node->op == op_Free);
1974 return node->attr.f = skip_tid(node->attr.f);
1978 set_Free_type (ir_node *node, type *type) {
1979 assert (node->op == op_Free);
1980 node->attr.f = type;
1984 get_Sync_preds_arr (ir_node *node) {
1985 assert (node->op == op_Sync);
1986 return (ir_node **)&(get_irn_in(node)[1]);
1990 get_Sync_n_preds (ir_node *node) {
1991 assert (node->op == op_Sync);
1992 return (get_irn_arity(node));
1997 set_Sync_n_preds (ir_node *node, int n_preds) {
1998 assert (node->op == op_Sync);
2003 get_Sync_pred (ir_node *node, int pos) {
2004 assert (node->op == op_Sync);
2005 return get_irn_n(node, pos);
2009 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
2010 assert (node->op == op_Sync);
2011 set_irn_n(node, pos, pred);
2015 get_Proj_pred (ir_node *node) {
2016 assert (is_Proj(node));
2017 return get_irn_n(node, 0);
2021 set_Proj_pred (ir_node *node, ir_node *pred) {
2022 assert (is_Proj(node));
2023 set_irn_n(node, 0, pred);
2027 get_Proj_proj (ir_node *node) {
2028 assert (is_Proj(node));
2029 if (get_irn_opcode(node) == iro_Proj) {
2030 return node->attr.proj;
2032 assert(get_irn_opcode(node) == iro_Filter);
2033 return node->attr.filter.proj;
2038 set_Proj_proj (ir_node *node, long proj) {
2039 assert (node->op == op_Proj);
2040 node->attr.proj = proj;
2044 get_Tuple_preds_arr (ir_node *node) {
2045 assert (node->op == op_Tuple);
2046 return (ir_node **)&(get_irn_in(node)[1]);
2050 get_Tuple_n_preds (ir_node *node) {
2051 assert (node->op == op_Tuple);
2052 return (get_irn_arity(node));
2057 set_Tuple_n_preds (ir_node *node, int n_preds) {
2058 assert (node->op == op_Tuple);
2063 get_Tuple_pred (ir_node *node, int pos) {
2064 assert (node->op == op_Tuple);
2065 return get_irn_n(node, pos);
2069 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2070 assert (node->op == op_Tuple);
2071 set_irn_n(node, pos, pred);
2075 get_Id_pred (ir_node *node) {
2076 assert (node->op == op_Id);
2077 return get_irn_n(node, 0);
2081 set_Id_pred (ir_node *node, ir_node *pred) {
2082 assert (node->op == op_Id);
2083 set_irn_n(node, 0, pred);
2088 get_Filter_pred (ir_node *node) {
2089 assert(node->op == op_Filter);
2093 set_Filter_pred (ir_node *node, ir_node *pred) {
2094 assert(node->op == op_Filter);
2098 get_Filter_proj(ir_node *node) {
2099 assert(node->op == op_Filter);
2100 return node->attr.filter.proj;
2103 set_Filter_proj (ir_node *node, long proj) {
2104 assert(node->op == op_Filter);
2105 node->attr.filter.proj = proj;
2108 /* Don't use get_irn_arity, get_irn_n in implementation as access
2109 shall work independent of view!!! */
2110 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2111 assert(node->op == op_Filter);
2112 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2113 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2114 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2115 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2116 node->attr.filter.in_cg[0] = node->in[0];
2118 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2121 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2122 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2123 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2124 node->attr.filter.in_cg[pos + 1] = pred;
2126 int get_Filter_n_cg_preds(ir_node *node) {
2127 assert(node->op == op_Filter && node->attr.filter.in_cg);
2128 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2130 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2132 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2134 arity = ARR_LEN(node->attr.filter.in_cg);
2135 assert(pos < arity - 1);
2136 return node->attr.filter.in_cg[pos + 1];
2141 get_irn_irg(ir_node *node) {
2142 if (get_irn_op(node) == op_CallBegin) {
2143 return node->attr.callbegin.irg;
2144 } else if (get_irn_op(node) == op_EndReg ||
2145 get_irn_op(node) == op_EndExcept) {
2146 return node->attr.end.irg;
2148 assert(0 && "no irg attr");
2153 /******************************************************************/
2154 /* Auxiliary routines */
2155 /******************************************************************/
2158 skip_Proj (ir_node *node) {
2159 /* don't assert node !!! */
2160 if (node && is_Proj(node)) {
2161 return get_Proj_pred(node);
2168 skip_Tuple (ir_node *node) {
2171 node = skip_nop(node);
2172 if (get_irn_op(node) == op_Proj) {
2173 pred = skip_nop(get_Proj_pred(node));
2174 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2175 pred = skip_nop(skip_Tuple(pred));
2176 if (get_irn_op(pred) == op_Tuple)
2177 return get_Tuple_pred(pred, get_Proj_proj(node));
2183 skip_nop (ir_node *node) {
2184 /* don't assert node !!! */
2186 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
2187 /* Don't use get_Id_pred: We get into an endless loop for
2188 self-referencing Ids. */
2189 assert (get_irn_arity (node) > 0);
2190 return node->in[0+1];
2197 skip_Id (ir_node *node) {
2198 return skip_nop(node);
2202 is_Bad (ir_node *node) {
2204 if ((node) && get_irn_opcode(node) == iro_Bad)
2210 is_no_Block (ir_node *node) {
2212 return (get_irn_opcode(node) != iro_Block);
2216 is_Proj (ir_node *node) {
2218 return node->op == op_Proj
2219 || (!interprocedural_view && node->op == op_Filter);
2222 /* Returns true if the operation manipulates control flow. */
2224 is_cfop(ir_node *node) {
2225 return is_cfopcode(get_irn_op(node));
2228 /* Returns true if the operation manipulates interprocedural control flow:
2229 CallBegin, EndReg, EndExcept */
2230 int is_ip_cfop(ir_node *node) {
2231 return is_ip_cfopcode(get_irn_op(node));
2234 /* Returns true if the operation can change the control flow because
2237 is_fragile_op(ir_node *node) {
2238 return ( (get_irn_opcode(node) == iro_Call)
2239 || (get_irn_opcode(node) == iro_Quot)
2240 || (get_irn_opcode(node) == iro_DivMod)
2241 || (get_irn_opcode(node) == iro_Div)
2242 || (get_irn_opcode(node) == iro_Mod)
2243 || (get_irn_opcode(node) == iro_Load)
2244 || (get_irn_opcode(node) == iro_Store)
2245 || (get_irn_opcode(node) == iro_Alloc)
2246 || (get_irn_opcode(node) == iro_Bad)
2247 || (get_irn_opcode(node) == iro_Unknown));
2251 /* Returns the memory operand of fragile operations. */
2252 ir_node *get_fragile_op_mem(ir_node *node) {
2253 assert(node && is_fragile_op(node));
2255 switch (get_irn_opcode (node)) {
2264 return get_irn_n(node, 0);
2269 assert(0 && "not reached");