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);
687 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
688 end->in = NULL; /* @@@ make sure we get an error if we use the
689 in array afterwards ... */
692 ir_graph *get_EndReg_irg (const ir_node *end) {
693 assert (end->op == op_EndReg);
694 return end->attr.end.irg;
697 ir_graph *get_EndExcept_irg (const ir_node *end) {
698 assert (end->op == op_EndReg);
699 return end->attr.end.irg;
703 > Implementing the case construct (which is where the constant Proj node is
704 > important) involves far more than simply determining the constant values.
705 > We could argue that this is more properly a function of the translator from
706 > Firm to the target machine. That could be done if there was some way of
707 > projecting "default" out of the Cond node.
708 I know it's complicated.
709 Basically there are two proglems:
710 - determining the gaps between the projs
711 - determining the biggest case constant to konw the proj number for
713 I see several solutions:
714 1. Introduce a ProjDefault node. Solves both problems.
715 This means to extend all optimizations executed during construction.
716 2. Give the Cond node for switch two flavors:
717 a) there are no gaps in the projs (existing flavor)
718 b) gaps may exist, default proj is still the Proj with the largest
719 projection number. This covers also the gaps.
720 3. Fix the semantic of the Cond to that of 2b)
722 Solution 2 seems to be the best:
723 Computing the gaps in the Firm representation is not too hard, i.e.,
724 libfirm can implement a routine that transforms betweeen the two
725 flavours. This is also possible for 1) but 2) does not require to
726 change any existing optimization.
727 Further it should be far simpler to determine the biggest constant than
729 I don't want to choose 3) as 2a) seems to have advantages for
730 dataflow analysis and 3) does not allow to convert the representation to
734 get_Cond_selector (ir_node *node) {
735 assert (node->op == op_Cond);
736 return get_irn_n(node, 0);
740 set_Cond_selector (ir_node *node, ir_node *selector) {
741 assert (node->op == op_Cond);
742 set_irn_n(node, 0, selector);
746 get_Cond_kind (ir_node *node) {
747 assert (node->op == op_Cond);
748 return node->attr.c.kind;
752 set_Cond_kind (ir_node *node, cond_kind kind) {
753 assert (node->op == op_Cond);
754 node->attr.c.kind = kind;
758 get_Return_mem (ir_node *node) {
759 assert (node->op == op_Return);
760 return get_irn_n(node, 0);
764 set_Return_mem (ir_node *node, ir_node *mem) {
765 assert (node->op == op_Return);
766 set_irn_n(node, 0, mem);
770 get_Return_n_ress (ir_node *node) {
771 assert (node->op == op_Return);
772 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
776 get_Return_res_arr (ir_node *node)
778 assert ((node->op == op_Return));
779 if (get_Return_n_ress(node) > 0)
780 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
787 set_Return_n_res (ir_node *node, int results) {
788 assert (node->op == op_Return);
793 get_Return_res (ir_node *node, int pos) {
794 assert (node->op == op_Return);
795 assert (get_Return_n_ress(node) > pos);
796 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
800 set_Return_res (ir_node *node, int pos, ir_node *res){
801 assert (node->op == op_Return);
802 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
806 get_Raise_mem (ir_node *node) {
807 assert (node->op == op_Raise);
808 return get_irn_n(node, 0);
812 set_Raise_mem (ir_node *node, ir_node *mem) {
813 assert (node->op == op_Raise);
814 set_irn_n(node, 0, mem);
818 get_Raise_exo_ptr (ir_node *node) {
819 assert (node->op == op_Raise);
820 return get_irn_n(node, 1);
824 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
825 assert (node->op == op_Raise);
826 set_irn_n(node, 1, exo_ptr);
829 INLINE tarval *get_Const_tarval (ir_node *node) {
830 assert (node->op == op_Const);
831 return node->attr.con.tv;
835 set_Const_tarval (ir_node *node, tarval *con) {
836 assert (node->op == op_Const);
837 node->attr.con.tv = con;
841 /* The source language type. Must be an atomic type. Mode of type must
842 be mode of node. For tarvals from entities type must be pointer to
845 get_Const_type (ir_node *node) {
846 assert (node->op == op_Const);
847 return node->attr.con.tp;
851 set_Const_type (ir_node *node, type *tp) {
852 assert (node->op == op_Const);
853 if (tp != unknown_type) {
854 assert (is_atomic_type(tp));
855 assert (get_type_mode(tp) == get_irn_mode(node));
856 assert (!tarval_is_entity(get_Const_tarval(node)) ||
857 (is_pointer_type(tp) &&
858 (get_pointer_points_to_type(tp) ==
859 get_entity_type(get_tarval_entity(get_Const_tarval(node))))));
862 node->attr.con.tp = tp;
867 get_SymConst_kind (const ir_node *node) {
868 assert (node->op == op_SymConst);
869 return node->attr.i.num;
873 set_SymConst_kind (ir_node *node, symconst_kind num) {
874 assert (node->op == op_SymConst);
875 node->attr.i.num = num;
879 get_SymConst_type (ir_node *node) {
880 assert ( (node->op == op_SymConst)
881 && ( get_SymConst_kind(node) == type_tag
882 || get_SymConst_kind(node) == size));
883 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
887 set_SymConst_type (ir_node *node, type *tp) {
888 assert ( (node->op == op_SymConst)
889 && ( get_SymConst_kind(node) == type_tag
890 || get_SymConst_kind(node) == size));
891 node->attr.i.tori.typ = tp;
895 get_SymConst_ptrinfo (ir_node *node) {
896 assert ( (node->op == op_SymConst)
897 && (get_SymConst_kind(node) == linkage_ptr_info));
898 return node->attr.i.tori.ptrinfo;
902 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
903 assert ( (node->op == op_SymConst)
904 && (get_SymConst_kind(node) == linkage_ptr_info));
905 node->attr.i.tori.ptrinfo = ptrinfo;
909 get_SymConst_type_or_id (ir_node *node) {
910 assert (node->op == op_SymConst);
911 return &(node->attr.i.tori);
915 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
916 assert (node->op == op_SymConst);
917 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
921 get_Sel_mem (ir_node *node) {
922 assert (node->op == op_Sel);
923 return get_irn_n(node, 0);
927 set_Sel_mem (ir_node *node, ir_node *mem) {
928 assert (node->op == op_Sel);
929 set_irn_n(node, 0, mem);
933 get_Sel_ptr (ir_node *node) {
934 assert (node->op == op_Sel);
935 return get_irn_n(node, 1);
939 set_Sel_ptr (ir_node *node, ir_node *ptr) {
940 assert (node->op == op_Sel);
941 set_irn_n(node, 1, ptr);
945 get_Sel_n_indexs (ir_node *node) {
946 assert (node->op == op_Sel);
947 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
951 get_Sel_index_arr (ir_node *node)
953 assert ((node->op == op_Sel));
954 if (get_Sel_n_indexs(node) > 0)
955 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
961 get_Sel_index (ir_node *node, int pos) {
962 assert (node->op == op_Sel);
963 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
967 set_Sel_index (ir_node *node, int pos, ir_node *index) {
968 assert (node->op == op_Sel);
969 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
973 get_Sel_entity (ir_node *node) {
974 assert (node->op == op_Sel);
975 return node->attr.s.ent;
979 set_Sel_entity (ir_node *node, entity *ent) {
980 assert (node->op == op_Sel);
981 node->attr.s.ent = ent;
985 get_InstOf_ent (ir_node *node) {
986 assert (node->op = op_InstOf);
987 return (node->attr.io.ent);
991 set_InstOf_ent (ir_node *node, type *ent) {
992 assert (node->op = op_InstOf);
993 node->attr.io.ent = ent;
997 get_InstOf_store (ir_node *node) {
998 assert (node->op = op_InstOf);
999 return (get_irn_n (node, 0));
1003 set_InstOf_store (ir_node *node, ir_node *obj) {
1004 assert (node->op = op_InstOf);
1005 set_irn_n (node, 0, obj);
1009 get_InstOf_obj (ir_node *node) {
1010 assert (node->op = op_InstOf);
1011 return (get_irn_n (node, 1));
1015 set_InstOf_obj (ir_node *node, ir_node *obj) {
1016 assert (node->op = op_InstOf);
1017 set_irn_n (node, 1, obj);
1021 /* For unary and binary arithmetic operations the access to the
1022 operands can be factored out. Left is the first, right the
1023 second arithmetic value as listed in tech report 0999-33.
1024 unops are: Minus, Abs, Not, Conv, Cast
1025 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1026 Shr, Shrs, Rotate, Cmp */
1030 get_Call_mem (ir_node *node) {
1031 assert (node->op == op_Call);
1032 return get_irn_n(node, 0);
1036 set_Call_mem (ir_node *node, ir_node *mem) {
1037 assert (node->op == op_Call);
1038 set_irn_n(node, 0, mem);
1042 get_Call_ptr (ir_node *node) {
1043 assert (node->op == op_Call);
1044 return get_irn_n(node, 1);
1048 set_Call_ptr (ir_node *node, ir_node *ptr) {
1049 assert (node->op == op_Call);
1050 set_irn_n(node, 1, ptr);
1054 get_Call_param_arr (ir_node *node) {
1055 assert (node->op == op_Call);
1056 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1060 get_Call_n_params (ir_node *node) {
1061 assert (node->op == op_Call);
1062 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1066 get_Call_arity (ir_node *node) {
1067 assert (node->op == op_Call);
1068 return get_Call_n_params(node);
1072 set_Call_arity (ir_node *node, ir_node *arity) {
1073 assert (node->op == op_Call);
1078 get_Call_param (ir_node *node, int pos) {
1079 assert (node->op == op_Call);
1080 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1084 set_Call_param (ir_node *node, int pos, ir_node *param) {
1085 assert (node->op == op_Call);
1086 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1090 get_Call_type (ir_node *node) {
1091 assert (node->op == op_Call);
1092 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1096 set_Call_type (ir_node *node, type *tp) {
1097 assert (node->op == op_Call);
1098 assert (is_method_type(tp));
1099 node->attr.call.cld_tp = tp;
1102 int get_Call_n_callees(ir_node * node) {
1103 assert(node->op == op_Call && node->attr.call.callee_arr);
1104 return ARR_LEN(node->attr.call.callee_arr);
1107 entity * get_Call_callee(ir_node * node, int pos) {
1108 assert(node->op == op_Call && node->attr.call.callee_arr);
1109 return node->attr.call.callee_arr[pos];
1112 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1113 assert(node->op == op_Call);
1114 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1115 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1117 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1120 void remove_Call_callee_arr(ir_node * node) {
1121 assert(node->op == op_Call);
1122 node->attr.call.callee_arr = NULL;
1125 ir_node * get_CallBegin_ptr (ir_node *node) {
1126 assert(node->op == op_CallBegin);
1127 return get_irn_n(node, 0);
1129 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1130 assert(node->op == op_CallBegin);
1131 set_irn_n(node, 0, ptr);
1133 ir_graph * get_CallBegin_irg (ir_node *node) {
1134 assert(node->op == op_CallBegin);
1135 return node->attr.callbegin.irg;
1137 ir_node * get_CallBegin_call (ir_node *node) {
1138 assert(node->op == op_CallBegin);
1139 return node->attr.callbegin.call;
1141 void set_CallBegin_call (ir_node *node, ir_node *call) {
1142 assert(node->op == op_CallBegin);
1143 node->attr.callbegin.call = call;
1147 get_Add_left (ir_node *node) {
1148 assert (node->op == op_Add);
1149 return get_irn_n(node, 0);
1153 set_Add_left (ir_node *node, ir_node *left) {
1154 assert (node->op == op_Add);
1155 set_irn_n(node, 0, left);
1159 get_Add_right (ir_node *node) {
1160 assert (node->op == op_Add);
1161 return get_irn_n(node, 1);
1165 set_Add_right (ir_node *node, ir_node *right) {
1166 assert (node->op == op_Add);
1167 set_irn_n(node, 1, right);
1171 get_Sub_left (ir_node *node) {
1172 assert (node->op == op_Sub);
1173 return get_irn_n(node, 0);
1177 set_Sub_left (ir_node *node, ir_node *left) {
1178 assert (node->op == op_Sub);
1179 set_irn_n(node, 0, left);
1183 get_Sub_right (ir_node *node) {
1184 assert (node->op == op_Sub);
1185 return get_irn_n(node, 1);
1189 set_Sub_right (ir_node *node, ir_node *right) {
1190 assert (node->op == op_Sub);
1191 set_irn_n(node, 1, right);
1196 get_Minus_op (ir_node *node) {
1197 assert (node->op == op_Minus);
1198 return get_irn_n(node, 0);
1202 set_Minus_op (ir_node *node, ir_node *op) {
1203 assert (node->op == op_Minus);
1204 set_irn_n(node, 0, op);
1209 get_Mul_left (ir_node *node) {
1210 assert (node->op == op_Mul);
1211 return get_irn_n(node, 0);
1215 set_Mul_left (ir_node *node, ir_node *left) {
1216 assert (node->op == op_Mul);
1217 set_irn_n(node, 0, left);
1221 get_Mul_right (ir_node *node) {
1222 assert (node->op == op_Mul);
1223 return get_irn_n(node, 1);
1227 set_Mul_right (ir_node *node, ir_node *right) {
1228 assert (node->op == op_Mul);
1229 set_irn_n(node, 1, right);
1233 get_Quot_left (ir_node *node) {
1234 assert (node->op == op_Quot);
1235 return get_irn_n(node, 1);
1239 set_Quot_left (ir_node *node, ir_node *left) {
1240 assert (node->op == op_Quot);
1241 set_irn_n(node, 1, left);
1245 get_Quot_right (ir_node *node) {
1246 assert (node->op == op_Quot);
1247 return get_irn_n(node, 2);
1251 set_Quot_right (ir_node *node, ir_node *right) {
1252 assert (node->op == op_Quot);
1253 set_irn_n(node, 2, right);
1257 get_Quot_mem (ir_node *node) {
1258 assert (node->op == op_Quot);
1259 return get_irn_n(node, 0);
1263 set_Quot_mem (ir_node *node, ir_node *mem) {
1264 assert (node->op == op_Quot);
1265 set_irn_n(node, 0, mem);
1269 get_DivMod_left (ir_node *node) {
1270 assert (node->op == op_DivMod);
1271 return get_irn_n(node, 1);
1275 set_DivMod_left (ir_node *node, ir_node *left) {
1276 assert (node->op == op_DivMod);
1277 set_irn_n(node, 1, left);
1281 get_DivMod_right (ir_node *node) {
1282 assert (node->op == op_DivMod);
1283 return get_irn_n(node, 2);
1287 set_DivMod_right (ir_node *node, ir_node *right) {
1288 assert (node->op == op_DivMod);
1289 set_irn_n(node, 2, right);
1293 get_DivMod_mem (ir_node *node) {
1294 assert (node->op == op_DivMod);
1295 return get_irn_n(node, 0);
1299 set_DivMod_mem (ir_node *node, ir_node *mem) {
1300 assert (node->op == op_DivMod);
1301 set_irn_n(node, 0, mem);
1305 get_Div_left (ir_node *node) {
1306 assert (node->op == op_Div);
1307 return get_irn_n(node, 1);
1311 set_Div_left (ir_node *node, ir_node *left) {
1312 assert (node->op == op_Div);
1313 set_irn_n(node, 1, left);
1317 get_Div_right (ir_node *node) {
1318 assert (node->op == op_Div);
1319 return get_irn_n(node, 2);
1323 set_Div_right (ir_node *node, ir_node *right) {
1324 assert (node->op == op_Div);
1325 set_irn_n(node, 2, right);
1329 get_Div_mem (ir_node *node) {
1330 assert (node->op == op_Div);
1331 return get_irn_n(node, 0);
1335 set_Div_mem (ir_node *node, ir_node *mem) {
1336 assert (node->op == op_Div);
1337 set_irn_n(node, 0, mem);
1341 get_Mod_left (ir_node *node) {
1342 assert (node->op == op_Mod);
1343 return get_irn_n(node, 1);
1347 set_Mod_left (ir_node *node, ir_node *left) {
1348 assert (node->op == op_Mod);
1349 set_irn_n(node, 1, left);
1353 get_Mod_right (ir_node *node) {
1354 assert (node->op == op_Mod);
1355 return get_irn_n(node, 2);
1359 set_Mod_right (ir_node *node, ir_node *right) {
1360 assert (node->op == op_Mod);
1361 set_irn_n(node, 2, right);
1365 get_Mod_mem (ir_node *node) {
1366 assert (node->op == op_Mod);
1367 return get_irn_n(node, 0);
1371 set_Mod_mem (ir_node *node, ir_node *mem) {
1372 assert (node->op == op_Mod);
1373 set_irn_n(node, 0, mem);
1377 get_Abs_op (ir_node *node) {
1378 assert (node->op == op_Abs);
1379 return get_irn_n(node, 0);
1383 set_Abs_op (ir_node *node, ir_node *op) {
1384 assert (node->op == op_Abs);
1385 set_irn_n(node, 0, op);
1389 get_And_left (ir_node *node) {
1390 assert (node->op == op_And);
1391 return get_irn_n(node, 0);
1395 set_And_left (ir_node *node, ir_node *left) {
1396 assert (node->op == op_And);
1397 set_irn_n(node, 0, left);
1401 get_And_right (ir_node *node) {
1402 assert (node->op == op_And);
1403 return get_irn_n(node, 1);
1407 set_And_right (ir_node *node, ir_node *right) {
1408 assert (node->op == op_And);
1409 set_irn_n(node, 1, right);
1413 get_Or_left (ir_node *node) {
1414 assert (node->op == op_Or);
1415 return get_irn_n(node, 0);
1419 set_Or_left (ir_node *node, ir_node *left) {
1420 assert (node->op == op_Or);
1421 set_irn_n(node, 0, left);
1425 get_Or_right (ir_node *node) {
1426 assert (node->op == op_Or);
1427 return get_irn_n(node, 1);
1431 set_Or_right (ir_node *node, ir_node *right) {
1432 assert (node->op == op_Or);
1433 set_irn_n(node, 1, right);
1437 get_Eor_left (ir_node *node) {
1438 assert (node->op == op_Eor);
1439 return get_irn_n(node, 0);
1443 set_Eor_left (ir_node *node, ir_node *left) {
1444 assert (node->op == op_Eor);
1445 set_irn_n(node, 0, left);
1449 get_Eor_right (ir_node *node) {
1450 assert (node->op == op_Eor);
1451 return get_irn_n(node, 1);
1455 set_Eor_right (ir_node *node, ir_node *right) {
1456 assert (node->op == op_Eor);
1457 set_irn_n(node, 1, right);
1462 get_Not_op (ir_node *node) {
1463 assert (node->op == op_Not);
1464 return get_irn_n(node, 0);
1468 set_Not_op (ir_node *node, ir_node *op) {
1469 assert (node->op == op_Not);
1470 set_irn_n(node, 0, op);
1475 get_Shl_left (ir_node *node) {
1476 assert (node->op == op_Shl);
1477 return get_irn_n(node, 0);
1481 set_Shl_left (ir_node *node, ir_node *left) {
1482 assert (node->op == op_Shl);
1483 set_irn_n(node, 0, left);
1487 get_Shl_right (ir_node *node) {
1488 assert (node->op == op_Shl);
1489 return get_irn_n(node, 1);
1493 set_Shl_right (ir_node *node, ir_node *right) {
1494 assert (node->op == op_Shl);
1495 set_irn_n(node, 1, right);
1499 get_Shr_left (ir_node *node) {
1500 assert (node->op == op_Shr);
1501 return get_irn_n(node, 0);
1505 set_Shr_left (ir_node *node, ir_node *left) {
1506 assert (node->op == op_Shr);
1507 set_irn_n(node, 0, left);
1511 get_Shr_right (ir_node *node) {
1512 assert (node->op == op_Shr);
1513 return get_irn_n(node, 1);
1517 set_Shr_right (ir_node *node, ir_node *right) {
1518 assert (node->op == op_Shr);
1519 set_irn_n(node, 1, right);
1523 get_Shrs_left (ir_node *node) {
1524 assert (node->op == op_Shrs);
1525 return get_irn_n(node, 0);
1529 set_Shrs_left (ir_node *node, ir_node *left) {
1530 assert (node->op == op_Shrs);
1531 set_irn_n(node, 0, left);
1535 get_Shrs_right (ir_node *node) {
1536 assert (node->op == op_Shrs);
1537 return get_irn_n(node, 1);
1541 set_Shrs_right (ir_node *node, ir_node *right) {
1542 assert (node->op == op_Shrs);
1543 set_irn_n(node, 1, right);
1547 get_Rot_left (ir_node *node) {
1548 assert (node->op == op_Rot);
1549 return get_irn_n(node, 0);
1553 set_Rot_left (ir_node *node, ir_node *left) {
1554 assert (node->op == op_Rot);
1555 set_irn_n(node, 0, left);
1559 get_Rot_right (ir_node *node) {
1560 assert (node->op == op_Rot);
1561 return get_irn_n(node, 1);
1565 set_Rot_right (ir_node *node, ir_node *right) {
1566 assert (node->op == op_Rot);
1567 set_irn_n(node, 1, right);
1571 get_Cmp_left (ir_node *node) {
1572 assert (node->op == op_Cmp);
1573 return get_irn_n(node, 0);
1577 set_Cmp_left (ir_node *node, ir_node *left) {
1578 assert (node->op == op_Cmp);
1579 set_irn_n(node, 0, left);
1583 get_Cmp_right (ir_node *node) {
1584 assert (node->op == op_Cmp);
1585 return get_irn_n(node, 1);
1589 set_Cmp_right (ir_node *node, ir_node *right) {
1590 assert (node->op == op_Cmp);
1591 set_irn_n(node, 1, right);
1595 get_Conv_op (ir_node *node) {
1596 assert (node->op == op_Conv);
1597 return get_irn_n(node, 0);
1601 set_Conv_op (ir_node *node, ir_node *op) {
1602 assert (node->op == op_Conv);
1603 set_irn_n(node, 0, op);
1607 get_Cast_op (ir_node *node) {
1608 assert (node->op == op_Cast);
1609 return get_irn_n(node, 0);
1613 set_Cast_op (ir_node *node, ir_node *op) {
1614 assert (node->op == op_Cast);
1615 set_irn_n(node, 0, op);
1619 get_Cast_type (ir_node *node) {
1620 assert (node->op == op_Cast);
1621 return node->attr.cast.totype;
1625 set_Cast_type (ir_node *node, type *to_tp) {
1626 assert (node->op == op_Cast);
1627 node->attr.cast.totype = to_tp;
1631 is_unop (ir_node *node) {
1632 return ( node->op == op_Minus ||
1633 node->op == op_Abs ||
1634 node->op == op_Not ||
1635 node->op == op_Conv ||
1636 node->op == op_Cast );
1640 get_unop_op (ir_node *node) {
1641 assert (is_unop(node));
1642 switch (get_irn_opcode (node)) {
1643 case iro_Minus: return get_Minus_op(node); break;
1644 case iro_Abs: return get_Abs_op(node); break;
1645 case iro_Not: return get_Not_op(node); break;
1646 case iro_Conv: return get_Conv_op(node); break;
1647 case iro_Cast: return get_Cast_op(node); break;
1648 default: return NULL;
1653 set_unop_op (ir_node *node, ir_node *op) {
1654 assert (is_unop(node));
1655 switch (get_irn_opcode (node)) {
1656 case iro_Minus: set_Minus_op(node, op); break;
1657 case iro_Abs: set_Abs_op(node, op); break;
1658 case iro_Not: set_Not_op(node, op); break;
1659 case iro_Conv: set_Conv_op(node, op); break;
1660 case iro_Cast: set_Cast_op(node, op); break;
1667 is_binop (ir_node *node) {
1668 return (node->op == op_Add ||
1669 node->op == op_Sub ||
1670 node->op == op_Mul ||
1671 node->op == op_Quot ||
1672 node->op == op_DivMod ||
1673 node->op == op_Div ||
1674 node->op == op_Mod ||
1675 node->op == op_And ||
1676 node->op == op_Or ||
1677 node->op == op_Eor ||
1678 node->op == op_Shl ||
1679 node->op == op_Shr ||
1680 node->op == op_Shrs ||
1681 node->op == op_Rot ||
1682 node->op == op_Cmp );
1686 get_binop_left (ir_node *node) {
1687 assert (node->op == op_Add ||
1688 node->op == op_Sub ||
1689 node->op == op_Mul ||
1690 node->op == op_Quot ||
1691 node->op == op_DivMod ||
1692 node->op == op_Div ||
1693 node->op == op_Mod ||
1694 node->op == op_And ||
1695 node->op == op_Or ||
1696 node->op == op_Eor ||
1697 node->op == op_Shl ||
1698 node->op == op_Shr ||
1699 node->op == op_Shrs ||
1700 node->op == op_Rot ||
1701 node->op == op_Cmp );
1703 switch (get_irn_opcode (node)) {
1704 case iro_Add : return get_Add_left(node); break;
1705 case iro_Sub : return get_Sub_left(node); break;
1706 case iro_Mul : return get_Mul_left(node); break;
1707 case iro_Quot : return get_Quot_left(node); break;
1708 case iro_DivMod: return get_DivMod_left(node); break;
1709 case iro_Div : return get_Div_left(node); break;
1710 case iro_Mod : return get_Mod_left(node); break;
1711 case iro_And : return get_And_left(node); break;
1712 case iro_Or : return get_Or_left(node); break;
1713 case iro_Eor : return get_Eor_left(node); break;
1714 case iro_Shl : return get_Shl_left(node); break;
1715 case iro_Shr : return get_Shr_left(node); break;
1716 case iro_Shrs : return get_Shrs_left(node); break;
1717 case iro_Rot : return get_Rot_left(node); break;
1718 case iro_Cmp : return get_Cmp_left(node); break;
1719 default: return NULL;
1724 set_binop_left (ir_node *node, ir_node *left) {
1725 assert (node->op == op_Add ||
1726 node->op == op_Sub ||
1727 node->op == op_Mul ||
1728 node->op == op_Quot ||
1729 node->op == op_DivMod ||
1730 node->op == op_Div ||
1731 node->op == op_Mod ||
1732 node->op == op_And ||
1733 node->op == op_Or ||
1734 node->op == op_Eor ||
1735 node->op == op_Shl ||
1736 node->op == op_Shr ||
1737 node->op == op_Shrs ||
1738 node->op == op_Rot ||
1739 node->op == op_Cmp );
1741 switch (get_irn_opcode (node)) {
1742 case iro_Add : set_Add_left(node, left); break;
1743 case iro_Sub : set_Sub_left(node, left); break;
1744 case iro_Mul : set_Mul_left(node, left); break;
1745 case iro_Quot : set_Quot_left(node, left); break;
1746 case iro_DivMod: set_DivMod_left(node, left); break;
1747 case iro_Div : set_Div_left(node, left); break;
1748 case iro_Mod : set_Mod_left(node, left); break;
1749 case iro_And : set_And_left(node, left); break;
1750 case iro_Or : set_Or_left(node, left); break;
1751 case iro_Eor : set_Eor_left(node, left); break;
1752 case iro_Shl : set_Shl_left(node, left); break;
1753 case iro_Shr : set_Shr_left(node, left); break;
1754 case iro_Shrs : set_Shrs_left(node, left); break;
1755 case iro_Rot : set_Rot_left(node, left); break;
1756 case iro_Cmp : set_Cmp_left(node, left); break;
1762 get_binop_right (ir_node *node) {
1763 assert (node->op == op_Add ||
1764 node->op == op_Sub ||
1765 node->op == op_Mul ||
1766 node->op == op_Quot ||
1767 node->op == op_DivMod ||
1768 node->op == op_Div ||
1769 node->op == op_Mod ||
1770 node->op == op_And ||
1771 node->op == op_Or ||
1772 node->op == op_Eor ||
1773 node->op == op_Shl ||
1774 node->op == op_Shr ||
1775 node->op == op_Shrs ||
1776 node->op == op_Rot ||
1777 node->op == op_Cmp );
1779 switch (get_irn_opcode (node)) {
1780 case iro_Add : return get_Add_right(node); break;
1781 case iro_Sub : return get_Sub_right(node); break;
1782 case iro_Mul : return get_Mul_right(node); break;
1783 case iro_Quot : return get_Quot_right(node); break;
1784 case iro_DivMod: return get_DivMod_right(node); break;
1785 case iro_Div : return get_Div_right(node); break;
1786 case iro_Mod : return get_Mod_right(node); break;
1787 case iro_And : return get_And_right(node); break;
1788 case iro_Or : return get_Or_right(node); break;
1789 case iro_Eor : return get_Eor_right(node); break;
1790 case iro_Shl : return get_Shl_right(node); break;
1791 case iro_Shr : return get_Shr_right(node); break;
1792 case iro_Shrs : return get_Shrs_right(node); break;
1793 case iro_Rot : return get_Rot_right(node); break;
1794 case iro_Cmp : return get_Cmp_right(node); break;
1795 default: return NULL;
1800 set_binop_right (ir_node *node, ir_node *right) {
1801 assert (node->op == op_Add ||
1802 node->op == op_Sub ||
1803 node->op == op_Mul ||
1804 node->op == op_Quot ||
1805 node->op == op_DivMod ||
1806 node->op == op_Div ||
1807 node->op == op_Mod ||
1808 node->op == op_And ||
1809 node->op == op_Or ||
1810 node->op == op_Eor ||
1811 node->op == op_Shl ||
1812 node->op == op_Shr ||
1813 node->op == op_Shrs ||
1814 node->op == op_Rot ||
1815 node->op == op_Cmp );
1817 switch (get_irn_opcode (node)) {
1818 case iro_Add : set_Add_right(node, right); break;
1819 case iro_Sub : set_Sub_right(node, right); break;
1820 case iro_Mul : set_Mul_right(node, right); break;
1821 case iro_Quot : set_Quot_right(node, right); break;
1822 case iro_DivMod: set_DivMod_right(node, right); break;
1823 case iro_Div : set_Div_right(node, right); break;
1824 case iro_Mod : set_Mod_right(node, right); break;
1825 case iro_And : set_And_right(node, right); break;
1826 case iro_Or : set_Or_right(node, right); break;
1827 case iro_Eor : set_Eor_right(node, right); break;
1828 case iro_Shl : set_Shl_right(node, right); break;
1829 case iro_Shr : set_Shr_right(node, right); break;
1830 case iro_Shrs : set_Shrs_right(node, right); break;
1831 case iro_Rot : set_Rot_right(node, right); break;
1832 case iro_Cmp : set_Cmp_right(node, right); break;
1839 get_Phi_preds_arr (ir_node *node) {
1840 assert (node->op == op_Phi);
1841 return (ir_node **)&(get_irn_in(node)[1]);
1845 get_Phi_n_preds (ir_node *node) {
1846 assert (node->op == op_Phi);
1847 return (get_irn_arity(node));
1851 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1852 assert (node->op == op_Phi);
1857 get_Phi_pred (ir_node *node, int pos) {
1858 assert (node->op == op_Phi);
1859 return get_irn_n(node, pos);
1863 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1864 assert (node->op == op_Phi);
1865 set_irn_n(node, pos, pred);
1869 get_Load_mem (ir_node *node) {
1870 assert (node->op == op_Load);
1871 return get_irn_n(node, 0);
1875 set_Load_mem (ir_node *node, ir_node *mem) {
1876 assert (node->op == op_Load);
1877 set_irn_n(node, 0, mem);
1881 get_Load_ptr (ir_node *node) {
1882 assert (node->op == op_Load);
1883 return get_irn_n(node, 1);
1887 set_Load_ptr (ir_node *node, ir_node *ptr) {
1888 assert (node->op == op_Load);
1889 set_irn_n(node, 1, ptr);
1894 get_Store_mem (ir_node *node) {
1895 assert (node->op == op_Store);
1896 return get_irn_n(node, 0);
1900 set_Store_mem (ir_node *node, ir_node *mem) {
1901 assert (node->op == op_Store);
1902 set_irn_n(node, 0, mem);
1906 get_Store_ptr (ir_node *node) {
1907 assert (node->op == op_Store);
1908 return get_irn_n(node, 1);
1912 set_Store_ptr (ir_node *node, ir_node *ptr) {
1913 assert (node->op == op_Store);
1914 set_irn_n(node, 1, ptr);
1918 get_Store_value (ir_node *node) {
1919 assert (node->op == op_Store);
1920 return get_irn_n(node, 2);
1924 set_Store_value (ir_node *node, ir_node *value) {
1925 assert (node->op == op_Store);
1926 set_irn_n(node, 2, value);
1930 get_Alloc_mem (ir_node *node) {
1931 assert (node->op == op_Alloc);
1932 return get_irn_n(node, 0);
1936 set_Alloc_mem (ir_node *node, ir_node *mem) {
1937 assert (node->op == op_Alloc);
1938 set_irn_n(node, 0, mem);
1942 get_Alloc_size (ir_node *node) {
1943 assert (node->op == op_Alloc);
1944 return get_irn_n(node, 1);
1948 set_Alloc_size (ir_node *node, ir_node *size) {
1949 assert (node->op == op_Alloc);
1950 set_irn_n(node, 1, size);
1954 get_Alloc_type (ir_node *node) {
1955 assert (node->op == op_Alloc);
1956 return node->attr.a.type = skip_tid(node->attr.a.type);
1960 set_Alloc_type (ir_node *node, type *tp) {
1961 assert (node->op == op_Alloc);
1962 node->attr.a.type = tp;
1966 get_Alloc_where (ir_node *node) {
1967 assert (node->op == op_Alloc);
1968 return node->attr.a.where;
1972 set_Alloc_where (ir_node *node, where_alloc where) {
1973 assert (node->op == op_Alloc);
1974 node->attr.a.where = where;
1979 get_Free_mem (ir_node *node) {
1980 assert (node->op == op_Free);
1981 return get_irn_n(node, 0);
1985 set_Free_mem (ir_node *node, ir_node *mem) {
1986 assert (node->op == op_Free);
1987 set_irn_n(node, 0, mem);
1991 get_Free_ptr (ir_node *node) {
1992 assert (node->op == op_Free);
1993 return get_irn_n(node, 1);
1997 set_Free_ptr (ir_node *node, ir_node *ptr) {
1998 assert (node->op == op_Free);
1999 set_irn_n(node, 1, ptr);
2003 get_Free_size (ir_node *node) {
2004 assert (node->op == op_Free);
2005 return get_irn_n(node, 2);
2009 set_Free_size (ir_node *node, ir_node *size) {
2010 assert (node->op == op_Free);
2011 set_irn_n(node, 2, size);
2015 get_Free_type (ir_node *node) {
2016 assert (node->op == op_Free);
2017 return node->attr.f = skip_tid(node->attr.f);
2021 set_Free_type (ir_node *node, type *tp) {
2022 assert (node->op == op_Free);
2027 get_Sync_preds_arr (ir_node *node) {
2028 assert (node->op == op_Sync);
2029 return (ir_node **)&(get_irn_in(node)[1]);
2033 get_Sync_n_preds (ir_node *node) {
2034 assert (node->op == op_Sync);
2035 return (get_irn_arity(node));
2040 set_Sync_n_preds (ir_node *node, int n_preds) {
2041 assert (node->op == op_Sync);
2046 get_Sync_pred (ir_node *node, int pos) {
2047 assert (node->op == op_Sync);
2048 return get_irn_n(node, pos);
2052 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
2053 assert (node->op == op_Sync);
2054 set_irn_n(node, pos, pred);
2058 get_Proj_pred (ir_node *node) {
2059 assert (is_Proj(node));
2060 return get_irn_n(node, 0);
2064 set_Proj_pred (ir_node *node, ir_node *pred) {
2065 assert (is_Proj(node));
2066 set_irn_n(node, 0, pred);
2070 get_Proj_proj (ir_node *node) {
2071 assert (is_Proj(node));
2072 if (get_irn_opcode(node) == iro_Proj) {
2073 return node->attr.proj;
2075 assert(get_irn_opcode(node) == iro_Filter);
2076 return node->attr.filter.proj;
2081 set_Proj_proj (ir_node *node, long proj) {
2082 assert (node->op == op_Proj);
2083 node->attr.proj = proj;
2087 get_Tuple_preds_arr (ir_node *node) {
2088 assert (node->op == op_Tuple);
2089 return (ir_node **)&(get_irn_in(node)[1]);
2093 get_Tuple_n_preds (ir_node *node) {
2094 assert (node->op == op_Tuple);
2095 return (get_irn_arity(node));
2100 set_Tuple_n_preds (ir_node *node, int n_preds) {
2101 assert (node->op == op_Tuple);
2106 get_Tuple_pred (ir_node *node, int pos) {
2107 assert (node->op == op_Tuple);
2108 return get_irn_n(node, pos);
2112 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2113 assert (node->op == op_Tuple);
2114 set_irn_n(node, pos, pred);
2118 get_Id_pred (ir_node *node) {
2119 assert (node->op == op_Id);
2120 return get_irn_n(node, 0);
2124 set_Id_pred (ir_node *node, ir_node *pred) {
2125 assert (node->op == op_Id);
2126 set_irn_n(node, 0, pred);
2131 get_Filter_pred (ir_node *node) {
2132 assert(node->op == op_Filter);
2136 set_Filter_pred (ir_node *node, ir_node *pred) {
2137 assert(node->op == op_Filter);
2141 get_Filter_proj(ir_node *node) {
2142 assert(node->op == op_Filter);
2143 return node->attr.filter.proj;
2146 set_Filter_proj (ir_node *node, long proj) {
2147 assert(node->op == op_Filter);
2148 node->attr.filter.proj = proj;
2151 /* Don't use get_irn_arity, get_irn_n in implementation as access
2152 shall work independent of view!!! */
2153 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2154 assert(node->op == op_Filter);
2155 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2156 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2157 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2158 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2159 node->attr.filter.in_cg[0] = node->in[0];
2161 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2164 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2165 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2166 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2167 node->attr.filter.in_cg[pos + 1] = pred;
2169 int get_Filter_n_cg_preds(ir_node *node) {
2170 assert(node->op == op_Filter && node->attr.filter.in_cg);
2171 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2173 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2175 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2177 arity = ARR_LEN(node->attr.filter.in_cg);
2178 assert(pos < arity - 1);
2179 return node->attr.filter.in_cg[pos + 1];
2184 get_irn_irg(ir_node *node) {
2185 if (get_irn_op(node) == op_CallBegin) {
2186 return node->attr.callbegin.irg;
2187 } else if (get_irn_op(node) == op_EndReg ||
2188 get_irn_op(node) == op_EndExcept) {
2189 return node->attr.end.irg;
2190 } else if (get_irn_op(node) == op_Start) {
2191 return node->attr.start.irg;
2193 assert(0 && "no irg attr");
2199 /******************************************************************/
2200 /* Auxiliary routines */
2201 /******************************************************************/
2204 skip_Proj (ir_node *node) {
2205 /* don't assert node !!! */
2206 if (node && is_Proj(node)) {
2207 return get_Proj_pred(node);
2214 skip_Tuple (ir_node *node) {
2217 if (!get_opt_normalize()) return node;
2219 node = skip_nop(node);
2220 if (get_irn_op(node) == op_Proj) {
2221 pred = skip_nop(get_Proj_pred(node));
2222 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2223 pred = skip_nop(skip_Tuple(pred));
2224 if (get_irn_op(pred) == op_Tuple)
2225 return get_Tuple_pred(pred, get_Proj_proj(node));
2230 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2231 than any other approach, as Id chains are resolved and all point to the real node, or
2232 all id's are self loops. */
2234 skip_nop (ir_node *node) {
2235 /* don't assert node !!! */
2237 if (!get_opt_normalize()) return node;
2239 /* Don't use get_Id_pred: We get into an endless loop for
2240 self-referencing Ids. */
2241 if (node && (node->op == op_Id) && (node != node->in[0+1])) {
2242 ir_node *rem_pred = node->in[0+1];
2245 assert (get_irn_arity (node) > 0);
2247 node->in[0+1] = node;
2248 res = skip_nop(rem_pred);
2249 if (res->op == op_Id) /* self-loop */ return node;
2251 node->in[0+1] = res;
2259 skip_Id (ir_node *node) {
2260 return skip_nop(node);
2264 is_Bad (ir_node *node) {
2266 if ((node) && get_irn_opcode(node) == iro_Bad)
2272 is_no_Block (ir_node *node) {
2274 return (get_irn_opcode(node) != iro_Block);
2278 is_Block (ir_node *node) {
2280 return (get_irn_opcode(node) == iro_Block);
2284 is_Proj (const ir_node *node) {
2286 return node->op == op_Proj
2287 || (!interprocedural_view && node->op == op_Filter);
2290 /* Returns true if the operation manipulates control flow. */
2292 is_cfop(ir_node *node) {
2293 return is_cfopcode(get_irn_op(node));
2296 /* Returns true if the operation manipulates interprocedural control flow:
2297 CallBegin, EndReg, EndExcept */
2298 INLINE int is_ip_cfop(ir_node *node) {
2299 return is_ip_cfopcode(get_irn_op(node));
2302 ir_graph *get_ip_cfop_irg(ir_node *n) {
2303 switch (get_irn_opcode(n)) {
2305 return get_EndReg_irg(n);
2307 return get_EndExcept_irg(n);
2309 return get_CallBegin_irg(n);
2311 assert(is_ip_cfop(n));
2313 return NULL; /* should never be reached */
2316 /* Returns true if the operation can change the control flow because
2319 is_fragile_op(ir_node *node) {
2320 return ( (get_irn_opcode(node) == iro_Call)
2321 || (get_irn_opcode(node) == iro_Quot)
2322 || (get_irn_opcode(node) == iro_DivMod)
2323 || (get_irn_opcode(node) == iro_Div)
2324 || (get_irn_opcode(node) == iro_Mod)
2325 || (get_irn_opcode(node) == iro_Load)
2326 || (get_irn_opcode(node) == iro_Store)
2327 || (get_irn_opcode(node) == iro_Alloc)
2328 || (get_irn_opcode(node) == iro_Bad)
2329 || (get_irn_opcode(node) == iro_Unknown));
2333 /* Returns the memory operand of fragile operations. */
2334 ir_node *get_fragile_op_mem(ir_node *node) {
2335 assert(node && is_fragile_op(node));
2337 switch (get_irn_opcode (node)) {
2346 return get_irn_n(node, 0);
2351 assert(0 && "not reached");