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"
31 /* some constants fixing the positions of nodes predecessors
33 #define CALL_PARAM_OFFSET 2
34 #define SEL_INDEX_OFFSET 2
35 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
36 #define END_KEEPALIVE_OFFSET 0
38 /* Declarations for inlineing */
39 INLINE ir_node ** get_irn_in (const ir_node *node);
40 INLINE ir_mode *get_irn_mode (const ir_node *node);
41 INLINE ir_op *get_irn_op (const ir_node *node);
42 INLINE opcode get_irn_opcode (const ir_node *node);
43 INLINE ident *get_irn_opident (const ir_node *node);
44 INLINE type *get_SymConst_type (ir_node *node);
45 INLINE ir_node *skip_nop (ir_node *node);
46 INLINE int is_Proj (const ir_node *node);
49 static const char *pnc_name_arr [] = {
50 "False", "Eq", "Lt", "Le",
51 "Gt", "Ge", "Lg", "Leg", "Uo",
52 "Ue", "Ul", "Ule", "Ug", "Uge",
56 INLINE const char *get_pnc_string(int pnc) {
57 return pnc_name_arr[pnc];
62 get_negated_pnc(int pnc) {
64 case False: return True; break;
65 case Eq: return Ne; break;
66 case Lt: return Uge; break;
67 case Le: return Ug; break;
68 case Gt: return Ule; break;
69 case Ge: return Ul; break;
70 case Lg: return Ue; break;
71 case Leg: return Uo; break;
72 case Uo: return Leg; break;
73 case Ue: return Lg; break;
74 case Ul: return Ge; break;
75 case Ule: return Gt; break;
76 case Ug: return Le; break;
77 case Uge: return Lt; break;
78 case Ne: return Eq; break;
79 case True: return False; break;
81 return 99; /* to shut up gcc */
84 const char *pns_name_arr [] = {
85 "initial_exec", "global_store",
86 "frame_base", "globals", "args"
89 const char *symconst_name_arr [] = {
90 "type_tag", "size", "linkage_ptr_info"
100 * Create a new irnode in irg, with an op, mode, arity and
101 * some incoming irnodes.
102 * If arity is negative, a node with a dynamic array is created.
105 new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
106 int arity, ir_node **in)
109 int node_size = offsetof (ir_node, attr) + op->attr_size;
111 res = (ir_node *) obstack_alloc (irg->obst, node_size);
113 res->kind = k_ir_node;
119 res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
121 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
122 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
125 set_irn_dbg_info(res, db);
129 res->node_nr = get_irp_new_node_nr();
135 /* Copies all attributes stored in the old node to the new node.
136 Assumes both have the same opcode and sufficient size. */
138 copy_attrs (const ir_node *old_node, ir_node *new_node) {
139 assert(get_irn_op(old_node) == get_irn_op(new_node));
140 memcpy(&new_node->attr, &old_node->attr, get_op_attr_size(get_irn_op(old_node)));
143 /** getting some parameters from ir_nodes **/
146 is_ir_node (const void *thing) {
148 if (get_kind(thing) == k_ir_node)
154 /* returns the number of predecessors without the block predecessor. */
156 get_irn_intra_arity (const ir_node *node) {
158 return ARR_LEN(node->in) - 1;
161 /* returns the number of predecessors without the block predecessor. */
163 get_irn_inter_arity (const ir_node *node) {
165 if (get_irn_opcode(node) == iro_Filter) {
166 assert(node->attr.filter.in_cg);
167 return ARR_LEN(node->attr.filter.in_cg) - 1;
168 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
169 return ARR_LEN(node->attr.block.in_cg) - 1;
171 return get_irn_intra_arity(node);
174 /* returns the number of predecessors without the block predecessor. */
176 get_irn_arity (const ir_node *node) {
178 if (interprocedural_view) return get_irn_inter_arity(node);
179 return get_irn_intra_arity(node);
182 /* Returns the array with ins. This array is shifted with respect to the
183 array accessed by get_irn_n: The block operand is at position 0 not -1.
184 (@@@ This should be changed.)
185 The order of the predecessors in this array is not guaranteed, except that
186 lists of operands as predecessors of Block or arguments of a Call are
189 get_irn_in (const ir_node *node) {
191 if (interprocedural_view) { /* handle Filter and Block specially */
192 if (get_irn_opcode(node) == iro_Filter) {
193 assert(node->attr.filter.in_cg);
194 return node->attr.filter.in_cg;
195 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
196 return node->attr.block.in_cg;
198 /* else fall through */
204 set_irn_in (ir_node *node, int arity, ir_node **in) {
207 if (interprocedural_view) { /* handle Filter and Block specially */
208 if (get_irn_opcode(node) == iro_Filter) {
209 assert(node->attr.filter.in_cg);
210 arr = &node->attr.filter.in_cg;
211 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
212 arr = &node->attr.block.in_cg;
219 if (arity != ARR_LEN(*arr) - 1) {
220 ir_node * block = (*arr)[0];
221 *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
224 fix_backedges(current_ir_graph->obst, node);
225 memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
229 get_irn_intra_n (ir_node *node, int n) {
230 return (node->in[n + 1] = skip_nop(node->in[n + 1]));
234 get_irn_inter_n (ir_node *node, int n) {
235 /* handle Filter and Block specially */
236 if (get_irn_opcode(node) == iro_Filter) {
237 assert(node->attr.filter.in_cg);
238 return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
239 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
240 return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
243 return get_irn_intra_n (node, n);
246 /* to iterate through the predecessors without touching the array */
247 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
248 to iterate including the Block predecessor iterate from i = -1 to
250 If it is a block, the entry -1 is NULL. */
252 get_irn_n (ir_node *node, int n) {
253 assert(node); assert(-1 <= n && n < get_irn_arity(node));
254 if (interprocedural_view) return get_irn_inter_n (node, n);
255 return get_irn_intra_n (node, n);
260 set_irn_n (ir_node *node, int n, ir_node *in) {
261 assert(node && -1 <= n && n < get_irn_arity(node));
262 if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
263 /* Change block pred in both views! */
264 node->in[n + 1] = in;
265 assert(node->attr.filter.in_cg);
266 node->attr.filter.in_cg[n + 1] = in;
269 if (interprocedural_view) { /* handle Filter and Block specially */
270 if (get_irn_opcode(node) == iro_Filter) {
271 assert(node->attr.filter.in_cg);
272 node->attr.filter.in_cg[n + 1] = in;
274 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
275 node->attr.block.in_cg[n + 1] = in;
278 /* else fall through */
280 node->in[n + 1] = in;
284 get_irn_mode (const ir_node *node)
291 set_irn_mode (ir_node *node, ir_mode *mode)
299 get_irn_modecode (const ir_node *node)
302 return node->mode->code;
305 /** Gets the string representation of the mode .*/
307 get_irn_modename (const ir_node *node)
310 return get_mode_name(node->mode);
314 get_irn_modeident (const ir_node *node)
317 return get_mode_ident(node->mode);
321 get_irn_op (const ir_node *node)
327 /* should be private to the library: */
329 set_irn_op (ir_node *node, ir_op *op)
336 get_irn_opcode (const ir_node *node)
339 assert (k_ir_node == get_kind(node));
341 return node->op->code;
345 get_irn_opname (const ir_node *node)
348 return get_id_str(node->op->name);
352 get_irn_opident (const ir_node *node)
355 return node->op->name;
359 get_irn_visited (const ir_node *node)
362 return node->visited;
366 set_irn_visited (ir_node *node, unsigned long visited)
369 node->visited = visited;
373 mark_irn_visited (ir_node *node) {
375 node->visited = current_ir_graph->visited;
379 irn_not_visited (const ir_node *node) {
381 return (node->visited < current_ir_graph->visited);
385 irn_visited (const ir_node *node) {
387 return (node->visited >= current_ir_graph->visited);
391 set_irn_link (ir_node *node, void *link) {
393 /* Link field is used for Phi construction and various optimizations
395 assert(get_irg_phase_state(current_ir_graph) != phase_building);
401 get_irn_link (const ir_node *node) {
406 /* Outputs a unique number for this node */
408 get_irn_node_nr(const ir_node *node) {
411 return node->node_nr;
418 get_irn_const_attr (ir_node *node)
420 assert (node->op == op_Const);
421 return node->attr.con;
425 get_irn_proj_attr (ir_node *node)
427 assert (node->op == op_Proj);
428 return node->attr.proj;
432 get_irn_alloc_attr (ir_node *node)
434 assert (node->op == op_Alloc);
439 get_irn_free_attr (ir_node *node)
441 assert (node->op == op_Free);
442 return node->attr.f = skip_tid(node->attr.f);
446 get_irn_symconst_attr (ir_node *node)
448 assert (node->op == op_SymConst);
453 get_irn_call_attr (ir_node *node)
455 assert (node->op == op_Call);
456 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
460 get_irn_sel_attr (ir_node *node)
462 assert (node->op == op_Sel);
467 get_irn_phi_attr (ir_node *node)
469 assert (node->op == op_Phi);
470 return node->attr.phi0_pos;
474 get_irn_block_attr (ir_node *node)
476 assert (node->op == op_Block);
477 return node->attr.block;
480 /** manipulate fields of individual nodes **/
482 /* this works for all except Block */
484 get_nodes_Block (ir_node *node) {
485 assert (!(node->op == op_Block));
486 return get_irn_n(node, -1);
490 set_nodes_Block (ir_node *node, ir_node *block) {
491 assert (!(node->op == op_Block));
492 set_irn_n(node, -1, block);
495 /* Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
496 * from Start. If so returns frame type, else Null. */
497 type *is_frame_pointer(ir_node *n) {
498 if ((get_irn_op(n) == op_Proj) &&
499 (get_Proj_proj(n) == pn_Start_P_frame_base)) {
500 ir_node *start = get_Proj_pred(n);
501 if (get_irn_op(start) == op_Start) {
502 return get_irg_frame_type(get_irn_irg(start));
508 /* Test whether arbitrary node is globals pointer, i.e. Proj(pn_Start_P_globals)
509 * from Start. If so returns global type, else Null. */
510 type *is_globals_pointer(ir_node *n) {
511 if ((get_irn_op(n) == op_Proj) &&
512 (get_Proj_proj(n) == pn_Start_P_globals)) {
513 ir_node *start = get_Proj_pred(n);
514 if (get_irn_op(start) == op_Start) {
515 return get_glob_type();
521 /* Test whether arbitrary node is value arg base, i.e. Proj(pn_Start_P_value_arg_base)
522 * from Start. If so returns 1, else 0. */
523 int is_value_arg_pointer(ir_node *n) {
524 if ((get_irn_op(n) == op_Proj) &&
525 (get_Proj_proj(n) == pn_Start_P_value_arg_base) &&
526 (get_irn_op(get_Proj_pred(n)) == op_Start))
531 /* Returns an array with the predecessors of the Block. Depending on
532 the implementation of the graph data structure this can be a copy of
533 the internal representation of predecessors as well as the internal
534 array itself. Therefore writing to this array might obstruct the ir. */
536 get_Block_cfgpred_arr (ir_node *node)
538 assert ((node->op == op_Block));
539 return (ir_node **)&(get_irn_in(node)[1]);
544 get_Block_n_cfgpreds (ir_node *node) {
545 assert ((node->op == op_Block));
546 return (get_irn_arity(node));
550 get_Block_cfgpred (ir_node *node, int pos) {
551 assert (node->op == op_Block);
553 if (-1 > pos || get_irn_arity(node) <= pos) {
554 dump_ir_block_graph(current_ir_graph);
555 printf("pos: %d, arity: %d ", pos, get_irn_arity(node));
558 assert(node); assert(-1 <= pos && pos < get_irn_arity(node));
559 return get_irn_n(node, pos);
563 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
564 assert (node->op == op_Block);
565 set_irn_n(node, pos, pred);
569 get_Block_matured (ir_node *node) {
570 assert (node->op == op_Block);
571 return node->attr.block.matured;
575 set_Block_matured (ir_node *node, bool matured) {
576 assert (node->op == op_Block);
577 node->attr.block.matured = matured;
580 get_Block_block_visited (ir_node *node) {
581 assert (node->op == op_Block);
582 return node->attr.block.block_visited;
586 set_Block_block_visited (ir_node *node, unsigned long visit) {
587 assert (node->op == op_Block);
588 node->attr.block.block_visited = visit;
591 /* For this current_ir_graph must be set. */
593 mark_Block_block_visited (ir_node *node) {
594 assert (node->op == op_Block);
595 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
599 Block_not_block_visited(ir_node *node) {
600 assert (node->op == op_Block);
601 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
605 get_Block_graph_arr (ir_node *node, int pos) {
606 assert (node->op == op_Block);
607 return node->attr.block.graph_arr[pos+1];
611 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
612 assert (node->op == op_Block);
613 node->attr.block.graph_arr[pos+1] = value;
616 /* handler handling for Blocks * /
618 set_Block_handler (ir_node *block, ir_node *handler) {
619 assert ((block->op == op_Block));
620 assert ((handler->op == op_Block));
621 block->attr.block.handler_entry = handler;
625 get_Block_handler (ir_node *block) {
626 assert ((block->op == op_Block));
627 return (block->attr.block.handler_entry);
630 / * handler handling for Nodes * /
632 set_Node_handler (ir_node *node, ir_node *handler) {
633 set_Block_handler (get_nodes_Block (node), handler);
637 get_Node_handler (ir_node *node) {
638 return (get_Block_handler (get_nodes_Block (node)));
641 / * exc_t handling for Blocks * /
642 void set_Block_exc (ir_node *block, exc_t exc) {
643 assert ((block->op == op_Block));
644 block->attr.block.exc = exc;
647 exc_t get_Block_exc (ir_node *block) {
648 assert ((block->op == op_Block));
649 return (block->attr.block.exc);
652 / * exc_t handling for Nodes * /
653 void set_Node_exc (ir_node *node, exc_t exc) {
654 set_Block_exc (get_nodes_Block (node), exc);
657 exc_t get_Node_exc (ir_node *node) {
658 return (get_Block_exc (get_nodes_Block (node)));
662 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
663 assert(node->op == op_Block);
664 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
665 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
666 node->attr.block.in_cg[0] = NULL;
667 node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
669 /* Fix backedge array. fix_backedges operates depending on
670 interprocedural_view. */
671 bool ipv = interprocedural_view;
672 interprocedural_view = true;
673 fix_backedges(current_ir_graph->obst, node);
674 interprocedural_view = ipv;
677 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
680 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
681 assert(node->op == op_Block &&
682 node->attr.block.in_cg &&
683 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
684 node->attr.block.in_cg[pos + 1] = pred;
687 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
688 assert(node->op == op_Block);
689 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
692 int get_Block_cg_n_cfgpreds(ir_node * node) {
693 assert(node->op == op_Block);
694 return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
697 ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
698 assert(node->op == op_Block && node->attr.block.in_cg);
699 return node->attr.block.in_cg[pos + 1];
702 void remove_Block_cg_cfgpred_arr(ir_node * node) {
703 assert(node->op == op_Block);
704 node->attr.block.in_cg = NULL;
707 /* Start references the irg it is in. */
709 get_Start_irg(ir_node *node) {
710 return get_irn_irg(node);
714 set_Start_irg(ir_node *node, ir_graph *irg) {
715 assert(node->op == op_Start);
716 assert(is_ir_graph(irg));
717 assert(0 && " Why set irg? ");
718 //node->attr.start.irg = irg;
722 get_End_n_keepalives(ir_node *end) {
723 assert (end->op == op_End);
724 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
728 get_End_keepalive(ir_node *end, int pos) {
729 assert (end->op == op_End);
730 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
734 add_End_keepalive (ir_node *end, ir_node *ka) {
735 assert (end->op == op_End);
736 ARR_APP1 (ir_node *, end->in, ka);
740 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
741 assert (end->op == op_End);
742 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
746 free_End (ir_node *end) {
747 assert (end->op == op_End);
749 DEL_ARR_F(end->in); /* GL @@@ tut nicht ! */
750 end->in = NULL; /* @@@ make sure we get an error if we use the
751 in array afterwards ... */
754 ir_graph *get_EndReg_irg (ir_node *end) {
755 return get_irn_irg(end);
758 ir_graph *get_EndExcept_irg (ir_node *end) {
759 return get_irn_irg(end);
763 > Implementing the case construct (which is where the constant Proj node is
764 > important) involves far more than simply determining the constant values.
765 > We could argue that this is more properly a function of the translator from
766 > Firm to the target machine. That could be done if there was some way of
767 > projecting "default" out of the Cond node.
768 I know it's complicated.
769 Basically there are two proglems:
770 - determining the gaps between the projs
771 - determining the biggest case constant to know the proj number for
773 I see several solutions:
774 1. Introduce a ProjDefault node. Solves both problems.
775 This means to extend all optimizations executed during construction.
776 2. Give the Cond node for switch two flavors:
777 a) there are no gaps in the projs (existing flavor)
778 b) gaps may exist, default proj is still the Proj with the largest
779 projection number. This covers also the gaps.
780 3. Fix the semantic of the Cond to that of 2b)
782 Solution 2 seems to be the best:
783 Computing the gaps in the Firm representation is not too hard, i.e.,
784 libFIRM can implement a routine that transforms between the two
785 flavours. This is also possible for 1) but 2) does not require to
786 change any existing optimization.
787 Further it should be far simpler to determine the biggest constant than
789 I don't want to choose 3) as 2a) seems to have advantages for
790 dataflow analysis and 3) does not allow to convert the representation to
794 get_Cond_selector (ir_node *node) {
795 assert (node->op == op_Cond);
796 return get_irn_n(node, 0);
800 set_Cond_selector (ir_node *node, ir_node *selector) {
801 assert (node->op == op_Cond);
802 set_irn_n(node, 0, selector);
806 get_Cond_kind (ir_node *node) {
807 assert (node->op == op_Cond);
808 return node->attr.c.kind;
812 set_Cond_kind (ir_node *node, cond_kind kind) {
813 assert (node->op == op_Cond);
814 node->attr.c.kind = kind;
818 get_Return_mem (ir_node *node) {
819 assert (node->op == op_Return);
820 return get_irn_n(node, 0);
824 set_Return_mem (ir_node *node, ir_node *mem) {
825 assert (node->op == op_Return);
826 set_irn_n(node, 0, mem);
830 get_Return_n_ress (ir_node *node) {
831 assert (node->op == op_Return);
832 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
836 get_Return_res_arr (ir_node *node)
838 assert ((node->op == op_Return));
839 if (get_Return_n_ress(node) > 0)
840 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
847 set_Return_n_res (ir_node *node, int results) {
848 assert (node->op == op_Return);
853 get_Return_res (ir_node *node, int pos) {
854 assert (node->op == op_Return);
855 assert (get_Return_n_ress(node) > pos);
856 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
860 set_Return_res (ir_node *node, int pos, ir_node *res){
861 assert (node->op == op_Return);
862 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
866 get_Raise_mem (ir_node *node) {
867 assert (node->op == op_Raise);
868 return get_irn_n(node, 0);
872 set_Raise_mem (ir_node *node, ir_node *mem) {
873 assert (node->op == op_Raise);
874 set_irn_n(node, 0, mem);
878 get_Raise_exo_ptr (ir_node *node) {
879 assert (node->op == op_Raise);
880 return get_irn_n(node, 1);
884 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
885 assert (node->op == op_Raise);
886 set_irn_n(node, 1, exo_ptr);
889 INLINE tarval *get_Const_tarval (ir_node *node) {
890 assert (node->op == op_Const);
891 return node->attr.con.tv;
895 set_Const_tarval (ir_node *node, tarval *con) {
896 assert (node->op == op_Const);
897 node->attr.con.tv = con;
901 /* The source language type. Must be an atomic type. Mode of type must
902 be mode of node. For tarvals from entities type must be pointer to
905 get_Const_type (ir_node *node) {
906 assert (node->op == op_Const);
907 return node->attr.con.tp;
911 set_Const_type (ir_node *node, type *tp) {
912 assert (node->op == op_Const);
913 if (tp != unknown_type) {
914 assert (is_atomic_type(tp));
915 assert (get_type_mode(tp) == get_irn_mode(node));
916 assert (!tarval_is_entity(get_Const_tarval(node)) ||
917 (is_pointer_type(tp) &&
918 (get_pointer_points_to_type(tp) ==
919 get_entity_type(get_tarval_entity(get_Const_tarval(node))))));
922 node->attr.con.tp = tp;
927 get_SymConst_kind (const ir_node *node) {
928 assert (node->op == op_SymConst);
929 return node->attr.i.num;
933 set_SymConst_kind (ir_node *node, symconst_kind num) {
934 assert (node->op == op_SymConst);
935 node->attr.i.num = num;
939 get_SymConst_type (ir_node *node) {
940 assert ( (node->op == op_SymConst)
941 && ( get_SymConst_kind(node) == type_tag
942 || get_SymConst_kind(node) == size));
943 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
947 set_SymConst_type (ir_node *node, type *tp) {
948 assert ( (node->op == op_SymConst)
949 && ( get_SymConst_kind(node) == type_tag
950 || get_SymConst_kind(node) == size));
951 node->attr.i.tori.typ = tp;
955 get_SymConst_ptrinfo (ir_node *node) {
956 assert ( (node->op == op_SymConst)
957 && (get_SymConst_kind(node) == linkage_ptr_info));
958 return node->attr.i.tori.ptrinfo;
962 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
963 assert ( (node->op == op_SymConst)
964 && (get_SymConst_kind(node) == linkage_ptr_info));
965 node->attr.i.tori.ptrinfo = ptrinfo;
969 get_SymConst_type_or_id (ir_node *node) {
970 assert (node->op == op_SymConst);
971 return &(node->attr.i.tori);
975 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
976 assert (node->op == op_SymConst);
977 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
981 get_Sel_mem (ir_node *node) {
982 assert (node->op == op_Sel);
983 return get_irn_n(node, 0);
987 set_Sel_mem (ir_node *node, ir_node *mem) {
988 assert (node->op == op_Sel);
989 set_irn_n(node, 0, mem);
993 get_Sel_ptr (ir_node *node) {
994 assert (node->op == op_Sel);
995 return get_irn_n(node, 1);
999 set_Sel_ptr (ir_node *node, ir_node *ptr) {
1000 assert (node->op == op_Sel);
1001 set_irn_n(node, 1, ptr);
1005 get_Sel_n_indexs (ir_node *node) {
1006 assert (node->op == op_Sel);
1007 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
1011 get_Sel_index_arr (ir_node *node)
1013 assert ((node->op == op_Sel));
1014 if (get_Sel_n_indexs(node) > 0)
1015 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
1021 get_Sel_index (ir_node *node, int pos) {
1022 assert (node->op == op_Sel);
1023 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
1027 set_Sel_index (ir_node *node, int pos, ir_node *index) {
1028 assert (node->op == op_Sel);
1029 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
1033 get_Sel_entity (ir_node *node) {
1034 assert (node->op == op_Sel);
1035 return node->attr.s.ent;
1039 set_Sel_entity (ir_node *node, entity *ent) {
1040 assert (node->op == op_Sel);
1041 node->attr.s.ent = ent;
1045 get_InstOf_ent (ir_node *node) {
1046 assert (node->op = op_InstOf);
1047 return (node->attr.io.ent);
1051 set_InstOf_ent (ir_node *node, type *ent) {
1052 assert (node->op = op_InstOf);
1053 node->attr.io.ent = ent;
1057 get_InstOf_store (ir_node *node) {
1058 assert (node->op = op_InstOf);
1059 return (get_irn_n (node, 0));
1063 set_InstOf_store (ir_node *node, ir_node *obj) {
1064 assert (node->op = op_InstOf);
1065 set_irn_n (node, 0, obj);
1069 get_InstOf_obj (ir_node *node) {
1070 assert (node->op = op_InstOf);
1071 return (get_irn_n (node, 1));
1075 set_InstOf_obj (ir_node *node, ir_node *obj) {
1076 assert (node->op = op_InstOf);
1077 set_irn_n (node, 1, obj);
1081 /* For unary and binary arithmetic operations the access to the
1082 operands can be factored out. Left is the first, right the
1083 second arithmetic value as listed in tech report 0999-33.
1084 unops are: Minus, Abs, Not, Conv, Cast
1085 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1086 Shr, Shrs, Rotate, Cmp */
1090 get_Call_mem (ir_node *node) {
1091 assert (node->op == op_Call);
1092 return get_irn_n(node, 0);
1096 set_Call_mem (ir_node *node, ir_node *mem) {
1097 assert (node->op == op_Call);
1098 set_irn_n(node, 0, mem);
1102 get_Call_ptr (ir_node *node) {
1103 assert (node->op == op_Call);
1104 return get_irn_n(node, 1);
1108 set_Call_ptr (ir_node *node, ir_node *ptr) {
1109 assert (node->op == op_Call);
1110 set_irn_n(node, 1, ptr);
1114 get_Call_param_arr (ir_node *node) {
1115 assert (node->op == op_Call);
1116 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1120 get_Call_n_params (ir_node *node) {
1121 assert (node->op == op_Call);
1122 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1126 get_Call_arity (ir_node *node) {
1127 assert (node->op == op_Call);
1128 return get_Call_n_params(node);
1132 set_Call_arity (ir_node *node, ir_node *arity) {
1133 assert (node->op == op_Call);
1138 get_Call_param (ir_node *node, int pos) {
1139 assert (node->op == op_Call);
1140 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1144 set_Call_param (ir_node *node, int pos, ir_node *param) {
1145 assert (node->op == op_Call);
1146 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1150 get_Call_type (ir_node *node) {
1151 assert (node->op == op_Call);
1152 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1156 set_Call_type (ir_node *node, type *tp) {
1157 assert (node->op == op_Call);
1158 assert (is_method_type(tp));
1159 node->attr.call.cld_tp = tp;
1162 int Call_has_callees(ir_node *node) {
1163 return (node->attr.call.callee_arr != NULL);
1166 int get_Call_n_callees(ir_node * node) {
1167 assert(node->op == op_Call && node->attr.call.callee_arr);
1168 return ARR_LEN(node->attr.call.callee_arr);
1171 entity * get_Call_callee(ir_node * node, int pos) {
1172 assert(node->op == op_Call && node->attr.call.callee_arr);
1173 return node->attr.call.callee_arr[pos];
1176 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1177 assert(node->op == op_Call);
1178 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1179 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1181 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1184 void remove_Call_callee_arr(ir_node * node) {
1185 assert(node->op == op_Call);
1186 node->attr.call.callee_arr = NULL;
1189 ir_node * get_CallBegin_ptr (ir_node *node) {
1190 assert(node->op == op_CallBegin);
1191 return get_irn_n(node, 0);
1193 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1194 assert(node->op == op_CallBegin);
1195 set_irn_n(node, 0, ptr);
1197 ir_graph * get_CallBegin_irg (ir_node *node) {
1198 return get_irn_irg(node);
1200 ir_node * get_CallBegin_call (ir_node *node) {
1201 assert(node->op == op_CallBegin);
1202 return node->attr.callbegin.call;
1204 void set_CallBegin_call (ir_node *node, ir_node *call) {
1205 assert(node->op == op_CallBegin);
1206 node->attr.callbegin.call = call;
1210 get_Add_left (ir_node *node) {
1211 assert (node->op == op_Add);
1212 return get_irn_n(node, 0);
1216 set_Add_left (ir_node *node, ir_node *left) {
1217 assert (node->op == op_Add);
1218 set_irn_n(node, 0, left);
1222 get_Add_right (ir_node *node) {
1223 assert (node->op == op_Add);
1224 return get_irn_n(node, 1);
1228 set_Add_right (ir_node *node, ir_node *right) {
1229 assert (node->op == op_Add);
1230 set_irn_n(node, 1, right);
1234 get_Sub_left (ir_node *node) {
1235 assert (node->op == op_Sub);
1236 return get_irn_n(node, 0);
1240 set_Sub_left (ir_node *node, ir_node *left) {
1241 assert (node->op == op_Sub);
1242 set_irn_n(node, 0, left);
1246 get_Sub_right (ir_node *node) {
1247 assert (node->op == op_Sub);
1248 return get_irn_n(node, 1);
1252 set_Sub_right (ir_node *node, ir_node *right) {
1253 assert (node->op == op_Sub);
1254 set_irn_n(node, 1, right);
1259 get_Minus_op (ir_node *node) {
1260 assert (node->op == op_Minus);
1261 return get_irn_n(node, 0);
1265 set_Minus_op (ir_node *node, ir_node *op) {
1266 assert (node->op == op_Minus);
1267 set_irn_n(node, 0, op);
1272 get_Mul_left (ir_node *node) {
1273 assert (node->op == op_Mul);
1274 return get_irn_n(node, 0);
1278 set_Mul_left (ir_node *node, ir_node *left) {
1279 assert (node->op == op_Mul);
1280 set_irn_n(node, 0, left);
1284 get_Mul_right (ir_node *node) {
1285 assert (node->op == op_Mul);
1286 return get_irn_n(node, 1);
1290 set_Mul_right (ir_node *node, ir_node *right) {
1291 assert (node->op == op_Mul);
1292 set_irn_n(node, 1, right);
1296 get_Quot_left (ir_node *node) {
1297 assert (node->op == op_Quot);
1298 return get_irn_n(node, 1);
1302 set_Quot_left (ir_node *node, ir_node *left) {
1303 assert (node->op == op_Quot);
1304 set_irn_n(node, 1, left);
1308 get_Quot_right (ir_node *node) {
1309 assert (node->op == op_Quot);
1310 return get_irn_n(node, 2);
1314 set_Quot_right (ir_node *node, ir_node *right) {
1315 assert (node->op == op_Quot);
1316 set_irn_n(node, 2, right);
1320 get_Quot_mem (ir_node *node) {
1321 assert (node->op == op_Quot);
1322 return get_irn_n(node, 0);
1326 set_Quot_mem (ir_node *node, ir_node *mem) {
1327 assert (node->op == op_Quot);
1328 set_irn_n(node, 0, mem);
1332 get_DivMod_left (ir_node *node) {
1333 assert (node->op == op_DivMod);
1334 return get_irn_n(node, 1);
1338 set_DivMod_left (ir_node *node, ir_node *left) {
1339 assert (node->op == op_DivMod);
1340 set_irn_n(node, 1, left);
1344 get_DivMod_right (ir_node *node) {
1345 assert (node->op == op_DivMod);
1346 return get_irn_n(node, 2);
1350 set_DivMod_right (ir_node *node, ir_node *right) {
1351 assert (node->op == op_DivMod);
1352 set_irn_n(node, 2, right);
1356 get_DivMod_mem (ir_node *node) {
1357 assert (node->op == op_DivMod);
1358 return get_irn_n(node, 0);
1362 set_DivMod_mem (ir_node *node, ir_node *mem) {
1363 assert (node->op == op_DivMod);
1364 set_irn_n(node, 0, mem);
1368 get_Div_left (ir_node *node) {
1369 assert (node->op == op_Div);
1370 return get_irn_n(node, 1);
1374 set_Div_left (ir_node *node, ir_node *left) {
1375 assert (node->op == op_Div);
1376 set_irn_n(node, 1, left);
1380 get_Div_right (ir_node *node) {
1381 assert (node->op == op_Div);
1382 return get_irn_n(node, 2);
1386 set_Div_right (ir_node *node, ir_node *right) {
1387 assert (node->op == op_Div);
1388 set_irn_n(node, 2, right);
1392 get_Div_mem (ir_node *node) {
1393 assert (node->op == op_Div);
1394 return get_irn_n(node, 0);
1398 set_Div_mem (ir_node *node, ir_node *mem) {
1399 assert (node->op == op_Div);
1400 set_irn_n(node, 0, mem);
1404 get_Mod_left (ir_node *node) {
1405 assert (node->op == op_Mod);
1406 return get_irn_n(node, 1);
1410 set_Mod_left (ir_node *node, ir_node *left) {
1411 assert (node->op == op_Mod);
1412 set_irn_n(node, 1, left);
1416 get_Mod_right (ir_node *node) {
1417 assert (node->op == op_Mod);
1418 return get_irn_n(node, 2);
1422 set_Mod_right (ir_node *node, ir_node *right) {
1423 assert (node->op == op_Mod);
1424 set_irn_n(node, 2, right);
1428 get_Mod_mem (ir_node *node) {
1429 assert (node->op == op_Mod);
1430 return get_irn_n(node, 0);
1434 set_Mod_mem (ir_node *node, ir_node *mem) {
1435 assert (node->op == op_Mod);
1436 set_irn_n(node, 0, mem);
1440 get_Abs_op (ir_node *node) {
1441 assert (node->op == op_Abs);
1442 return get_irn_n(node, 0);
1446 set_Abs_op (ir_node *node, ir_node *op) {
1447 assert (node->op == op_Abs);
1448 set_irn_n(node, 0, op);
1452 get_And_left (ir_node *node) {
1453 assert (node->op == op_And);
1454 return get_irn_n(node, 0);
1458 set_And_left (ir_node *node, ir_node *left) {
1459 assert (node->op == op_And);
1460 set_irn_n(node, 0, left);
1464 get_And_right (ir_node *node) {
1465 assert (node->op == op_And);
1466 return get_irn_n(node, 1);
1470 set_And_right (ir_node *node, ir_node *right) {
1471 assert (node->op == op_And);
1472 set_irn_n(node, 1, right);
1476 get_Or_left (ir_node *node) {
1477 assert (node->op == op_Or);
1478 return get_irn_n(node, 0);
1482 set_Or_left (ir_node *node, ir_node *left) {
1483 assert (node->op == op_Or);
1484 set_irn_n(node, 0, left);
1488 get_Or_right (ir_node *node) {
1489 assert (node->op == op_Or);
1490 return get_irn_n(node, 1);
1494 set_Or_right (ir_node *node, ir_node *right) {
1495 assert (node->op == op_Or);
1496 set_irn_n(node, 1, right);
1500 get_Eor_left (ir_node *node) {
1501 assert (node->op == op_Eor);
1502 return get_irn_n(node, 0);
1506 set_Eor_left (ir_node *node, ir_node *left) {
1507 assert (node->op == op_Eor);
1508 set_irn_n(node, 0, left);
1512 get_Eor_right (ir_node *node) {
1513 assert (node->op == op_Eor);
1514 return get_irn_n(node, 1);
1518 set_Eor_right (ir_node *node, ir_node *right) {
1519 assert (node->op == op_Eor);
1520 set_irn_n(node, 1, right);
1525 get_Not_op (ir_node *node) {
1526 assert (node->op == op_Not);
1527 return get_irn_n(node, 0);
1531 set_Not_op (ir_node *node, ir_node *op) {
1532 assert (node->op == op_Not);
1533 set_irn_n(node, 0, op);
1538 get_Shl_left (ir_node *node) {
1539 assert (node->op == op_Shl);
1540 return get_irn_n(node, 0);
1544 set_Shl_left (ir_node *node, ir_node *left) {
1545 assert (node->op == op_Shl);
1546 set_irn_n(node, 0, left);
1550 get_Shl_right (ir_node *node) {
1551 assert (node->op == op_Shl);
1552 return get_irn_n(node, 1);
1556 set_Shl_right (ir_node *node, ir_node *right) {
1557 assert (node->op == op_Shl);
1558 set_irn_n(node, 1, right);
1562 get_Shr_left (ir_node *node) {
1563 assert (node->op == op_Shr);
1564 return get_irn_n(node, 0);
1568 set_Shr_left (ir_node *node, ir_node *left) {
1569 assert (node->op == op_Shr);
1570 set_irn_n(node, 0, left);
1574 get_Shr_right (ir_node *node) {
1575 assert (node->op == op_Shr);
1576 return get_irn_n(node, 1);
1580 set_Shr_right (ir_node *node, ir_node *right) {
1581 assert (node->op == op_Shr);
1582 set_irn_n(node, 1, right);
1586 get_Shrs_left (ir_node *node) {
1587 assert (node->op == op_Shrs);
1588 return get_irn_n(node, 0);
1592 set_Shrs_left (ir_node *node, ir_node *left) {
1593 assert (node->op == op_Shrs);
1594 set_irn_n(node, 0, left);
1598 get_Shrs_right (ir_node *node) {
1599 assert (node->op == op_Shrs);
1600 return get_irn_n(node, 1);
1604 set_Shrs_right (ir_node *node, ir_node *right) {
1605 assert (node->op == op_Shrs);
1606 set_irn_n(node, 1, right);
1610 get_Rot_left (ir_node *node) {
1611 assert (node->op == op_Rot);
1612 return get_irn_n(node, 0);
1616 set_Rot_left (ir_node *node, ir_node *left) {
1617 assert (node->op == op_Rot);
1618 set_irn_n(node, 0, left);
1622 get_Rot_right (ir_node *node) {
1623 assert (node->op == op_Rot);
1624 return get_irn_n(node, 1);
1628 set_Rot_right (ir_node *node, ir_node *right) {
1629 assert (node->op == op_Rot);
1630 set_irn_n(node, 1, right);
1634 get_Cmp_left (ir_node *node) {
1635 assert (node->op == op_Cmp);
1636 return get_irn_n(node, 0);
1640 set_Cmp_left (ir_node *node, ir_node *left) {
1641 assert (node->op == op_Cmp);
1642 set_irn_n(node, 0, left);
1646 get_Cmp_right (ir_node *node) {
1647 assert (node->op == op_Cmp);
1648 return get_irn_n(node, 1);
1652 set_Cmp_right (ir_node *node, ir_node *right) {
1653 assert (node->op == op_Cmp);
1654 set_irn_n(node, 1, right);
1658 get_Conv_op (ir_node *node) {
1659 assert (node->op == op_Conv);
1660 return get_irn_n(node, 0);
1664 set_Conv_op (ir_node *node, ir_node *op) {
1665 assert (node->op == op_Conv);
1666 set_irn_n(node, 0, op);
1670 get_Cast_op (ir_node *node) {
1671 assert (node->op == op_Cast);
1672 return get_irn_n(node, 0);
1676 set_Cast_op (ir_node *node, ir_node *op) {
1677 assert (node->op == op_Cast);
1678 set_irn_n(node, 0, op);
1682 get_Cast_type (ir_node *node) {
1683 assert (node->op == op_Cast);
1684 return node->attr.cast.totype;
1688 set_Cast_type (ir_node *node, type *to_tp) {
1689 assert (node->op == op_Cast);
1690 node->attr.cast.totype = to_tp;
1694 is_unop (ir_node *node) {
1695 return (node->op->opar == oparity_unary);
1699 get_unop_op (ir_node *node) {
1700 assert (is_unop(node));
1701 switch (get_irn_opcode (node)) {
1702 case iro_Minus: return get_Minus_op(node); break;
1703 case iro_Abs: return get_Abs_op(node); break;
1704 case iro_Not: return get_Not_op(node); break;
1705 case iro_Conv: return get_Conv_op(node); break;
1706 case iro_Cast: return get_Cast_op(node); break;
1707 default: return NULL;
1712 set_unop_op (ir_node *node, ir_node *op) {
1713 assert (is_unop(node));
1714 switch (get_irn_opcode (node)) {
1715 case iro_Minus: set_Minus_op(node, op); break;
1716 case iro_Abs: set_Abs_op(node, op); break;
1717 case iro_Not: set_Not_op(node, op); break;
1718 case iro_Conv: set_Conv_op(node, op); break;
1719 case iro_Cast: set_Cast_op(node, op); break;
1726 is_binop (ir_node *node) {
1727 return (node->op->opar == oparity_binary);
1728 /* return (node->op == op_Add ||
1729 node->op == op_Cmp ||
1730 node->op == op_Sub ||
1731 node->op == op_Mul ||
1732 node->op == op_Quot ||
1733 node->op == op_DivMod ||
1734 node->op == op_Div ||
1735 node->op == op_Mod ||
1736 node->op == op_And ||
1737 node->op == op_Or ||
1738 node->op == op_Eor ||
1739 node->op == op_Shl ||
1740 node->op == op_Shr ||
1741 node->op == op_Shrs ||
1742 node->op == op_Rot );
1747 get_binop_left (ir_node *node) {
1748 assert (node->op->opar == oparity_binary);
1750 switch (get_irn_opcode (node)) {
1751 case iro_Add : return get_Add_left(node); break;
1752 case iro_Sub : return get_Sub_left(node); break;
1753 case iro_Mul : return get_Mul_left(node); break;
1754 case iro_Quot : return get_Quot_left(node); break;
1755 case iro_DivMod: return get_DivMod_left(node); break;
1756 case iro_Div : return get_Div_left(node); break;
1757 case iro_Mod : return get_Mod_left(node); break;
1758 case iro_And : return get_And_left(node); break;
1759 case iro_Or : return get_Or_left(node); break;
1760 case iro_Eor : return get_Eor_left(node); break;
1761 case iro_Shl : return get_Shl_left(node); break;
1762 case iro_Shr : return get_Shr_left(node); break;
1763 case iro_Shrs : return get_Shrs_left(node); break;
1764 case iro_Rot : return get_Rot_left(node); break;
1765 case iro_Cmp : return get_Cmp_left(node); break;
1766 default: return NULL;
1771 set_binop_left (ir_node *node, ir_node *left) {
1772 assert (node->op->opar == oparity_binary);
1774 switch (get_irn_opcode (node)) {
1775 case iro_Add : set_Add_left(node, left); break;
1776 case iro_Sub : set_Sub_left(node, left); break;
1777 case iro_Mul : set_Mul_left(node, left); break;
1778 case iro_Quot : set_Quot_left(node, left); break;
1779 case iro_DivMod: set_DivMod_left(node, left); break;
1780 case iro_Div : set_Div_left(node, left); break;
1781 case iro_Mod : set_Mod_left(node, left); break;
1782 case iro_And : set_And_left(node, left); break;
1783 case iro_Or : set_Or_left(node, left); break;
1784 case iro_Eor : set_Eor_left(node, left); break;
1785 case iro_Shl : set_Shl_left(node, left); break;
1786 case iro_Shr : set_Shr_left(node, left); break;
1787 case iro_Shrs : set_Shrs_left(node, left); break;
1788 case iro_Rot : set_Rot_left(node, left); break;
1789 case iro_Cmp : set_Cmp_left(node, left); break;
1795 get_binop_right (ir_node *node) {
1796 assert (node->op->opar == oparity_binary);
1798 switch (get_irn_opcode (node)) {
1799 case iro_Add : return get_Add_right(node); break;
1800 case iro_Sub : return get_Sub_right(node); break;
1801 case iro_Mul : return get_Mul_right(node); break;
1802 case iro_Quot : return get_Quot_right(node); break;
1803 case iro_DivMod: return get_DivMod_right(node); break;
1804 case iro_Div : return get_Div_right(node); break;
1805 case iro_Mod : return get_Mod_right(node); break;
1806 case iro_And : return get_And_right(node); break;
1807 case iro_Or : return get_Or_right(node); break;
1808 case iro_Eor : return get_Eor_right(node); break;
1809 case iro_Shl : return get_Shl_right(node); break;
1810 case iro_Shr : return get_Shr_right(node); break;
1811 case iro_Shrs : return get_Shrs_right(node); break;
1812 case iro_Rot : return get_Rot_right(node); break;
1813 case iro_Cmp : return get_Cmp_right(node); break;
1814 default: return NULL;
1819 set_binop_right (ir_node *node, ir_node *right) {
1820 assert (node->op->opar == oparity_binary);
1822 switch (get_irn_opcode (node)) {
1823 case iro_Add : set_Add_right(node, right); break;
1824 case iro_Sub : set_Sub_right(node, right); break;
1825 case iro_Mul : set_Mul_right(node, right); break;
1826 case iro_Quot : set_Quot_right(node, right); break;
1827 case iro_DivMod: set_DivMod_right(node, right); break;
1828 case iro_Div : set_Div_right(node, right); break;
1829 case iro_Mod : set_Mod_right(node, right); break;
1830 case iro_And : set_And_right(node, right); break;
1831 case iro_Or : set_Or_right(node, right); break;
1832 case iro_Eor : set_Eor_right(node, right); break;
1833 case iro_Shl : set_Shl_right(node, right); break;
1834 case iro_Shr : set_Shr_right(node, right); break;
1835 case iro_Shrs : set_Shrs_right(node, right); break;
1836 case iro_Rot : set_Rot_right(node, right); break;
1837 case iro_Cmp : set_Cmp_right(node, right); break;
1842 INLINE int is_Phi (ir_node *n) {
1844 return ((get_irn_op(n) == op_Phi) ||
1845 (get_irn_op(n) == op_Filter && interprocedural_view));
1849 get_Phi_preds_arr (ir_node *node) {
1850 assert (node->op == op_Phi);
1851 return (ir_node **)&(get_irn_in(node)[1]);
1855 get_Phi_n_preds (ir_node *node) {
1856 assert (is_Phi(node));
1857 return (get_irn_arity(node));
1861 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1862 assert (node->op == op_Phi);
1867 get_Phi_pred (ir_node *node, int pos) {
1868 assert (is_Phi(node));
1869 return get_irn_n(node, pos);
1873 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1874 assert (is_Phi(node));
1875 set_irn_n(node, pos, pred);
1879 get_Load_mem (ir_node *node) {
1880 assert (node->op == op_Load);
1881 return get_irn_n(node, 0);
1885 set_Load_mem (ir_node *node, ir_node *mem) {
1886 assert (node->op == op_Load);
1887 set_irn_n(node, 0, mem);
1891 get_Load_ptr (ir_node *node) {
1892 assert (node->op == op_Load);
1893 return get_irn_n(node, 1);
1897 set_Load_ptr (ir_node *node, ir_node *ptr) {
1898 assert (node->op == op_Load);
1899 set_irn_n(node, 1, ptr);
1904 get_Store_mem (ir_node *node) {
1905 assert (node->op == op_Store);
1906 return get_irn_n(node, 0);
1910 set_Store_mem (ir_node *node, ir_node *mem) {
1911 assert (node->op == op_Store);
1912 set_irn_n(node, 0, mem);
1916 get_Store_ptr (ir_node *node) {
1917 assert (node->op == op_Store);
1918 return get_irn_n(node, 1);
1922 set_Store_ptr (ir_node *node, ir_node *ptr) {
1923 assert (node->op == op_Store);
1924 set_irn_n(node, 1, ptr);
1928 get_Store_value (ir_node *node) {
1929 assert (node->op == op_Store);
1930 return get_irn_n(node, 2);
1934 set_Store_value (ir_node *node, ir_node *value) {
1935 assert (node->op == op_Store);
1936 set_irn_n(node, 2, value);
1940 get_Alloc_mem (ir_node *node) {
1941 assert (node->op == op_Alloc);
1942 return get_irn_n(node, 0);
1946 set_Alloc_mem (ir_node *node, ir_node *mem) {
1947 assert (node->op == op_Alloc);
1948 set_irn_n(node, 0, mem);
1952 get_Alloc_size (ir_node *node) {
1953 assert (node->op == op_Alloc);
1954 return get_irn_n(node, 1);
1958 set_Alloc_size (ir_node *node, ir_node *size) {
1959 assert (node->op == op_Alloc);
1960 set_irn_n(node, 1, size);
1964 get_Alloc_type (ir_node *node) {
1965 assert (node->op == op_Alloc);
1966 return node->attr.a.type = skip_tid(node->attr.a.type);
1970 set_Alloc_type (ir_node *node, type *tp) {
1971 assert (node->op == op_Alloc);
1972 node->attr.a.type = tp;
1976 get_Alloc_where (ir_node *node) {
1977 assert (node->op == op_Alloc);
1978 return node->attr.a.where;
1982 set_Alloc_where (ir_node *node, where_alloc where) {
1983 assert (node->op == op_Alloc);
1984 node->attr.a.where = where;
1989 get_Free_mem (ir_node *node) {
1990 assert (node->op == op_Free);
1991 return get_irn_n(node, 0);
1995 set_Free_mem (ir_node *node, ir_node *mem) {
1996 assert (node->op == op_Free);
1997 set_irn_n(node, 0, mem);
2001 get_Free_ptr (ir_node *node) {
2002 assert (node->op == op_Free);
2003 return get_irn_n(node, 1);
2007 set_Free_ptr (ir_node *node, ir_node *ptr) {
2008 assert (node->op == op_Free);
2009 set_irn_n(node, 1, ptr);
2013 get_Free_size (ir_node *node) {
2014 assert (node->op == op_Free);
2015 return get_irn_n(node, 2);
2019 set_Free_size (ir_node *node, ir_node *size) {
2020 assert (node->op == op_Free);
2021 set_irn_n(node, 2, size);
2025 get_Free_type (ir_node *node) {
2026 assert (node->op == op_Free);
2027 return node->attr.f = skip_tid(node->attr.f);
2031 set_Free_type (ir_node *node, type *tp) {
2032 assert (node->op == op_Free);
2037 get_Sync_preds_arr (ir_node *node) {
2038 assert (node->op == op_Sync);
2039 return (ir_node **)&(get_irn_in(node)[1]);
2043 get_Sync_n_preds (ir_node *node) {
2044 assert (node->op == op_Sync);
2045 return (get_irn_arity(node));
2050 set_Sync_n_preds (ir_node *node, int n_preds) {
2051 assert (node->op == op_Sync);
2056 get_Sync_pred (ir_node *node, int pos) {
2057 assert (node->op == op_Sync);
2058 return get_irn_n(node, pos);
2062 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
2063 assert (node->op == op_Sync);
2064 set_irn_n(node, pos, pred);
2068 get_Proj_pred (ir_node *node) {
2069 assert (is_Proj(node));
2070 return get_irn_n(node, 0);
2074 set_Proj_pred (ir_node *node, ir_node *pred) {
2075 assert (is_Proj(node));
2076 set_irn_n(node, 0, pred);
2080 get_Proj_proj (ir_node *node) {
2081 assert (is_Proj(node));
2082 if (get_irn_opcode(node) == iro_Proj) {
2083 return node->attr.proj;
2085 assert(get_irn_opcode(node) == iro_Filter);
2086 return node->attr.filter.proj;
2091 set_Proj_proj (ir_node *node, long proj) {
2092 assert (node->op == op_Proj);
2093 node->attr.proj = proj;
2097 get_Tuple_preds_arr (ir_node *node) {
2098 assert (node->op == op_Tuple);
2099 return (ir_node **)&(get_irn_in(node)[1]);
2103 get_Tuple_n_preds (ir_node *node) {
2104 assert (node->op == op_Tuple);
2105 return (get_irn_arity(node));
2110 set_Tuple_n_preds (ir_node *node, int n_preds) {
2111 assert (node->op == op_Tuple);
2116 get_Tuple_pred (ir_node *node, int pos) {
2117 assert (node->op == op_Tuple);
2118 return get_irn_n(node, pos);
2122 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2123 assert (node->op == op_Tuple);
2124 set_irn_n(node, pos, pred);
2128 get_Id_pred (ir_node *node) {
2129 assert (node->op == op_Id);
2130 return get_irn_n(node, 0);
2134 set_Id_pred (ir_node *node, ir_node *pred) {
2135 assert (node->op == op_Id);
2136 set_irn_n(node, 0, pred);
2139 INLINE ir_node *get_Confirm_value (ir_node *node) {
2140 assert (node->op == op_Confirm);
2141 return get_irn_n(node, 0);
2143 INLINE void set_Confirm_value (ir_node *node, ir_node *value) {
2144 assert (node->op == op_Confirm);
2145 set_irn_n(node, 0, value);
2147 INLINE ir_node *get_Confirm_bound (ir_node *node) {
2148 assert (node->op == op_Confirm);
2149 return get_irn_n(node, 1);
2151 INLINE void set_Confirm_bound (ir_node *node, ir_node *bound) {
2152 assert (node->op == op_Confirm);
2153 set_irn_n(node, 0, bound);
2155 INLINE pn_Cmp get_Confirm_cmp (ir_node *node) {
2156 assert (node->op == op_Confirm);
2157 return node->attr.confirm_cmp;
2159 INLINE void set_Confirm_cmp (ir_node *node, pn_Cmp cmp) {
2160 assert (node->op == op_Confirm);
2161 node->attr.confirm_cmp = cmp;
2166 get_Filter_pred (ir_node *node) {
2167 assert(node->op == op_Filter);
2171 set_Filter_pred (ir_node *node, ir_node *pred) {
2172 assert(node->op == op_Filter);
2176 get_Filter_proj(ir_node *node) {
2177 assert(node->op == op_Filter);
2178 return node->attr.filter.proj;
2181 set_Filter_proj (ir_node *node, long proj) {
2182 assert(node->op == op_Filter);
2183 node->attr.filter.proj = proj;
2186 /* Don't use get_irn_arity, get_irn_n in implementation as access
2187 shall work independent of view!!! */
2188 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2189 assert(node->op == op_Filter);
2190 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2191 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2192 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2193 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2194 node->attr.filter.in_cg[0] = node->in[0];
2196 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2199 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2200 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2201 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2202 node->attr.filter.in_cg[pos + 1] = pred;
2204 int get_Filter_n_cg_preds(ir_node *node) {
2205 assert(node->op == op_Filter && node->attr.filter.in_cg);
2206 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2208 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2210 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2212 arity = ARR_LEN(node->attr.filter.in_cg);
2213 assert(pos < arity - 1);
2214 return node->attr.filter.in_cg[pos + 1];
2219 get_irn_irg(ir_node *node) {
2220 if (get_irn_op(node) != op_Block)
2221 node = get_nodes_block(node);
2222 assert(get_irn_op(node) == op_Block);
2223 return node->attr.block.irg;
2227 /******************************************************************/
2228 /* Auxiliary routines */
2229 /******************************************************************/
2232 skip_Proj (ir_node *node) {
2233 /* don't assert node !!! */
2234 if (node && is_Proj(node)) {
2235 return get_Proj_pred(node);
2242 skip_Tuple (ir_node *node) {
2245 if (!get_opt_normalize()) return node;
2247 node = skip_nop(node);
2248 if (get_irn_op(node) == op_Proj) {
2249 pred = skip_nop(get_Proj_pred(node));
2250 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2251 pred = skip_nop(skip_Tuple(pred));
2252 if (get_irn_op(pred) == op_Tuple)
2253 return get_Tuple_pred(pred, get_Proj_proj(node));
2259 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2260 than any other approach, as Id chains are resolved and all point to the real node, or
2261 all id's are self loops. */
2263 skip_nop (ir_node *node) {
2264 /* don't assert node !!! */
2266 if (!get_opt_normalize()) return node;
2268 /* Don't use get_Id_pred: We get into an endless loop for
2269 self-referencing Ids. */
2270 if (node && (node->op == op_Id) && (node != node->in[0+1])) {
2271 ir_node *rem_pred = node->in[0+1];
2274 assert (get_irn_arity (node) > 0);
2276 node->in[0+1] = node;
2277 res = skip_nop(rem_pred);
2278 if (res->op == op_Id) /* self-loop */ return node;
2280 node->in[0+1] = res;
2287 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2288 than any other approach, as Id chains are resolved and all point to the real node, or
2289 all id's are self loops. */
2290 extern int opt_normalize;
2292 skip_nop (ir_node *node) {
2294 /* don't assert node !!! */
2296 if (!get_opt_normalize()) return node;
2298 /* Don't use get_Id_pred: We get into an endless loop for
2299 self-referencing Ids. */
2300 if (node && (node->op == op_Id) && (node != (pred = node->in[0+1]))) {
2301 ir_node *rem_pred, *res;
2303 if (pred->op != op_Id) return pred; /* shortcut */
2306 assert (get_irn_arity (node) > 0);
2308 node->in[0+1] = node;
2309 res = skip_nop(rem_pred);
2310 if (res->op == op_Id) /* self-loop */ return node;
2312 node->in[0+1] = res;
2323 skip_Id (ir_node *node) {
2324 return skip_nop(node);
2328 is_Bad (ir_node *node) {
2330 if ((node) && get_irn_opcode(node) == iro_Bad)
2336 is_no_Block (ir_node *node) {
2338 return (get_irn_opcode(node) != iro_Block);
2342 is_Block (ir_node *node) {
2344 return (get_irn_opcode(node) == iro_Block);
2347 /* returns true if node is a Unknown node. */
2349 is_Unknown (ir_node *node) {
2351 return (get_irn_opcode(node) == iro_Unknown);
2355 is_Proj (const ir_node *node) {
2357 return node->op == op_Proj
2358 || (!interprocedural_view && node->op == op_Filter);
2361 /* Returns true if the operation manipulates control flow. */
2363 is_cfop(ir_node *node) {
2364 return is_cfopcode(get_irn_op(node));
2367 /* Returns true if the operation manipulates interprocedural control flow:
2368 CallBegin, EndReg, EndExcept */
2369 INLINE int is_ip_cfop(ir_node *node) {
2370 return is_ip_cfopcode(get_irn_op(node));
2373 ir_graph *get_ip_cfop_irg(ir_node *n) {
2374 return get_irn_irg(n);
2377 /* Returns true if the operation can change the control flow because
2380 is_fragile_op(ir_node *node) {
2381 return ( (get_irn_opcode(node) == iro_Call)
2382 || (get_irn_opcode(node) == iro_Quot)
2383 || (get_irn_opcode(node) == iro_DivMod)
2384 || (get_irn_opcode(node) == iro_Div)
2385 || (get_irn_opcode(node) == iro_Mod)
2386 || (get_irn_opcode(node) == iro_Load)
2387 || (get_irn_opcode(node) == iro_Store)
2388 || (get_irn_opcode(node) == iro_Alloc)
2389 || (get_irn_opcode(node) == iro_Bad)
2390 || (get_irn_opcode(node) == iro_Unknown));
2394 /* Returns the memory operand of fragile operations. */
2395 ir_node *get_fragile_op_mem(ir_node *node) {
2396 assert(node && is_fragile_op(node));
2398 switch (get_irn_opcode (node)) {
2407 return get_irn_n(node, 0);
2412 assert(0 && "should not be reached");