1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
16 #include "irgraph_t.h"
19 #include "typegmod_t.h"
21 #include "irbackedge_t.h"
28 /* some constants fixing the positions of nodes predecessors
30 #define CALL_PARAM_OFFSET 2
31 #define SEL_INDEX_OFFSET 2
32 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
33 #define END_KEEPALIVE_OFFSET 0
35 /* Declarations for inlineing */
36 INLINE ir_node ** get_irn_in (ir_node *node);
37 INLINE ir_mode *get_irn_mode (ir_node *node);
38 INLINE ir_op *get_irn_op (ir_node *node);
39 INLINE opcode get_irn_opcode (ir_node *node);
40 INLINE ident *get_irn_opident (ir_node *node);
41 INLINE type *get_SymConst_type (ir_node *node);
42 INLINE ir_node *skip_nop (ir_node *node);
43 INLINE ir_node *skip_nop (ir_node *node);
44 INLINE int is_Proj (ir_node *node);
47 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
48 "Gt", "Ge", "Lg", "Leg", "Uo",
49 "Ue", "Ul", "Ule", "Ug", "Uge",
52 INLINE char *get_pnc_string(int pnc) {
53 return pnc_name_arr[pnc];
58 get_negated_pnc(int pnc) {
60 case False: return True; break;
61 case Eq: return Ne; break;
62 case Lt: return Uge; break;
63 case Le: return Ug; break;
64 case Gt: return Ule; break;
65 case Ge: return Ul; break;
66 case Lg: return Ue; break;
67 case Leg: return Uo; break;
68 case Uo: return Leg; break;
69 case Ue: return Lg; break;
70 case Ul: return Ge; break;
71 case Ule: return Gt; break;
72 case Ug: return Le; break;
73 case Uge: return Lt; break;
74 case Ne: return Eq; break;
75 case True: return False; break;
77 return 99; /* to shut up gcc */
80 static char *pns_name_arr [] = {"initial_exec", "global_store",
81 "frame_base", "globals", "args"};
83 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
90 /* irnode constructor */
91 /* create a new irnode in irg, with an op, mode, arity and */
92 /* some incoming irnodes */
93 /* this constructor is used in every specified irnode constructor */
95 new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
96 int arity, ir_node **in)
99 int node_size = offsetof (ir_node, attr) + op->attr_size;
101 res = (ir_node *) obstack_alloc (irg->obst, node_size);
103 res->kind = k_ir_node;
109 res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
111 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
112 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
115 set_irn_dbg_info(res, db);
119 res->node_nr = get_irp_new_node_nr();
125 /* Copies all attributes stored in the old node to the new node.
126 Assumes both have the same opcode and sufficient size. */
128 copy_attrs (ir_node *old, ir_node *new) {
129 assert (get_irn_op(old) == get_irn_op(new));
130 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
133 /* IR-Nodes with attributes */
135 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
138 ir_node *np = XP_GETARG (ir_node *, 0);
141 XPS ("<null ir_node>");
145 XPF1 ("%I", get_irn_opident(np));
147 switch (get_irn_opcode (np)) { /* node label */
149 XPF1 ("%I", get_irn_mode(np)->name);
151 XPF1 ("%v", get_irn_const_attr);
154 if (get_irn_mode (np) == mode_b) {
156 XP (pnc_name_arr[get_irn_proj_attr(np)]);
157 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
159 XP (pns_name_arr[get_irn_proj_attr(np)]);
161 XPF1 ("%I", get_irn_mode(np)->name);
163 XPF1 ("%d", get_irn_proj_attr(np));
167 XPF1 ("%I", get_irn_mode(np)->name);
169 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
170 XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
172 case iro_Start: /* don't dump mode of these */
185 XPF1 ("%I", get_irn_mode(np)->name);
191 /** getting some parameters from ir_nodes **/
193 /* returns the number of predecessors without the block predecessor. */
195 get_irn_arity (ir_node *node) {
197 if (interprocedural_view) { /* handle Filter and Block specially */
198 if (get_irn_opcode(node) == iro_Filter) {
199 assert(node->attr.filter.in_cg);
200 return ARR_LEN(node->attr.filter.in_cg) - 1;
201 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
202 return ARR_LEN(node->attr.block.in_cg) - 1;
204 /* else fall through */
206 return ARR_LEN(node->in) - 1;
209 /* Returns the array with ins. This array is shifted with respect to the
210 array accessed by get_irn_n: The block operand is at position 0 not -1.
211 (@@@ This should be changed.)
212 The order of the predecessors in this array is not guaranteed, except that
213 lists of operands as predecessors of Block or arguments of a Call are
216 get_irn_in (ir_node *node) {
218 if (interprocedural_view) { /* handle Filter and Block specially */
219 if (get_irn_opcode(node) == iro_Filter) {
220 assert(node->attr.filter.in_cg);
221 return node->attr.filter.in_cg;
222 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
223 return node->attr.block.in_cg;
225 /* else fall through */
231 set_irn_in (ir_node *node, int arity, ir_node **in) {
234 if (interprocedural_view) { /* handle Filter and Block specially */
235 if (get_irn_opcode(node) == iro_Filter) {
236 assert(node->attr.filter.in_cg);
237 arr = &node->attr.filter.in_cg;
238 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
239 arr = &node->attr.block.in_cg;
246 if (arity != ARR_LEN(*arr) - 1) {
247 ir_node * block = (*arr)[0];
248 *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
251 fix_backedges(current_ir_graph->obst, node);
252 memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
255 /* to iterate through the predecessors without touching the array */
256 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
257 to iterate includind the Block predecessor iterate from i = -1 to
259 If it is a block, the entry -1 is NULL. */
261 get_irn_n (ir_node *node, int n) {
263 if (-1 > n || get_irn_arity(node) <= n) {
264 printf("pos: %d, arity: %d ", n, get_irn_arity(node));
267 assert(node); assert(-1 <= n && n < get_irn_arity(node));
268 if (interprocedural_view) { /* handle Filter and Block specially */
269 if (get_irn_opcode(node) == iro_Filter) {
270 assert(node->attr.filter.in_cg);
271 return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
272 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
273 return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
275 /* else fall through */
277 return (node->in[n + 1] = skip_nop(node->in[n + 1]));
281 set_irn_n (ir_node *node, int n, ir_node *in) {
282 assert(node && -1 <= n && n < get_irn_arity(node));
283 if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
284 /* Change block pred in both views! */
285 node->in[n + 1] = in;
286 assert(node->attr.filter.in_cg);
287 node->attr.filter.in_cg[n + 1] = in;
290 if (interprocedural_view) { /* handle Filter and Block specially */
291 if (get_irn_opcode(node) == iro_Filter) {
292 assert(node->attr.filter.in_cg);
293 node->attr.filter.in_cg[n + 1] = in;
295 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
296 node->attr.block.in_cg[n + 1] = in;
299 /* else fall through */
301 node->in[n + 1] = in;
305 get_irn_mode (ir_node *node)
312 get_irn_modecode (ir_node *node)
315 return node->mode->code;
320 get_irn_modeident (ir_node *node)
323 return node->mode->name;
327 get_irn_op (ir_node *node)
333 /* should be private to the library: */
335 set_irn_op (ir_node *node, ir_op *op)
342 get_irn_opcode (ir_node *node)
345 return node->op->code;
349 get_irn_opname (ir_node *node)
352 return id_to_str(node->op->name);
356 get_irn_opident (ir_node *node)
359 return node->op->name;
363 get_irn_visited (ir_node *node)
366 return node->visited;
370 set_irn_visited (ir_node *node, unsigned long visited)
373 node->visited = visited;
377 mark_irn_visited (ir_node *node) {
379 node->visited = current_ir_graph->visited;
383 irn_not_visited (ir_node *node) {
385 return (node->visited < current_ir_graph->visited);
389 irn_visited (ir_node *node) {
391 return (node->visited >= current_ir_graph->visited);
395 set_irn_link (ir_node *node, void *link) {
397 /* Link field is used for Phi construction and various optimizations
399 assert(get_irg_phase_state(current_ir_graph) != phase_building);
405 get_irn_link (ir_node *node) {
410 /* Outputs a unique number for this node */
412 get_irn_node_nr(ir_node *node) {
415 return node->node_nr;
422 get_irn_const_attr (ir_node *node)
424 assert (node->op == op_Const);
425 return node->attr.con;
429 get_irn_proj_attr (ir_node *node)
431 assert (node->op == op_Proj);
432 return node->attr.proj;
436 get_irn_alloc_attr (ir_node *node)
438 assert (node->op == op_Alloc);
443 get_irn_free_attr (ir_node *node)
445 assert (node->op == op_Free);
446 return node->attr.f = skip_tid(node->attr.f);
450 get_irn_symconst_attr (ir_node *node)
452 assert (node->op == op_SymConst);
457 get_irn_call_attr (ir_node *node)
459 assert (node->op == op_Call);
460 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
464 get_irn_sel_attr (ir_node *node)
466 assert (node->op == op_Sel);
471 get_irn_phi_attr (ir_node *node)
473 assert (node->op == op_Phi);
474 return node->attr.phi0_pos;
478 get_irn_block_attr (ir_node *node)
480 assert (node->op == op_Block);
481 return node->attr.block;
484 /** manipulate fields of individual nodes **/
486 /* this works for all except Block */
488 get_nodes_Block (ir_node *node) {
489 assert (!(node->op == op_Block));
490 return get_irn_n(node, -1);
494 set_nodes_Block (ir_node *node, ir_node *block) {
495 assert (!(node->op == op_Block));
496 set_irn_n(node, -1, block);
499 /* Returns an array with the predecessors of the Block. Depending on
500 the implementation of the graph datastructure this can be a copy of
501 the internal representation of predecessors as well as the internal
502 array itself. Therefore writing to this array might obstruct the ir. */
504 get_Block_cfgpred_arr (ir_node *node)
506 assert ((node->op == op_Block));
507 return (ir_node **)&(get_irn_in(node)[1]);
512 get_Block_n_cfgpreds (ir_node *node) {
513 assert ((node->op == op_Block));
514 return (get_irn_arity(node));
518 get_Block_cfgpred (ir_node *node, int pos) {
519 assert (node->op == op_Block);
521 if (-1 > pos || get_irn_arity(node) <= pos) {
522 dump_ir_block_graph(current_ir_graph);
523 printf("pos: %d, arity: %d ", pos, get_irn_arity(node));
526 assert(node); assert(-1 <= pos && pos < get_irn_arity(node));
527 return get_irn_n(node, pos);
531 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
532 assert (node->op == op_Block);
533 set_irn_n(node, pos, pred);
537 get_Block_matured (ir_node *node) {
538 assert (node->op == op_Block);
539 return node->attr.block.matured;
543 set_Block_matured (ir_node *node, bool matured) {
544 assert (node->op == op_Block);
545 node->attr.block.matured = matured;
548 get_Block_block_visited (ir_node *node) {
549 assert (node->op == op_Block);
550 return node->attr.block.block_visited;
554 set_Block_block_visited (ir_node *node, unsigned long visit) {
555 assert (node->op == op_Block);
556 node->attr.block.block_visited = visit;
559 /* For this current_ir_graph must be set. */
561 mark_Block_block_visited (ir_node *node) {
562 assert (node->op == op_Block);
563 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
567 Block_not_block_visited(ir_node *node) {
568 assert (node->op == op_Block);
569 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
573 get_Block_graph_arr (ir_node *node, int pos) {
574 assert (node->op == op_Block);
575 return node->attr.block.graph_arr[pos+1];
579 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
580 assert (node->op == op_Block);
581 node->attr.block.graph_arr[pos+1] = value;
584 /* handler handling for Blocks */
586 set_Block_handler (ir_node *block, ir_node *handler) {
587 assert ((block->op == op_Block));
588 assert ((handler->op == op_Block));
589 block->attr.block.handler_entry = handler;
593 get_Block_handler (ir_node *block) {
594 assert ((block->op == op_Block));
595 return (block->attr.block.handler_entry);
598 /* handler handling for Nodes */
600 set_Node_handler (ir_node *node, ir_node *handler) {
601 set_Block_handler (get_nodes_Block (node), handler);
605 get_Node_handler (ir_node *node) {
606 return (get_Block_handler (get_nodes_Block (node)));
609 /* exc_t handling for Blocks */
610 void set_Block_exc (ir_node *block, exc_t exc) {
611 assert ((block->op == op_Block));
612 block->attr.block.exc = exc;
615 exc_t get_Block_exc (ir_node *block) {
616 assert ((block->op == op_Block));
618 return (block->attr.block.exc);
621 /* exc_t handling for Nodes */
622 void set_Node_exc (ir_node *node, exc_t exc) {
623 set_Block_exc (get_nodes_Block (node), exc);
626 exc_t get_Node_exc (ir_node *node) {
627 return (get_Block_exc (get_nodes_Block (node)));
630 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
631 assert(node->op == op_Block);
632 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
633 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
634 node->attr.block.in_cg[0] = NULL;
635 node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
637 /* Fix backedge array. fix_backedges operates depending on
638 interprocedural_view. */
639 bool ipv = interprocedural_view;
640 interprocedural_view = true;
641 fix_backedges(current_ir_graph->obst, node);
642 interprocedural_view = ipv;
645 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
648 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
649 assert(node->op == op_Block &&
650 node->attr.block.in_cg &&
651 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
652 node->attr.block.in_cg[pos + 1] = pred;
655 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
656 assert(node->op == op_Block);
657 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
660 int get_Block_cg_n_cfgpreds(ir_node * node) {
661 assert(node->op == op_Block);
662 return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
665 ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
666 assert(node->op == op_Block && node->attr.block.in_cg);
667 return node->attr.block.in_cg[pos + 1];
670 void remove_Block_cg_cfgpred_arr(ir_node * node) {
671 assert(node->op == op_Block);
672 node->attr.block.in_cg = NULL;
676 get_End_n_keepalives(ir_node *end) {
677 assert (end->op == op_End);
678 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
682 get_End_keepalive(ir_node *end, int pos) {
683 assert (end->op == op_End);
684 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
688 add_End_keepalive (ir_node *end, ir_node *ka) {
689 assert (end->op == op_End);
690 ARR_APP1 (ir_node *, end->in, ka);
694 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
695 assert (end->op == op_End);
696 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
700 free_End (ir_node *end) {
701 assert (end->op == op_End);
702 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
703 end->in = NULL; /* @@@ make sure we get an error if we use the
704 in array afterwards ... */
707 ir_graph *get_EndReg_irg (ir_node *end) {
708 assert (end->op == op_EndReg);
709 return end->attr.end.irg;
712 ir_graph *get_EndExcept_irg (ir_node *end) {
713 assert (end->op == op_EndReg);
714 return end->attr.end.irg;
718 > Implementing the case construct (which is where the constant Proj node is
719 > important) involves far more than simply determining the constant values.
720 > We could argue that this is more properly a function of the translator from
721 > Firm to the target machine. That could be done if there was some way of
722 > projecting "default" out of the Cond node.
723 I know it's complicated.
724 Basically there are two proglems:
725 - determining the gaps between the projs
726 - determining the biggest case constant to konw the proj number for
728 I see several solutions:
729 1. Introduce a ProjDefault node. Solves both problems.
730 This means to extend all optimizations executed during construction.
731 2. Give the Cond node for switch two flavors:
732 a) there are no gaps in the projs (existing flavor)
733 b) gaps may exist, default proj is still the Proj with the largest
734 projection number. This covers also the gaps.
735 3. Fix the semantic of the Cond to that of 2b)
737 Solution 2 seems to be the best:
738 Computing the gaps in the Firm representation is not too hard, i.e.,
739 libfirm can implement a routine that transforms betweeen the two
740 flavours. This is also possible for 1) but 2) does not require to
741 change any existing optimization.
742 Further it should be far simpler to determine the biggest constant than
744 I don't want to choose 3) as 2a) seems to have advantages for
745 dataflow analysis and 3) does not allow to convert the representation to
749 get_Cond_selector (ir_node *node) {
750 assert (node->op == op_Cond);
751 return get_irn_n(node, 0);
755 set_Cond_selector (ir_node *node, ir_node *selector) {
756 assert (node->op == op_Cond);
757 set_irn_n(node, 0, selector);
761 get_Cond_kind (ir_node *node) {
762 assert (node->op == op_Cond);
763 return node->attr.c.kind;
767 set_Cond_kind (ir_node *node, cond_kind kind) {
768 assert (node->op == op_Cond);
769 node->attr.c.kind = kind;
773 get_Return_mem (ir_node *node) {
774 assert (node->op == op_Return);
775 return get_irn_n(node, 0);
779 set_Return_mem (ir_node *node, ir_node *mem) {
780 assert (node->op == op_Return);
781 set_irn_n(node, 0, mem);
785 get_Return_n_ress (ir_node *node) {
786 assert (node->op == op_Return);
787 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
791 get_Return_res_arr (ir_node *node)
793 assert ((node->op == op_Return));
794 if (get_Return_n_ress(node) > 0)
795 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
802 set_Return_n_res (ir_node *node, int results) {
803 assert (node->op == op_Return);
808 get_Return_res (ir_node *node, int pos) {
809 assert (node->op == op_Return);
810 assert (get_Return_n_ress(node) > pos);
811 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
815 set_Return_res (ir_node *node, int pos, ir_node *res){
816 assert (node->op == op_Return);
817 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
821 get_Raise_mem (ir_node *node) {
822 assert (node->op == op_Return);
823 return get_irn_n(node, 0);
827 set_Raise_mem (ir_node *node, ir_node *mem) {
828 assert (node->op == op_Raise);
829 set_irn_n(node, 0, mem);
833 get_Raise_exo_ptr (ir_node *node) {
834 assert (node->op == op_Raise);
835 return get_irn_n(node, 1);
839 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
840 assert (node->op == op_Raise);
841 set_irn_n(node, 1, exo_ptr);
844 INLINE tarval *get_Const_tarval (ir_node *node) {
845 assert (node->op == op_Const);
846 return get_irn_const_attr(node);
850 set_Const_tarval (ir_node *node, tarval *con) {
851 assert (node->op == op_Const);
852 node->attr.con = con;
856 get_SymConst_kind (ir_node *node) {
857 assert (node->op == op_SymConst);
858 return node->attr.i.num;
862 set_SymConst_kind (ir_node *node, symconst_kind num) {
863 assert (node->op == op_SymConst);
864 node->attr.i.num = num;
868 get_SymConst_type (ir_node *node) {
869 assert ( (node->op == op_SymConst)
870 && ( get_SymConst_kind(node) == type_tag
871 || get_SymConst_kind(node) == size));
872 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
876 set_SymConst_type (ir_node *node, type *tp) {
877 assert ( (node->op == op_SymConst)
878 && ( get_SymConst_kind(node) == type_tag
879 || get_SymConst_kind(node) == size));
880 node->attr.i.tori.typ = tp;
884 get_SymConst_ptrinfo (ir_node *node) {
885 assert ( (node->op == op_SymConst)
886 && (get_SymConst_kind(node) == linkage_ptr_info));
887 return node->attr.i.tori.ptrinfo;
891 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
892 assert ( (node->op == op_SymConst)
893 && (get_SymConst_kind(node) == linkage_ptr_info));
894 node->attr.i.tori.ptrinfo = ptrinfo;
898 get_SymConst_type_or_id (ir_node *node) {
899 assert (node->op == op_SymConst);
900 return &(node->attr.i.tori);
904 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
905 assert (node->op == op_SymConst);
906 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
910 get_Sel_mem (ir_node *node) {
911 assert (node->op == op_Sel);
912 return get_irn_n(node, 0);
916 set_Sel_mem (ir_node *node, ir_node *mem) {
917 assert (node->op == op_Sel);
918 set_irn_n(node, 0, mem);
922 get_Sel_ptr (ir_node *node) {
923 assert (node->op == op_Sel);
924 return get_irn_n(node, 1);
928 set_Sel_ptr (ir_node *node, ir_node *ptr) {
929 assert (node->op == op_Sel);
930 set_irn_n(node, 1, ptr);
934 get_Sel_n_indexs (ir_node *node) {
935 assert (node->op == op_Sel);
936 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
940 get_Sel_index_arr (ir_node *node)
942 assert ((node->op == op_Sel));
943 if (get_Sel_n_indexs(node) > 0)
944 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
950 get_Sel_index (ir_node *node, int pos) {
951 assert (node->op == op_Sel);
952 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
956 set_Sel_index (ir_node *node, int pos, ir_node *index) {
957 assert (node->op == op_Sel);
958 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
962 get_Sel_entity (ir_node *node) {
963 assert (node->op == op_Sel);
964 return node->attr.s.ent;
968 set_Sel_entity (ir_node *node, entity *ent) {
969 assert (node->op == op_Sel);
970 node->attr.s.ent = ent;
974 get_InstOf_ent (ir_node *node) {
975 assert (node->op = op_InstOf);
976 return (node->attr.io.ent);
980 set_InstOf_ent (ir_node *node, type *ent) {
981 assert (node->op = op_InstOf);
982 node->attr.io.ent = ent;
986 get_InstOf_store (ir_node *node) {
987 assert (node->op = op_InstOf);
988 return (get_irn_n (node, 0));
992 set_InstOf_store (ir_node *node, ir_node *obj) {
993 assert (node->op = op_InstOf);
994 set_irn_n (node, 0, obj);
998 get_InstOf_obj (ir_node *node) {
999 assert (node->op = op_InstOf);
1000 return (get_irn_n (node, 1));
1004 set_InstOf_obj (ir_node *node, ir_node *obj) {
1005 assert (node->op = op_InstOf);
1006 set_irn_n (node, 1, obj);
1010 /* For unary and binary arithmetic operations the access to the
1011 operands can be factored out. Left is the first, right the
1012 second arithmetic value as listed in tech report 0999-33.
1013 unops are: Minus, Abs, Not, Conv
1014 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1015 Shr, Shrs, Rotate, Cmp */
1019 get_Call_mem (ir_node *node) {
1020 assert (node->op == op_Call);
1021 return get_irn_n(node, 0);
1025 set_Call_mem (ir_node *node, ir_node *mem) {
1026 assert (node->op == op_Call);
1027 set_irn_n(node, 0, mem);
1031 get_Call_ptr (ir_node *node) {
1032 assert (node->op == op_Call);
1033 return get_irn_n(node, 1);
1037 set_Call_ptr (ir_node *node, ir_node *ptr) {
1038 assert (node->op == op_Call);
1039 set_irn_n(node, 1, ptr);
1043 get_Call_param_arr (ir_node *node) {
1044 assert (node->op == op_Call);
1045 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1049 get_Call_n_params (ir_node *node) {
1050 assert (node->op == op_Call);
1051 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1055 get_Call_arity (ir_node *node) {
1056 assert (node->op == op_Call);
1057 return get_Call_n_params(node);
1061 set_Call_arity (ir_node *node, ir_node *arity) {
1062 assert (node->op == op_Call);
1067 get_Call_param (ir_node *node, int pos) {
1068 assert (node->op == op_Call);
1069 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1073 set_Call_param (ir_node *node, int pos, ir_node *param) {
1074 assert (node->op == op_Call);
1075 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1079 get_Call_type (ir_node *node) {
1080 assert (node->op == op_Call);
1081 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1085 set_Call_type (ir_node *node, type *tp) {
1086 assert (node->op == op_Call);
1087 assert (is_method_type(tp));
1088 node->attr.call.cld_tp = tp;
1091 int get_Call_n_callees(ir_node * node) {
1092 assert(node->op == op_Call && node->attr.call.callee_arr);
1093 return ARR_LEN(node->attr.call.callee_arr);
1096 entity * get_Call_callee(ir_node * node, int pos) {
1097 assert(node->op == op_Call && node->attr.call.callee_arr);
1098 return node->attr.call.callee_arr[pos];
1101 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1102 assert(node->op == op_Call);
1103 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1104 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1106 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1109 void remove_Call_callee_arr(ir_node * node) {
1110 assert(node->op == op_Call);
1111 node->attr.call.callee_arr = NULL;
1114 ir_node * get_CallBegin_ptr (ir_node *node) {
1115 assert(node->op == op_CallBegin);
1116 return get_irn_n(node, 0);
1118 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1119 assert(node->op == op_CallBegin);
1120 set_irn_n(node, 0, ptr);
1122 ir_graph * get_CallBegin_irg (ir_node *node) {
1123 assert(node->op == op_CallBegin);
1124 return node->attr.callbegin.irg;
1126 ir_node * get_CallBegin_call (ir_node *node) {
1127 assert(node->op == op_CallBegin);
1128 return node->attr.callbegin.call;
1130 void set_CallBegin_call (ir_node *node, ir_node *call) {
1131 assert(node->op == op_CallBegin);
1132 node->attr.callbegin.call = call;
1136 get_Add_left (ir_node *node) {
1137 assert (node->op == op_Add);
1138 return get_irn_n(node, 0);
1142 set_Add_left (ir_node *node, ir_node *left) {
1143 assert (node->op == op_Add);
1144 set_irn_n(node, 0, left);
1148 get_Add_right (ir_node *node) {
1149 assert (node->op == op_Add);
1150 return get_irn_n(node, 1);
1154 set_Add_right (ir_node *node, ir_node *right) {
1155 assert (node->op == op_Add);
1156 set_irn_n(node, 1, right);
1160 get_Sub_left (ir_node *node) {
1161 assert (node->op == op_Sub);
1162 return get_irn_n(node, 0);
1166 set_Sub_left (ir_node *node, ir_node *left) {
1167 assert (node->op == op_Sub);
1168 set_irn_n(node, 0, left);
1172 get_Sub_right (ir_node *node) {
1173 assert (node->op == op_Sub);
1174 return get_irn_n(node, 1);
1178 set_Sub_right (ir_node *node, ir_node *right) {
1179 assert (node->op == op_Sub);
1180 set_irn_n(node, 1, right);
1185 get_Minus_op (ir_node *node) {
1186 assert (node->op == op_Minus);
1187 return get_irn_n(node, 0);
1191 set_Minus_op (ir_node *node, ir_node *op) {
1192 assert (node->op == op_Minus);
1193 set_irn_n(node, 0, op);
1198 get_Mul_left (ir_node *node) {
1199 assert (node->op == op_Mul);
1200 return get_irn_n(node, 0);
1204 set_Mul_left (ir_node *node, ir_node *left) {
1205 assert (node->op == op_Mul);
1206 set_irn_n(node, 0, left);
1210 get_Mul_right (ir_node *node) {
1211 assert (node->op == op_Mul);
1212 return get_irn_n(node, 1);
1216 set_Mul_right (ir_node *node, ir_node *right) {
1217 assert (node->op == op_Mul);
1218 set_irn_n(node, 1, right);
1222 get_Quot_left (ir_node *node) {
1223 assert (node->op == op_Quot);
1224 return get_irn_n(node, 1);
1228 set_Quot_left (ir_node *node, ir_node *left) {
1229 assert (node->op == op_Quot);
1230 set_irn_n(node, 1, left);
1234 get_Quot_right (ir_node *node) {
1235 assert (node->op == op_Quot);
1236 return get_irn_n(node, 2);
1240 set_Quot_right (ir_node *node, ir_node *right) {
1241 assert (node->op == op_Quot);
1242 set_irn_n(node, 2, right);
1246 get_Quot_mem (ir_node *node) {
1247 assert (node->op == op_Quot);
1248 return get_irn_n(node, 0);
1252 set_Quot_mem (ir_node *node, ir_node *mem) {
1253 assert (node->op == op_Quot);
1254 set_irn_n(node, 0, mem);
1258 get_DivMod_left (ir_node *node) {
1259 assert (node->op == op_DivMod);
1260 return get_irn_n(node, 1);
1264 set_DivMod_left (ir_node *node, ir_node *left) {
1265 assert (node->op == op_DivMod);
1266 set_irn_n(node, 1, left);
1270 get_DivMod_right (ir_node *node) {
1271 assert (node->op == op_DivMod);
1272 return get_irn_n(node, 2);
1276 set_DivMod_right (ir_node *node, ir_node *right) {
1277 assert (node->op == op_DivMod);
1278 set_irn_n(node, 2, right);
1282 get_DivMod_mem (ir_node *node) {
1283 assert (node->op == op_DivMod);
1284 return get_irn_n(node, 0);
1288 set_DivMod_mem (ir_node *node, ir_node *mem) {
1289 assert (node->op == op_DivMod);
1290 set_irn_n(node, 0, mem);
1294 get_Div_left (ir_node *node) {
1295 assert (node->op == op_Div);
1296 return get_irn_n(node, 1);
1300 set_Div_left (ir_node *node, ir_node *left) {
1301 assert (node->op == op_Div);
1302 set_irn_n(node, 1, left);
1306 get_Div_right (ir_node *node) {
1307 assert (node->op == op_Div);
1308 return get_irn_n(node, 2);
1312 set_Div_right (ir_node *node, ir_node *right) {
1313 assert (node->op == op_Div);
1314 set_irn_n(node, 2, right);
1318 get_Div_mem (ir_node *node) {
1319 assert (node->op == op_Div);
1320 return get_irn_n(node, 0);
1324 set_Div_mem (ir_node *node, ir_node *mem) {
1325 assert (node->op == op_Div);
1326 set_irn_n(node, 0, mem);
1330 get_Mod_left (ir_node *node) {
1331 assert (node->op == op_Mod);
1332 return get_irn_n(node, 1);
1336 set_Mod_left (ir_node *node, ir_node *left) {
1337 assert (node->op == op_Mod);
1338 set_irn_n(node, 1, left);
1342 get_Mod_right (ir_node *node) {
1343 assert (node->op == op_Mod);
1344 return get_irn_n(node, 2);
1348 set_Mod_right (ir_node *node, ir_node *right) {
1349 assert (node->op == op_Mod);
1350 set_irn_n(node, 2, right);
1354 get_Mod_mem (ir_node *node) {
1355 assert (node->op == op_Mod);
1356 return get_irn_n(node, 0);
1360 set_Mod_mem (ir_node *node, ir_node *mem) {
1361 assert (node->op == op_Mod);
1362 set_irn_n(node, 0, mem);
1366 get_Abs_op (ir_node *node) {
1367 assert (node->op == op_Abs);
1368 return get_irn_n(node, 0);
1372 set_Abs_op (ir_node *node, ir_node *op) {
1373 assert (node->op == op_Abs);
1374 set_irn_n(node, 0, op);
1378 get_And_left (ir_node *node) {
1379 assert (node->op == op_And);
1380 return get_irn_n(node, 0);
1384 set_And_left (ir_node *node, ir_node *left) {
1385 assert (node->op == op_And);
1386 set_irn_n(node, 0, left);
1390 get_And_right (ir_node *node) {
1391 assert (node->op == op_And);
1392 return get_irn_n(node, 1);
1396 set_And_right (ir_node *node, ir_node *right) {
1397 assert (node->op == op_And);
1398 set_irn_n(node, 1, right);
1402 get_Or_left (ir_node *node) {
1403 assert (node->op == op_Or);
1404 return get_irn_n(node, 0);
1408 set_Or_left (ir_node *node, ir_node *left) {
1409 assert (node->op == op_Or);
1410 set_irn_n(node, 0, left);
1414 get_Or_right (ir_node *node) {
1415 assert (node->op == op_Or);
1416 return get_irn_n(node, 1);
1420 set_Or_right (ir_node *node, ir_node *right) {
1421 assert (node->op == op_Or);
1422 set_irn_n(node, 1, right);
1426 get_Eor_left (ir_node *node) {
1427 assert (node->op == op_Eor);
1428 return get_irn_n(node, 0);
1432 set_Eor_left (ir_node *node, ir_node *left) {
1433 assert (node->op == op_Eor);
1434 set_irn_n(node, 0, left);
1438 get_Eor_right (ir_node *node) {
1439 assert (node->op == op_Eor);
1440 return get_irn_n(node, 1);
1444 set_Eor_right (ir_node *node, ir_node *right) {
1445 assert (node->op == op_Eor);
1446 set_irn_n(node, 1, right);
1451 get_Not_op (ir_node *node) {
1452 assert (node->op == op_Not);
1453 return get_irn_n(node, 0);
1457 set_Not_op (ir_node *node, ir_node *op) {
1458 assert (node->op == op_Not);
1459 set_irn_n(node, 0, op);
1464 get_Shl_left (ir_node *node) {
1465 assert (node->op == op_Shl);
1466 return get_irn_n(node, 0);
1470 set_Shl_left (ir_node *node, ir_node *left) {
1471 assert (node->op == op_Shl);
1472 set_irn_n(node, 0, left);
1476 get_Shl_right (ir_node *node) {
1477 assert (node->op == op_Shl);
1478 return get_irn_n(node, 1);
1482 set_Shl_right (ir_node *node, ir_node *right) {
1483 assert (node->op == op_Shl);
1484 set_irn_n(node, 1, right);
1488 get_Shr_left (ir_node *node) {
1489 assert (node->op == op_Shr);
1490 return get_irn_n(node, 0);
1494 set_Shr_left (ir_node *node, ir_node *left) {
1495 assert (node->op == op_Shr);
1496 set_irn_n(node, 0, left);
1500 get_Shr_right (ir_node *node) {
1501 assert (node->op == op_Shr);
1502 return get_irn_n(node, 1);
1506 set_Shr_right (ir_node *node, ir_node *right) {
1507 assert (node->op == op_Shr);
1508 set_irn_n(node, 1, right);
1512 get_Shrs_left (ir_node *node) {
1513 assert (node->op == op_Shrs);
1514 return get_irn_n(node, 0);
1518 set_Shrs_left (ir_node *node, ir_node *left) {
1519 assert (node->op == op_Shrs);
1520 set_irn_n(node, 0, left);
1524 get_Shrs_right (ir_node *node) {
1525 assert (node->op == op_Shrs);
1526 return get_irn_n(node, 1);
1530 set_Shrs_right (ir_node *node, ir_node *right) {
1531 assert (node->op == op_Shrs);
1532 set_irn_n(node, 1, right);
1536 get_Rot_left (ir_node *node) {
1537 assert (node->op == op_Rot);
1538 return get_irn_n(node, 0);
1542 set_Rot_left (ir_node *node, ir_node *left) {
1543 assert (node->op == op_Rot);
1544 set_irn_n(node, 0, left);
1548 get_Rot_right (ir_node *node) {
1549 assert (node->op == op_Rot);
1550 return get_irn_n(node, 1);
1554 set_Rot_right (ir_node *node, ir_node *right) {
1555 assert (node->op == op_Rot);
1556 set_irn_n(node, 1, right);
1560 get_Cmp_left (ir_node *node) {
1561 assert (node->op == op_Cmp);
1562 return get_irn_n(node, 0);
1566 set_Cmp_left (ir_node *node, ir_node *left) {
1567 assert (node->op == op_Cmp);
1568 set_irn_n(node, 0, left);
1572 get_Cmp_right (ir_node *node) {
1573 assert (node->op == op_Cmp);
1574 return get_irn_n(node, 1);
1578 set_Cmp_right (ir_node *node, ir_node *right) {
1579 assert (node->op == op_Cmp);
1580 set_irn_n(node, 1, right);
1584 get_Conv_op (ir_node *node) {
1585 assert (node->op == op_Conv);
1586 return get_irn_n(node, 0);
1590 set_Conv_op (ir_node *node, ir_node *op) {
1591 assert (node->op == op_Conv);
1592 set_irn_n(node, 0, op);
1598 is_unop (ir_node *node) {
1599 return ( node->op == op_Minus ||
1600 node->op == op_Abs ||
1601 node->op == op_Not ||
1602 node->op == op_Conv );
1606 get_unop_op (ir_node *node) {
1607 assert ( node->op == op_Minus ||
1608 node->op == op_Abs ||
1609 node->op == op_Not ||
1610 node->op == op_Conv );
1611 switch (get_irn_opcode (node)) {
1612 case iro_Minus: return get_Minus_op(node); break;
1613 case iro_Abs: return get_Abs_op(node); break;
1614 case iro_Not: return get_Not_op(node); break;
1615 case iro_Conv: return get_Conv_op(node); break;
1616 default: return NULL;
1621 set_unop_op (ir_node *node, ir_node *op) {
1622 assert (node->op == op_Minus ||
1623 node->op == op_Abs ||
1624 node->op == op_Not ||
1625 node->op == op_Conv );
1626 switch (get_irn_opcode (node)) {
1627 case iro_Minus: set_Minus_op(node, op); break;
1628 case iro_Abs: set_Abs_op(node, op); break;
1629 case iro_Not: set_Not_op(node, op); break;
1630 case iro_Conv: set_Conv_op(node, op); break;
1637 is_binop (ir_node *node) {
1638 return (node->op == op_Add ||
1639 node->op == op_Sub ||
1640 node->op == op_Mul ||
1641 node->op == op_Quot ||
1642 node->op == op_DivMod ||
1643 node->op == op_Div ||
1644 node->op == op_Mod ||
1645 node->op == op_And ||
1646 node->op == op_Or ||
1647 node->op == op_Eor ||
1648 node->op == op_Shl ||
1649 node->op == op_Shr ||
1650 node->op == op_Shrs ||
1651 node->op == op_Rot ||
1652 node->op == op_Cmp );
1656 get_binop_left (ir_node *node) {
1657 assert (node->op == op_Add ||
1658 node->op == op_Sub ||
1659 node->op == op_Mul ||
1660 node->op == op_Quot ||
1661 node->op == op_DivMod ||
1662 node->op == op_Div ||
1663 node->op == op_Mod ||
1664 node->op == op_And ||
1665 node->op == op_Or ||
1666 node->op == op_Eor ||
1667 node->op == op_Shl ||
1668 node->op == op_Shr ||
1669 node->op == op_Shrs ||
1670 node->op == op_Rot ||
1671 node->op == op_Cmp );
1673 switch (get_irn_opcode (node)) {
1674 case iro_Add : return get_Add_left(node); break;
1675 case iro_Sub : return get_Sub_left(node); break;
1676 case iro_Mul : return get_Mul_left(node); break;
1677 case iro_Quot : return get_Quot_left(node); break;
1678 case iro_DivMod: return get_DivMod_left(node); break;
1679 case iro_Div : return get_Div_left(node); break;
1680 case iro_Mod : return get_Mod_left(node); break;
1681 case iro_And : return get_And_left(node); break;
1682 case iro_Or : return get_Or_left(node); break;
1683 case iro_Eor : return get_Eor_left(node); break;
1684 case iro_Shl : return get_Shl_left(node); break;
1685 case iro_Shr : return get_Shr_left(node); break;
1686 case iro_Shrs : return get_Shrs_left(node); break;
1687 case iro_Rot : return get_Rot_left(node); break;
1688 case iro_Cmp : return get_Cmp_left(node); break;
1689 default: return NULL;
1694 set_binop_left (ir_node *node, ir_node *left) {
1695 assert (node->op == op_Add ||
1696 node->op == op_Sub ||
1697 node->op == op_Mul ||
1698 node->op == op_Quot ||
1699 node->op == op_DivMod ||
1700 node->op == op_Div ||
1701 node->op == op_Mod ||
1702 node->op == op_And ||
1703 node->op == op_Or ||
1704 node->op == op_Eor ||
1705 node->op == op_Shl ||
1706 node->op == op_Shr ||
1707 node->op == op_Shrs ||
1708 node->op == op_Rot ||
1709 node->op == op_Cmp );
1711 switch (get_irn_opcode (node)) {
1712 case iro_Add : set_Add_left(node, left); break;
1713 case iro_Sub : set_Sub_left(node, left); break;
1714 case iro_Mul : set_Mul_left(node, left); break;
1715 case iro_Quot : set_Quot_left(node, left); break;
1716 case iro_DivMod: set_DivMod_left(node, left); break;
1717 case iro_Div : set_Div_left(node, left); break;
1718 case iro_Mod : set_Mod_left(node, left); break;
1719 case iro_And : set_And_left(node, left); break;
1720 case iro_Or : set_Or_left(node, left); break;
1721 case iro_Eor : set_Eor_left(node, left); break;
1722 case iro_Shl : set_Shl_left(node, left); break;
1723 case iro_Shr : set_Shr_left(node, left); break;
1724 case iro_Shrs : set_Shrs_left(node, left); break;
1725 case iro_Rot : set_Rot_left(node, left); break;
1726 case iro_Cmp : set_Cmp_left(node, left); break;
1732 get_binop_right (ir_node *node) {
1733 assert (node->op == op_Add ||
1734 node->op == op_Sub ||
1735 node->op == op_Mul ||
1736 node->op == op_Quot ||
1737 node->op == op_DivMod ||
1738 node->op == op_Div ||
1739 node->op == op_Mod ||
1740 node->op == op_And ||
1741 node->op == op_Or ||
1742 node->op == op_Eor ||
1743 node->op == op_Shl ||
1744 node->op == op_Shr ||
1745 node->op == op_Shrs ||
1746 node->op == op_Rot ||
1747 node->op == op_Cmp );
1749 switch (get_irn_opcode (node)) {
1750 case iro_Add : return get_Add_right(node); break;
1751 case iro_Sub : return get_Sub_right(node); break;
1752 case iro_Mul : return get_Mul_right(node); break;
1753 case iro_Quot : return get_Quot_right(node); break;
1754 case iro_DivMod: return get_DivMod_right(node); break;
1755 case iro_Div : return get_Div_right(node); break;
1756 case iro_Mod : return get_Mod_right(node); break;
1757 case iro_And : return get_And_right(node); break;
1758 case iro_Or : return get_Or_right(node); break;
1759 case iro_Eor : return get_Eor_right(node); break;
1760 case iro_Shl : return get_Shl_right(node); break;
1761 case iro_Shr : return get_Shr_right(node); break;
1762 case iro_Shrs : return get_Shrs_right(node); break;
1763 case iro_Rot : return get_Rot_right(node); break;
1764 case iro_Cmp : return get_Cmp_right(node); break;
1765 default: return NULL;
1770 set_binop_right (ir_node *node, ir_node *right) {
1771 assert (node->op == op_Add ||
1772 node->op == op_Sub ||
1773 node->op == op_Mul ||
1774 node->op == op_Quot ||
1775 node->op == op_DivMod ||
1776 node->op == op_Div ||
1777 node->op == op_Mod ||
1778 node->op == op_And ||
1779 node->op == op_Or ||
1780 node->op == op_Eor ||
1781 node->op == op_Shl ||
1782 node->op == op_Shr ||
1783 node->op == op_Shrs ||
1784 node->op == op_Rot ||
1785 node->op == op_Cmp );
1787 switch (get_irn_opcode (node)) {
1788 case iro_Add : set_Add_right(node, right); break;
1789 case iro_Sub : set_Sub_right(node, right); break;
1790 case iro_Mul : set_Mul_right(node, right); break;
1791 case iro_Quot : set_Quot_right(node, right); break;
1792 case iro_DivMod: set_DivMod_right(node, right); break;
1793 case iro_Div : set_Div_right(node, right); break;
1794 case iro_Mod : set_Mod_right(node, right); break;
1795 case iro_And : set_And_right(node, right); break;
1796 case iro_Or : set_Or_right(node, right); break;
1797 case iro_Eor : set_Eor_right(node, right); break;
1798 case iro_Shl : set_Shl_right(node, right); break;
1799 case iro_Shr : set_Shr_right(node, right); break;
1800 case iro_Shrs : set_Shrs_right(node, right); break;
1801 case iro_Rot : set_Rot_right(node, right); break;
1802 case iro_Cmp : set_Cmp_right(node, right); break;
1809 get_Phi_preds_arr (ir_node *node) {
1810 assert (node->op == op_Phi);
1811 return (ir_node **)&(get_irn_in(node)[1]);
1815 get_Phi_n_preds (ir_node *node) {
1816 assert (node->op == op_Phi);
1817 return (get_irn_arity(node));
1821 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1822 assert (node->op == op_Phi);
1827 get_Phi_pred (ir_node *node, int pos) {
1828 assert (node->op == op_Phi);
1829 return get_irn_n(node, pos);
1833 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1834 assert (node->op == op_Phi);
1835 set_irn_n(node, pos, pred);
1839 get_Load_mem (ir_node *node) {
1840 assert (node->op == op_Load);
1841 return get_irn_n(node, 0);
1845 set_Load_mem (ir_node *node, ir_node *mem) {
1846 assert (node->op == op_Load);
1847 set_irn_n(node, 0, mem);
1851 get_Load_ptr (ir_node *node) {
1852 assert (node->op == op_Load);
1853 return get_irn_n(node, 1);
1857 set_Load_ptr (ir_node *node, ir_node *ptr) {
1858 assert (node->op == op_Load);
1859 set_irn_n(node, 1, ptr);
1864 get_Store_mem (ir_node *node) {
1865 assert (node->op == op_Store);
1866 return get_irn_n(node, 0);
1870 set_Store_mem (ir_node *node, ir_node *mem) {
1871 assert (node->op == op_Store);
1872 set_irn_n(node, 0, mem);
1876 get_Store_ptr (ir_node *node) {
1877 assert (node->op == op_Store);
1878 return get_irn_n(node, 1);
1882 set_Store_ptr (ir_node *node, ir_node *ptr) {
1883 assert (node->op == op_Store);
1884 set_irn_n(node, 1, ptr);
1888 get_Store_value (ir_node *node) {
1889 assert (node->op == op_Store);
1890 return get_irn_n(node, 2);
1894 set_Store_value (ir_node *node, ir_node *value) {
1895 assert (node->op == op_Store);
1896 set_irn_n(node, 2, value);
1900 get_Alloc_mem (ir_node *node) {
1901 assert (node->op == op_Alloc);
1902 return get_irn_n(node, 0);
1906 set_Alloc_mem (ir_node *node, ir_node *mem) {
1907 assert (node->op == op_Alloc);
1908 set_irn_n(node, 0, mem);
1912 get_Alloc_size (ir_node *node) {
1913 assert (node->op == op_Alloc);
1914 return get_irn_n(node, 1);
1918 set_Alloc_size (ir_node *node, ir_node *size) {
1919 assert (node->op == op_Alloc);
1920 set_irn_n(node, 1, size);
1924 get_Alloc_type (ir_node *node) {
1925 assert (node->op == op_Alloc);
1926 return node->attr.a.type = skip_tid(node->attr.a.type);
1930 set_Alloc_type (ir_node *node, type *tp) {
1931 assert (node->op == op_Alloc);
1932 node->attr.a.type = tp;
1936 get_Alloc_where (ir_node *node) {
1937 assert (node->op == op_Alloc);
1938 return node->attr.a.where;
1942 set_Alloc_where (ir_node *node, where_alloc where) {
1943 assert (node->op == op_Alloc);
1944 node->attr.a.where = where;
1949 get_Free_mem (ir_node *node) {
1950 assert (node->op == op_Free);
1951 return get_irn_n(node, 0);
1955 set_Free_mem (ir_node *node, ir_node *mem) {
1956 assert (node->op == op_Free);
1957 set_irn_n(node, 0, mem);
1961 get_Free_ptr (ir_node *node) {
1962 assert (node->op == op_Free);
1963 return get_irn_n(node, 1);
1967 set_Free_ptr (ir_node *node, ir_node *ptr) {
1968 assert (node->op == op_Free);
1969 set_irn_n(node, 1, ptr);
1973 get_Free_size (ir_node *node) {
1974 assert (node->op == op_Free);
1975 return get_irn_n(node, 2);
1979 set_Free_size (ir_node *node, ir_node *size) {
1980 assert (node->op == op_Free);
1981 set_irn_n(node, 2, size);
1985 get_Free_type (ir_node *node) {
1986 assert (node->op == op_Free);
1987 return node->attr.f = skip_tid(node->attr.f);
1991 set_Free_type (ir_node *node, type *tp) {
1992 assert (node->op == op_Free);
1997 get_Sync_preds_arr (ir_node *node) {
1998 assert (node->op == op_Sync);
1999 return (ir_node **)&(get_irn_in(node)[1]);
2003 get_Sync_n_preds (ir_node *node) {
2004 assert (node->op == op_Sync);
2005 return (get_irn_arity(node));
2010 set_Sync_n_preds (ir_node *node, int n_preds) {
2011 assert (node->op == op_Sync);
2016 get_Sync_pred (ir_node *node, int pos) {
2017 assert (node->op == op_Sync);
2018 return get_irn_n(node, pos);
2022 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
2023 assert (node->op == op_Sync);
2024 set_irn_n(node, pos, pred);
2028 get_Proj_pred (ir_node *node) {
2029 assert (is_Proj(node));
2030 return get_irn_n(node, 0);
2034 set_Proj_pred (ir_node *node, ir_node *pred) {
2035 assert (is_Proj(node));
2036 set_irn_n(node, 0, pred);
2040 get_Proj_proj (ir_node *node) {
2041 assert (is_Proj(node));
2042 if (get_irn_opcode(node) == iro_Proj) {
2043 return node->attr.proj;
2045 assert(get_irn_opcode(node) == iro_Filter);
2046 return node->attr.filter.proj;
2051 set_Proj_proj (ir_node *node, long proj) {
2052 assert (node->op == op_Proj);
2053 node->attr.proj = proj;
2057 get_Tuple_preds_arr (ir_node *node) {
2058 assert (node->op == op_Tuple);
2059 return (ir_node **)&(get_irn_in(node)[1]);
2063 get_Tuple_n_preds (ir_node *node) {
2064 assert (node->op == op_Tuple);
2065 return (get_irn_arity(node));
2070 set_Tuple_n_preds (ir_node *node, int n_preds) {
2071 assert (node->op == op_Tuple);
2076 get_Tuple_pred (ir_node *node, int pos) {
2077 assert (node->op == op_Tuple);
2078 return get_irn_n(node, pos);
2082 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2083 assert (node->op == op_Tuple);
2084 set_irn_n(node, pos, pred);
2088 get_Id_pred (ir_node *node) {
2089 assert (node->op == op_Id);
2090 return get_irn_n(node, 0);
2094 set_Id_pred (ir_node *node, ir_node *pred) {
2095 assert (node->op == op_Id);
2096 set_irn_n(node, 0, pred);
2101 get_Filter_pred (ir_node *node) {
2102 assert(node->op == op_Filter);
2106 set_Filter_pred (ir_node *node, ir_node *pred) {
2107 assert(node->op == op_Filter);
2111 get_Filter_proj(ir_node *node) {
2112 assert(node->op == op_Filter);
2113 return node->attr.filter.proj;
2116 set_Filter_proj (ir_node *node, long proj) {
2117 assert(node->op == op_Filter);
2118 node->attr.filter.proj = proj;
2121 /* Don't use get_irn_arity, get_irn_n in implementation as access
2122 shall work independent of view!!! */
2123 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2124 assert(node->op == op_Filter);
2125 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2126 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2127 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2128 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2129 node->attr.filter.in_cg[0] = node->in[0];
2131 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2134 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2135 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2136 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2137 node->attr.filter.in_cg[pos + 1] = pred;
2139 int get_Filter_n_cg_preds(ir_node *node) {
2140 assert(node->op == op_Filter && node->attr.filter.in_cg);
2141 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2143 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2145 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2147 arity = ARR_LEN(node->attr.filter.in_cg);
2148 assert(pos < arity - 1);
2149 return node->attr.filter.in_cg[pos + 1];
2154 get_irn_irg(ir_node *node) {
2155 if (get_irn_op(node) == op_CallBegin) {
2156 return node->attr.callbegin.irg;
2157 } else if (get_irn_op(node) == op_EndReg ||
2158 get_irn_op(node) == op_EndExcept) {
2159 return node->attr.end.irg;
2161 assert(0 && "no irg attr");
2166 /******************************************************************/
2167 /* Auxiliary routines */
2168 /******************************************************************/
2171 skip_Proj (ir_node *node) {
2172 /* don't assert node !!! */
2173 if (node && is_Proj(node)) {
2174 return get_Proj_pred(node);
2181 skip_Tuple (ir_node *node) {
2184 node = skip_nop(node);
2185 if (get_irn_op(node) == op_Proj) {
2186 pred = skip_nop(get_Proj_pred(node));
2187 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2188 pred = skip_nop(skip_Tuple(pred));
2189 if (get_irn_op(pred) == op_Tuple)
2190 return get_Tuple_pred(pred, get_Proj_proj(node));
2196 skip_nop (ir_node *node) {
2197 /* don't assert node !!! */
2199 /* Don't use get_Id_pred: We get into an endless loop for
2200 self-referencing Ids. */
2201 if (node && (node->op == op_Id) && (node != node->in[0+1])) {
2202 assert (get_irn_arity (node) > 0);
2203 return node->in[0+1];
2210 skip_Id (ir_node *node) {
2211 return skip_nop(node);
2215 is_Bad (ir_node *node) {
2217 if ((node) && get_irn_opcode(node) == iro_Bad)
2223 is_no_Block (ir_node *node) {
2225 return (get_irn_opcode(node) != iro_Block);
2229 is_Block (ir_node *node) {
2231 return (get_irn_opcode(node) == iro_Block);
2235 is_Proj (ir_node *node) {
2237 return node->op == op_Proj
2238 || (!interprocedural_view && node->op == op_Filter);
2241 /* Returns true if the operation manipulates control flow. */
2243 is_cfop(ir_node *node) {
2244 return is_cfopcode(get_irn_op(node));
2247 /* Returns true if the operation manipulates interprocedural control flow:
2248 CallBegin, EndReg, EndExcept */
2249 INLINE int is_ip_cfop(ir_node *node) {
2250 return is_ip_cfopcode(get_irn_op(node));
2253 ir_graph *get_ip_cfop_irg(ir_node *n) {
2254 switch (get_irn_opcode(n)) {
2256 return get_EndReg_irg(n);
2258 return get_EndExcept_irg(n);
2260 return get_CallBegin_irg(n);
2262 assert(is_ip_cfop(n));
2264 return NULL; /* should never be reached */
2267 /* Returns true if the operation can change the control flow because
2270 is_fragile_op(ir_node *node) {
2271 return ( (get_irn_opcode(node) == iro_Call)
2272 || (get_irn_opcode(node) == iro_Quot)
2273 || (get_irn_opcode(node) == iro_DivMod)
2274 || (get_irn_opcode(node) == iro_Div)
2275 || (get_irn_opcode(node) == iro_Mod)
2276 || (get_irn_opcode(node) == iro_Load)
2277 || (get_irn_opcode(node) == iro_Store)
2278 || (get_irn_opcode(node) == iro_Alloc)
2279 || (get_irn_opcode(node) == iro_Bad)
2280 || (get_irn_opcode(node) == iro_Unknown));
2284 /* Returns the memory operand of fragile operations. */
2285 ir_node *get_fragile_op_mem(ir_node *node) {
2286 assert(node && is_fragile_op(node));
2288 switch (get_irn_opcode (node)) {
2297 return get_irn_n(node, 0);
2302 assert(0 && "not reached");