3 * File name: ir/ir/irnode.c
4 * Purpose: Representation of an intermediate operation.
5 * Author: Martin Trapp, Christian Schaefer
6 * Modified by: Goetz Lindenmaier
9 * Copyright: (c) 1998-2003 Universität Karlsruhe
10 * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
20 #include "irgraph_t.h"
24 #include "irbackedge_t.h"
32 /* some constants fixing the positions of nodes predecessors
34 #define CALL_PARAM_OFFSET 2
35 #define SEL_INDEX_OFFSET 2
36 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
37 #define END_KEEPALIVE_OFFSET 0
39 /* Declarations for inlineing */
40 INLINE ir_node ** get_irn_in (const ir_node *node);
41 INLINE ir_mode *get_irn_mode (const ir_node *node);
42 INLINE ir_op *get_irn_op (const ir_node *node);
43 INLINE opcode get_irn_opcode (const ir_node *node);
44 INLINE ident *get_irn_opident (const ir_node *node);
45 INLINE type *get_SymConst_type (ir_node *node);
46 INLINE ir_node *skip_nop (ir_node *node);
47 INLINE int is_Proj (const ir_node *node);
50 static const char *pnc_name_arr [] = {
51 "False", "Eq", "Lt", "Le",
52 "Gt", "Ge", "Lg", "Leg", "Uo",
53 "Ue", "Ul", "Ule", "Ug", "Uge",
57 INLINE const char *get_pnc_string(int pnc) {
58 return pnc_name_arr[pnc];
63 get_negated_pnc(int pnc) {
65 case False: return True; break;
66 case Eq: return Ne; break;
67 case Lt: return Uge; break;
68 case Le: return Ug; break;
69 case Gt: return Ule; break;
70 case Ge: return Ul; break;
71 case Lg: return Ue; break;
72 case Leg: return Uo; break;
73 case Uo: return Leg; break;
74 case Ue: return Lg; break;
75 case Ul: return Ge; break;
76 case Ule: return Gt; break;
77 case Ug: return Le; break;
78 case Uge: return Lt; break;
79 case Ne: return Eq; break;
80 case True: return False; break;
82 return 99; /* to shut up gcc */
85 const char *pns_name_arr [] = {
86 "initial_exec", "global_store",
87 "frame_base", "globals", "args"
90 const char *symconst_name_arr [] = {
91 "type_tag", "size", "linkage_ptr_info"
99 /* irnode constructor */
100 /* create a new irnode in irg, with an op, mode, arity and */
101 /* some incoming irnodes */
102 /* this constructor is used in every specified irnode constructor */
104 new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
105 int arity, ir_node **in)
108 int node_size = offsetof (ir_node, attr) + op->attr_size;
110 res = (ir_node *) obstack_alloc (irg->obst, node_size);
112 res->kind = k_ir_node;
118 res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
120 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
121 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
124 set_irn_dbg_info(res, db);
128 res->node_nr = get_irp_new_node_nr();
134 /* Copies all attributes stored in the old node to the new node.
135 Assumes both have the same opcode and sufficient size. */
137 copy_attrs (ir_node *old, ir_node *new) {
138 assert (get_irn_op(old) == get_irn_op(new));
139 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
142 /** getting some parameters from ir_nodes **/
145 is_ir_node (void *thing) {
147 if (get_kind(thing) == k_ir_node)
153 /* returns the number of predecessors without the block predecessor. */
155 get_irn_arity (const ir_node *node) {
157 if (interprocedural_view) { /* handle Filter and Block specially */
158 if (get_irn_opcode(node) == iro_Filter) {
159 assert(node->attr.filter.in_cg);
160 return ARR_LEN(node->attr.filter.in_cg) - 1;
161 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
162 return ARR_LEN(node->attr.block.in_cg) - 1;
164 /* else fall through */
166 return ARR_LEN(node->in) - 1;
169 /* Returns the array with ins. This array is shifted with respect to the
170 array accessed by get_irn_n: The block operand is at position 0 not -1.
171 (@@@ This should be changed.)
172 The order of the predecessors in this array is not guaranteed, except that
173 lists of operands as predecessors of Block or arguments of a Call are
176 get_irn_in (const ir_node *node) {
178 if (interprocedural_view) { /* handle Filter and Block specially */
179 if (get_irn_opcode(node) == iro_Filter) {
180 assert(node->attr.filter.in_cg);
181 return node->attr.filter.in_cg;
182 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
183 return node->attr.block.in_cg;
185 /* else fall through */
191 set_irn_in (ir_node *node, int arity, ir_node **in) {
194 if (interprocedural_view) { /* handle Filter and Block specially */
195 if (get_irn_opcode(node) == iro_Filter) {
196 assert(node->attr.filter.in_cg);
197 arr = &node->attr.filter.in_cg;
198 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
199 arr = &node->attr.block.in_cg;
206 if (arity != ARR_LEN(*arr) - 1) {
207 ir_node * block = (*arr)[0];
208 *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
211 fix_backedges(current_ir_graph->obst, node);
212 memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
215 /* to iterate through the predecessors without touching the array */
216 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
217 to iterate includind the Block predecessor iterate from i = -1 to
219 If it is a block, the entry -1 is NULL. */
221 get_irn_n (ir_node *node, int n) {
223 if (-1 > n || get_irn_arity(node) <= n) {
224 printf("pos: %d, arity: %d ", n, get_irn_arity(node));
227 assert(node); assert(-1 <= n && n < get_irn_arity(node));
228 if (interprocedural_view) { /* handle Filter and Block specially */
229 if (get_irn_opcode(node) == iro_Filter) {
230 assert(node->attr.filter.in_cg);
231 return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
232 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
233 return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
235 /* else fall through */
237 return (node->in[n + 1] = skip_nop(node->in[n + 1]));
241 set_irn_n (ir_node *node, int n, ir_node *in) {
242 assert(node && -1 <= n && n < get_irn_arity(node));
243 if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
244 /* Change block pred in both views! */
245 node->in[n + 1] = in;
246 assert(node->attr.filter.in_cg);
247 node->attr.filter.in_cg[n + 1] = in;
250 if (interprocedural_view) { /* handle Filter and Block specially */
251 if (get_irn_opcode(node) == iro_Filter) {
252 assert(node->attr.filter.in_cg);
253 node->attr.filter.in_cg[n + 1] = in;
255 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
256 node->attr.block.in_cg[n + 1] = in;
259 /* else fall through */
261 node->in[n + 1] = in;
265 get_irn_mode (const ir_node *node)
272 set_irn_mode (ir_node *node, ir_mode *mode)
280 get_irn_modecode (const ir_node *node)
283 return node->mode->code;
288 get_irn_modeident (const ir_node *node)
291 return get_mode_ident(node->mode);
295 get_irn_op (const ir_node *node)
301 /* should be private to the library: */
303 set_irn_op (ir_node *node, ir_op *op)
310 get_irn_opcode (const ir_node *node)
313 assert (k_ir_node == get_kind(node));
315 return node->op->code;
319 get_irn_opname (const ir_node *node)
322 return get_id_str(node->op->name);
326 get_irn_opident (const ir_node *node)
329 return node->op->name;
333 get_irn_visited (const ir_node *node)
336 return node->visited;
340 set_irn_visited (ir_node *node, unsigned long visited)
343 node->visited = visited;
347 mark_irn_visited (ir_node *node) {
349 node->visited = current_ir_graph->visited;
353 irn_not_visited (const ir_node *node) {
355 return (node->visited < current_ir_graph->visited);
359 irn_visited (const ir_node *node) {
361 return (node->visited >= current_ir_graph->visited);
365 set_irn_link (ir_node *node, void *link) {
367 /* Link field is used for Phi construction and various optimizations
369 assert(get_irg_phase_state(current_ir_graph) != phase_building);
375 get_irn_link (const ir_node *node) {
380 /* Outputs a unique number for this node */
382 get_irn_node_nr(const ir_node *node) {
385 return node->node_nr;
392 get_irn_const_attr (ir_node *node)
394 assert (node->op == op_Const);
395 return node->attr.con;
399 get_irn_proj_attr (ir_node *node)
401 assert (node->op == op_Proj);
402 return node->attr.proj;
406 get_irn_alloc_attr (ir_node *node)
408 assert (node->op == op_Alloc);
413 get_irn_free_attr (ir_node *node)
415 assert (node->op == op_Free);
416 return node->attr.f = skip_tid(node->attr.f);
420 get_irn_symconst_attr (ir_node *node)
422 assert (node->op == op_SymConst);
427 get_irn_call_attr (ir_node *node)
429 assert (node->op == op_Call);
430 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
434 get_irn_sel_attr (ir_node *node)
436 assert (node->op == op_Sel);
441 get_irn_phi_attr (ir_node *node)
443 assert (node->op == op_Phi);
444 return node->attr.phi0_pos;
448 get_irn_block_attr (ir_node *node)
450 assert (node->op == op_Block);
451 return node->attr.block;
454 /** manipulate fields of individual nodes **/
456 /* this works for all except Block */
458 get_nodes_Block (ir_node *node) {
459 assert (!(node->op == op_Block));
460 return get_irn_n(node, -1);
464 set_nodes_Block (ir_node *node, ir_node *block) {
465 assert (!(node->op == op_Block));
466 set_irn_n(node, -1, block);
469 /* Returns an array with the predecessors of the Block. Depending on
470 the implementation of the graph datastructure this can be a copy of
471 the internal representation of predecessors as well as the internal
472 array itself. Therefore writing to this array might obstruct the ir. */
474 get_Block_cfgpred_arr (ir_node *node)
476 assert ((node->op == op_Block));
477 return (ir_node **)&(get_irn_in(node)[1]);
482 get_Block_n_cfgpreds (ir_node *node) {
483 assert ((node->op == op_Block));
484 return (get_irn_arity(node));
488 get_Block_cfgpred (ir_node *node, int pos) {
489 assert (node->op == op_Block);
491 if (-1 > pos || get_irn_arity(node) <= pos) {
492 dump_ir_block_graph(current_ir_graph);
493 printf("pos: %d, arity: %d ", pos, get_irn_arity(node));
496 assert(node); assert(-1 <= pos && pos < get_irn_arity(node));
497 return get_irn_n(node, pos);
501 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
502 assert (node->op == op_Block);
503 set_irn_n(node, pos, pred);
507 get_Block_matured (ir_node *node) {
508 assert (node->op == op_Block);
509 return node->attr.block.matured;
513 set_Block_matured (ir_node *node, bool matured) {
514 assert (node->op == op_Block);
515 node->attr.block.matured = matured;
518 get_Block_block_visited (ir_node *node) {
519 assert (node->op == op_Block);
520 return node->attr.block.block_visited;
524 set_Block_block_visited (ir_node *node, unsigned long visit) {
525 assert (node->op == op_Block);
526 node->attr.block.block_visited = visit;
529 /* For this current_ir_graph must be set. */
531 mark_Block_block_visited (ir_node *node) {
532 assert (node->op == op_Block);
533 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
537 Block_not_block_visited(ir_node *node) {
538 assert (node->op == op_Block);
539 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
543 get_Block_graph_arr (ir_node *node, int pos) {
544 assert (node->op == op_Block);
545 return node->attr.block.graph_arr[pos+1];
549 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
550 assert (node->op == op_Block);
551 node->attr.block.graph_arr[pos+1] = value;
554 /* handler handling for Blocks */
556 set_Block_handler (ir_node *block, ir_node *handler) {
557 assert ((block->op == op_Block));
558 assert ((handler->op == op_Block));
559 block->attr.block.handler_entry = handler;
563 get_Block_handler (ir_node *block) {
564 assert ((block->op == op_Block));
565 return (block->attr.block.handler_entry);
568 /* handler handling for Nodes */
570 set_Node_handler (ir_node *node, ir_node *handler) {
571 set_Block_handler (get_nodes_Block (node), handler);
575 get_Node_handler (ir_node *node) {
576 return (get_Block_handler (get_nodes_Block (node)));
579 /* exc_t handling for Blocks */
580 void set_Block_exc (ir_node *block, exc_t exc) {
581 assert ((block->op == op_Block));
582 block->attr.block.exc = exc;
585 exc_t get_Block_exc (ir_node *block) {
586 assert ((block->op == op_Block));
588 return (block->attr.block.exc);
591 /* exc_t handling for Nodes */
592 void set_Node_exc (ir_node *node, exc_t exc) {
593 set_Block_exc (get_nodes_Block (node), exc);
596 exc_t get_Node_exc (ir_node *node) {
597 return (get_Block_exc (get_nodes_Block (node)));
600 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
601 assert(node->op == op_Block);
602 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
603 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
604 node->attr.block.in_cg[0] = NULL;
605 node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
607 /* Fix backedge array. fix_backedges operates depending on
608 interprocedural_view. */
609 bool ipv = interprocedural_view;
610 interprocedural_view = true;
611 fix_backedges(current_ir_graph->obst, node);
612 interprocedural_view = ipv;
615 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
618 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
619 assert(node->op == op_Block &&
620 node->attr.block.in_cg &&
621 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
622 node->attr.block.in_cg[pos + 1] = pred;
625 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
626 assert(node->op == op_Block);
627 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
630 int get_Block_cg_n_cfgpreds(ir_node * node) {
631 assert(node->op == op_Block);
632 return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
635 ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
636 assert(node->op == op_Block && node->attr.block.in_cg);
637 return node->attr.block.in_cg[pos + 1];
640 void remove_Block_cg_cfgpred_arr(ir_node * node) {
641 assert(node->op == op_Block);
642 node->attr.block.in_cg = NULL;
645 /* Start references the irg it is in. */
647 get_Start_irg(ir_node *node) {
648 assert(node->op == op_Start);
649 return node->attr.start.irg;
653 set_Start_irg(ir_node *node, ir_graph *irg) {
654 assert(node->op == op_Start);
655 assert(is_ir_graph(irg));
656 node->attr.start.irg = irg;
660 get_End_n_keepalives(ir_node *end) {
661 assert (end->op == op_End);
662 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
666 get_End_keepalive(ir_node *end, int pos) {
667 assert (end->op == op_End);
668 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
672 add_End_keepalive (ir_node *end, ir_node *ka) {
673 assert (end->op == op_End);
674 ARR_APP1 (ir_node *, end->in, ka);
678 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
679 assert (end->op == op_End);
680 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
684 free_End (ir_node *end) {
685 assert (end->op == op_End);
686 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
687 end->in = NULL; /* @@@ make sure we get an error if we use the
688 in array afterwards ... */
691 ir_graph *get_EndReg_irg (const ir_node *end) {
692 assert (end->op == op_EndReg);
693 return end->attr.end.irg;
696 ir_graph *get_EndExcept_irg (const ir_node *end) {
697 assert (end->op == op_EndReg);
698 return end->attr.end.irg;
702 > Implementing the case construct (which is where the constant Proj node is
703 > important) involves far more than simply determining the constant values.
704 > We could argue that this is more properly a function of the translator from
705 > Firm to the target machine. That could be done if there was some way of
706 > projecting "default" out of the Cond node.
707 I know it's complicated.
708 Basically there are two proglems:
709 - determining the gaps between the projs
710 - determining the biggest case constant to konw the proj number for
712 I see several solutions:
713 1. Introduce a ProjDefault node. Solves both problems.
714 This means to extend all optimizations executed during construction.
715 2. Give the Cond node for switch two flavors:
716 a) there are no gaps in the projs (existing flavor)
717 b) gaps may exist, default proj is still the Proj with the largest
718 projection number. This covers also the gaps.
719 3. Fix the semantic of the Cond to that of 2b)
721 Solution 2 seems to be the best:
722 Computing the gaps in the Firm representation is not too hard, i.e.,
723 libfirm can implement a routine that transforms betweeen the two
724 flavours. This is also possible for 1) but 2) does not require to
725 change any existing optimization.
726 Further it should be far simpler to determine the biggest constant than
728 I don't want to choose 3) as 2a) seems to have advantages for
729 dataflow analysis and 3) does not allow to convert the representation to
733 get_Cond_selector (ir_node *node) {
734 assert (node->op == op_Cond);
735 return get_irn_n(node, 0);
739 set_Cond_selector (ir_node *node, ir_node *selector) {
740 assert (node->op == op_Cond);
741 set_irn_n(node, 0, selector);
745 get_Cond_kind (ir_node *node) {
746 assert (node->op == op_Cond);
747 return node->attr.c.kind;
751 set_Cond_kind (ir_node *node, cond_kind kind) {
752 assert (node->op == op_Cond);
753 node->attr.c.kind = kind;
757 get_Return_mem (ir_node *node) {
758 assert (node->op == op_Return);
759 return get_irn_n(node, 0);
763 set_Return_mem (ir_node *node, ir_node *mem) {
764 assert (node->op == op_Return);
765 set_irn_n(node, 0, mem);
769 get_Return_n_ress (ir_node *node) {
770 assert (node->op == op_Return);
771 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
775 get_Return_res_arr (ir_node *node)
777 assert ((node->op == op_Return));
778 if (get_Return_n_ress(node) > 0)
779 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
786 set_Return_n_res (ir_node *node, int results) {
787 assert (node->op == op_Return);
792 get_Return_res (ir_node *node, int pos) {
793 assert (node->op == op_Return);
794 assert (get_Return_n_ress(node) > pos);
795 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
799 set_Return_res (ir_node *node, int pos, ir_node *res){
800 assert (node->op == op_Return);
801 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
805 get_Raise_mem (ir_node *node) {
806 assert (node->op == op_Raise);
807 return get_irn_n(node, 0);
811 set_Raise_mem (ir_node *node, ir_node *mem) {
812 assert (node->op == op_Raise);
813 set_irn_n(node, 0, mem);
817 get_Raise_exo_ptr (ir_node *node) {
818 assert (node->op == op_Raise);
819 return get_irn_n(node, 1);
823 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
824 assert (node->op == op_Raise);
825 set_irn_n(node, 1, exo_ptr);
828 INLINE tarval *get_Const_tarval (ir_node *node) {
829 assert (node->op == op_Const);
830 return get_irn_const_attr(node);
834 set_Const_tarval (ir_node *node, tarval *con) {
835 assert (node->op == op_Const);
836 node->attr.con = con;
840 get_SymConst_kind (const ir_node *node) {
841 assert (node->op == op_SymConst);
842 return node->attr.i.num;
846 set_SymConst_kind (ir_node *node, symconst_kind num) {
847 assert (node->op == op_SymConst);
848 node->attr.i.num = num;
852 get_SymConst_type (ir_node *node) {
853 assert ( (node->op == op_SymConst)
854 && ( get_SymConst_kind(node) == type_tag
855 || get_SymConst_kind(node) == size));
856 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
860 set_SymConst_type (ir_node *node, type *tp) {
861 assert ( (node->op == op_SymConst)
862 && ( get_SymConst_kind(node) == type_tag
863 || get_SymConst_kind(node) == size));
864 node->attr.i.tori.typ = tp;
868 get_SymConst_ptrinfo (ir_node *node) {
869 assert ( (node->op == op_SymConst)
870 && (get_SymConst_kind(node) == linkage_ptr_info));
871 return node->attr.i.tori.ptrinfo;
875 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
876 assert ( (node->op == op_SymConst)
877 && (get_SymConst_kind(node) == linkage_ptr_info));
878 node->attr.i.tori.ptrinfo = ptrinfo;
882 get_SymConst_type_or_id (ir_node *node) {
883 assert (node->op == op_SymConst);
884 return &(node->attr.i.tori);
888 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
889 assert (node->op == op_SymConst);
890 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
894 get_Sel_mem (ir_node *node) {
895 assert (node->op == op_Sel);
896 return get_irn_n(node, 0);
900 set_Sel_mem (ir_node *node, ir_node *mem) {
901 assert (node->op == op_Sel);
902 set_irn_n(node, 0, mem);
906 get_Sel_ptr (ir_node *node) {
907 assert (node->op == op_Sel);
908 return get_irn_n(node, 1);
912 set_Sel_ptr (ir_node *node, ir_node *ptr) {
913 assert (node->op == op_Sel);
914 set_irn_n(node, 1, ptr);
918 get_Sel_n_indexs (ir_node *node) {
919 assert (node->op == op_Sel);
920 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
924 get_Sel_index_arr (ir_node *node)
926 assert ((node->op == op_Sel));
927 if (get_Sel_n_indexs(node) > 0)
928 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
934 get_Sel_index (ir_node *node, int pos) {
935 assert (node->op == op_Sel);
936 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
940 set_Sel_index (ir_node *node, int pos, ir_node *index) {
941 assert (node->op == op_Sel);
942 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
946 get_Sel_entity (ir_node *node) {
947 assert (node->op == op_Sel);
948 return node->attr.s.ent;
952 set_Sel_entity (ir_node *node, entity *ent) {
953 assert (node->op == op_Sel);
954 node->attr.s.ent = ent;
958 get_InstOf_ent (ir_node *node) {
959 assert (node->op = op_InstOf);
960 return (node->attr.io.ent);
964 set_InstOf_ent (ir_node *node, type *ent) {
965 assert (node->op = op_InstOf);
966 node->attr.io.ent = ent;
970 get_InstOf_store (ir_node *node) {
971 assert (node->op = op_InstOf);
972 return (get_irn_n (node, 0));
976 set_InstOf_store (ir_node *node, ir_node *obj) {
977 assert (node->op = op_InstOf);
978 set_irn_n (node, 0, obj);
982 get_InstOf_obj (ir_node *node) {
983 assert (node->op = op_InstOf);
984 return (get_irn_n (node, 1));
988 set_InstOf_obj (ir_node *node, ir_node *obj) {
989 assert (node->op = op_InstOf);
990 set_irn_n (node, 1, obj);
994 /* For unary and binary arithmetic operations the access to the
995 operands can be factored out. Left is the first, right the
996 second arithmetic value as listed in tech report 0999-33.
997 unops are: Minus, Abs, Not, Conv, Cast
998 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
999 Shr, Shrs, Rotate, Cmp */
1003 get_Call_mem (ir_node *node) {
1004 assert (node->op == op_Call);
1005 return get_irn_n(node, 0);
1009 set_Call_mem (ir_node *node, ir_node *mem) {
1010 assert (node->op == op_Call);
1011 set_irn_n(node, 0, mem);
1015 get_Call_ptr (ir_node *node) {
1016 assert (node->op == op_Call);
1017 return get_irn_n(node, 1);
1021 set_Call_ptr (ir_node *node, ir_node *ptr) {
1022 assert (node->op == op_Call);
1023 set_irn_n(node, 1, ptr);
1027 get_Call_param_arr (ir_node *node) {
1028 assert (node->op == op_Call);
1029 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1033 get_Call_n_params (ir_node *node) {
1034 assert (node->op == op_Call);
1035 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1039 get_Call_arity (ir_node *node) {
1040 assert (node->op == op_Call);
1041 return get_Call_n_params(node);
1045 set_Call_arity (ir_node *node, ir_node *arity) {
1046 assert (node->op == op_Call);
1051 get_Call_param (ir_node *node, int pos) {
1052 assert (node->op == op_Call);
1053 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1057 set_Call_param (ir_node *node, int pos, ir_node *param) {
1058 assert (node->op == op_Call);
1059 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1063 get_Call_type (ir_node *node) {
1064 assert (node->op == op_Call);
1065 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1069 set_Call_type (ir_node *node, type *tp) {
1070 assert (node->op == op_Call);
1071 assert (is_method_type(tp));
1072 node->attr.call.cld_tp = tp;
1075 int get_Call_n_callees(ir_node * node) {
1076 assert(node->op == op_Call && node->attr.call.callee_arr);
1077 return ARR_LEN(node->attr.call.callee_arr);
1080 entity * get_Call_callee(ir_node * node, int pos) {
1081 assert(node->op == op_Call && node->attr.call.callee_arr);
1082 return node->attr.call.callee_arr[pos];
1085 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1086 assert(node->op == op_Call);
1087 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1088 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1090 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1093 void remove_Call_callee_arr(ir_node * node) {
1094 assert(node->op == op_Call);
1095 node->attr.call.callee_arr = NULL;
1098 ir_node * get_CallBegin_ptr (ir_node *node) {
1099 assert(node->op == op_CallBegin);
1100 return get_irn_n(node, 0);
1102 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1103 assert(node->op == op_CallBegin);
1104 set_irn_n(node, 0, ptr);
1106 ir_graph * get_CallBegin_irg (ir_node *node) {
1107 assert(node->op == op_CallBegin);
1108 return node->attr.callbegin.irg;
1110 ir_node * get_CallBegin_call (ir_node *node) {
1111 assert(node->op == op_CallBegin);
1112 return node->attr.callbegin.call;
1114 void set_CallBegin_call (ir_node *node, ir_node *call) {
1115 assert(node->op == op_CallBegin);
1116 node->attr.callbegin.call = call;
1120 get_Add_left (ir_node *node) {
1121 assert (node->op == op_Add);
1122 return get_irn_n(node, 0);
1126 set_Add_left (ir_node *node, ir_node *left) {
1127 assert (node->op == op_Add);
1128 set_irn_n(node, 0, left);
1132 get_Add_right (ir_node *node) {
1133 assert (node->op == op_Add);
1134 return get_irn_n(node, 1);
1138 set_Add_right (ir_node *node, ir_node *right) {
1139 assert (node->op == op_Add);
1140 set_irn_n(node, 1, right);
1144 get_Sub_left (ir_node *node) {
1145 assert (node->op == op_Sub);
1146 return get_irn_n(node, 0);
1150 set_Sub_left (ir_node *node, ir_node *left) {
1151 assert (node->op == op_Sub);
1152 set_irn_n(node, 0, left);
1156 get_Sub_right (ir_node *node) {
1157 assert (node->op == op_Sub);
1158 return get_irn_n(node, 1);
1162 set_Sub_right (ir_node *node, ir_node *right) {
1163 assert (node->op == op_Sub);
1164 set_irn_n(node, 1, right);
1169 get_Minus_op (ir_node *node) {
1170 assert (node->op == op_Minus);
1171 return get_irn_n(node, 0);
1175 set_Minus_op (ir_node *node, ir_node *op) {
1176 assert (node->op == op_Minus);
1177 set_irn_n(node, 0, op);
1182 get_Mul_left (ir_node *node) {
1183 assert (node->op == op_Mul);
1184 return get_irn_n(node, 0);
1188 set_Mul_left (ir_node *node, ir_node *left) {
1189 assert (node->op == op_Mul);
1190 set_irn_n(node, 0, left);
1194 get_Mul_right (ir_node *node) {
1195 assert (node->op == op_Mul);
1196 return get_irn_n(node, 1);
1200 set_Mul_right (ir_node *node, ir_node *right) {
1201 assert (node->op == op_Mul);
1202 set_irn_n(node, 1, right);
1206 get_Quot_left (ir_node *node) {
1207 assert (node->op == op_Quot);
1208 return get_irn_n(node, 1);
1212 set_Quot_left (ir_node *node, ir_node *left) {
1213 assert (node->op == op_Quot);
1214 set_irn_n(node, 1, left);
1218 get_Quot_right (ir_node *node) {
1219 assert (node->op == op_Quot);
1220 return get_irn_n(node, 2);
1224 set_Quot_right (ir_node *node, ir_node *right) {
1225 assert (node->op == op_Quot);
1226 set_irn_n(node, 2, right);
1230 get_Quot_mem (ir_node *node) {
1231 assert (node->op == op_Quot);
1232 return get_irn_n(node, 0);
1236 set_Quot_mem (ir_node *node, ir_node *mem) {
1237 assert (node->op == op_Quot);
1238 set_irn_n(node, 0, mem);
1242 get_DivMod_left (ir_node *node) {
1243 assert (node->op == op_DivMod);
1244 return get_irn_n(node, 1);
1248 set_DivMod_left (ir_node *node, ir_node *left) {
1249 assert (node->op == op_DivMod);
1250 set_irn_n(node, 1, left);
1254 get_DivMod_right (ir_node *node) {
1255 assert (node->op == op_DivMod);
1256 return get_irn_n(node, 2);
1260 set_DivMod_right (ir_node *node, ir_node *right) {
1261 assert (node->op == op_DivMod);
1262 set_irn_n(node, 2, right);
1266 get_DivMod_mem (ir_node *node) {
1267 assert (node->op == op_DivMod);
1268 return get_irn_n(node, 0);
1272 set_DivMod_mem (ir_node *node, ir_node *mem) {
1273 assert (node->op == op_DivMod);
1274 set_irn_n(node, 0, mem);
1278 get_Div_left (ir_node *node) {
1279 assert (node->op == op_Div);
1280 return get_irn_n(node, 1);
1284 set_Div_left (ir_node *node, ir_node *left) {
1285 assert (node->op == op_Div);
1286 set_irn_n(node, 1, left);
1290 get_Div_right (ir_node *node) {
1291 assert (node->op == op_Div);
1292 return get_irn_n(node, 2);
1296 set_Div_right (ir_node *node, ir_node *right) {
1297 assert (node->op == op_Div);
1298 set_irn_n(node, 2, right);
1302 get_Div_mem (ir_node *node) {
1303 assert (node->op == op_Div);
1304 return get_irn_n(node, 0);
1308 set_Div_mem (ir_node *node, ir_node *mem) {
1309 assert (node->op == op_Div);
1310 set_irn_n(node, 0, mem);
1314 get_Mod_left (ir_node *node) {
1315 assert (node->op == op_Mod);
1316 return get_irn_n(node, 1);
1320 set_Mod_left (ir_node *node, ir_node *left) {
1321 assert (node->op == op_Mod);
1322 set_irn_n(node, 1, left);
1326 get_Mod_right (ir_node *node) {
1327 assert (node->op == op_Mod);
1328 return get_irn_n(node, 2);
1332 set_Mod_right (ir_node *node, ir_node *right) {
1333 assert (node->op == op_Mod);
1334 set_irn_n(node, 2, right);
1338 get_Mod_mem (ir_node *node) {
1339 assert (node->op == op_Mod);
1340 return get_irn_n(node, 0);
1344 set_Mod_mem (ir_node *node, ir_node *mem) {
1345 assert (node->op == op_Mod);
1346 set_irn_n(node, 0, mem);
1350 get_Abs_op (ir_node *node) {
1351 assert (node->op == op_Abs);
1352 return get_irn_n(node, 0);
1356 set_Abs_op (ir_node *node, ir_node *op) {
1357 assert (node->op == op_Abs);
1358 set_irn_n(node, 0, op);
1362 get_And_left (ir_node *node) {
1363 assert (node->op == op_And);
1364 return get_irn_n(node, 0);
1368 set_And_left (ir_node *node, ir_node *left) {
1369 assert (node->op == op_And);
1370 set_irn_n(node, 0, left);
1374 get_And_right (ir_node *node) {
1375 assert (node->op == op_And);
1376 return get_irn_n(node, 1);
1380 set_And_right (ir_node *node, ir_node *right) {
1381 assert (node->op == op_And);
1382 set_irn_n(node, 1, right);
1386 get_Or_left (ir_node *node) {
1387 assert (node->op == op_Or);
1388 return get_irn_n(node, 0);
1392 set_Or_left (ir_node *node, ir_node *left) {
1393 assert (node->op == op_Or);
1394 set_irn_n(node, 0, left);
1398 get_Or_right (ir_node *node) {
1399 assert (node->op == op_Or);
1400 return get_irn_n(node, 1);
1404 set_Or_right (ir_node *node, ir_node *right) {
1405 assert (node->op == op_Or);
1406 set_irn_n(node, 1, right);
1410 get_Eor_left (ir_node *node) {
1411 assert (node->op == op_Eor);
1412 return get_irn_n(node, 0);
1416 set_Eor_left (ir_node *node, ir_node *left) {
1417 assert (node->op == op_Eor);
1418 set_irn_n(node, 0, left);
1422 get_Eor_right (ir_node *node) {
1423 assert (node->op == op_Eor);
1424 return get_irn_n(node, 1);
1428 set_Eor_right (ir_node *node, ir_node *right) {
1429 assert (node->op == op_Eor);
1430 set_irn_n(node, 1, right);
1435 get_Not_op (ir_node *node) {
1436 assert (node->op == op_Not);
1437 return get_irn_n(node, 0);
1441 set_Not_op (ir_node *node, ir_node *op) {
1442 assert (node->op == op_Not);
1443 set_irn_n(node, 0, op);
1448 get_Shl_left (ir_node *node) {
1449 assert (node->op == op_Shl);
1450 return get_irn_n(node, 0);
1454 set_Shl_left (ir_node *node, ir_node *left) {
1455 assert (node->op == op_Shl);
1456 set_irn_n(node, 0, left);
1460 get_Shl_right (ir_node *node) {
1461 assert (node->op == op_Shl);
1462 return get_irn_n(node, 1);
1466 set_Shl_right (ir_node *node, ir_node *right) {
1467 assert (node->op == op_Shl);
1468 set_irn_n(node, 1, right);
1472 get_Shr_left (ir_node *node) {
1473 assert (node->op == op_Shr);
1474 return get_irn_n(node, 0);
1478 set_Shr_left (ir_node *node, ir_node *left) {
1479 assert (node->op == op_Shr);
1480 set_irn_n(node, 0, left);
1484 get_Shr_right (ir_node *node) {
1485 assert (node->op == op_Shr);
1486 return get_irn_n(node, 1);
1490 set_Shr_right (ir_node *node, ir_node *right) {
1491 assert (node->op == op_Shr);
1492 set_irn_n(node, 1, right);
1496 get_Shrs_left (ir_node *node) {
1497 assert (node->op == op_Shrs);
1498 return get_irn_n(node, 0);
1502 set_Shrs_left (ir_node *node, ir_node *left) {
1503 assert (node->op == op_Shrs);
1504 set_irn_n(node, 0, left);
1508 get_Shrs_right (ir_node *node) {
1509 assert (node->op == op_Shrs);
1510 return get_irn_n(node, 1);
1514 set_Shrs_right (ir_node *node, ir_node *right) {
1515 assert (node->op == op_Shrs);
1516 set_irn_n(node, 1, right);
1520 get_Rot_left (ir_node *node) {
1521 assert (node->op == op_Rot);
1522 return get_irn_n(node, 0);
1526 set_Rot_left (ir_node *node, ir_node *left) {
1527 assert (node->op == op_Rot);
1528 set_irn_n(node, 0, left);
1532 get_Rot_right (ir_node *node) {
1533 assert (node->op == op_Rot);
1534 return get_irn_n(node, 1);
1538 set_Rot_right (ir_node *node, ir_node *right) {
1539 assert (node->op == op_Rot);
1540 set_irn_n(node, 1, right);
1544 get_Cmp_left (ir_node *node) {
1545 assert (node->op == op_Cmp);
1546 return get_irn_n(node, 0);
1550 set_Cmp_left (ir_node *node, ir_node *left) {
1551 assert (node->op == op_Cmp);
1552 set_irn_n(node, 0, left);
1556 get_Cmp_right (ir_node *node) {
1557 assert (node->op == op_Cmp);
1558 return get_irn_n(node, 1);
1562 set_Cmp_right (ir_node *node, ir_node *right) {
1563 assert (node->op == op_Cmp);
1564 set_irn_n(node, 1, right);
1568 get_Conv_op (ir_node *node) {
1569 assert (node->op == op_Conv);
1570 return get_irn_n(node, 0);
1574 set_Conv_op (ir_node *node, ir_node *op) {
1575 assert (node->op == op_Conv);
1576 set_irn_n(node, 0, op);
1580 get_Cast_op (ir_node *node) {
1581 assert (node->op == op_Cast);
1582 return get_irn_n(node, 0);
1586 set_Cast_op (ir_node *node, ir_node *op) {
1587 assert (node->op == op_Cast);
1588 set_irn_n(node, 0, op);
1592 get_Cast_type (ir_node *node) {
1593 assert (node->op == op_Cast);
1594 return node->attr.cast.totype;
1598 set_Cast_type (ir_node *node, type *to_tp) {
1599 assert (node->op == op_Cast);
1600 node->attr.cast.totype = to_tp;
1604 is_unop (ir_node *node) {
1605 return ( node->op == op_Minus ||
1606 node->op == op_Abs ||
1607 node->op == op_Not ||
1608 node->op == op_Conv ||
1609 node->op == op_Cast );
1613 get_unop_op (ir_node *node) {
1614 assert (is_unop(node));
1615 switch (get_irn_opcode (node)) {
1616 case iro_Minus: return get_Minus_op(node); break;
1617 case iro_Abs: return get_Abs_op(node); break;
1618 case iro_Not: return get_Not_op(node); break;
1619 case iro_Conv: return get_Conv_op(node); break;
1620 case iro_Cast: return get_Cast_op(node); break;
1621 default: return NULL;
1626 set_unop_op (ir_node *node, ir_node *op) {
1627 assert (is_unop(node));
1628 switch (get_irn_opcode (node)) {
1629 case iro_Minus: set_Minus_op(node, op); break;
1630 case iro_Abs: set_Abs_op(node, op); break;
1631 case iro_Not: set_Not_op(node, op); break;
1632 case iro_Conv: set_Conv_op(node, op); break;
1633 case iro_Cast: set_Cast_op(node, op); break;
1640 is_binop (ir_node *node) {
1641 return (node->op == op_Add ||
1642 node->op == op_Sub ||
1643 node->op == op_Mul ||
1644 node->op == op_Quot ||
1645 node->op == op_DivMod ||
1646 node->op == op_Div ||
1647 node->op == op_Mod ||
1648 node->op == op_And ||
1649 node->op == op_Or ||
1650 node->op == op_Eor ||
1651 node->op == op_Shl ||
1652 node->op == op_Shr ||
1653 node->op == op_Shrs ||
1654 node->op == op_Rot ||
1655 node->op == op_Cmp );
1659 get_binop_left (ir_node *node) {
1660 assert (node->op == op_Add ||
1661 node->op == op_Sub ||
1662 node->op == op_Mul ||
1663 node->op == op_Quot ||
1664 node->op == op_DivMod ||
1665 node->op == op_Div ||
1666 node->op == op_Mod ||
1667 node->op == op_And ||
1668 node->op == op_Or ||
1669 node->op == op_Eor ||
1670 node->op == op_Shl ||
1671 node->op == op_Shr ||
1672 node->op == op_Shrs ||
1673 node->op == op_Rot ||
1674 node->op == op_Cmp );
1676 switch (get_irn_opcode (node)) {
1677 case iro_Add : return get_Add_left(node); break;
1678 case iro_Sub : return get_Sub_left(node); break;
1679 case iro_Mul : return get_Mul_left(node); break;
1680 case iro_Quot : return get_Quot_left(node); break;
1681 case iro_DivMod: return get_DivMod_left(node); break;
1682 case iro_Div : return get_Div_left(node); break;
1683 case iro_Mod : return get_Mod_left(node); break;
1684 case iro_And : return get_And_left(node); break;
1685 case iro_Or : return get_Or_left(node); break;
1686 case iro_Eor : return get_Eor_left(node); break;
1687 case iro_Shl : return get_Shl_left(node); break;
1688 case iro_Shr : return get_Shr_left(node); break;
1689 case iro_Shrs : return get_Shrs_left(node); break;
1690 case iro_Rot : return get_Rot_left(node); break;
1691 case iro_Cmp : return get_Cmp_left(node); break;
1692 default: return NULL;
1697 set_binop_left (ir_node *node, ir_node *left) {
1698 assert (node->op == op_Add ||
1699 node->op == op_Sub ||
1700 node->op == op_Mul ||
1701 node->op == op_Quot ||
1702 node->op == op_DivMod ||
1703 node->op == op_Div ||
1704 node->op == op_Mod ||
1705 node->op == op_And ||
1706 node->op == op_Or ||
1707 node->op == op_Eor ||
1708 node->op == op_Shl ||
1709 node->op == op_Shr ||
1710 node->op == op_Shrs ||
1711 node->op == op_Rot ||
1712 node->op == op_Cmp );
1714 switch (get_irn_opcode (node)) {
1715 case iro_Add : set_Add_left(node, left); break;
1716 case iro_Sub : set_Sub_left(node, left); break;
1717 case iro_Mul : set_Mul_left(node, left); break;
1718 case iro_Quot : set_Quot_left(node, left); break;
1719 case iro_DivMod: set_DivMod_left(node, left); break;
1720 case iro_Div : set_Div_left(node, left); break;
1721 case iro_Mod : set_Mod_left(node, left); break;
1722 case iro_And : set_And_left(node, left); break;
1723 case iro_Or : set_Or_left(node, left); break;
1724 case iro_Eor : set_Eor_left(node, left); break;
1725 case iro_Shl : set_Shl_left(node, left); break;
1726 case iro_Shr : set_Shr_left(node, left); break;
1727 case iro_Shrs : set_Shrs_left(node, left); break;
1728 case iro_Rot : set_Rot_left(node, left); break;
1729 case iro_Cmp : set_Cmp_left(node, left); break;
1735 get_binop_right (ir_node *node) {
1736 assert (node->op == op_Add ||
1737 node->op == op_Sub ||
1738 node->op == op_Mul ||
1739 node->op == op_Quot ||
1740 node->op == op_DivMod ||
1741 node->op == op_Div ||
1742 node->op == op_Mod ||
1743 node->op == op_And ||
1744 node->op == op_Or ||
1745 node->op == op_Eor ||
1746 node->op == op_Shl ||
1747 node->op == op_Shr ||
1748 node->op == op_Shrs ||
1749 node->op == op_Rot ||
1750 node->op == op_Cmp );
1752 switch (get_irn_opcode (node)) {
1753 case iro_Add : return get_Add_right(node); break;
1754 case iro_Sub : return get_Sub_right(node); break;
1755 case iro_Mul : return get_Mul_right(node); break;
1756 case iro_Quot : return get_Quot_right(node); break;
1757 case iro_DivMod: return get_DivMod_right(node); break;
1758 case iro_Div : return get_Div_right(node); break;
1759 case iro_Mod : return get_Mod_right(node); break;
1760 case iro_And : return get_And_right(node); break;
1761 case iro_Or : return get_Or_right(node); break;
1762 case iro_Eor : return get_Eor_right(node); break;
1763 case iro_Shl : return get_Shl_right(node); break;
1764 case iro_Shr : return get_Shr_right(node); break;
1765 case iro_Shrs : return get_Shrs_right(node); break;
1766 case iro_Rot : return get_Rot_right(node); break;
1767 case iro_Cmp : return get_Cmp_right(node); break;
1768 default: return NULL;
1773 set_binop_right (ir_node *node, ir_node *right) {
1774 assert (node->op == op_Add ||
1775 node->op == op_Sub ||
1776 node->op == op_Mul ||
1777 node->op == op_Quot ||
1778 node->op == op_DivMod ||
1779 node->op == op_Div ||
1780 node->op == op_Mod ||
1781 node->op == op_And ||
1782 node->op == op_Or ||
1783 node->op == op_Eor ||
1784 node->op == op_Shl ||
1785 node->op == op_Shr ||
1786 node->op == op_Shrs ||
1787 node->op == op_Rot ||
1788 node->op == op_Cmp );
1790 switch (get_irn_opcode (node)) {
1791 case iro_Add : set_Add_right(node, right); break;
1792 case iro_Sub : set_Sub_right(node, right); break;
1793 case iro_Mul : set_Mul_right(node, right); break;
1794 case iro_Quot : set_Quot_right(node, right); break;
1795 case iro_DivMod: set_DivMod_right(node, right); break;
1796 case iro_Div : set_Div_right(node, right); break;
1797 case iro_Mod : set_Mod_right(node, right); break;
1798 case iro_And : set_And_right(node, right); break;
1799 case iro_Or : set_Or_right(node, right); break;
1800 case iro_Eor : set_Eor_right(node, right); break;
1801 case iro_Shl : set_Shl_right(node, right); break;
1802 case iro_Shr : set_Shr_right(node, right); break;
1803 case iro_Shrs : set_Shrs_right(node, right); break;
1804 case iro_Rot : set_Rot_right(node, right); break;
1805 case iro_Cmp : set_Cmp_right(node, right); break;
1812 get_Phi_preds_arr (ir_node *node) {
1813 assert (node->op == op_Phi);
1814 return (ir_node **)&(get_irn_in(node)[1]);
1818 get_Phi_n_preds (ir_node *node) {
1819 assert (node->op == op_Phi);
1820 return (get_irn_arity(node));
1824 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1825 assert (node->op == op_Phi);
1830 get_Phi_pred (ir_node *node, int pos) {
1831 assert (node->op == op_Phi);
1832 return get_irn_n(node, pos);
1836 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1837 assert (node->op == op_Phi);
1838 set_irn_n(node, pos, pred);
1842 get_Load_mem (ir_node *node) {
1843 assert (node->op == op_Load);
1844 return get_irn_n(node, 0);
1848 set_Load_mem (ir_node *node, ir_node *mem) {
1849 assert (node->op == op_Load);
1850 set_irn_n(node, 0, mem);
1854 get_Load_ptr (ir_node *node) {
1855 assert (node->op == op_Load);
1856 return get_irn_n(node, 1);
1860 set_Load_ptr (ir_node *node, ir_node *ptr) {
1861 assert (node->op == op_Load);
1862 set_irn_n(node, 1, ptr);
1867 get_Store_mem (ir_node *node) {
1868 assert (node->op == op_Store);
1869 return get_irn_n(node, 0);
1873 set_Store_mem (ir_node *node, ir_node *mem) {
1874 assert (node->op == op_Store);
1875 set_irn_n(node, 0, mem);
1879 get_Store_ptr (ir_node *node) {
1880 assert (node->op == op_Store);
1881 return get_irn_n(node, 1);
1885 set_Store_ptr (ir_node *node, ir_node *ptr) {
1886 assert (node->op == op_Store);
1887 set_irn_n(node, 1, ptr);
1891 get_Store_value (ir_node *node) {
1892 assert (node->op == op_Store);
1893 return get_irn_n(node, 2);
1897 set_Store_value (ir_node *node, ir_node *value) {
1898 assert (node->op == op_Store);
1899 set_irn_n(node, 2, value);
1903 get_Alloc_mem (ir_node *node) {
1904 assert (node->op == op_Alloc);
1905 return get_irn_n(node, 0);
1909 set_Alloc_mem (ir_node *node, ir_node *mem) {
1910 assert (node->op == op_Alloc);
1911 set_irn_n(node, 0, mem);
1915 get_Alloc_size (ir_node *node) {
1916 assert (node->op == op_Alloc);
1917 return get_irn_n(node, 1);
1921 set_Alloc_size (ir_node *node, ir_node *size) {
1922 assert (node->op == op_Alloc);
1923 set_irn_n(node, 1, size);
1927 get_Alloc_type (ir_node *node) {
1928 assert (node->op == op_Alloc);
1929 return node->attr.a.type = skip_tid(node->attr.a.type);
1933 set_Alloc_type (ir_node *node, type *tp) {
1934 assert (node->op == op_Alloc);
1935 node->attr.a.type = tp;
1939 get_Alloc_where (ir_node *node) {
1940 assert (node->op == op_Alloc);
1941 return node->attr.a.where;
1945 set_Alloc_where (ir_node *node, where_alloc where) {
1946 assert (node->op == op_Alloc);
1947 node->attr.a.where = where;
1952 get_Free_mem (ir_node *node) {
1953 assert (node->op == op_Free);
1954 return get_irn_n(node, 0);
1958 set_Free_mem (ir_node *node, ir_node *mem) {
1959 assert (node->op == op_Free);
1960 set_irn_n(node, 0, mem);
1964 get_Free_ptr (ir_node *node) {
1965 assert (node->op == op_Free);
1966 return get_irn_n(node, 1);
1970 set_Free_ptr (ir_node *node, ir_node *ptr) {
1971 assert (node->op == op_Free);
1972 set_irn_n(node, 1, ptr);
1976 get_Free_size (ir_node *node) {
1977 assert (node->op == op_Free);
1978 return get_irn_n(node, 2);
1982 set_Free_size (ir_node *node, ir_node *size) {
1983 assert (node->op == op_Free);
1984 set_irn_n(node, 2, size);
1988 get_Free_type (ir_node *node) {
1989 assert (node->op == op_Free);
1990 return node->attr.f = skip_tid(node->attr.f);
1994 set_Free_type (ir_node *node, type *tp) {
1995 assert (node->op == op_Free);
2000 get_Sync_preds_arr (ir_node *node) {
2001 assert (node->op == op_Sync);
2002 return (ir_node **)&(get_irn_in(node)[1]);
2006 get_Sync_n_preds (ir_node *node) {
2007 assert (node->op == op_Sync);
2008 return (get_irn_arity(node));
2013 set_Sync_n_preds (ir_node *node, int n_preds) {
2014 assert (node->op == op_Sync);
2019 get_Sync_pred (ir_node *node, int pos) {
2020 assert (node->op == op_Sync);
2021 return get_irn_n(node, pos);
2025 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
2026 assert (node->op == op_Sync);
2027 set_irn_n(node, pos, pred);
2031 get_Proj_pred (ir_node *node) {
2032 assert (is_Proj(node));
2033 return get_irn_n(node, 0);
2037 set_Proj_pred (ir_node *node, ir_node *pred) {
2038 assert (is_Proj(node));
2039 set_irn_n(node, 0, pred);
2043 get_Proj_proj (ir_node *node) {
2044 assert (is_Proj(node));
2045 if (get_irn_opcode(node) == iro_Proj) {
2046 return node->attr.proj;
2048 assert(get_irn_opcode(node) == iro_Filter);
2049 return node->attr.filter.proj;
2054 set_Proj_proj (ir_node *node, long proj) {
2055 assert (node->op == op_Proj);
2056 node->attr.proj = proj;
2060 get_Tuple_preds_arr (ir_node *node) {
2061 assert (node->op == op_Tuple);
2062 return (ir_node **)&(get_irn_in(node)[1]);
2066 get_Tuple_n_preds (ir_node *node) {
2067 assert (node->op == op_Tuple);
2068 return (get_irn_arity(node));
2073 set_Tuple_n_preds (ir_node *node, int n_preds) {
2074 assert (node->op == op_Tuple);
2079 get_Tuple_pred (ir_node *node, int pos) {
2080 assert (node->op == op_Tuple);
2081 return get_irn_n(node, pos);
2085 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2086 assert (node->op == op_Tuple);
2087 set_irn_n(node, pos, pred);
2091 get_Id_pred (ir_node *node) {
2092 assert (node->op == op_Id);
2093 return get_irn_n(node, 0);
2097 set_Id_pred (ir_node *node, ir_node *pred) {
2098 assert (node->op == op_Id);
2099 set_irn_n(node, 0, pred);
2104 get_Filter_pred (ir_node *node) {
2105 assert(node->op == op_Filter);
2109 set_Filter_pred (ir_node *node, ir_node *pred) {
2110 assert(node->op == op_Filter);
2114 get_Filter_proj(ir_node *node) {
2115 assert(node->op == op_Filter);
2116 return node->attr.filter.proj;
2119 set_Filter_proj (ir_node *node, long proj) {
2120 assert(node->op == op_Filter);
2121 node->attr.filter.proj = proj;
2124 /* Don't use get_irn_arity, get_irn_n in implementation as access
2125 shall work independent of view!!! */
2126 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2127 assert(node->op == op_Filter);
2128 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2129 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2130 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2131 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2132 node->attr.filter.in_cg[0] = node->in[0];
2134 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2137 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2138 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2139 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2140 node->attr.filter.in_cg[pos + 1] = pred;
2142 int get_Filter_n_cg_preds(ir_node *node) {
2143 assert(node->op == op_Filter && node->attr.filter.in_cg);
2144 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2146 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2148 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2150 arity = ARR_LEN(node->attr.filter.in_cg);
2151 assert(pos < arity - 1);
2152 return node->attr.filter.in_cg[pos + 1];
2157 get_irn_irg(ir_node *node) {
2158 if (get_irn_op(node) == op_CallBegin) {
2159 return node->attr.callbegin.irg;
2160 } else if (get_irn_op(node) == op_EndReg ||
2161 get_irn_op(node) == op_EndExcept) {
2162 return node->attr.end.irg;
2163 } else if (get_irn_op(node) == op_Start) {
2164 return node->attr.start.irg;
2166 assert(0 && "no irg attr");
2172 /******************************************************************/
2173 /* Auxiliary routines */
2174 /******************************************************************/
2177 skip_Proj (ir_node *node) {
2178 /* don't assert node !!! */
2179 if (node && is_Proj(node)) {
2180 return get_Proj_pred(node);
2187 skip_Tuple (ir_node *node) {
2190 if (!get_opt_normalize()) return node;
2192 node = skip_nop(node);
2193 if (get_irn_op(node) == op_Proj) {
2194 pred = skip_nop(get_Proj_pred(node));
2195 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2196 pred = skip_nop(skip_Tuple(pred));
2197 if (get_irn_op(pred) == op_Tuple)
2198 return get_Tuple_pred(pred, get_Proj_proj(node));
2203 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2204 than any other approach, as Id chains are resolved and all point to the real node, or
2205 all id's are self loops. */
2207 skip_nop (ir_node *node) {
2208 /* don't assert node !!! */
2210 if (!get_opt_normalize()) return node;
2212 /* Don't use get_Id_pred: We get into an endless loop for
2213 self-referencing Ids. */
2214 if (node && (node->op == op_Id) && (node != node->in[0+1])) {
2215 ir_node *rem_pred = node->in[0+1];
2218 assert (get_irn_arity (node) > 0);
2220 node->in[0+1] = node;
2221 res = skip_nop(rem_pred);
2222 if (res->op == op_Id) /* self-loop */ return node;
2224 node->in[0+1] = res;
2232 skip_Id (ir_node *node) {
2233 return skip_nop(node);
2237 is_Bad (ir_node *node) {
2239 if ((node) && get_irn_opcode(node) == iro_Bad)
2245 is_no_Block (ir_node *node) {
2247 return (get_irn_opcode(node) != iro_Block);
2251 is_Block (ir_node *node) {
2253 return (get_irn_opcode(node) == iro_Block);
2257 is_Proj (const ir_node *node) {
2259 return node->op == op_Proj
2260 || (!interprocedural_view && node->op == op_Filter);
2263 /* Returns true if the operation manipulates control flow. */
2265 is_cfop(ir_node *node) {
2266 return is_cfopcode(get_irn_op(node));
2269 /* Returns true if the operation manipulates interprocedural control flow:
2270 CallBegin, EndReg, EndExcept */
2271 INLINE int is_ip_cfop(ir_node *node) {
2272 return is_ip_cfopcode(get_irn_op(node));
2275 ir_graph *get_ip_cfop_irg(ir_node *n) {
2276 switch (get_irn_opcode(n)) {
2278 return get_EndReg_irg(n);
2280 return get_EndExcept_irg(n);
2282 return get_CallBegin_irg(n);
2284 assert(is_ip_cfop(n));
2286 return NULL; /* should never be reached */
2289 /* Returns true if the operation can change the control flow because
2292 is_fragile_op(ir_node *node) {
2293 return ( (get_irn_opcode(node) == iro_Call)
2294 || (get_irn_opcode(node) == iro_Quot)
2295 || (get_irn_opcode(node) == iro_DivMod)
2296 || (get_irn_opcode(node) == iro_Div)
2297 || (get_irn_opcode(node) == iro_Mod)
2298 || (get_irn_opcode(node) == iro_Load)
2299 || (get_irn_opcode(node) == iro_Store)
2300 || (get_irn_opcode(node) == iro_Alloc)
2301 || (get_irn_opcode(node) == iro_Bad)
2302 || (get_irn_opcode(node) == iro_Unknown));
2306 /* Returns the memory operand of fragile operations. */
2307 ir_node *get_fragile_op_mem(ir_node *node) {
2308 assert(node && is_fragile_op(node));
2310 switch (get_irn_opcode (node)) {
2319 return get_irn_n(node, 0);
2324 assert(0 && "not reached");