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 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
640 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
641 assert(node->op == op_Block &&
642 node->attr.block.in_cg &&
643 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
644 node->attr.block.in_cg[pos + 1] = pred;
647 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
648 assert(node->op == op_Block);
649 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
652 int get_Block_cg_n_cfgpreds(ir_node * node) {
653 assert(node->op == op_Block);
654 return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
657 ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
658 assert(node->op == op_Block && node->attr.block.in_cg);
659 return node->attr.block.in_cg[pos + 1];
662 void remove_Block_cg_cfgpred_arr(ir_node * node) {
663 assert(node->op == op_Block);
664 node->attr.block.in_cg = NULL;
668 get_End_n_keepalives(ir_node *end) {
669 assert (end->op == op_End);
670 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
674 get_End_keepalive(ir_node *end, int pos) {
675 assert (end->op == op_End);
676 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
680 add_End_keepalive (ir_node *end, ir_node *ka) {
681 assert (end->op == op_End);
682 ARR_APP1 (ir_node *, end->in, ka);
686 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
687 assert (end->op == op_End);
688 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
692 free_End (ir_node *end) {
693 assert (end->op == op_End);
694 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
695 end->in = NULL; /* @@@ make sure we get an error if we use the
696 in array afterwards ... */
699 ir_graph *get_EndReg_irg (ir_node *end) {
700 assert (end->op == op_EndReg);
701 return end->attr.end.irg;
704 ir_graph *get_EndExcept_irg (ir_node *end) {
705 assert (end->op == op_EndReg);
706 return end->attr.end.irg;
710 > Implementing the case construct (which is where the constant Proj node is
711 > important) involves far more than simply determining the constant values.
712 > We could argue that this is more properly a function of the translator from
713 > Firm to the target machine. That could be done if there was some way of
714 > projecting "default" out of the Cond node.
715 I know it's complicated.
716 Basically there are two proglems:
717 - determining the gaps between the projs
718 - determining the biggest case constant to konw the proj number for
720 I see several solutions:
721 1. Introduce a ProjDefault node. Solves both problems.
722 This means to extend all optimizations executed during construction.
723 2. Give the Cond node for switch two flavors:
724 a) there are no gaps in the projs (existing flavor)
725 b) gaps may exist, default proj is still the Proj with the largest
726 projection number. This covers also the gaps.
727 3. Fix the semantic of the Cond to that of 2b)
729 Solution 2 seems to be the best:
730 Computing the gaps in the Firm representation is not too hard, i.e.,
731 libfirm can implement a routine that transforms betweeen the two
732 flavours. This is also possible for 1) but 2) does not require to
733 change any existing optimization.
734 Further it should be far simpler to determine the biggest constant than
736 I don't want to choose 3) as 2a) seems to have advantages for
737 dataflow analysis and 3) does not allow to convert the representation to
741 get_Cond_selector (ir_node *node) {
742 assert (node->op == op_Cond);
743 return get_irn_n(node, 0);
747 set_Cond_selector (ir_node *node, ir_node *selector) {
748 assert (node->op == op_Cond);
749 set_irn_n(node, 0, selector);
753 get_Cond_kind (ir_node *node) {
754 assert (node->op == op_Cond);
755 return node->attr.c.kind;
759 set_Cond_kind (ir_node *node, cond_kind kind) {
760 assert (node->op == op_Cond);
761 node->attr.c.kind = kind;
765 get_Return_mem (ir_node *node) {
766 assert (node->op == op_Return);
767 return get_irn_n(node, 0);
771 set_Return_mem (ir_node *node, ir_node *mem) {
772 assert (node->op == op_Return);
773 set_irn_n(node, 0, mem);
777 get_Return_n_ress (ir_node *node) {
778 assert (node->op == op_Return);
779 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
783 get_Return_res_arr (ir_node *node)
785 assert ((node->op == op_Return));
786 if (get_Return_n_ress(node) > 0)
787 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
794 set_Return_n_res (ir_node *node, int results) {
795 assert (node->op == op_Return);
800 get_Return_res (ir_node *node, int pos) {
801 assert (node->op == op_Return);
802 assert (get_Return_n_ress(node) > pos);
803 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
807 set_Return_res (ir_node *node, int pos, ir_node *res){
808 assert (node->op == op_Return);
809 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
813 get_Raise_mem (ir_node *node) {
814 assert (node->op == op_Return);
815 return get_irn_n(node, 0);
819 set_Raise_mem (ir_node *node, ir_node *mem) {
820 assert (node->op == op_Raise);
821 set_irn_n(node, 0, mem);
825 get_Raise_exo_ptr (ir_node *node) {
826 assert (node->op == op_Raise);
827 return get_irn_n(node, 1);
831 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
832 assert (node->op == op_Raise);
833 set_irn_n(node, 1, exo_ptr);
836 INLINE tarval *get_Const_tarval (ir_node *node) {
837 assert (node->op == op_Const);
838 return get_irn_const_attr(node);
842 set_Const_tarval (ir_node *node, tarval *con) {
843 assert (node->op == op_Const);
844 node->attr.con = con;
848 get_SymConst_kind (ir_node *node) {
849 assert (node->op == op_SymConst);
850 return node->attr.i.num;
854 set_SymConst_kind (ir_node *node, symconst_kind num) {
855 assert (node->op == op_SymConst);
856 node->attr.i.num = num;
860 get_SymConst_type (ir_node *node) {
861 assert ( (node->op == op_SymConst)
862 && ( get_SymConst_kind(node) == type_tag
863 || get_SymConst_kind(node) == size));
864 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
868 set_SymConst_type (ir_node *node, type *tp) {
869 assert ( (node->op == op_SymConst)
870 && ( get_SymConst_kind(node) == type_tag
871 || get_SymConst_kind(node) == size));
872 node->attr.i.tori.typ = tp;
876 get_SymConst_ptrinfo (ir_node *node) {
877 assert ( (node->op == op_SymConst)
878 && (get_SymConst_kind(node) == linkage_ptr_info));
879 return node->attr.i.tori.ptrinfo;
883 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
884 assert ( (node->op == op_SymConst)
885 && (get_SymConst_kind(node) == linkage_ptr_info));
886 node->attr.i.tori.ptrinfo = ptrinfo;
890 get_SymConst_type_or_id (ir_node *node) {
891 assert (node->op == op_SymConst);
892 return &(node->attr.i.tori);
896 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
897 assert (node->op == op_SymConst);
898 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
902 get_Sel_mem (ir_node *node) {
903 assert (node->op == op_Sel);
904 return get_irn_n(node, 0);
908 set_Sel_mem (ir_node *node, ir_node *mem) {
909 assert (node->op == op_Sel);
910 set_irn_n(node, 0, mem);
914 get_Sel_ptr (ir_node *node) {
915 assert (node->op == op_Sel);
916 return get_irn_n(node, 1);
920 set_Sel_ptr (ir_node *node, ir_node *ptr) {
921 assert (node->op == op_Sel);
922 set_irn_n(node, 1, ptr);
926 get_Sel_n_indexs (ir_node *node) {
927 assert (node->op == op_Sel);
928 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
932 get_Sel_index_arr (ir_node *node)
934 assert ((node->op == op_Sel));
935 if (get_Sel_n_indexs(node) > 0)
936 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
942 get_Sel_index (ir_node *node, int pos) {
943 assert (node->op == op_Sel);
944 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
948 set_Sel_index (ir_node *node, int pos, ir_node *index) {
949 assert (node->op == op_Sel);
950 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
954 get_Sel_entity (ir_node *node) {
955 assert (node->op == op_Sel);
956 return node->attr.s.ent;
960 set_Sel_entity (ir_node *node, entity *ent) {
961 assert (node->op == op_Sel);
962 node->attr.s.ent = ent;
966 get_InstOf_ent (ir_node *node) {
967 assert (node->op = op_InstOf);
968 return (node->attr.io.ent);
972 set_InstOf_ent (ir_node *node, type *ent) {
973 assert (node->op = op_InstOf);
974 node->attr.io.ent = ent;
978 get_InstOf_store (ir_node *node) {
979 assert (node->op = op_InstOf);
980 return (get_irn_n (node, 0));
984 set_InstOf_store (ir_node *node, ir_node *obj) {
985 assert (node->op = op_InstOf);
986 set_irn_n (node, 0, obj);
990 get_InstOf_obj (ir_node *node) {
991 assert (node->op = op_InstOf);
992 return (get_irn_n (node, 1));
996 set_InstOf_obj (ir_node *node, ir_node *obj) {
997 assert (node->op = op_InstOf);
998 set_irn_n (node, 1, obj);
1002 /* For unary and binary arithmetic operations the access to the
1003 operands can be factored out. Left is the first, right the
1004 second arithmetic value as listed in tech report 0999-33.
1005 unops are: Minus, Abs, Not, Conv
1006 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1007 Shr, Shrs, Rotate, Cmp */
1011 get_Call_mem (ir_node *node) {
1012 assert (node->op == op_Call);
1013 return get_irn_n(node, 0);
1017 set_Call_mem (ir_node *node, ir_node *mem) {
1018 assert (node->op == op_Call);
1019 set_irn_n(node, 0, mem);
1023 get_Call_ptr (ir_node *node) {
1024 assert (node->op == op_Call);
1025 return get_irn_n(node, 1);
1029 set_Call_ptr (ir_node *node, ir_node *ptr) {
1030 assert (node->op == op_Call);
1031 set_irn_n(node, 1, ptr);
1035 get_Call_param_arr (ir_node *node) {
1036 assert (node->op == op_Call);
1037 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1041 get_Call_n_params (ir_node *node) {
1042 assert (node->op == op_Call);
1043 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1047 get_Call_arity (ir_node *node) {
1048 assert (node->op == op_Call);
1049 return get_Call_n_params(node);
1053 set_Call_arity (ir_node *node, ir_node *arity) {
1054 assert (node->op == op_Call);
1059 get_Call_param (ir_node *node, int pos) {
1060 assert (node->op == op_Call);
1061 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1065 set_Call_param (ir_node *node, int pos, ir_node *param) {
1066 assert (node->op == op_Call);
1067 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1071 get_Call_type (ir_node *node) {
1072 assert (node->op == op_Call);
1073 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1077 set_Call_type (ir_node *node, type *tp) {
1078 assert (node->op == op_Call);
1079 assert (is_method_type(tp));
1080 node->attr.call.cld_tp = tp;
1083 int get_Call_n_callees(ir_node * node) {
1084 assert(node->op == op_Call && node->attr.call.callee_arr);
1085 return ARR_LEN(node->attr.call.callee_arr);
1088 entity * get_Call_callee(ir_node * node, int pos) {
1089 assert(node->op == op_Call && node->attr.call.callee_arr);
1090 return node->attr.call.callee_arr[pos];
1093 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1094 assert(node->op == op_Call);
1095 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1096 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1098 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1101 void remove_Call_callee_arr(ir_node * node) {
1102 assert(node->op == op_Call);
1103 node->attr.call.callee_arr = NULL;
1106 ir_node * get_CallBegin_ptr (ir_node *node) {
1107 assert(node->op == op_CallBegin);
1108 return get_irn_n(node, 0);
1110 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1111 assert(node->op == op_CallBegin);
1112 set_irn_n(node, 0, ptr);
1114 ir_graph * get_CallBegin_irg (ir_node *node) {
1115 assert(node->op == op_CallBegin);
1116 return node->attr.callbegin.irg;
1118 ir_node * get_CallBegin_call (ir_node *node) {
1119 assert(node->op == op_CallBegin);
1120 return node->attr.callbegin.call;
1122 void set_CallBegin_call (ir_node *node, ir_node *call) {
1123 assert(node->op == op_CallBegin);
1124 node->attr.callbegin.call = call;
1128 get_Add_left (ir_node *node) {
1129 assert (node->op == op_Add);
1130 return get_irn_n(node, 0);
1134 set_Add_left (ir_node *node, ir_node *left) {
1135 assert (node->op == op_Add);
1136 set_irn_n(node, 0, left);
1140 get_Add_right (ir_node *node) {
1141 assert (node->op == op_Add);
1142 return get_irn_n(node, 1);
1146 set_Add_right (ir_node *node, ir_node *right) {
1147 assert (node->op == op_Add);
1148 set_irn_n(node, 1, right);
1152 get_Sub_left (ir_node *node) {
1153 assert (node->op == op_Sub);
1154 return get_irn_n(node, 0);
1158 set_Sub_left (ir_node *node, ir_node *left) {
1159 assert (node->op == op_Sub);
1160 set_irn_n(node, 0, left);
1164 get_Sub_right (ir_node *node) {
1165 assert (node->op == op_Sub);
1166 return get_irn_n(node, 1);
1170 set_Sub_right (ir_node *node, ir_node *right) {
1171 assert (node->op == op_Sub);
1172 set_irn_n(node, 1, right);
1177 get_Minus_op (ir_node *node) {
1178 assert (node->op == op_Minus);
1179 return get_irn_n(node, 0);
1183 set_Minus_op (ir_node *node, ir_node *op) {
1184 assert (node->op == op_Minus);
1185 set_irn_n(node, 0, op);
1190 get_Mul_left (ir_node *node) {
1191 assert (node->op == op_Mul);
1192 return get_irn_n(node, 0);
1196 set_Mul_left (ir_node *node, ir_node *left) {
1197 assert (node->op == op_Mul);
1198 set_irn_n(node, 0, left);
1202 get_Mul_right (ir_node *node) {
1203 assert (node->op == op_Mul);
1204 return get_irn_n(node, 1);
1208 set_Mul_right (ir_node *node, ir_node *right) {
1209 assert (node->op == op_Mul);
1210 set_irn_n(node, 1, right);
1214 get_Quot_left (ir_node *node) {
1215 assert (node->op == op_Quot);
1216 return get_irn_n(node, 1);
1220 set_Quot_left (ir_node *node, ir_node *left) {
1221 assert (node->op == op_Quot);
1222 set_irn_n(node, 1, left);
1226 get_Quot_right (ir_node *node) {
1227 assert (node->op == op_Quot);
1228 return get_irn_n(node, 2);
1232 set_Quot_right (ir_node *node, ir_node *right) {
1233 assert (node->op == op_Quot);
1234 set_irn_n(node, 2, right);
1238 get_Quot_mem (ir_node *node) {
1239 assert (node->op == op_Quot);
1240 return get_irn_n(node, 0);
1244 set_Quot_mem (ir_node *node, ir_node *mem) {
1245 assert (node->op == op_Quot);
1246 set_irn_n(node, 0, mem);
1250 get_DivMod_left (ir_node *node) {
1251 assert (node->op == op_DivMod);
1252 return get_irn_n(node, 1);
1256 set_DivMod_left (ir_node *node, ir_node *left) {
1257 assert (node->op == op_DivMod);
1258 set_irn_n(node, 1, left);
1262 get_DivMod_right (ir_node *node) {
1263 assert (node->op == op_DivMod);
1264 return get_irn_n(node, 2);
1268 set_DivMod_right (ir_node *node, ir_node *right) {
1269 assert (node->op == op_DivMod);
1270 set_irn_n(node, 2, right);
1274 get_DivMod_mem (ir_node *node) {
1275 assert (node->op == op_DivMod);
1276 return get_irn_n(node, 0);
1280 set_DivMod_mem (ir_node *node, ir_node *mem) {
1281 assert (node->op == op_DivMod);
1282 set_irn_n(node, 0, mem);
1286 get_Div_left (ir_node *node) {
1287 assert (node->op == op_Div);
1288 return get_irn_n(node, 1);
1292 set_Div_left (ir_node *node, ir_node *left) {
1293 assert (node->op == op_Div);
1294 set_irn_n(node, 1, left);
1298 get_Div_right (ir_node *node) {
1299 assert (node->op == op_Div);
1300 return get_irn_n(node, 2);
1304 set_Div_right (ir_node *node, ir_node *right) {
1305 assert (node->op == op_Div);
1306 set_irn_n(node, 2, right);
1310 get_Div_mem (ir_node *node) {
1311 assert (node->op == op_Div);
1312 return get_irn_n(node, 0);
1316 set_Div_mem (ir_node *node, ir_node *mem) {
1317 assert (node->op == op_Div);
1318 set_irn_n(node, 0, mem);
1322 get_Mod_left (ir_node *node) {
1323 assert (node->op == op_Mod);
1324 return get_irn_n(node, 1);
1328 set_Mod_left (ir_node *node, ir_node *left) {
1329 assert (node->op == op_Mod);
1330 set_irn_n(node, 1, left);
1334 get_Mod_right (ir_node *node) {
1335 assert (node->op == op_Mod);
1336 return get_irn_n(node, 2);
1340 set_Mod_right (ir_node *node, ir_node *right) {
1341 assert (node->op == op_Mod);
1342 set_irn_n(node, 2, right);
1346 get_Mod_mem (ir_node *node) {
1347 assert (node->op == op_Mod);
1348 return get_irn_n(node, 0);
1352 set_Mod_mem (ir_node *node, ir_node *mem) {
1353 assert (node->op == op_Mod);
1354 set_irn_n(node, 0, mem);
1358 get_Abs_op (ir_node *node) {
1359 assert (node->op == op_Abs);
1360 return get_irn_n(node, 0);
1364 set_Abs_op (ir_node *node, ir_node *op) {
1365 assert (node->op == op_Abs);
1366 set_irn_n(node, 0, op);
1370 get_And_left (ir_node *node) {
1371 assert (node->op == op_And);
1372 return get_irn_n(node, 0);
1376 set_And_left (ir_node *node, ir_node *left) {
1377 assert (node->op == op_And);
1378 set_irn_n(node, 0, left);
1382 get_And_right (ir_node *node) {
1383 assert (node->op == op_And);
1384 return get_irn_n(node, 1);
1388 set_And_right (ir_node *node, ir_node *right) {
1389 assert (node->op == op_And);
1390 set_irn_n(node, 1, right);
1394 get_Or_left (ir_node *node) {
1395 assert (node->op == op_Or);
1396 return get_irn_n(node, 0);
1400 set_Or_left (ir_node *node, ir_node *left) {
1401 assert (node->op == op_Or);
1402 set_irn_n(node, 0, left);
1406 get_Or_right (ir_node *node) {
1407 assert (node->op == op_Or);
1408 return get_irn_n(node, 1);
1412 set_Or_right (ir_node *node, ir_node *right) {
1413 assert (node->op == op_Or);
1414 set_irn_n(node, 1, right);
1418 get_Eor_left (ir_node *node) {
1419 assert (node->op == op_Eor);
1420 return get_irn_n(node, 0);
1424 set_Eor_left (ir_node *node, ir_node *left) {
1425 assert (node->op == op_Eor);
1426 set_irn_n(node, 0, left);
1430 get_Eor_right (ir_node *node) {
1431 assert (node->op == op_Eor);
1432 return get_irn_n(node, 1);
1436 set_Eor_right (ir_node *node, ir_node *right) {
1437 assert (node->op == op_Eor);
1438 set_irn_n(node, 1, right);
1443 get_Not_op (ir_node *node) {
1444 assert (node->op == op_Not);
1445 return get_irn_n(node, 0);
1449 set_Not_op (ir_node *node, ir_node *op) {
1450 assert (node->op == op_Not);
1451 set_irn_n(node, 0, op);
1456 get_Shl_left (ir_node *node) {
1457 assert (node->op == op_Shl);
1458 return get_irn_n(node, 0);
1462 set_Shl_left (ir_node *node, ir_node *left) {
1463 assert (node->op == op_Shl);
1464 set_irn_n(node, 0, left);
1468 get_Shl_right (ir_node *node) {
1469 assert (node->op == op_Shl);
1470 return get_irn_n(node, 1);
1474 set_Shl_right (ir_node *node, ir_node *right) {
1475 assert (node->op == op_Shl);
1476 set_irn_n(node, 1, right);
1480 get_Shr_left (ir_node *node) {
1481 assert (node->op == op_Shr);
1482 return get_irn_n(node, 0);
1486 set_Shr_left (ir_node *node, ir_node *left) {
1487 assert (node->op == op_Shr);
1488 set_irn_n(node, 0, left);
1492 get_Shr_right (ir_node *node) {
1493 assert (node->op == op_Shr);
1494 return get_irn_n(node, 1);
1498 set_Shr_right (ir_node *node, ir_node *right) {
1499 assert (node->op == op_Shr);
1500 set_irn_n(node, 1, right);
1504 get_Shrs_left (ir_node *node) {
1505 assert (node->op == op_Shrs);
1506 return get_irn_n(node, 0);
1510 set_Shrs_left (ir_node *node, ir_node *left) {
1511 assert (node->op == op_Shrs);
1512 set_irn_n(node, 0, left);
1516 get_Shrs_right (ir_node *node) {
1517 assert (node->op == op_Shrs);
1518 return get_irn_n(node, 1);
1522 set_Shrs_right (ir_node *node, ir_node *right) {
1523 assert (node->op == op_Shrs);
1524 set_irn_n(node, 1, right);
1528 get_Rot_left (ir_node *node) {
1529 assert (node->op == op_Rot);
1530 return get_irn_n(node, 0);
1534 set_Rot_left (ir_node *node, ir_node *left) {
1535 assert (node->op == op_Rot);
1536 set_irn_n(node, 0, left);
1540 get_Rot_right (ir_node *node) {
1541 assert (node->op == op_Rot);
1542 return get_irn_n(node, 1);
1546 set_Rot_right (ir_node *node, ir_node *right) {
1547 assert (node->op == op_Rot);
1548 set_irn_n(node, 1, right);
1552 get_Cmp_left (ir_node *node) {
1553 assert (node->op == op_Cmp);
1554 return get_irn_n(node, 0);
1558 set_Cmp_left (ir_node *node, ir_node *left) {
1559 assert (node->op == op_Cmp);
1560 set_irn_n(node, 0, left);
1564 get_Cmp_right (ir_node *node) {
1565 assert (node->op == op_Cmp);
1566 return get_irn_n(node, 1);
1570 set_Cmp_right (ir_node *node, ir_node *right) {
1571 assert (node->op == op_Cmp);
1572 set_irn_n(node, 1, right);
1576 get_Conv_op (ir_node *node) {
1577 assert (node->op == op_Conv);
1578 return get_irn_n(node, 0);
1582 set_Conv_op (ir_node *node, ir_node *op) {
1583 assert (node->op == op_Conv);
1584 set_irn_n(node, 0, op);
1590 is_unop (ir_node *node) {
1591 return ( node->op == op_Minus ||
1592 node->op == op_Abs ||
1593 node->op == op_Not ||
1594 node->op == op_Conv );
1598 get_unop_op (ir_node *node) {
1599 assert ( node->op == op_Minus ||
1600 node->op == op_Abs ||
1601 node->op == op_Not ||
1602 node->op == op_Conv );
1603 switch (get_irn_opcode (node)) {
1604 case iro_Minus: return get_Minus_op(node); break;
1605 case iro_Abs: return get_Abs_op(node); break;
1606 case iro_Not: return get_Not_op(node); break;
1607 case iro_Conv: return get_Conv_op(node); break;
1608 default: return NULL;
1613 set_unop_op (ir_node *node, ir_node *op) {
1614 assert (node->op == op_Minus ||
1615 node->op == op_Abs ||
1616 node->op == op_Not ||
1617 node->op == op_Conv );
1618 switch (get_irn_opcode (node)) {
1619 case iro_Minus: set_Minus_op(node, op); break;
1620 case iro_Abs: set_Abs_op(node, op); break;
1621 case iro_Not: set_Not_op(node, op); break;
1622 case iro_Conv: set_Conv_op(node, op); break;
1629 is_binop (ir_node *node) {
1630 return (node->op == op_Add ||
1631 node->op == op_Sub ||
1632 node->op == op_Mul ||
1633 node->op == op_Quot ||
1634 node->op == op_DivMod ||
1635 node->op == op_Div ||
1636 node->op == op_Mod ||
1637 node->op == op_And ||
1638 node->op == op_Or ||
1639 node->op == op_Eor ||
1640 node->op == op_Shl ||
1641 node->op == op_Shr ||
1642 node->op == op_Shrs ||
1643 node->op == op_Rot ||
1644 node->op == op_Cmp );
1648 get_binop_left (ir_node *node) {
1649 assert (node->op == op_Add ||
1650 node->op == op_Sub ||
1651 node->op == op_Mul ||
1652 node->op == op_Quot ||
1653 node->op == op_DivMod ||
1654 node->op == op_Div ||
1655 node->op == op_Mod ||
1656 node->op == op_And ||
1657 node->op == op_Or ||
1658 node->op == op_Eor ||
1659 node->op == op_Shl ||
1660 node->op == op_Shr ||
1661 node->op == op_Shrs ||
1662 node->op == op_Rot ||
1663 node->op == op_Cmp );
1665 switch (get_irn_opcode (node)) {
1666 case iro_Add : return get_Add_left(node); break;
1667 case iro_Sub : return get_Sub_left(node); break;
1668 case iro_Mul : return get_Mul_left(node); break;
1669 case iro_Quot : return get_Quot_left(node); break;
1670 case iro_DivMod: return get_DivMod_left(node); break;
1671 case iro_Div : return get_Div_left(node); break;
1672 case iro_Mod : return get_Mod_left(node); break;
1673 case iro_And : return get_And_left(node); break;
1674 case iro_Or : return get_Or_left(node); break;
1675 case iro_Eor : return get_Eor_left(node); break;
1676 case iro_Shl : return get_Shl_left(node); break;
1677 case iro_Shr : return get_Shr_left(node); break;
1678 case iro_Shrs : return get_Shrs_left(node); break;
1679 case iro_Rot : return get_Rot_left(node); break;
1680 case iro_Cmp : return get_Cmp_left(node); break;
1681 default: return NULL;
1686 set_binop_left (ir_node *node, ir_node *left) {
1687 assert (node->op == op_Add ||
1688 node->op == op_Sub ||
1689 node->op == op_Mul ||
1690 node->op == op_Quot ||
1691 node->op == op_DivMod ||
1692 node->op == op_Div ||
1693 node->op == op_Mod ||
1694 node->op == op_And ||
1695 node->op == op_Or ||
1696 node->op == op_Eor ||
1697 node->op == op_Shl ||
1698 node->op == op_Shr ||
1699 node->op == op_Shrs ||
1700 node->op == op_Rot ||
1701 node->op == op_Cmp );
1703 switch (get_irn_opcode (node)) {
1704 case iro_Add : set_Add_left(node, left); break;
1705 case iro_Sub : set_Sub_left(node, left); break;
1706 case iro_Mul : set_Mul_left(node, left); break;
1707 case iro_Quot : set_Quot_left(node, left); break;
1708 case iro_DivMod: set_DivMod_left(node, left); break;
1709 case iro_Div : set_Div_left(node, left); break;
1710 case iro_Mod : set_Mod_left(node, left); break;
1711 case iro_And : set_And_left(node, left); break;
1712 case iro_Or : set_Or_left(node, left); break;
1713 case iro_Eor : set_Eor_left(node, left); break;
1714 case iro_Shl : set_Shl_left(node, left); break;
1715 case iro_Shr : set_Shr_left(node, left); break;
1716 case iro_Shrs : set_Shrs_left(node, left); break;
1717 case iro_Rot : set_Rot_left(node, left); break;
1718 case iro_Cmp : set_Cmp_left(node, left); break;
1724 get_binop_right (ir_node *node) {
1725 assert (node->op == op_Add ||
1726 node->op == op_Sub ||
1727 node->op == op_Mul ||
1728 node->op == op_Quot ||
1729 node->op == op_DivMod ||
1730 node->op == op_Div ||
1731 node->op == op_Mod ||
1732 node->op == op_And ||
1733 node->op == op_Or ||
1734 node->op == op_Eor ||
1735 node->op == op_Shl ||
1736 node->op == op_Shr ||
1737 node->op == op_Shrs ||
1738 node->op == op_Rot ||
1739 node->op == op_Cmp );
1741 switch (get_irn_opcode (node)) {
1742 case iro_Add : return get_Add_right(node); break;
1743 case iro_Sub : return get_Sub_right(node); break;
1744 case iro_Mul : return get_Mul_right(node); break;
1745 case iro_Quot : return get_Quot_right(node); break;
1746 case iro_DivMod: return get_DivMod_right(node); break;
1747 case iro_Div : return get_Div_right(node); break;
1748 case iro_Mod : return get_Mod_right(node); break;
1749 case iro_And : return get_And_right(node); break;
1750 case iro_Or : return get_Or_right(node); break;
1751 case iro_Eor : return get_Eor_right(node); break;
1752 case iro_Shl : return get_Shl_right(node); break;
1753 case iro_Shr : return get_Shr_right(node); break;
1754 case iro_Shrs : return get_Shrs_right(node); break;
1755 case iro_Rot : return get_Rot_right(node); break;
1756 case iro_Cmp : return get_Cmp_right(node); break;
1757 default: return NULL;
1762 set_binop_right (ir_node *node, ir_node *right) {
1763 assert (node->op == op_Add ||
1764 node->op == op_Sub ||
1765 node->op == op_Mul ||
1766 node->op == op_Quot ||
1767 node->op == op_DivMod ||
1768 node->op == op_Div ||
1769 node->op == op_Mod ||
1770 node->op == op_And ||
1771 node->op == op_Or ||
1772 node->op == op_Eor ||
1773 node->op == op_Shl ||
1774 node->op == op_Shr ||
1775 node->op == op_Shrs ||
1776 node->op == op_Rot ||
1777 node->op == op_Cmp );
1779 switch (get_irn_opcode (node)) {
1780 case iro_Add : set_Add_right(node, right); break;
1781 case iro_Sub : set_Sub_right(node, right); break;
1782 case iro_Mul : set_Mul_right(node, right); break;
1783 case iro_Quot : set_Quot_right(node, right); break;
1784 case iro_DivMod: set_DivMod_right(node, right); break;
1785 case iro_Div : set_Div_right(node, right); break;
1786 case iro_Mod : set_Mod_right(node, right); break;
1787 case iro_And : set_And_right(node, right); break;
1788 case iro_Or : set_Or_right(node, right); break;
1789 case iro_Eor : set_Eor_right(node, right); break;
1790 case iro_Shl : set_Shl_right(node, right); break;
1791 case iro_Shr : set_Shr_right(node, right); break;
1792 case iro_Shrs : set_Shrs_right(node, right); break;
1793 case iro_Rot : set_Rot_right(node, right); break;
1794 case iro_Cmp : set_Cmp_right(node, right); break;
1801 get_Phi_preds_arr (ir_node *node) {
1802 assert (node->op == op_Phi);
1803 return (ir_node **)&(get_irn_in(node)[1]);
1807 get_Phi_n_preds (ir_node *node) {
1808 assert (node->op == op_Phi);
1809 return (get_irn_arity(node));
1813 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1814 assert (node->op == op_Phi);
1819 get_Phi_pred (ir_node *node, int pos) {
1820 assert (node->op == op_Phi);
1821 return get_irn_n(node, pos);
1825 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1826 assert (node->op == op_Phi);
1827 set_irn_n(node, pos, pred);
1831 get_Load_mem (ir_node *node) {
1832 assert (node->op == op_Load);
1833 return get_irn_n(node, 0);
1837 set_Load_mem (ir_node *node, ir_node *mem) {
1838 assert (node->op == op_Load);
1839 set_irn_n(node, 0, mem);
1843 get_Load_ptr (ir_node *node) {
1844 assert (node->op == op_Load);
1845 return get_irn_n(node, 1);
1849 set_Load_ptr (ir_node *node, ir_node *ptr) {
1850 assert (node->op == op_Load);
1851 set_irn_n(node, 1, ptr);
1856 get_Store_mem (ir_node *node) {
1857 assert (node->op == op_Store);
1858 return get_irn_n(node, 0);
1862 set_Store_mem (ir_node *node, ir_node *mem) {
1863 assert (node->op == op_Store);
1864 set_irn_n(node, 0, mem);
1868 get_Store_ptr (ir_node *node) {
1869 assert (node->op == op_Store);
1870 return get_irn_n(node, 1);
1874 set_Store_ptr (ir_node *node, ir_node *ptr) {
1875 assert (node->op == op_Store);
1876 set_irn_n(node, 1, ptr);
1880 get_Store_value (ir_node *node) {
1881 assert (node->op == op_Store);
1882 return get_irn_n(node, 2);
1886 set_Store_value (ir_node *node, ir_node *value) {
1887 assert (node->op == op_Store);
1888 set_irn_n(node, 2, value);
1892 get_Alloc_mem (ir_node *node) {
1893 assert (node->op == op_Alloc);
1894 return get_irn_n(node, 0);
1898 set_Alloc_mem (ir_node *node, ir_node *mem) {
1899 assert (node->op == op_Alloc);
1900 set_irn_n(node, 0, mem);
1904 get_Alloc_size (ir_node *node) {
1905 assert (node->op == op_Alloc);
1906 return get_irn_n(node, 1);
1910 set_Alloc_size (ir_node *node, ir_node *size) {
1911 assert (node->op == op_Alloc);
1912 set_irn_n(node, 1, size);
1916 get_Alloc_type (ir_node *node) {
1917 assert (node->op == op_Alloc);
1918 return node->attr.a.type = skip_tid(node->attr.a.type);
1922 set_Alloc_type (ir_node *node, type *tp) {
1923 assert (node->op == op_Alloc);
1924 node->attr.a.type = tp;
1928 get_Alloc_where (ir_node *node) {
1929 assert (node->op == op_Alloc);
1930 return node->attr.a.where;
1934 set_Alloc_where (ir_node *node, where_alloc where) {
1935 assert (node->op == op_Alloc);
1936 node->attr.a.where = where;
1941 get_Free_mem (ir_node *node) {
1942 assert (node->op == op_Free);
1943 return get_irn_n(node, 0);
1947 set_Free_mem (ir_node *node, ir_node *mem) {
1948 assert (node->op == op_Free);
1949 set_irn_n(node, 0, mem);
1953 get_Free_ptr (ir_node *node) {
1954 assert (node->op == op_Free);
1955 return get_irn_n(node, 1);
1959 set_Free_ptr (ir_node *node, ir_node *ptr) {
1960 assert (node->op == op_Free);
1961 set_irn_n(node, 1, ptr);
1965 get_Free_size (ir_node *node) {
1966 assert (node->op == op_Free);
1967 return get_irn_n(node, 2);
1971 set_Free_size (ir_node *node, ir_node *size) {
1972 assert (node->op == op_Free);
1973 set_irn_n(node, 2, size);
1977 get_Free_type (ir_node *node) {
1978 assert (node->op == op_Free);
1979 return node->attr.f = skip_tid(node->attr.f);
1983 set_Free_type (ir_node *node, type *tp) {
1984 assert (node->op == op_Free);
1989 get_Sync_preds_arr (ir_node *node) {
1990 assert (node->op == op_Sync);
1991 return (ir_node **)&(get_irn_in(node)[1]);
1995 get_Sync_n_preds (ir_node *node) {
1996 assert (node->op == op_Sync);
1997 return (get_irn_arity(node));
2002 set_Sync_n_preds (ir_node *node, int n_preds) {
2003 assert (node->op == op_Sync);
2008 get_Sync_pred (ir_node *node, int pos) {
2009 assert (node->op == op_Sync);
2010 return get_irn_n(node, pos);
2014 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
2015 assert (node->op == op_Sync);
2016 set_irn_n(node, pos, pred);
2020 get_Proj_pred (ir_node *node) {
2021 assert (is_Proj(node));
2022 return get_irn_n(node, 0);
2026 set_Proj_pred (ir_node *node, ir_node *pred) {
2027 assert (is_Proj(node));
2028 set_irn_n(node, 0, pred);
2032 get_Proj_proj (ir_node *node) {
2033 assert (is_Proj(node));
2034 if (get_irn_opcode(node) == iro_Proj) {
2035 return node->attr.proj;
2037 assert(get_irn_opcode(node) == iro_Filter);
2038 return node->attr.filter.proj;
2043 set_Proj_proj (ir_node *node, long proj) {
2044 assert (node->op == op_Proj);
2045 node->attr.proj = proj;
2049 get_Tuple_preds_arr (ir_node *node) {
2050 assert (node->op == op_Tuple);
2051 return (ir_node **)&(get_irn_in(node)[1]);
2055 get_Tuple_n_preds (ir_node *node) {
2056 assert (node->op == op_Tuple);
2057 return (get_irn_arity(node));
2062 set_Tuple_n_preds (ir_node *node, int n_preds) {
2063 assert (node->op == op_Tuple);
2068 get_Tuple_pred (ir_node *node, int pos) {
2069 assert (node->op == op_Tuple);
2070 return get_irn_n(node, pos);
2074 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2075 assert (node->op == op_Tuple);
2076 set_irn_n(node, pos, pred);
2080 get_Id_pred (ir_node *node) {
2081 assert (node->op == op_Id);
2082 return get_irn_n(node, 0);
2086 set_Id_pred (ir_node *node, ir_node *pred) {
2087 assert (node->op == op_Id);
2088 set_irn_n(node, 0, pred);
2093 get_Filter_pred (ir_node *node) {
2094 assert(node->op == op_Filter);
2098 set_Filter_pred (ir_node *node, ir_node *pred) {
2099 assert(node->op == op_Filter);
2103 get_Filter_proj(ir_node *node) {
2104 assert(node->op == op_Filter);
2105 return node->attr.filter.proj;
2108 set_Filter_proj (ir_node *node, long proj) {
2109 assert(node->op == op_Filter);
2110 node->attr.filter.proj = proj;
2113 /* Don't use get_irn_arity, get_irn_n in implementation as access
2114 shall work independent of view!!! */
2115 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2116 assert(node->op == op_Filter);
2117 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2118 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2119 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2120 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2121 node->attr.filter.in_cg[0] = node->in[0];
2123 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2126 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2127 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2128 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2129 node->attr.filter.in_cg[pos + 1] = pred;
2131 int get_Filter_n_cg_preds(ir_node *node) {
2132 assert(node->op == op_Filter && node->attr.filter.in_cg);
2133 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2135 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2137 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2139 arity = ARR_LEN(node->attr.filter.in_cg);
2140 assert(pos < arity - 1);
2141 return node->attr.filter.in_cg[pos + 1];
2146 get_irn_irg(ir_node *node) {
2147 if (get_irn_op(node) == op_CallBegin) {
2148 return node->attr.callbegin.irg;
2149 } else if (get_irn_op(node) == op_EndReg ||
2150 get_irn_op(node) == op_EndExcept) {
2151 return node->attr.end.irg;
2153 assert(0 && "no irg attr");
2158 /******************************************************************/
2159 /* Auxiliary routines */
2160 /******************************************************************/
2163 skip_Proj (ir_node *node) {
2164 /* don't assert node !!! */
2165 if (node && is_Proj(node)) {
2166 return get_Proj_pred(node);
2173 skip_Tuple (ir_node *node) {
2176 node = skip_nop(node);
2177 if (get_irn_op(node) == op_Proj) {
2178 pred = skip_nop(get_Proj_pred(node));
2179 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2180 pred = skip_nop(skip_Tuple(pred));
2181 if (get_irn_op(pred) == op_Tuple)
2182 return get_Tuple_pred(pred, get_Proj_proj(node));
2188 skip_nop (ir_node *node) {
2189 /* don't assert node !!! */
2191 /* Don't use get_Id_pred: We get into an endless loop for
2192 self-referencing Ids. */
2193 if (node && (node->op == op_Id) && (node != node->in[0+1])) {
2194 assert (get_irn_arity (node) > 0);
2195 return node->in[0+1];
2202 skip_Id (ir_node *node) {
2203 return skip_nop(node);
2207 is_Bad (ir_node *node) {
2209 if ((node) && get_irn_opcode(node) == iro_Bad)
2215 is_no_Block (ir_node *node) {
2217 return (get_irn_opcode(node) != iro_Block);
2221 is_Block (ir_node *node) {
2223 return (get_irn_opcode(node) == iro_Block);
2227 is_Proj (ir_node *node) {
2229 return node->op == op_Proj
2230 || (!interprocedural_view && node->op == op_Filter);
2233 /* Returns true if the operation manipulates control flow. */
2235 is_cfop(ir_node *node) {
2236 return is_cfopcode(get_irn_op(node));
2239 /* Returns true if the operation manipulates interprocedural control flow:
2240 CallBegin, EndReg, EndExcept */
2241 INLINE int is_ip_cfop(ir_node *node) {
2242 return is_ip_cfopcode(get_irn_op(node));
2245 ir_graph *get_ip_cfop_irg(ir_node *n) {
2246 switch (get_irn_opcode(n)) {
2248 return get_EndReg_irg(n);
2250 return get_EndExcept_irg(n);
2252 return get_CallBegin_irg(n);
2254 assert(is_ip_cfop(n));
2256 return NULL; /* should never be reached */
2259 /* Returns true if the operation can change the control flow because
2262 is_fragile_op(ir_node *node) {
2263 return ( (get_irn_opcode(node) == iro_Call)
2264 || (get_irn_opcode(node) == iro_Quot)
2265 || (get_irn_opcode(node) == iro_DivMod)
2266 || (get_irn_opcode(node) == iro_Div)
2267 || (get_irn_opcode(node) == iro_Mod)
2268 || (get_irn_opcode(node) == iro_Load)
2269 || (get_irn_opcode(node) == iro_Store)
2270 || (get_irn_opcode(node) == iro_Alloc)
2271 || (get_irn_opcode(node) == iro_Bad)
2272 || (get_irn_opcode(node) == iro_Unknown));
2276 /* Returns the memory operand of fragile operations. */
2277 ir_node *get_fragile_op_mem(ir_node *node) {
2278 assert(node && is_fragile_op(node));
2280 switch (get_irn_opcode (node)) {
2289 return get_irn_n(node, 0);
2294 assert(0 && "not reached");