1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
4 * Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
16 #include "irgraph_t.h"
18 #include "typegmod_t.h"
20 #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 (const ir_node *node);
37 INLINE ir_mode *get_irn_mode (const ir_node *node);
38 INLINE ir_op *get_irn_op (const ir_node *node);
39 INLINE opcode get_irn_opcode (const ir_node *node);
40 INLINE ident *get_irn_opident (const ir_node *node);
41 INLINE type *get_SymConst_type (ir_node *node);
42 INLINE ir_node *skip_nop (ir_node *node);
43 INLINE int is_Proj (const ir_node *node);
46 static const char *pnc_name_arr [] = {
47 "False", "Eq", "Lt", "Le",
48 "Gt", "Ge", "Lg", "Leg", "Uo",
49 "Ue", "Ul", "Ule", "Ug", "Uge",
53 INLINE const char *get_pnc_string(int pnc) {
54 return pnc_name_arr[pnc];
59 get_negated_pnc(int pnc) {
61 case False: return True; break;
62 case Eq: return Ne; break;
63 case Lt: return Uge; break;
64 case Le: return Ug; break;
65 case Gt: return Ule; break;
66 case Ge: return Ul; break;
67 case Lg: return Ue; break;
68 case Leg: return Uo; break;
69 case Uo: return Leg; break;
70 case Ue: return Lg; break;
71 case Ul: return Ge; break;
72 case Ule: return Gt; break;
73 case Ug: return Le; break;
74 case Uge: return Lt; break;
75 case Ne: return Eq; break;
76 case True: return False; break;
78 return 99; /* to shut up gcc */
81 static const char *pns_name_arr [] = {
82 "initial_exec", "global_store",
83 "frame_base", "globals", "args"
86 static const char *symconst_name_arr [] = {
87 "type_tag", "size", "linkage_ptr_info"
95 /* irnode constructor */
96 /* create a new irnode in irg, with an op, mode, arity and */
97 /* some incoming irnodes */
98 /* this constructor is used in every specified irnode constructor */
100 new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
101 int arity, ir_node **in)
104 int node_size = offsetof (ir_node, attr) + op->attr_size;
106 res = (ir_node *) obstack_alloc (irg->obst, node_size);
108 res->kind = k_ir_node;
114 res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
116 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
117 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
120 set_irn_dbg_info(res, db);
124 res->node_nr = get_irp_new_node_nr();
130 /* Copies all attributes stored in the old node to the new node.
131 Assumes both have the same opcode and sufficient size. */
133 copy_attrs (ir_node *old, ir_node *new) {
134 assert (get_irn_op(old) == get_irn_op(new));
135 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
138 /** getting some parameters from ir_nodes **/
140 /* returns the number of predecessors without the block predecessor. */
142 get_irn_arity (const ir_node *node) {
144 if (interprocedural_view) { /* handle Filter and Block specially */
145 if (get_irn_opcode(node) == iro_Filter) {
146 assert(node->attr.filter.in_cg);
147 return ARR_LEN(node->attr.filter.in_cg) - 1;
148 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
149 return ARR_LEN(node->attr.block.in_cg) - 1;
151 /* else fall through */
153 return ARR_LEN(node->in) - 1;
156 /* Returns the array with ins. This array is shifted with respect to the
157 array accessed by get_irn_n: The block operand is at position 0 not -1.
158 (@@@ This should be changed.)
159 The order of the predecessors in this array is not guaranteed, except that
160 lists of operands as predecessors of Block or arguments of a Call are
163 get_irn_in (const ir_node *node) {
165 if (interprocedural_view) { /* handle Filter and Block specially */
166 if (get_irn_opcode(node) == iro_Filter) {
167 assert(node->attr.filter.in_cg);
168 return node->attr.filter.in_cg;
169 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
170 return node->attr.block.in_cg;
172 /* else fall through */
178 set_irn_in (ir_node *node, int arity, ir_node **in) {
181 if (interprocedural_view) { /* handle Filter and Block specially */
182 if (get_irn_opcode(node) == iro_Filter) {
183 assert(node->attr.filter.in_cg);
184 arr = &node->attr.filter.in_cg;
185 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
186 arr = &node->attr.block.in_cg;
193 if (arity != ARR_LEN(*arr) - 1) {
194 ir_node * block = (*arr)[0];
195 *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
198 fix_backedges(current_ir_graph->obst, node);
199 memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
202 /* to iterate through the predecessors without touching the array */
203 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
204 to iterate includind the Block predecessor iterate from i = -1 to
206 If it is a block, the entry -1 is NULL. */
208 get_irn_n (ir_node *node, int n) {
210 if (-1 > n || get_irn_arity(node) <= n) {
211 printf("pos: %d, arity: %d ", n, get_irn_arity(node));
214 assert(node); assert(-1 <= n && n < get_irn_arity(node));
215 if (interprocedural_view) { /* handle Filter and Block specially */
216 if (get_irn_opcode(node) == iro_Filter) {
217 assert(node->attr.filter.in_cg);
218 return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
219 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
220 return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
222 /* else fall through */
224 return (node->in[n + 1] = skip_nop(node->in[n + 1]));
228 set_irn_n (ir_node *node, int n, ir_node *in) {
229 assert(node && -1 <= n && n < get_irn_arity(node));
230 if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
231 /* Change block pred in both views! */
232 node->in[n + 1] = in;
233 assert(node->attr.filter.in_cg);
234 node->attr.filter.in_cg[n + 1] = in;
237 if (interprocedural_view) { /* handle Filter and Block specially */
238 if (get_irn_opcode(node) == iro_Filter) {
239 assert(node->attr.filter.in_cg);
240 node->attr.filter.in_cg[n + 1] = in;
242 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
243 node->attr.block.in_cg[n + 1] = in;
246 /* else fall through */
248 node->in[n + 1] = in;
252 get_irn_mode (const ir_node *node)
259 set_irn_mode (ir_node *node, ir_mode *mode)
267 get_irn_modecode (const ir_node *node)
270 return node->mode->code;
275 get_irn_modeident (const ir_node *node)
278 return get_mode_ident(node->mode);
282 get_irn_op (const ir_node *node)
288 /* should be private to the library: */
290 set_irn_op (ir_node *node, ir_op *op)
297 get_irn_opcode (const ir_node *node)
300 assert (k_ir_node == get_kind(node));
302 return node->op->code;
306 get_irn_opname (const ir_node *node)
309 return id_to_str(node->op->name);
313 get_irn_opident (const ir_node *node)
316 return node->op->name;
320 get_irn_visited (const ir_node *node)
323 return node->visited;
327 set_irn_visited (ir_node *node, unsigned long visited)
330 node->visited = visited;
334 mark_irn_visited (ir_node *node) {
336 node->visited = current_ir_graph->visited;
340 irn_not_visited (const ir_node *node) {
342 return (node->visited < current_ir_graph->visited);
346 irn_visited (const ir_node *node) {
348 return (node->visited >= current_ir_graph->visited);
352 set_irn_link (ir_node *node, void *link) {
354 /* Link field is used for Phi construction and various optimizations
356 assert(get_irg_phase_state(current_ir_graph) != phase_building);
362 get_irn_link (const ir_node *node) {
367 /* Outputs a unique number for this node */
369 get_irn_node_nr(const ir_node *node) {
372 return node->node_nr;
379 get_irn_const_attr (ir_node *node)
381 assert (node->op == op_Const);
382 return node->attr.con;
386 get_irn_proj_attr (ir_node *node)
388 assert (node->op == op_Proj);
389 return node->attr.proj;
393 get_irn_alloc_attr (ir_node *node)
395 assert (node->op == op_Alloc);
400 get_irn_free_attr (ir_node *node)
402 assert (node->op == op_Free);
403 return node->attr.f = skip_tid(node->attr.f);
407 get_irn_symconst_attr (ir_node *node)
409 assert (node->op == op_SymConst);
414 get_irn_call_attr (ir_node *node)
416 assert (node->op == op_Call);
417 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
421 get_irn_sel_attr (ir_node *node)
423 assert (node->op == op_Sel);
428 get_irn_phi_attr (ir_node *node)
430 assert (node->op == op_Phi);
431 return node->attr.phi0_pos;
435 get_irn_block_attr (ir_node *node)
437 assert (node->op == op_Block);
438 return node->attr.block;
441 /** manipulate fields of individual nodes **/
443 /* this works for all except Block */
445 get_nodes_Block (ir_node *node) {
446 assert (!(node->op == op_Block));
447 return get_irn_n(node, -1);
451 set_nodes_Block (ir_node *node, ir_node *block) {
452 assert (!(node->op == op_Block));
453 set_irn_n(node, -1, block);
456 /* Returns an array with the predecessors of the Block. Depending on
457 the implementation of the graph datastructure this can be a copy of
458 the internal representation of predecessors as well as the internal
459 array itself. Therefore writing to this array might obstruct the ir. */
461 get_Block_cfgpred_arr (ir_node *node)
463 assert ((node->op == op_Block));
464 return (ir_node **)&(get_irn_in(node)[1]);
469 get_Block_n_cfgpreds (ir_node *node) {
470 assert ((node->op == op_Block));
471 return (get_irn_arity(node));
475 get_Block_cfgpred (ir_node *node, int pos) {
476 assert (node->op == op_Block);
478 if (-1 > pos || get_irn_arity(node) <= pos) {
479 dump_ir_block_graph(current_ir_graph);
480 printf("pos: %d, arity: %d ", pos, get_irn_arity(node));
483 assert(node); assert(-1 <= pos && pos < get_irn_arity(node));
484 return get_irn_n(node, pos);
488 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
489 assert (node->op == op_Block);
490 set_irn_n(node, pos, pred);
494 get_Block_matured (ir_node *node) {
495 assert (node->op == op_Block);
496 return node->attr.block.matured;
500 set_Block_matured (ir_node *node, bool matured) {
501 assert (node->op == op_Block);
502 node->attr.block.matured = matured;
505 get_Block_block_visited (ir_node *node) {
506 assert (node->op == op_Block);
507 return node->attr.block.block_visited;
511 set_Block_block_visited (ir_node *node, unsigned long visit) {
512 assert (node->op == op_Block);
513 node->attr.block.block_visited = visit;
516 /* For this current_ir_graph must be set. */
518 mark_Block_block_visited (ir_node *node) {
519 assert (node->op == op_Block);
520 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
524 Block_not_block_visited(ir_node *node) {
525 assert (node->op == op_Block);
526 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
530 get_Block_graph_arr (ir_node *node, int pos) {
531 assert (node->op == op_Block);
532 return node->attr.block.graph_arr[pos+1];
536 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
537 assert (node->op == op_Block);
538 node->attr.block.graph_arr[pos+1] = value;
541 /* handler handling for Blocks */
543 set_Block_handler (ir_node *block, ir_node *handler) {
544 assert ((block->op == op_Block));
545 assert ((handler->op == op_Block));
546 block->attr.block.handler_entry = handler;
550 get_Block_handler (ir_node *block) {
551 assert ((block->op == op_Block));
552 return (block->attr.block.handler_entry);
555 /* handler handling for Nodes */
557 set_Node_handler (ir_node *node, ir_node *handler) {
558 set_Block_handler (get_nodes_Block (node), handler);
562 get_Node_handler (ir_node *node) {
563 return (get_Block_handler (get_nodes_Block (node)));
566 /* exc_t handling for Blocks */
567 void set_Block_exc (ir_node *block, exc_t exc) {
568 assert ((block->op == op_Block));
569 block->attr.block.exc = exc;
572 exc_t get_Block_exc (ir_node *block) {
573 assert ((block->op == op_Block));
575 return (block->attr.block.exc);
578 /* exc_t handling for Nodes */
579 void set_Node_exc (ir_node *node, exc_t exc) {
580 set_Block_exc (get_nodes_Block (node), exc);
583 exc_t get_Node_exc (ir_node *node) {
584 return (get_Block_exc (get_nodes_Block (node)));
587 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
588 assert(node->op == op_Block);
589 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
590 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
591 node->attr.block.in_cg[0] = NULL;
592 node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
594 /* Fix backedge array. fix_backedges operates depending on
595 interprocedural_view. */
596 bool ipv = interprocedural_view;
597 interprocedural_view = true;
598 fix_backedges(current_ir_graph->obst, node);
599 interprocedural_view = ipv;
602 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
605 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
606 assert(node->op == op_Block &&
607 node->attr.block.in_cg &&
608 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
609 node->attr.block.in_cg[pos + 1] = pred;
612 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
613 assert(node->op == op_Block);
614 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
617 int get_Block_cg_n_cfgpreds(ir_node * node) {
618 assert(node->op == op_Block);
619 return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
622 ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
623 assert(node->op == op_Block && node->attr.block.in_cg);
624 return node->attr.block.in_cg[pos + 1];
627 void remove_Block_cg_cfgpred_arr(ir_node * node) {
628 assert(node->op == op_Block);
629 node->attr.block.in_cg = NULL;
633 get_End_n_keepalives(ir_node *end) {
634 assert (end->op == op_End);
635 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
639 get_End_keepalive(ir_node *end, int pos) {
640 assert (end->op == op_End);
641 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
645 add_End_keepalive (ir_node *end, ir_node *ka) {
646 assert (end->op == op_End);
647 ARR_APP1 (ir_node *, end->in, ka);
651 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
652 assert (end->op == op_End);
653 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
657 free_End (ir_node *end) {
658 assert (end->op == op_End);
659 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
660 end->in = NULL; /* @@@ make sure we get an error if we use the
661 in array afterwards ... */
664 ir_graph *get_EndReg_irg (const ir_node *end) {
665 assert (end->op == op_EndReg);
666 return end->attr.end.irg;
669 ir_graph *get_EndExcept_irg (const ir_node *end) {
670 assert (end->op == op_EndReg);
671 return end->attr.end.irg;
675 > Implementing the case construct (which is where the constant Proj node is
676 > important) involves far more than simply determining the constant values.
677 > We could argue that this is more properly a function of the translator from
678 > Firm to the target machine. That could be done if there was some way of
679 > projecting "default" out of the Cond node.
680 I know it's complicated.
681 Basically there are two proglems:
682 - determining the gaps between the projs
683 - determining the biggest case constant to konw the proj number for
685 I see several solutions:
686 1. Introduce a ProjDefault node. Solves both problems.
687 This means to extend all optimizations executed during construction.
688 2. Give the Cond node for switch two flavors:
689 a) there are no gaps in the projs (existing flavor)
690 b) gaps may exist, default proj is still the Proj with the largest
691 projection number. This covers also the gaps.
692 3. Fix the semantic of the Cond to that of 2b)
694 Solution 2 seems to be the best:
695 Computing the gaps in the Firm representation is not too hard, i.e.,
696 libfirm can implement a routine that transforms betweeen the two
697 flavours. This is also possible for 1) but 2) does not require to
698 change any existing optimization.
699 Further it should be far simpler to determine the biggest constant than
701 I don't want to choose 3) as 2a) seems to have advantages for
702 dataflow analysis and 3) does not allow to convert the representation to
706 get_Cond_selector (ir_node *node) {
707 assert (node->op == op_Cond);
708 return get_irn_n(node, 0);
712 set_Cond_selector (ir_node *node, ir_node *selector) {
713 assert (node->op == op_Cond);
714 set_irn_n(node, 0, selector);
718 get_Cond_kind (ir_node *node) {
719 assert (node->op == op_Cond);
720 return node->attr.c.kind;
724 set_Cond_kind (ir_node *node, cond_kind kind) {
725 assert (node->op == op_Cond);
726 node->attr.c.kind = kind;
730 get_Return_mem (ir_node *node) {
731 assert (node->op == op_Return);
732 return get_irn_n(node, 0);
736 set_Return_mem (ir_node *node, ir_node *mem) {
737 assert (node->op == op_Return);
738 set_irn_n(node, 0, mem);
742 get_Return_n_ress (ir_node *node) {
743 assert (node->op == op_Return);
744 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
748 get_Return_res_arr (ir_node *node)
750 assert ((node->op == op_Return));
751 if (get_Return_n_ress(node) > 0)
752 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
759 set_Return_n_res (ir_node *node, int results) {
760 assert (node->op == op_Return);
765 get_Return_res (ir_node *node, int pos) {
766 assert (node->op == op_Return);
767 assert (get_Return_n_ress(node) > pos);
768 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
772 set_Return_res (ir_node *node, int pos, ir_node *res){
773 assert (node->op == op_Return);
774 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
778 get_Raise_mem (ir_node *node) {
779 assert (node->op == op_Return);
780 return get_irn_n(node, 0);
784 set_Raise_mem (ir_node *node, ir_node *mem) {
785 assert (node->op == op_Raise);
786 set_irn_n(node, 0, mem);
790 get_Raise_exo_ptr (ir_node *node) {
791 assert (node->op == op_Raise);
792 return get_irn_n(node, 1);
796 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
797 assert (node->op == op_Raise);
798 set_irn_n(node, 1, exo_ptr);
801 INLINE tarval *get_Const_tarval (ir_node *node) {
802 assert (node->op == op_Const);
803 return get_irn_const_attr(node);
807 set_Const_tarval (ir_node *node, tarval *con) {
808 assert (node->op == op_Const);
809 node->attr.con = con;
813 get_SymConst_kind (const ir_node *node) {
814 assert (node->op == op_SymConst);
815 return node->attr.i.num;
819 set_SymConst_kind (ir_node *node, symconst_kind num) {
820 assert (node->op == op_SymConst);
821 node->attr.i.num = num;
825 get_SymConst_type (ir_node *node) {
826 assert ( (node->op == op_SymConst)
827 && ( get_SymConst_kind(node) == type_tag
828 || get_SymConst_kind(node) == size));
829 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
833 set_SymConst_type (ir_node *node, type *tp) {
834 assert ( (node->op == op_SymConst)
835 && ( get_SymConst_kind(node) == type_tag
836 || get_SymConst_kind(node) == size));
837 node->attr.i.tori.typ = tp;
841 get_SymConst_ptrinfo (ir_node *node) {
842 assert ( (node->op == op_SymConst)
843 && (get_SymConst_kind(node) == linkage_ptr_info));
844 return node->attr.i.tori.ptrinfo;
848 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
849 assert ( (node->op == op_SymConst)
850 && (get_SymConst_kind(node) == linkage_ptr_info));
851 node->attr.i.tori.ptrinfo = ptrinfo;
855 get_SymConst_type_or_id (ir_node *node) {
856 assert (node->op == op_SymConst);
857 return &(node->attr.i.tori);
861 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
862 assert (node->op == op_SymConst);
863 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
867 get_Sel_mem (ir_node *node) {
868 assert (node->op == op_Sel);
869 return get_irn_n(node, 0);
873 set_Sel_mem (ir_node *node, ir_node *mem) {
874 assert (node->op == op_Sel);
875 set_irn_n(node, 0, mem);
879 get_Sel_ptr (ir_node *node) {
880 assert (node->op == op_Sel);
881 return get_irn_n(node, 1);
885 set_Sel_ptr (ir_node *node, ir_node *ptr) {
886 assert (node->op == op_Sel);
887 set_irn_n(node, 1, ptr);
891 get_Sel_n_indexs (ir_node *node) {
892 assert (node->op == op_Sel);
893 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
897 get_Sel_index_arr (ir_node *node)
899 assert ((node->op == op_Sel));
900 if (get_Sel_n_indexs(node) > 0)
901 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
907 get_Sel_index (ir_node *node, int pos) {
908 assert (node->op == op_Sel);
909 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
913 set_Sel_index (ir_node *node, int pos, ir_node *index) {
914 assert (node->op == op_Sel);
915 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
919 get_Sel_entity (ir_node *node) {
920 assert (node->op == op_Sel);
921 return node->attr.s.ent;
925 set_Sel_entity (ir_node *node, entity *ent) {
926 assert (node->op == op_Sel);
927 node->attr.s.ent = ent;
931 get_InstOf_ent (ir_node *node) {
932 assert (node->op = op_InstOf);
933 return (node->attr.io.ent);
937 set_InstOf_ent (ir_node *node, type *ent) {
938 assert (node->op = op_InstOf);
939 node->attr.io.ent = ent;
943 get_InstOf_store (ir_node *node) {
944 assert (node->op = op_InstOf);
945 return (get_irn_n (node, 0));
949 set_InstOf_store (ir_node *node, ir_node *obj) {
950 assert (node->op = op_InstOf);
951 set_irn_n (node, 0, obj);
955 get_InstOf_obj (ir_node *node) {
956 assert (node->op = op_InstOf);
957 return (get_irn_n (node, 1));
961 set_InstOf_obj (ir_node *node, ir_node *obj) {
962 assert (node->op = op_InstOf);
963 set_irn_n (node, 1, obj);
967 /* For unary and binary arithmetic operations the access to the
968 operands can be factored out. Left is the first, right the
969 second arithmetic value as listed in tech report 0999-33.
970 unops are: Minus, Abs, Not, Conv
971 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
972 Shr, Shrs, Rotate, Cmp */
976 get_Call_mem (ir_node *node) {
977 assert (node->op == op_Call);
978 return get_irn_n(node, 0);
982 set_Call_mem (ir_node *node, ir_node *mem) {
983 assert (node->op == op_Call);
984 set_irn_n(node, 0, mem);
988 get_Call_ptr (ir_node *node) {
989 assert (node->op == op_Call);
990 return get_irn_n(node, 1);
994 set_Call_ptr (ir_node *node, ir_node *ptr) {
995 assert (node->op == op_Call);
996 set_irn_n(node, 1, ptr);
1000 get_Call_param_arr (ir_node *node) {
1001 assert (node->op == op_Call);
1002 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1006 get_Call_n_params (ir_node *node) {
1007 assert (node->op == op_Call);
1008 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1012 get_Call_arity (ir_node *node) {
1013 assert (node->op == op_Call);
1014 return get_Call_n_params(node);
1018 set_Call_arity (ir_node *node, ir_node *arity) {
1019 assert (node->op == op_Call);
1024 get_Call_param (ir_node *node, int pos) {
1025 assert (node->op == op_Call);
1026 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1030 set_Call_param (ir_node *node, int pos, ir_node *param) {
1031 assert (node->op == op_Call);
1032 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1036 get_Call_type (ir_node *node) {
1037 assert (node->op == op_Call);
1038 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1042 set_Call_type (ir_node *node, type *tp) {
1043 assert (node->op == op_Call);
1044 assert (is_method_type(tp));
1045 node->attr.call.cld_tp = tp;
1048 int get_Call_n_callees(ir_node * node) {
1049 assert(node->op == op_Call && node->attr.call.callee_arr);
1050 return ARR_LEN(node->attr.call.callee_arr);
1053 entity * get_Call_callee(ir_node * node, int pos) {
1054 assert(node->op == op_Call && node->attr.call.callee_arr);
1055 return node->attr.call.callee_arr[pos];
1058 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1059 assert(node->op == op_Call);
1060 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1061 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1063 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1066 void remove_Call_callee_arr(ir_node * node) {
1067 assert(node->op == op_Call);
1068 node->attr.call.callee_arr = NULL;
1071 ir_node * get_CallBegin_ptr (ir_node *node) {
1072 assert(node->op == op_CallBegin);
1073 return get_irn_n(node, 0);
1075 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1076 assert(node->op == op_CallBegin);
1077 set_irn_n(node, 0, ptr);
1079 ir_graph * get_CallBegin_irg (ir_node *node) {
1080 assert(node->op == op_CallBegin);
1081 return node->attr.callbegin.irg;
1083 ir_node * get_CallBegin_call (ir_node *node) {
1084 assert(node->op == op_CallBegin);
1085 return node->attr.callbegin.call;
1087 void set_CallBegin_call (ir_node *node, ir_node *call) {
1088 assert(node->op == op_CallBegin);
1089 node->attr.callbegin.call = call;
1093 get_Add_left (ir_node *node) {
1094 assert (node->op == op_Add);
1095 return get_irn_n(node, 0);
1099 set_Add_left (ir_node *node, ir_node *left) {
1100 assert (node->op == op_Add);
1101 set_irn_n(node, 0, left);
1105 get_Add_right (ir_node *node) {
1106 assert (node->op == op_Add);
1107 return get_irn_n(node, 1);
1111 set_Add_right (ir_node *node, ir_node *right) {
1112 assert (node->op == op_Add);
1113 set_irn_n(node, 1, right);
1117 get_Sub_left (ir_node *node) {
1118 assert (node->op == op_Sub);
1119 return get_irn_n(node, 0);
1123 set_Sub_left (ir_node *node, ir_node *left) {
1124 assert (node->op == op_Sub);
1125 set_irn_n(node, 0, left);
1129 get_Sub_right (ir_node *node) {
1130 assert (node->op == op_Sub);
1131 return get_irn_n(node, 1);
1135 set_Sub_right (ir_node *node, ir_node *right) {
1136 assert (node->op == op_Sub);
1137 set_irn_n(node, 1, right);
1142 get_Minus_op (ir_node *node) {
1143 assert (node->op == op_Minus);
1144 return get_irn_n(node, 0);
1148 set_Minus_op (ir_node *node, ir_node *op) {
1149 assert (node->op == op_Minus);
1150 set_irn_n(node, 0, op);
1155 get_Mul_left (ir_node *node) {
1156 assert (node->op == op_Mul);
1157 return get_irn_n(node, 0);
1161 set_Mul_left (ir_node *node, ir_node *left) {
1162 assert (node->op == op_Mul);
1163 set_irn_n(node, 0, left);
1167 get_Mul_right (ir_node *node) {
1168 assert (node->op == op_Mul);
1169 return get_irn_n(node, 1);
1173 set_Mul_right (ir_node *node, ir_node *right) {
1174 assert (node->op == op_Mul);
1175 set_irn_n(node, 1, right);
1179 get_Quot_left (ir_node *node) {
1180 assert (node->op == op_Quot);
1181 return get_irn_n(node, 1);
1185 set_Quot_left (ir_node *node, ir_node *left) {
1186 assert (node->op == op_Quot);
1187 set_irn_n(node, 1, left);
1191 get_Quot_right (ir_node *node) {
1192 assert (node->op == op_Quot);
1193 return get_irn_n(node, 2);
1197 set_Quot_right (ir_node *node, ir_node *right) {
1198 assert (node->op == op_Quot);
1199 set_irn_n(node, 2, right);
1203 get_Quot_mem (ir_node *node) {
1204 assert (node->op == op_Quot);
1205 return get_irn_n(node, 0);
1209 set_Quot_mem (ir_node *node, ir_node *mem) {
1210 assert (node->op == op_Quot);
1211 set_irn_n(node, 0, mem);
1215 get_DivMod_left (ir_node *node) {
1216 assert (node->op == op_DivMod);
1217 return get_irn_n(node, 1);
1221 set_DivMod_left (ir_node *node, ir_node *left) {
1222 assert (node->op == op_DivMod);
1223 set_irn_n(node, 1, left);
1227 get_DivMod_right (ir_node *node) {
1228 assert (node->op == op_DivMod);
1229 return get_irn_n(node, 2);
1233 set_DivMod_right (ir_node *node, ir_node *right) {
1234 assert (node->op == op_DivMod);
1235 set_irn_n(node, 2, right);
1239 get_DivMod_mem (ir_node *node) {
1240 assert (node->op == op_DivMod);
1241 return get_irn_n(node, 0);
1245 set_DivMod_mem (ir_node *node, ir_node *mem) {
1246 assert (node->op == op_DivMod);
1247 set_irn_n(node, 0, mem);
1251 get_Div_left (ir_node *node) {
1252 assert (node->op == op_Div);
1253 return get_irn_n(node, 1);
1257 set_Div_left (ir_node *node, ir_node *left) {
1258 assert (node->op == op_Div);
1259 set_irn_n(node, 1, left);
1263 get_Div_right (ir_node *node) {
1264 assert (node->op == op_Div);
1265 return get_irn_n(node, 2);
1269 set_Div_right (ir_node *node, ir_node *right) {
1270 assert (node->op == op_Div);
1271 set_irn_n(node, 2, right);
1275 get_Div_mem (ir_node *node) {
1276 assert (node->op == op_Div);
1277 return get_irn_n(node, 0);
1281 set_Div_mem (ir_node *node, ir_node *mem) {
1282 assert (node->op == op_Div);
1283 set_irn_n(node, 0, mem);
1287 get_Mod_left (ir_node *node) {
1288 assert (node->op == op_Mod);
1289 return get_irn_n(node, 1);
1293 set_Mod_left (ir_node *node, ir_node *left) {
1294 assert (node->op == op_Mod);
1295 set_irn_n(node, 1, left);
1299 get_Mod_right (ir_node *node) {
1300 assert (node->op == op_Mod);
1301 return get_irn_n(node, 2);
1305 set_Mod_right (ir_node *node, ir_node *right) {
1306 assert (node->op == op_Mod);
1307 set_irn_n(node, 2, right);
1311 get_Mod_mem (ir_node *node) {
1312 assert (node->op == op_Mod);
1313 return get_irn_n(node, 0);
1317 set_Mod_mem (ir_node *node, ir_node *mem) {
1318 assert (node->op == op_Mod);
1319 set_irn_n(node, 0, mem);
1323 get_Abs_op (ir_node *node) {
1324 assert (node->op == op_Abs);
1325 return get_irn_n(node, 0);
1329 set_Abs_op (ir_node *node, ir_node *op) {
1330 assert (node->op == op_Abs);
1331 set_irn_n(node, 0, op);
1335 get_And_left (ir_node *node) {
1336 assert (node->op == op_And);
1337 return get_irn_n(node, 0);
1341 set_And_left (ir_node *node, ir_node *left) {
1342 assert (node->op == op_And);
1343 set_irn_n(node, 0, left);
1347 get_And_right (ir_node *node) {
1348 assert (node->op == op_And);
1349 return get_irn_n(node, 1);
1353 set_And_right (ir_node *node, ir_node *right) {
1354 assert (node->op == op_And);
1355 set_irn_n(node, 1, right);
1359 get_Or_left (ir_node *node) {
1360 assert (node->op == op_Or);
1361 return get_irn_n(node, 0);
1365 set_Or_left (ir_node *node, ir_node *left) {
1366 assert (node->op == op_Or);
1367 set_irn_n(node, 0, left);
1371 get_Or_right (ir_node *node) {
1372 assert (node->op == op_Or);
1373 return get_irn_n(node, 1);
1377 set_Or_right (ir_node *node, ir_node *right) {
1378 assert (node->op == op_Or);
1379 set_irn_n(node, 1, right);
1383 get_Eor_left (ir_node *node) {
1384 assert (node->op == op_Eor);
1385 return get_irn_n(node, 0);
1389 set_Eor_left (ir_node *node, ir_node *left) {
1390 assert (node->op == op_Eor);
1391 set_irn_n(node, 0, left);
1395 get_Eor_right (ir_node *node) {
1396 assert (node->op == op_Eor);
1397 return get_irn_n(node, 1);
1401 set_Eor_right (ir_node *node, ir_node *right) {
1402 assert (node->op == op_Eor);
1403 set_irn_n(node, 1, right);
1408 get_Not_op (ir_node *node) {
1409 assert (node->op == op_Not);
1410 return get_irn_n(node, 0);
1414 set_Not_op (ir_node *node, ir_node *op) {
1415 assert (node->op == op_Not);
1416 set_irn_n(node, 0, op);
1421 get_Shl_left (ir_node *node) {
1422 assert (node->op == op_Shl);
1423 return get_irn_n(node, 0);
1427 set_Shl_left (ir_node *node, ir_node *left) {
1428 assert (node->op == op_Shl);
1429 set_irn_n(node, 0, left);
1433 get_Shl_right (ir_node *node) {
1434 assert (node->op == op_Shl);
1435 return get_irn_n(node, 1);
1439 set_Shl_right (ir_node *node, ir_node *right) {
1440 assert (node->op == op_Shl);
1441 set_irn_n(node, 1, right);
1445 get_Shr_left (ir_node *node) {
1446 assert (node->op == op_Shr);
1447 return get_irn_n(node, 0);
1451 set_Shr_left (ir_node *node, ir_node *left) {
1452 assert (node->op == op_Shr);
1453 set_irn_n(node, 0, left);
1457 get_Shr_right (ir_node *node) {
1458 assert (node->op == op_Shr);
1459 return get_irn_n(node, 1);
1463 set_Shr_right (ir_node *node, ir_node *right) {
1464 assert (node->op == op_Shr);
1465 set_irn_n(node, 1, right);
1469 get_Shrs_left (ir_node *node) {
1470 assert (node->op == op_Shrs);
1471 return get_irn_n(node, 0);
1475 set_Shrs_left (ir_node *node, ir_node *left) {
1476 assert (node->op == op_Shrs);
1477 set_irn_n(node, 0, left);
1481 get_Shrs_right (ir_node *node) {
1482 assert (node->op == op_Shrs);
1483 return get_irn_n(node, 1);
1487 set_Shrs_right (ir_node *node, ir_node *right) {
1488 assert (node->op == op_Shrs);
1489 set_irn_n(node, 1, right);
1493 get_Rot_left (ir_node *node) {
1494 assert (node->op == op_Rot);
1495 return get_irn_n(node, 0);
1499 set_Rot_left (ir_node *node, ir_node *left) {
1500 assert (node->op == op_Rot);
1501 set_irn_n(node, 0, left);
1505 get_Rot_right (ir_node *node) {
1506 assert (node->op == op_Rot);
1507 return get_irn_n(node, 1);
1511 set_Rot_right (ir_node *node, ir_node *right) {
1512 assert (node->op == op_Rot);
1513 set_irn_n(node, 1, right);
1517 get_Cmp_left (ir_node *node) {
1518 assert (node->op == op_Cmp);
1519 return get_irn_n(node, 0);
1523 set_Cmp_left (ir_node *node, ir_node *left) {
1524 assert (node->op == op_Cmp);
1525 set_irn_n(node, 0, left);
1529 get_Cmp_right (ir_node *node) {
1530 assert (node->op == op_Cmp);
1531 return get_irn_n(node, 1);
1535 set_Cmp_right (ir_node *node, ir_node *right) {
1536 assert (node->op == op_Cmp);
1537 set_irn_n(node, 1, right);
1541 get_Conv_op (ir_node *node) {
1542 assert (node->op == op_Conv);
1543 return get_irn_n(node, 0);
1547 set_Conv_op (ir_node *node, ir_node *op) {
1548 assert (node->op == op_Conv);
1549 set_irn_n(node, 0, op);
1555 is_unop (ir_node *node) {
1556 return ( node->op == op_Minus ||
1557 node->op == op_Abs ||
1558 node->op == op_Not ||
1559 node->op == op_Conv );
1563 get_unop_op (ir_node *node) {
1564 assert ( node->op == op_Minus ||
1565 node->op == op_Abs ||
1566 node->op == op_Not ||
1567 node->op == op_Conv );
1568 switch (get_irn_opcode (node)) {
1569 case iro_Minus: return get_Minus_op(node); break;
1570 case iro_Abs: return get_Abs_op(node); break;
1571 case iro_Not: return get_Not_op(node); break;
1572 case iro_Conv: return get_Conv_op(node); break;
1573 default: return NULL;
1578 set_unop_op (ir_node *node, ir_node *op) {
1579 assert (node->op == op_Minus ||
1580 node->op == op_Abs ||
1581 node->op == op_Not ||
1582 node->op == op_Conv );
1583 switch (get_irn_opcode (node)) {
1584 case iro_Minus: set_Minus_op(node, op); break;
1585 case iro_Abs: set_Abs_op(node, op); break;
1586 case iro_Not: set_Not_op(node, op); break;
1587 case iro_Conv: set_Conv_op(node, op); break;
1594 is_binop (ir_node *node) {
1595 return (node->op == op_Add ||
1596 node->op == op_Sub ||
1597 node->op == op_Mul ||
1598 node->op == op_Quot ||
1599 node->op == op_DivMod ||
1600 node->op == op_Div ||
1601 node->op == op_Mod ||
1602 node->op == op_And ||
1603 node->op == op_Or ||
1604 node->op == op_Eor ||
1605 node->op == op_Shl ||
1606 node->op == op_Shr ||
1607 node->op == op_Shrs ||
1608 node->op == op_Rot ||
1609 node->op == op_Cmp );
1613 get_binop_left (ir_node *node) {
1614 assert (node->op == op_Add ||
1615 node->op == op_Sub ||
1616 node->op == op_Mul ||
1617 node->op == op_Quot ||
1618 node->op == op_DivMod ||
1619 node->op == op_Div ||
1620 node->op == op_Mod ||
1621 node->op == op_And ||
1622 node->op == op_Or ||
1623 node->op == op_Eor ||
1624 node->op == op_Shl ||
1625 node->op == op_Shr ||
1626 node->op == op_Shrs ||
1627 node->op == op_Rot ||
1628 node->op == op_Cmp );
1630 switch (get_irn_opcode (node)) {
1631 case iro_Add : return get_Add_left(node); break;
1632 case iro_Sub : return get_Sub_left(node); break;
1633 case iro_Mul : return get_Mul_left(node); break;
1634 case iro_Quot : return get_Quot_left(node); break;
1635 case iro_DivMod: return get_DivMod_left(node); break;
1636 case iro_Div : return get_Div_left(node); break;
1637 case iro_Mod : return get_Mod_left(node); break;
1638 case iro_And : return get_And_left(node); break;
1639 case iro_Or : return get_Or_left(node); break;
1640 case iro_Eor : return get_Eor_left(node); break;
1641 case iro_Shl : return get_Shl_left(node); break;
1642 case iro_Shr : return get_Shr_left(node); break;
1643 case iro_Shrs : return get_Shrs_left(node); break;
1644 case iro_Rot : return get_Rot_left(node); break;
1645 case iro_Cmp : return get_Cmp_left(node); break;
1646 default: return NULL;
1651 set_binop_left (ir_node *node, ir_node *left) {
1652 assert (node->op == op_Add ||
1653 node->op == op_Sub ||
1654 node->op == op_Mul ||
1655 node->op == op_Quot ||
1656 node->op == op_DivMod ||
1657 node->op == op_Div ||
1658 node->op == op_Mod ||
1659 node->op == op_And ||
1660 node->op == op_Or ||
1661 node->op == op_Eor ||
1662 node->op == op_Shl ||
1663 node->op == op_Shr ||
1664 node->op == op_Shrs ||
1665 node->op == op_Rot ||
1666 node->op == op_Cmp );
1668 switch (get_irn_opcode (node)) {
1669 case iro_Add : set_Add_left(node, left); break;
1670 case iro_Sub : set_Sub_left(node, left); break;
1671 case iro_Mul : set_Mul_left(node, left); break;
1672 case iro_Quot : set_Quot_left(node, left); break;
1673 case iro_DivMod: set_DivMod_left(node, left); break;
1674 case iro_Div : set_Div_left(node, left); break;
1675 case iro_Mod : set_Mod_left(node, left); break;
1676 case iro_And : set_And_left(node, left); break;
1677 case iro_Or : set_Or_left(node, left); break;
1678 case iro_Eor : set_Eor_left(node, left); break;
1679 case iro_Shl : set_Shl_left(node, left); break;
1680 case iro_Shr : set_Shr_left(node, left); break;
1681 case iro_Shrs : set_Shrs_left(node, left); break;
1682 case iro_Rot : set_Rot_left(node, left); break;
1683 case iro_Cmp : set_Cmp_left(node, left); break;
1689 get_binop_right (ir_node *node) {
1690 assert (node->op == op_Add ||
1691 node->op == op_Sub ||
1692 node->op == op_Mul ||
1693 node->op == op_Quot ||
1694 node->op == op_DivMod ||
1695 node->op == op_Div ||
1696 node->op == op_Mod ||
1697 node->op == op_And ||
1698 node->op == op_Or ||
1699 node->op == op_Eor ||
1700 node->op == op_Shl ||
1701 node->op == op_Shr ||
1702 node->op == op_Shrs ||
1703 node->op == op_Rot ||
1704 node->op == op_Cmp );
1706 switch (get_irn_opcode (node)) {
1707 case iro_Add : return get_Add_right(node); break;
1708 case iro_Sub : return get_Sub_right(node); break;
1709 case iro_Mul : return get_Mul_right(node); break;
1710 case iro_Quot : return get_Quot_right(node); break;
1711 case iro_DivMod: return get_DivMod_right(node); break;
1712 case iro_Div : return get_Div_right(node); break;
1713 case iro_Mod : return get_Mod_right(node); break;
1714 case iro_And : return get_And_right(node); break;
1715 case iro_Or : return get_Or_right(node); break;
1716 case iro_Eor : return get_Eor_right(node); break;
1717 case iro_Shl : return get_Shl_right(node); break;
1718 case iro_Shr : return get_Shr_right(node); break;
1719 case iro_Shrs : return get_Shrs_right(node); break;
1720 case iro_Rot : return get_Rot_right(node); break;
1721 case iro_Cmp : return get_Cmp_right(node); break;
1722 default: return NULL;
1727 set_binop_right (ir_node *node, ir_node *right) {
1728 assert (node->op == op_Add ||
1729 node->op == op_Sub ||
1730 node->op == op_Mul ||
1731 node->op == op_Quot ||
1732 node->op == op_DivMod ||
1733 node->op == op_Div ||
1734 node->op == op_Mod ||
1735 node->op == op_And ||
1736 node->op == op_Or ||
1737 node->op == op_Eor ||
1738 node->op == op_Shl ||
1739 node->op == op_Shr ||
1740 node->op == op_Shrs ||
1741 node->op == op_Rot ||
1742 node->op == op_Cmp );
1744 switch (get_irn_opcode (node)) {
1745 case iro_Add : set_Add_right(node, right); break;
1746 case iro_Sub : set_Sub_right(node, right); break;
1747 case iro_Mul : set_Mul_right(node, right); break;
1748 case iro_Quot : set_Quot_right(node, right); break;
1749 case iro_DivMod: set_DivMod_right(node, right); break;
1750 case iro_Div : set_Div_right(node, right); break;
1751 case iro_Mod : set_Mod_right(node, right); break;
1752 case iro_And : set_And_right(node, right); break;
1753 case iro_Or : set_Or_right(node, right); break;
1754 case iro_Eor : set_Eor_right(node, right); break;
1755 case iro_Shl : set_Shl_right(node, right); break;
1756 case iro_Shr : set_Shr_right(node, right); break;
1757 case iro_Shrs : set_Shrs_right(node, right); break;
1758 case iro_Rot : set_Rot_right(node, right); break;
1759 case iro_Cmp : set_Cmp_right(node, right); break;
1766 get_Phi_preds_arr (ir_node *node) {
1767 assert (node->op == op_Phi);
1768 return (ir_node **)&(get_irn_in(node)[1]);
1772 get_Phi_n_preds (ir_node *node) {
1773 assert (node->op == op_Phi);
1774 return (get_irn_arity(node));
1778 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1779 assert (node->op == op_Phi);
1784 get_Phi_pred (ir_node *node, int pos) {
1785 assert (node->op == op_Phi);
1786 return get_irn_n(node, pos);
1790 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1791 assert (node->op == op_Phi);
1792 set_irn_n(node, pos, pred);
1796 get_Load_mem (ir_node *node) {
1797 assert (node->op == op_Load);
1798 return get_irn_n(node, 0);
1802 set_Load_mem (ir_node *node, ir_node *mem) {
1803 assert (node->op == op_Load);
1804 set_irn_n(node, 0, mem);
1808 get_Load_ptr (ir_node *node) {
1809 assert (node->op == op_Load);
1810 return get_irn_n(node, 1);
1814 set_Load_ptr (ir_node *node, ir_node *ptr) {
1815 assert (node->op == op_Load);
1816 set_irn_n(node, 1, ptr);
1821 get_Store_mem (ir_node *node) {
1822 assert (node->op == op_Store);
1823 return get_irn_n(node, 0);
1827 set_Store_mem (ir_node *node, ir_node *mem) {
1828 assert (node->op == op_Store);
1829 set_irn_n(node, 0, mem);
1833 get_Store_ptr (ir_node *node) {
1834 assert (node->op == op_Store);
1835 return get_irn_n(node, 1);
1839 set_Store_ptr (ir_node *node, ir_node *ptr) {
1840 assert (node->op == op_Store);
1841 set_irn_n(node, 1, ptr);
1845 get_Store_value (ir_node *node) {
1846 assert (node->op == op_Store);
1847 return get_irn_n(node, 2);
1851 set_Store_value (ir_node *node, ir_node *value) {
1852 assert (node->op == op_Store);
1853 set_irn_n(node, 2, value);
1857 get_Alloc_mem (ir_node *node) {
1858 assert (node->op == op_Alloc);
1859 return get_irn_n(node, 0);
1863 set_Alloc_mem (ir_node *node, ir_node *mem) {
1864 assert (node->op == op_Alloc);
1865 set_irn_n(node, 0, mem);
1869 get_Alloc_size (ir_node *node) {
1870 assert (node->op == op_Alloc);
1871 return get_irn_n(node, 1);
1875 set_Alloc_size (ir_node *node, ir_node *size) {
1876 assert (node->op == op_Alloc);
1877 set_irn_n(node, 1, size);
1881 get_Alloc_type (ir_node *node) {
1882 assert (node->op == op_Alloc);
1883 return node->attr.a.type = skip_tid(node->attr.a.type);
1887 set_Alloc_type (ir_node *node, type *tp) {
1888 assert (node->op == op_Alloc);
1889 node->attr.a.type = tp;
1893 get_Alloc_where (ir_node *node) {
1894 assert (node->op == op_Alloc);
1895 return node->attr.a.where;
1899 set_Alloc_where (ir_node *node, where_alloc where) {
1900 assert (node->op == op_Alloc);
1901 node->attr.a.where = where;
1906 get_Free_mem (ir_node *node) {
1907 assert (node->op == op_Free);
1908 return get_irn_n(node, 0);
1912 set_Free_mem (ir_node *node, ir_node *mem) {
1913 assert (node->op == op_Free);
1914 set_irn_n(node, 0, mem);
1918 get_Free_ptr (ir_node *node) {
1919 assert (node->op == op_Free);
1920 return get_irn_n(node, 1);
1924 set_Free_ptr (ir_node *node, ir_node *ptr) {
1925 assert (node->op == op_Free);
1926 set_irn_n(node, 1, ptr);
1930 get_Free_size (ir_node *node) {
1931 assert (node->op == op_Free);
1932 return get_irn_n(node, 2);
1936 set_Free_size (ir_node *node, ir_node *size) {
1937 assert (node->op == op_Free);
1938 set_irn_n(node, 2, size);
1942 get_Free_type (ir_node *node) {
1943 assert (node->op == op_Free);
1944 return node->attr.f = skip_tid(node->attr.f);
1948 set_Free_type (ir_node *node, type *tp) {
1949 assert (node->op == op_Free);
1954 get_Sync_preds_arr (ir_node *node) {
1955 assert (node->op == op_Sync);
1956 return (ir_node **)&(get_irn_in(node)[1]);
1960 get_Sync_n_preds (ir_node *node) {
1961 assert (node->op == op_Sync);
1962 return (get_irn_arity(node));
1967 set_Sync_n_preds (ir_node *node, int n_preds) {
1968 assert (node->op == op_Sync);
1973 get_Sync_pred (ir_node *node, int pos) {
1974 assert (node->op == op_Sync);
1975 return get_irn_n(node, pos);
1979 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1980 assert (node->op == op_Sync);
1981 set_irn_n(node, pos, pred);
1985 get_Proj_pred (ir_node *node) {
1986 assert (is_Proj(node));
1987 return get_irn_n(node, 0);
1991 set_Proj_pred (ir_node *node, ir_node *pred) {
1992 assert (is_Proj(node));
1993 set_irn_n(node, 0, pred);
1997 get_Proj_proj (ir_node *node) {
1998 assert (is_Proj(node));
1999 if (get_irn_opcode(node) == iro_Proj) {
2000 return node->attr.proj;
2002 assert(get_irn_opcode(node) == iro_Filter);
2003 return node->attr.filter.proj;
2008 set_Proj_proj (ir_node *node, long proj) {
2009 assert (node->op == op_Proj);
2010 node->attr.proj = proj;
2014 get_Tuple_preds_arr (ir_node *node) {
2015 assert (node->op == op_Tuple);
2016 return (ir_node **)&(get_irn_in(node)[1]);
2020 get_Tuple_n_preds (ir_node *node) {
2021 assert (node->op == op_Tuple);
2022 return (get_irn_arity(node));
2027 set_Tuple_n_preds (ir_node *node, int n_preds) {
2028 assert (node->op == op_Tuple);
2033 get_Tuple_pred (ir_node *node, int pos) {
2034 assert (node->op == op_Tuple);
2035 return get_irn_n(node, pos);
2039 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2040 assert (node->op == op_Tuple);
2041 set_irn_n(node, pos, pred);
2045 get_Id_pred (ir_node *node) {
2046 assert (node->op == op_Id);
2047 return get_irn_n(node, 0);
2051 set_Id_pred (ir_node *node, ir_node *pred) {
2052 assert (node->op == op_Id);
2053 set_irn_n(node, 0, pred);
2058 get_Filter_pred (ir_node *node) {
2059 assert(node->op == op_Filter);
2063 set_Filter_pred (ir_node *node, ir_node *pred) {
2064 assert(node->op == op_Filter);
2068 get_Filter_proj(ir_node *node) {
2069 assert(node->op == op_Filter);
2070 return node->attr.filter.proj;
2073 set_Filter_proj (ir_node *node, long proj) {
2074 assert(node->op == op_Filter);
2075 node->attr.filter.proj = proj;
2078 /* Don't use get_irn_arity, get_irn_n in implementation as access
2079 shall work independent of view!!! */
2080 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2081 assert(node->op == op_Filter);
2082 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2083 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2084 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2085 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2086 node->attr.filter.in_cg[0] = node->in[0];
2088 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2091 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2092 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2093 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2094 node->attr.filter.in_cg[pos + 1] = pred;
2096 int get_Filter_n_cg_preds(ir_node *node) {
2097 assert(node->op == op_Filter && node->attr.filter.in_cg);
2098 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2100 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2102 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2104 arity = ARR_LEN(node->attr.filter.in_cg);
2105 assert(pos < arity - 1);
2106 return node->attr.filter.in_cg[pos + 1];
2111 get_irn_irg(ir_node *node) {
2112 if (get_irn_op(node) == op_CallBegin) {
2113 return node->attr.callbegin.irg;
2114 } else if (get_irn_op(node) == op_EndReg ||
2115 get_irn_op(node) == op_EndExcept) {
2116 return node->attr.end.irg;
2118 assert(0 && "no irg attr");
2123 /******************************************************************/
2124 /* Auxiliary routines */
2125 /******************************************************************/
2128 skip_Proj (ir_node *node) {
2129 /* don't assert node !!! */
2130 if (node && is_Proj(node)) {
2131 return get_Proj_pred(node);
2138 skip_Tuple (ir_node *node) {
2141 if (!get_opt_normalize()) return node;
2143 node = skip_nop(node);
2144 if (get_irn_op(node) == op_Proj) {
2145 pred = skip_nop(get_Proj_pred(node));
2146 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2147 pred = skip_nop(skip_Tuple(pred));
2148 if (get_irn_op(pred) == op_Tuple)
2149 return get_Tuple_pred(pred, get_Proj_proj(node));
2155 skip_nop (ir_node *node) {
2156 /* don't assert node !!! */
2158 if (!get_opt_normalize()) return node;
2160 /* Don't use get_Id_pred: We get into an endless loop for
2161 self-referencing Ids. */
2162 if (node && (node->op == op_Id) && (node != node->in[0+1])) {
2163 assert (get_irn_arity (node) > 0);
2164 return node->in[0+1];
2171 skip_Id (ir_node *node) {
2172 return skip_nop(node);
2176 is_Bad (ir_node *node) {
2178 if ((node) && get_irn_opcode(node) == iro_Bad)
2184 is_no_Block (ir_node *node) {
2186 return (get_irn_opcode(node) != iro_Block);
2190 is_Block (ir_node *node) {
2192 return (get_irn_opcode(node) == iro_Block);
2196 is_Proj (const ir_node *node) {
2198 return node->op == op_Proj
2199 || (!interprocedural_view && node->op == op_Filter);
2202 /* Returns true if the operation manipulates control flow. */
2204 is_cfop(ir_node *node) {
2205 return is_cfopcode(get_irn_op(node));
2208 /* Returns true if the operation manipulates interprocedural control flow:
2209 CallBegin, EndReg, EndExcept */
2210 INLINE int is_ip_cfop(ir_node *node) {
2211 return is_ip_cfopcode(get_irn_op(node));
2214 ir_graph *get_ip_cfop_irg(ir_node *n) {
2215 switch (get_irn_opcode(n)) {
2217 return get_EndReg_irg(n);
2219 return get_EndExcept_irg(n);
2221 return get_CallBegin_irg(n);
2223 assert(is_ip_cfop(n));
2225 return NULL; /* should never be reached */
2228 /* Returns true if the operation can change the control flow because
2231 is_fragile_op(ir_node *node) {
2232 return ( (get_irn_opcode(node) == iro_Call)
2233 || (get_irn_opcode(node) == iro_Quot)
2234 || (get_irn_opcode(node) == iro_DivMod)
2235 || (get_irn_opcode(node) == iro_Div)
2236 || (get_irn_opcode(node) == iro_Mod)
2237 || (get_irn_opcode(node) == iro_Load)
2238 || (get_irn_opcode(node) == iro_Store)
2239 || (get_irn_opcode(node) == iro_Alloc)
2240 || (get_irn_opcode(node) == iro_Bad)
2241 || (get_irn_opcode(node) == iro_Unknown));
2245 /* Returns the memory operand of fragile operations. */
2246 ir_node *get_fragile_op_mem(ir_node *node) {
2247 assert(node && is_fragile_op(node));
2249 switch (get_irn_opcode (node)) {
2258 return get_irn_n(node, 0);
2263 assert(0 && "not reached");