1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
4 * Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
16 #include "irgraph_t.h"
18 #include "typegmod_t.h"
20 #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 (const ir_node *node);
37 INLINE ir_mode *get_irn_mode (const ir_node *node);
38 INLINE ir_op *get_irn_op (const ir_node *node);
39 INLINE opcode get_irn_opcode (const ir_node *node);
40 INLINE ident *get_irn_opident (const ir_node *node);
41 INLINE type *get_SymConst_type (ir_node *node);
42 INLINE ir_node *skip_nop (ir_node *node);
43 INLINE int is_Proj (const ir_node *node);
46 static const char *pnc_name_arr [] = {
47 "False", "Eq", "Lt", "Le",
48 "Gt", "Ge", "Lg", "Leg", "Uo",
49 "Ue", "Ul", "Ule", "Ug", "Uge",
53 INLINE const char *get_pnc_string(int pnc) {
54 return pnc_name_arr[pnc];
59 get_negated_pnc(int pnc) {
61 case False: return True; break;
62 case Eq: return Ne; break;
63 case Lt: return Uge; break;
64 case Le: return Ug; break;
65 case Gt: return Ule; break;
66 case Ge: return Ul; break;
67 case Lg: return Ue; break;
68 case Leg: return Uo; break;
69 case Uo: return Leg; break;
70 case Ue: return Lg; break;
71 case Ul: return Ge; break;
72 case Ule: return Gt; break;
73 case Ug: return Le; break;
74 case Uge: return Lt; break;
75 case Ne: return Eq; break;
76 case True: return False; break;
78 return 99; /* to shut up gcc */
81 static const char *pns_name_arr [] = {
82 "initial_exec", "global_store",
83 "frame_base", "globals", "args"
86 static const char *symconst_name_arr [] = {
87 "type_tag", "size", "linkage_ptr_info"
95 /* irnode constructor */
96 /* create a new irnode in irg, with an op, mode, arity and */
97 /* some incoming irnodes */
98 /* this constructor is used in every specified irnode constructor */
100 new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
101 int arity, ir_node **in)
104 int node_size = offsetof (ir_node, attr) + op->attr_size;
106 res = (ir_node *) obstack_alloc (irg->obst, node_size);
108 res->kind = k_ir_node;
114 res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
116 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
117 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
120 set_irn_dbg_info(res, db);
124 res->node_nr = get_irp_new_node_nr();
130 /* Copies all attributes stored in the old node to the new node.
131 Assumes both have the same opcode and sufficient size. */
133 copy_attrs (ir_node *old, ir_node *new) {
134 assert (get_irn_op(old) == get_irn_op(new));
135 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
138 /** getting some parameters from ir_nodes **/
140 /* returns the number of predecessors without the block predecessor. */
142 get_irn_arity (const ir_node *node) {
144 if (interprocedural_view) { /* handle Filter and Block specially */
145 if (get_irn_opcode(node) == iro_Filter) {
146 assert(node->attr.filter.in_cg);
147 return ARR_LEN(node->attr.filter.in_cg) - 1;
148 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
149 return ARR_LEN(node->attr.block.in_cg) - 1;
151 /* else fall through */
153 return ARR_LEN(node->in) - 1;
156 /* Returns the array with ins. This array is shifted with respect to the
157 array accessed by get_irn_n: The block operand is at position 0 not -1.
158 (@@@ This should be changed.)
159 The order of the predecessors in this array is not guaranteed, except that
160 lists of operands as predecessors of Block or arguments of a Call are
163 get_irn_in (const ir_node *node) {
165 if (interprocedural_view) { /* handle Filter and Block specially */
166 if (get_irn_opcode(node) == iro_Filter) {
167 assert(node->attr.filter.in_cg);
168 return node->attr.filter.in_cg;
169 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
170 return node->attr.block.in_cg;
172 /* else fall through */
178 set_irn_in (ir_node *node, int arity, ir_node **in) {
181 if (interprocedural_view) { /* handle Filter and Block specially */
182 if (get_irn_opcode(node) == iro_Filter) {
183 assert(node->attr.filter.in_cg);
184 arr = &node->attr.filter.in_cg;
185 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
186 arr = &node->attr.block.in_cg;
193 if (arity != ARR_LEN(*arr) - 1) {
194 ir_node * block = (*arr)[0];
195 *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
198 fix_backedges(current_ir_graph->obst, node);
199 memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
202 /* to iterate through the predecessors without touching the array */
203 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
204 to iterate includind the Block predecessor iterate from i = -1 to
206 If it is a block, the entry -1 is NULL. */
208 get_irn_n (ir_node *node, int n) {
210 if (-1 > n || get_irn_arity(node) <= n) {
211 printf("pos: %d, arity: %d ", n, get_irn_arity(node));
214 assert(node); assert(-1 <= n && n < get_irn_arity(node));
215 if (interprocedural_view) { /* handle Filter and Block specially */
216 if (get_irn_opcode(node) == iro_Filter) {
217 assert(node->attr.filter.in_cg);
218 return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
219 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
220 return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
222 /* else fall through */
224 return (node->in[n + 1] = skip_nop(node->in[n + 1]));
228 set_irn_n (ir_node *node, int n, ir_node *in) {
229 assert(node && -1 <= n && n < get_irn_arity(node));
230 if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
231 /* Change block pred in both views! */
232 node->in[n + 1] = in;
233 assert(node->attr.filter.in_cg);
234 node->attr.filter.in_cg[n + 1] = in;
237 if (interprocedural_view) { /* handle Filter and Block specially */
238 if (get_irn_opcode(node) == iro_Filter) {
239 assert(node->attr.filter.in_cg);
240 node->attr.filter.in_cg[n + 1] = in;
242 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
243 node->attr.block.in_cg[n + 1] = in;
246 /* else fall through */
248 node->in[n + 1] = in;
252 get_irn_mode (const ir_node *node)
259 get_irn_modecode (const ir_node *node)
262 return node->mode->code;
267 get_irn_modeident (const ir_node *node)
270 return get_mode_ident(node->mode);
274 get_irn_op (const ir_node *node)
280 /* should be private to the library: */
282 set_irn_op (ir_node *node, ir_op *op)
289 get_irn_opcode (const ir_node *node)
292 assert (k_ir_node == get_kind(node));
294 return node->op->code;
298 get_irn_opname (const ir_node *node)
301 return id_to_str(node->op->name);
305 get_irn_opident (const ir_node *node)
308 return node->op->name;
312 get_irn_visited (const ir_node *node)
315 return node->visited;
319 set_irn_visited (ir_node *node, unsigned long visited)
322 node->visited = visited;
326 mark_irn_visited (ir_node *node) {
328 node->visited = current_ir_graph->visited;
332 irn_not_visited (const ir_node *node) {
334 return (node->visited < current_ir_graph->visited);
338 irn_visited (const ir_node *node) {
340 return (node->visited >= current_ir_graph->visited);
344 set_irn_link (ir_node *node, void *link) {
346 /* Link field is used for Phi construction and various optimizations
348 assert(get_irg_phase_state(current_ir_graph) != phase_building);
354 get_irn_link (const ir_node *node) {
359 /* Outputs a unique number for this node */
361 get_irn_node_nr(const ir_node *node) {
364 return node->node_nr;
371 get_irn_const_attr (ir_node *node)
373 assert (node->op == op_Const);
374 return node->attr.con;
378 get_irn_proj_attr (ir_node *node)
380 assert (node->op == op_Proj);
381 return node->attr.proj;
385 get_irn_alloc_attr (ir_node *node)
387 assert (node->op == op_Alloc);
392 get_irn_free_attr (ir_node *node)
394 assert (node->op == op_Free);
395 return node->attr.f = skip_tid(node->attr.f);
399 get_irn_symconst_attr (ir_node *node)
401 assert (node->op == op_SymConst);
406 get_irn_call_attr (ir_node *node)
408 assert (node->op == op_Call);
409 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
413 get_irn_sel_attr (ir_node *node)
415 assert (node->op == op_Sel);
420 get_irn_phi_attr (ir_node *node)
422 assert (node->op == op_Phi);
423 return node->attr.phi0_pos;
427 get_irn_block_attr (ir_node *node)
429 assert (node->op == op_Block);
430 return node->attr.block;
433 /** manipulate fields of individual nodes **/
435 /* this works for all except Block */
437 get_nodes_Block (ir_node *node) {
438 assert (!(node->op == op_Block));
439 return get_irn_n(node, -1);
443 set_nodes_Block (ir_node *node, ir_node *block) {
444 assert (!(node->op == op_Block));
445 set_irn_n(node, -1, block);
448 /* Returns an array with the predecessors of the Block. Depending on
449 the implementation of the graph datastructure this can be a copy of
450 the internal representation of predecessors as well as the internal
451 array itself. Therefore writing to this array might obstruct the ir. */
453 get_Block_cfgpred_arr (ir_node *node)
455 assert ((node->op == op_Block));
456 return (ir_node **)&(get_irn_in(node)[1]);
461 get_Block_n_cfgpreds (ir_node *node) {
462 assert ((node->op == op_Block));
463 return (get_irn_arity(node));
467 get_Block_cfgpred (ir_node *node, int pos) {
468 assert (node->op == op_Block);
470 if (-1 > pos || get_irn_arity(node) <= pos) {
471 dump_ir_block_graph(current_ir_graph);
472 printf("pos: %d, arity: %d ", pos, get_irn_arity(node));
475 assert(node); assert(-1 <= pos && pos < get_irn_arity(node));
476 return get_irn_n(node, pos);
480 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
481 assert (node->op == op_Block);
482 set_irn_n(node, pos, pred);
486 get_Block_matured (ir_node *node) {
487 assert (node->op == op_Block);
488 return node->attr.block.matured;
492 set_Block_matured (ir_node *node, bool matured) {
493 assert (node->op == op_Block);
494 node->attr.block.matured = matured;
497 get_Block_block_visited (ir_node *node) {
498 assert (node->op == op_Block);
499 return node->attr.block.block_visited;
503 set_Block_block_visited (ir_node *node, unsigned long visit) {
504 assert (node->op == op_Block);
505 node->attr.block.block_visited = visit;
508 /* For this current_ir_graph must be set. */
510 mark_Block_block_visited (ir_node *node) {
511 assert (node->op == op_Block);
512 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
516 Block_not_block_visited(ir_node *node) {
517 assert (node->op == op_Block);
518 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
522 get_Block_graph_arr (ir_node *node, int pos) {
523 assert (node->op == op_Block);
524 return node->attr.block.graph_arr[pos+1];
528 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
529 assert (node->op == op_Block);
530 node->attr.block.graph_arr[pos+1] = value;
533 /* handler handling for Blocks */
535 set_Block_handler (ir_node *block, ir_node *handler) {
536 assert ((block->op == op_Block));
537 assert ((handler->op == op_Block));
538 block->attr.block.handler_entry = handler;
542 get_Block_handler (ir_node *block) {
543 assert ((block->op == op_Block));
544 return (block->attr.block.handler_entry);
547 /* handler handling for Nodes */
549 set_Node_handler (ir_node *node, ir_node *handler) {
550 set_Block_handler (get_nodes_Block (node), handler);
554 get_Node_handler (ir_node *node) {
555 return (get_Block_handler (get_nodes_Block (node)));
558 /* exc_t handling for Blocks */
559 void set_Block_exc (ir_node *block, exc_t exc) {
560 assert ((block->op == op_Block));
561 block->attr.block.exc = exc;
564 exc_t get_Block_exc (ir_node *block) {
565 assert ((block->op == op_Block));
567 return (block->attr.block.exc);
570 /* exc_t handling for Nodes */
571 void set_Node_exc (ir_node *node, exc_t exc) {
572 set_Block_exc (get_nodes_Block (node), exc);
575 exc_t get_Node_exc (ir_node *node) {
576 return (get_Block_exc (get_nodes_Block (node)));
579 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
580 assert(node->op == op_Block);
581 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
582 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
583 node->attr.block.in_cg[0] = NULL;
584 node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
586 /* Fix backedge array. fix_backedges operates depending on
587 interprocedural_view. */
588 bool ipv = interprocedural_view;
589 interprocedural_view = true;
590 fix_backedges(current_ir_graph->obst, node);
591 interprocedural_view = ipv;
594 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
597 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
598 assert(node->op == op_Block &&
599 node->attr.block.in_cg &&
600 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
601 node->attr.block.in_cg[pos + 1] = pred;
604 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
605 assert(node->op == op_Block);
606 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
609 int get_Block_cg_n_cfgpreds(ir_node * node) {
610 assert(node->op == op_Block);
611 return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
614 ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
615 assert(node->op == op_Block && node->attr.block.in_cg);
616 return node->attr.block.in_cg[pos + 1];
619 void remove_Block_cg_cfgpred_arr(ir_node * node) {
620 assert(node->op == op_Block);
621 node->attr.block.in_cg = NULL;
625 get_End_n_keepalives(ir_node *end) {
626 assert (end->op == op_End);
627 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
631 get_End_keepalive(ir_node *end, int pos) {
632 assert (end->op == op_End);
633 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
637 add_End_keepalive (ir_node *end, ir_node *ka) {
638 assert (end->op == op_End);
639 ARR_APP1 (ir_node *, end->in, ka);
643 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
644 assert (end->op == op_End);
645 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
649 free_End (ir_node *end) {
650 assert (end->op == op_End);
651 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
652 end->in = NULL; /* @@@ make sure we get an error if we use the
653 in array afterwards ... */
656 ir_graph *get_EndReg_irg (const ir_node *end) {
657 assert (end->op == op_EndReg);
658 return end->attr.end.irg;
661 ir_graph *get_EndExcept_irg (const ir_node *end) {
662 assert (end->op == op_EndReg);
663 return end->attr.end.irg;
667 > Implementing the case construct (which is where the constant Proj node is
668 > important) involves far more than simply determining the constant values.
669 > We could argue that this is more properly a function of the translator from
670 > Firm to the target machine. That could be done if there was some way of
671 > projecting "default" out of the Cond node.
672 I know it's complicated.
673 Basically there are two proglems:
674 - determining the gaps between the projs
675 - determining the biggest case constant to konw the proj number for
677 I see several solutions:
678 1. Introduce a ProjDefault node. Solves both problems.
679 This means to extend all optimizations executed during construction.
680 2. Give the Cond node for switch two flavors:
681 a) there are no gaps in the projs (existing flavor)
682 b) gaps may exist, default proj is still the Proj with the largest
683 projection number. This covers also the gaps.
684 3. Fix the semantic of the Cond to that of 2b)
686 Solution 2 seems to be the best:
687 Computing the gaps in the Firm representation is not too hard, i.e.,
688 libfirm can implement a routine that transforms betweeen the two
689 flavours. This is also possible for 1) but 2) does not require to
690 change any existing optimization.
691 Further it should be far simpler to determine the biggest constant than
693 I don't want to choose 3) as 2a) seems to have advantages for
694 dataflow analysis and 3) does not allow to convert the representation to
698 get_Cond_selector (ir_node *node) {
699 assert (node->op == op_Cond);
700 return get_irn_n(node, 0);
704 set_Cond_selector (ir_node *node, ir_node *selector) {
705 assert (node->op == op_Cond);
706 set_irn_n(node, 0, selector);
710 get_Cond_kind (ir_node *node) {
711 assert (node->op == op_Cond);
712 return node->attr.c.kind;
716 set_Cond_kind (ir_node *node, cond_kind kind) {
717 assert (node->op == op_Cond);
718 node->attr.c.kind = kind;
722 get_Return_mem (ir_node *node) {
723 assert (node->op == op_Return);
724 return get_irn_n(node, 0);
728 set_Return_mem (ir_node *node, ir_node *mem) {
729 assert (node->op == op_Return);
730 set_irn_n(node, 0, mem);
734 get_Return_n_ress (ir_node *node) {
735 assert (node->op == op_Return);
736 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
740 get_Return_res_arr (ir_node *node)
742 assert ((node->op == op_Return));
743 if (get_Return_n_ress(node) > 0)
744 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
751 set_Return_n_res (ir_node *node, int results) {
752 assert (node->op == op_Return);
757 get_Return_res (ir_node *node, int pos) {
758 assert (node->op == op_Return);
759 assert (get_Return_n_ress(node) > pos);
760 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
764 set_Return_res (ir_node *node, int pos, ir_node *res){
765 assert (node->op == op_Return);
766 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
770 get_Raise_mem (ir_node *node) {
771 assert (node->op == op_Return);
772 return get_irn_n(node, 0);
776 set_Raise_mem (ir_node *node, ir_node *mem) {
777 assert (node->op == op_Raise);
778 set_irn_n(node, 0, mem);
782 get_Raise_exo_ptr (ir_node *node) {
783 assert (node->op == op_Raise);
784 return get_irn_n(node, 1);
788 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
789 assert (node->op == op_Raise);
790 set_irn_n(node, 1, exo_ptr);
793 INLINE tarval *get_Const_tarval (ir_node *node) {
794 assert (node->op == op_Const);
795 return get_irn_const_attr(node);
799 set_Const_tarval (ir_node *node, tarval *con) {
800 assert (node->op == op_Const);
801 node->attr.con = con;
805 get_SymConst_kind (const ir_node *node) {
806 assert (node->op == op_SymConst);
807 return node->attr.i.num;
811 set_SymConst_kind (ir_node *node, symconst_kind num) {
812 assert (node->op == op_SymConst);
813 node->attr.i.num = num;
817 get_SymConst_type (ir_node *node) {
818 assert ( (node->op == op_SymConst)
819 && ( get_SymConst_kind(node) == type_tag
820 || get_SymConst_kind(node) == size));
821 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
825 set_SymConst_type (ir_node *node, type *tp) {
826 assert ( (node->op == op_SymConst)
827 && ( get_SymConst_kind(node) == type_tag
828 || get_SymConst_kind(node) == size));
829 node->attr.i.tori.typ = tp;
833 get_SymConst_ptrinfo (ir_node *node) {
834 assert ( (node->op == op_SymConst)
835 && (get_SymConst_kind(node) == linkage_ptr_info));
836 return node->attr.i.tori.ptrinfo;
840 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
841 assert ( (node->op == op_SymConst)
842 && (get_SymConst_kind(node) == linkage_ptr_info));
843 node->attr.i.tori.ptrinfo = ptrinfo;
847 get_SymConst_type_or_id (ir_node *node) {
848 assert (node->op == op_SymConst);
849 return &(node->attr.i.tori);
853 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
854 assert (node->op == op_SymConst);
855 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
859 get_Sel_mem (ir_node *node) {
860 assert (node->op == op_Sel);
861 return get_irn_n(node, 0);
865 set_Sel_mem (ir_node *node, ir_node *mem) {
866 assert (node->op == op_Sel);
867 set_irn_n(node, 0, mem);
871 get_Sel_ptr (ir_node *node) {
872 assert (node->op == op_Sel);
873 return get_irn_n(node, 1);
877 set_Sel_ptr (ir_node *node, ir_node *ptr) {
878 assert (node->op == op_Sel);
879 set_irn_n(node, 1, ptr);
883 get_Sel_n_indexs (ir_node *node) {
884 assert (node->op == op_Sel);
885 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
889 get_Sel_index_arr (ir_node *node)
891 assert ((node->op == op_Sel));
892 if (get_Sel_n_indexs(node) > 0)
893 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
899 get_Sel_index (ir_node *node, int pos) {
900 assert (node->op == op_Sel);
901 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
905 set_Sel_index (ir_node *node, int pos, ir_node *index) {
906 assert (node->op == op_Sel);
907 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
911 get_Sel_entity (ir_node *node) {
912 assert (node->op == op_Sel);
913 return node->attr.s.ent;
917 set_Sel_entity (ir_node *node, entity *ent) {
918 assert (node->op == op_Sel);
919 node->attr.s.ent = ent;
923 get_InstOf_ent (ir_node *node) {
924 assert (node->op = op_InstOf);
925 return (node->attr.io.ent);
929 set_InstOf_ent (ir_node *node, type *ent) {
930 assert (node->op = op_InstOf);
931 node->attr.io.ent = ent;
935 get_InstOf_store (ir_node *node) {
936 assert (node->op = op_InstOf);
937 return (get_irn_n (node, 0));
941 set_InstOf_store (ir_node *node, ir_node *obj) {
942 assert (node->op = op_InstOf);
943 set_irn_n (node, 0, obj);
947 get_InstOf_obj (ir_node *node) {
948 assert (node->op = op_InstOf);
949 return (get_irn_n (node, 1));
953 set_InstOf_obj (ir_node *node, ir_node *obj) {
954 assert (node->op = op_InstOf);
955 set_irn_n (node, 1, obj);
959 /* For unary and binary arithmetic operations the access to the
960 operands can be factored out. Left is the first, right the
961 second arithmetic value as listed in tech report 0999-33.
962 unops are: Minus, Abs, Not, Conv
963 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
964 Shr, Shrs, Rotate, Cmp */
968 get_Call_mem (ir_node *node) {
969 assert (node->op == op_Call);
970 return get_irn_n(node, 0);
974 set_Call_mem (ir_node *node, ir_node *mem) {
975 assert (node->op == op_Call);
976 set_irn_n(node, 0, mem);
980 get_Call_ptr (ir_node *node) {
981 assert (node->op == op_Call);
982 return get_irn_n(node, 1);
986 set_Call_ptr (ir_node *node, ir_node *ptr) {
987 assert (node->op == op_Call);
988 set_irn_n(node, 1, ptr);
992 get_Call_param_arr (ir_node *node) {
993 assert (node->op == op_Call);
994 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
998 get_Call_n_params (ir_node *node) {
999 assert (node->op == op_Call);
1000 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1004 get_Call_arity (ir_node *node) {
1005 assert (node->op == op_Call);
1006 return get_Call_n_params(node);
1010 set_Call_arity (ir_node *node, ir_node *arity) {
1011 assert (node->op == op_Call);
1016 get_Call_param (ir_node *node, int pos) {
1017 assert (node->op == op_Call);
1018 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1022 set_Call_param (ir_node *node, int pos, ir_node *param) {
1023 assert (node->op == op_Call);
1024 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1028 get_Call_type (ir_node *node) {
1029 assert (node->op == op_Call);
1030 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1034 set_Call_type (ir_node *node, type *tp) {
1035 assert (node->op == op_Call);
1036 assert (is_method_type(tp));
1037 node->attr.call.cld_tp = tp;
1040 int get_Call_n_callees(ir_node * node) {
1041 assert(node->op == op_Call && node->attr.call.callee_arr);
1042 return ARR_LEN(node->attr.call.callee_arr);
1045 entity * get_Call_callee(ir_node * node, int pos) {
1046 assert(node->op == op_Call && node->attr.call.callee_arr);
1047 return node->attr.call.callee_arr[pos];
1050 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1051 assert(node->op == op_Call);
1052 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1053 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1055 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1058 void remove_Call_callee_arr(ir_node * node) {
1059 assert(node->op == op_Call);
1060 node->attr.call.callee_arr = NULL;
1063 ir_node * get_CallBegin_ptr (ir_node *node) {
1064 assert(node->op == op_CallBegin);
1065 return get_irn_n(node, 0);
1067 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1068 assert(node->op == op_CallBegin);
1069 set_irn_n(node, 0, ptr);
1071 ir_graph * get_CallBegin_irg (ir_node *node) {
1072 assert(node->op == op_CallBegin);
1073 return node->attr.callbegin.irg;
1075 ir_node * get_CallBegin_call (ir_node *node) {
1076 assert(node->op == op_CallBegin);
1077 return node->attr.callbegin.call;
1079 void set_CallBegin_call (ir_node *node, ir_node *call) {
1080 assert(node->op == op_CallBegin);
1081 node->attr.callbegin.call = call;
1085 get_Add_left (ir_node *node) {
1086 assert (node->op == op_Add);
1087 return get_irn_n(node, 0);
1091 set_Add_left (ir_node *node, ir_node *left) {
1092 assert (node->op == op_Add);
1093 set_irn_n(node, 0, left);
1097 get_Add_right (ir_node *node) {
1098 assert (node->op == op_Add);
1099 return get_irn_n(node, 1);
1103 set_Add_right (ir_node *node, ir_node *right) {
1104 assert (node->op == op_Add);
1105 set_irn_n(node, 1, right);
1109 get_Sub_left (ir_node *node) {
1110 assert (node->op == op_Sub);
1111 return get_irn_n(node, 0);
1115 set_Sub_left (ir_node *node, ir_node *left) {
1116 assert (node->op == op_Sub);
1117 set_irn_n(node, 0, left);
1121 get_Sub_right (ir_node *node) {
1122 assert (node->op == op_Sub);
1123 return get_irn_n(node, 1);
1127 set_Sub_right (ir_node *node, ir_node *right) {
1128 assert (node->op == op_Sub);
1129 set_irn_n(node, 1, right);
1134 get_Minus_op (ir_node *node) {
1135 assert (node->op == op_Minus);
1136 return get_irn_n(node, 0);
1140 set_Minus_op (ir_node *node, ir_node *op) {
1141 assert (node->op == op_Minus);
1142 set_irn_n(node, 0, op);
1147 get_Mul_left (ir_node *node) {
1148 assert (node->op == op_Mul);
1149 return get_irn_n(node, 0);
1153 set_Mul_left (ir_node *node, ir_node *left) {
1154 assert (node->op == op_Mul);
1155 set_irn_n(node, 0, left);
1159 get_Mul_right (ir_node *node) {
1160 assert (node->op == op_Mul);
1161 return get_irn_n(node, 1);
1165 set_Mul_right (ir_node *node, ir_node *right) {
1166 assert (node->op == op_Mul);
1167 set_irn_n(node, 1, right);
1171 get_Quot_left (ir_node *node) {
1172 assert (node->op == op_Quot);
1173 return get_irn_n(node, 1);
1177 set_Quot_left (ir_node *node, ir_node *left) {
1178 assert (node->op == op_Quot);
1179 set_irn_n(node, 1, left);
1183 get_Quot_right (ir_node *node) {
1184 assert (node->op == op_Quot);
1185 return get_irn_n(node, 2);
1189 set_Quot_right (ir_node *node, ir_node *right) {
1190 assert (node->op == op_Quot);
1191 set_irn_n(node, 2, right);
1195 get_Quot_mem (ir_node *node) {
1196 assert (node->op == op_Quot);
1197 return get_irn_n(node, 0);
1201 set_Quot_mem (ir_node *node, ir_node *mem) {
1202 assert (node->op == op_Quot);
1203 set_irn_n(node, 0, mem);
1207 get_DivMod_left (ir_node *node) {
1208 assert (node->op == op_DivMod);
1209 return get_irn_n(node, 1);
1213 set_DivMod_left (ir_node *node, ir_node *left) {
1214 assert (node->op == op_DivMod);
1215 set_irn_n(node, 1, left);
1219 get_DivMod_right (ir_node *node) {
1220 assert (node->op == op_DivMod);
1221 return get_irn_n(node, 2);
1225 set_DivMod_right (ir_node *node, ir_node *right) {
1226 assert (node->op == op_DivMod);
1227 set_irn_n(node, 2, right);
1231 get_DivMod_mem (ir_node *node) {
1232 assert (node->op == op_DivMod);
1233 return get_irn_n(node, 0);
1237 set_DivMod_mem (ir_node *node, ir_node *mem) {
1238 assert (node->op == op_DivMod);
1239 set_irn_n(node, 0, mem);
1243 get_Div_left (ir_node *node) {
1244 assert (node->op == op_Div);
1245 return get_irn_n(node, 1);
1249 set_Div_left (ir_node *node, ir_node *left) {
1250 assert (node->op == op_Div);
1251 set_irn_n(node, 1, left);
1255 get_Div_right (ir_node *node) {
1256 assert (node->op == op_Div);
1257 return get_irn_n(node, 2);
1261 set_Div_right (ir_node *node, ir_node *right) {
1262 assert (node->op == op_Div);
1263 set_irn_n(node, 2, right);
1267 get_Div_mem (ir_node *node) {
1268 assert (node->op == op_Div);
1269 return get_irn_n(node, 0);
1273 set_Div_mem (ir_node *node, ir_node *mem) {
1274 assert (node->op == op_Div);
1275 set_irn_n(node, 0, mem);
1279 get_Mod_left (ir_node *node) {
1280 assert (node->op == op_Mod);
1281 return get_irn_n(node, 1);
1285 set_Mod_left (ir_node *node, ir_node *left) {
1286 assert (node->op == op_Mod);
1287 set_irn_n(node, 1, left);
1291 get_Mod_right (ir_node *node) {
1292 assert (node->op == op_Mod);
1293 return get_irn_n(node, 2);
1297 set_Mod_right (ir_node *node, ir_node *right) {
1298 assert (node->op == op_Mod);
1299 set_irn_n(node, 2, right);
1303 get_Mod_mem (ir_node *node) {
1304 assert (node->op == op_Mod);
1305 return get_irn_n(node, 0);
1309 set_Mod_mem (ir_node *node, ir_node *mem) {
1310 assert (node->op == op_Mod);
1311 set_irn_n(node, 0, mem);
1315 get_Abs_op (ir_node *node) {
1316 assert (node->op == op_Abs);
1317 return get_irn_n(node, 0);
1321 set_Abs_op (ir_node *node, ir_node *op) {
1322 assert (node->op == op_Abs);
1323 set_irn_n(node, 0, op);
1327 get_And_left (ir_node *node) {
1328 assert (node->op == op_And);
1329 return get_irn_n(node, 0);
1333 set_And_left (ir_node *node, ir_node *left) {
1334 assert (node->op == op_And);
1335 set_irn_n(node, 0, left);
1339 get_And_right (ir_node *node) {
1340 assert (node->op == op_And);
1341 return get_irn_n(node, 1);
1345 set_And_right (ir_node *node, ir_node *right) {
1346 assert (node->op == op_And);
1347 set_irn_n(node, 1, right);
1351 get_Or_left (ir_node *node) {
1352 assert (node->op == op_Or);
1353 return get_irn_n(node, 0);
1357 set_Or_left (ir_node *node, ir_node *left) {
1358 assert (node->op == op_Or);
1359 set_irn_n(node, 0, left);
1363 get_Or_right (ir_node *node) {
1364 assert (node->op == op_Or);
1365 return get_irn_n(node, 1);
1369 set_Or_right (ir_node *node, ir_node *right) {
1370 assert (node->op == op_Or);
1371 set_irn_n(node, 1, right);
1375 get_Eor_left (ir_node *node) {
1376 assert (node->op == op_Eor);
1377 return get_irn_n(node, 0);
1381 set_Eor_left (ir_node *node, ir_node *left) {
1382 assert (node->op == op_Eor);
1383 set_irn_n(node, 0, left);
1387 get_Eor_right (ir_node *node) {
1388 assert (node->op == op_Eor);
1389 return get_irn_n(node, 1);
1393 set_Eor_right (ir_node *node, ir_node *right) {
1394 assert (node->op == op_Eor);
1395 set_irn_n(node, 1, right);
1400 get_Not_op (ir_node *node) {
1401 assert (node->op == op_Not);
1402 return get_irn_n(node, 0);
1406 set_Not_op (ir_node *node, ir_node *op) {
1407 assert (node->op == op_Not);
1408 set_irn_n(node, 0, op);
1413 get_Shl_left (ir_node *node) {
1414 assert (node->op == op_Shl);
1415 return get_irn_n(node, 0);
1419 set_Shl_left (ir_node *node, ir_node *left) {
1420 assert (node->op == op_Shl);
1421 set_irn_n(node, 0, left);
1425 get_Shl_right (ir_node *node) {
1426 assert (node->op == op_Shl);
1427 return get_irn_n(node, 1);
1431 set_Shl_right (ir_node *node, ir_node *right) {
1432 assert (node->op == op_Shl);
1433 set_irn_n(node, 1, right);
1437 get_Shr_left (ir_node *node) {
1438 assert (node->op == op_Shr);
1439 return get_irn_n(node, 0);
1443 set_Shr_left (ir_node *node, ir_node *left) {
1444 assert (node->op == op_Shr);
1445 set_irn_n(node, 0, left);
1449 get_Shr_right (ir_node *node) {
1450 assert (node->op == op_Shr);
1451 return get_irn_n(node, 1);
1455 set_Shr_right (ir_node *node, ir_node *right) {
1456 assert (node->op == op_Shr);
1457 set_irn_n(node, 1, right);
1461 get_Shrs_left (ir_node *node) {
1462 assert (node->op == op_Shrs);
1463 return get_irn_n(node, 0);
1467 set_Shrs_left (ir_node *node, ir_node *left) {
1468 assert (node->op == op_Shrs);
1469 set_irn_n(node, 0, left);
1473 get_Shrs_right (ir_node *node) {
1474 assert (node->op == op_Shrs);
1475 return get_irn_n(node, 1);
1479 set_Shrs_right (ir_node *node, ir_node *right) {
1480 assert (node->op == op_Shrs);
1481 set_irn_n(node, 1, right);
1485 get_Rot_left (ir_node *node) {
1486 assert (node->op == op_Rot);
1487 return get_irn_n(node, 0);
1491 set_Rot_left (ir_node *node, ir_node *left) {
1492 assert (node->op == op_Rot);
1493 set_irn_n(node, 0, left);
1497 get_Rot_right (ir_node *node) {
1498 assert (node->op == op_Rot);
1499 return get_irn_n(node, 1);
1503 set_Rot_right (ir_node *node, ir_node *right) {
1504 assert (node->op == op_Rot);
1505 set_irn_n(node, 1, right);
1509 get_Cmp_left (ir_node *node) {
1510 assert (node->op == op_Cmp);
1511 return get_irn_n(node, 0);
1515 set_Cmp_left (ir_node *node, ir_node *left) {
1516 assert (node->op == op_Cmp);
1517 set_irn_n(node, 0, left);
1521 get_Cmp_right (ir_node *node) {
1522 assert (node->op == op_Cmp);
1523 return get_irn_n(node, 1);
1527 set_Cmp_right (ir_node *node, ir_node *right) {
1528 assert (node->op == op_Cmp);
1529 set_irn_n(node, 1, right);
1533 get_Conv_op (ir_node *node) {
1534 assert (node->op == op_Conv);
1535 return get_irn_n(node, 0);
1539 set_Conv_op (ir_node *node, ir_node *op) {
1540 assert (node->op == op_Conv);
1541 set_irn_n(node, 0, op);
1547 is_unop (ir_node *node) {
1548 return ( node->op == op_Minus ||
1549 node->op == op_Abs ||
1550 node->op == op_Not ||
1551 node->op == op_Conv );
1555 get_unop_op (ir_node *node) {
1556 assert ( node->op == op_Minus ||
1557 node->op == op_Abs ||
1558 node->op == op_Not ||
1559 node->op == op_Conv );
1560 switch (get_irn_opcode (node)) {
1561 case iro_Minus: return get_Minus_op(node); break;
1562 case iro_Abs: return get_Abs_op(node); break;
1563 case iro_Not: return get_Not_op(node); break;
1564 case iro_Conv: return get_Conv_op(node); break;
1565 default: return NULL;
1570 set_unop_op (ir_node *node, ir_node *op) {
1571 assert (node->op == op_Minus ||
1572 node->op == op_Abs ||
1573 node->op == op_Not ||
1574 node->op == op_Conv );
1575 switch (get_irn_opcode (node)) {
1576 case iro_Minus: set_Minus_op(node, op); break;
1577 case iro_Abs: set_Abs_op(node, op); break;
1578 case iro_Not: set_Not_op(node, op); break;
1579 case iro_Conv: set_Conv_op(node, op); break;
1586 is_binop (ir_node *node) {
1587 return (node->op == op_Add ||
1588 node->op == op_Sub ||
1589 node->op == op_Mul ||
1590 node->op == op_Quot ||
1591 node->op == op_DivMod ||
1592 node->op == op_Div ||
1593 node->op == op_Mod ||
1594 node->op == op_And ||
1595 node->op == op_Or ||
1596 node->op == op_Eor ||
1597 node->op == op_Shl ||
1598 node->op == op_Shr ||
1599 node->op == op_Shrs ||
1600 node->op == op_Rot ||
1601 node->op == op_Cmp );
1605 get_binop_left (ir_node *node) {
1606 assert (node->op == op_Add ||
1607 node->op == op_Sub ||
1608 node->op == op_Mul ||
1609 node->op == op_Quot ||
1610 node->op == op_DivMod ||
1611 node->op == op_Div ||
1612 node->op == op_Mod ||
1613 node->op == op_And ||
1614 node->op == op_Or ||
1615 node->op == op_Eor ||
1616 node->op == op_Shl ||
1617 node->op == op_Shr ||
1618 node->op == op_Shrs ||
1619 node->op == op_Rot ||
1620 node->op == op_Cmp );
1622 switch (get_irn_opcode (node)) {
1623 case iro_Add : return get_Add_left(node); break;
1624 case iro_Sub : return get_Sub_left(node); break;
1625 case iro_Mul : return get_Mul_left(node); break;
1626 case iro_Quot : return get_Quot_left(node); break;
1627 case iro_DivMod: return get_DivMod_left(node); break;
1628 case iro_Div : return get_Div_left(node); break;
1629 case iro_Mod : return get_Mod_left(node); break;
1630 case iro_And : return get_And_left(node); break;
1631 case iro_Or : return get_Or_left(node); break;
1632 case iro_Eor : return get_Eor_left(node); break;
1633 case iro_Shl : return get_Shl_left(node); break;
1634 case iro_Shr : return get_Shr_left(node); break;
1635 case iro_Shrs : return get_Shrs_left(node); break;
1636 case iro_Rot : return get_Rot_left(node); break;
1637 case iro_Cmp : return get_Cmp_left(node); break;
1638 default: return NULL;
1643 set_binop_left (ir_node *node, ir_node *left) {
1644 assert (node->op == op_Add ||
1645 node->op == op_Sub ||
1646 node->op == op_Mul ||
1647 node->op == op_Quot ||
1648 node->op == op_DivMod ||
1649 node->op == op_Div ||
1650 node->op == op_Mod ||
1651 node->op == op_And ||
1652 node->op == op_Or ||
1653 node->op == op_Eor ||
1654 node->op == op_Shl ||
1655 node->op == op_Shr ||
1656 node->op == op_Shrs ||
1657 node->op == op_Rot ||
1658 node->op == op_Cmp );
1660 switch (get_irn_opcode (node)) {
1661 case iro_Add : set_Add_left(node, left); break;
1662 case iro_Sub : set_Sub_left(node, left); break;
1663 case iro_Mul : set_Mul_left(node, left); break;
1664 case iro_Quot : set_Quot_left(node, left); break;
1665 case iro_DivMod: set_DivMod_left(node, left); break;
1666 case iro_Div : set_Div_left(node, left); break;
1667 case iro_Mod : set_Mod_left(node, left); break;
1668 case iro_And : set_And_left(node, left); break;
1669 case iro_Or : set_Or_left(node, left); break;
1670 case iro_Eor : set_Eor_left(node, left); break;
1671 case iro_Shl : set_Shl_left(node, left); break;
1672 case iro_Shr : set_Shr_left(node, left); break;
1673 case iro_Shrs : set_Shrs_left(node, left); break;
1674 case iro_Rot : set_Rot_left(node, left); break;
1675 case iro_Cmp : set_Cmp_left(node, left); break;
1681 get_binop_right (ir_node *node) {
1682 assert (node->op == op_Add ||
1683 node->op == op_Sub ||
1684 node->op == op_Mul ||
1685 node->op == op_Quot ||
1686 node->op == op_DivMod ||
1687 node->op == op_Div ||
1688 node->op == op_Mod ||
1689 node->op == op_And ||
1690 node->op == op_Or ||
1691 node->op == op_Eor ||
1692 node->op == op_Shl ||
1693 node->op == op_Shr ||
1694 node->op == op_Shrs ||
1695 node->op == op_Rot ||
1696 node->op == op_Cmp );
1698 switch (get_irn_opcode (node)) {
1699 case iro_Add : return get_Add_right(node); break;
1700 case iro_Sub : return get_Sub_right(node); break;
1701 case iro_Mul : return get_Mul_right(node); break;
1702 case iro_Quot : return get_Quot_right(node); break;
1703 case iro_DivMod: return get_DivMod_right(node); break;
1704 case iro_Div : return get_Div_right(node); break;
1705 case iro_Mod : return get_Mod_right(node); break;
1706 case iro_And : return get_And_right(node); break;
1707 case iro_Or : return get_Or_right(node); break;
1708 case iro_Eor : return get_Eor_right(node); break;
1709 case iro_Shl : return get_Shl_right(node); break;
1710 case iro_Shr : return get_Shr_right(node); break;
1711 case iro_Shrs : return get_Shrs_right(node); break;
1712 case iro_Rot : return get_Rot_right(node); break;
1713 case iro_Cmp : return get_Cmp_right(node); break;
1714 default: return NULL;
1719 set_binop_right (ir_node *node, ir_node *right) {
1720 assert (node->op == op_Add ||
1721 node->op == op_Sub ||
1722 node->op == op_Mul ||
1723 node->op == op_Quot ||
1724 node->op == op_DivMod ||
1725 node->op == op_Div ||
1726 node->op == op_Mod ||
1727 node->op == op_And ||
1728 node->op == op_Or ||
1729 node->op == op_Eor ||
1730 node->op == op_Shl ||
1731 node->op == op_Shr ||
1732 node->op == op_Shrs ||
1733 node->op == op_Rot ||
1734 node->op == op_Cmp );
1736 switch (get_irn_opcode (node)) {
1737 case iro_Add : set_Add_right(node, right); break;
1738 case iro_Sub : set_Sub_right(node, right); break;
1739 case iro_Mul : set_Mul_right(node, right); break;
1740 case iro_Quot : set_Quot_right(node, right); break;
1741 case iro_DivMod: set_DivMod_right(node, right); break;
1742 case iro_Div : set_Div_right(node, right); break;
1743 case iro_Mod : set_Mod_right(node, right); break;
1744 case iro_And : set_And_right(node, right); break;
1745 case iro_Or : set_Or_right(node, right); break;
1746 case iro_Eor : set_Eor_right(node, right); break;
1747 case iro_Shl : set_Shl_right(node, right); break;
1748 case iro_Shr : set_Shr_right(node, right); break;
1749 case iro_Shrs : set_Shrs_right(node, right); break;
1750 case iro_Rot : set_Rot_right(node, right); break;
1751 case iro_Cmp : set_Cmp_right(node, right); break;
1758 get_Phi_preds_arr (ir_node *node) {
1759 assert (node->op == op_Phi);
1760 return (ir_node **)&(get_irn_in(node)[1]);
1764 get_Phi_n_preds (ir_node *node) {
1765 assert (node->op == op_Phi);
1766 return (get_irn_arity(node));
1770 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1771 assert (node->op == op_Phi);
1776 get_Phi_pred (ir_node *node, int pos) {
1777 assert (node->op == op_Phi);
1778 return get_irn_n(node, pos);
1782 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1783 assert (node->op == op_Phi);
1784 set_irn_n(node, pos, pred);
1788 get_Load_mem (ir_node *node) {
1789 assert (node->op == op_Load);
1790 return get_irn_n(node, 0);
1794 set_Load_mem (ir_node *node, ir_node *mem) {
1795 assert (node->op == op_Load);
1796 set_irn_n(node, 0, mem);
1800 get_Load_ptr (ir_node *node) {
1801 assert (node->op == op_Load);
1802 return get_irn_n(node, 1);
1806 set_Load_ptr (ir_node *node, ir_node *ptr) {
1807 assert (node->op == op_Load);
1808 set_irn_n(node, 1, ptr);
1813 get_Store_mem (ir_node *node) {
1814 assert (node->op == op_Store);
1815 return get_irn_n(node, 0);
1819 set_Store_mem (ir_node *node, ir_node *mem) {
1820 assert (node->op == op_Store);
1821 set_irn_n(node, 0, mem);
1825 get_Store_ptr (ir_node *node) {
1826 assert (node->op == op_Store);
1827 return get_irn_n(node, 1);
1831 set_Store_ptr (ir_node *node, ir_node *ptr) {
1832 assert (node->op == op_Store);
1833 set_irn_n(node, 1, ptr);
1837 get_Store_value (ir_node *node) {
1838 assert (node->op == op_Store);
1839 return get_irn_n(node, 2);
1843 set_Store_value (ir_node *node, ir_node *value) {
1844 assert (node->op == op_Store);
1845 set_irn_n(node, 2, value);
1849 get_Alloc_mem (ir_node *node) {
1850 assert (node->op == op_Alloc);
1851 return get_irn_n(node, 0);
1855 set_Alloc_mem (ir_node *node, ir_node *mem) {
1856 assert (node->op == op_Alloc);
1857 set_irn_n(node, 0, mem);
1861 get_Alloc_size (ir_node *node) {
1862 assert (node->op == op_Alloc);
1863 return get_irn_n(node, 1);
1867 set_Alloc_size (ir_node *node, ir_node *size) {
1868 assert (node->op == op_Alloc);
1869 set_irn_n(node, 1, size);
1873 get_Alloc_type (ir_node *node) {
1874 assert (node->op == op_Alloc);
1875 return node->attr.a.type = skip_tid(node->attr.a.type);
1879 set_Alloc_type (ir_node *node, type *tp) {
1880 assert (node->op == op_Alloc);
1881 node->attr.a.type = tp;
1885 get_Alloc_where (ir_node *node) {
1886 assert (node->op == op_Alloc);
1887 return node->attr.a.where;
1891 set_Alloc_where (ir_node *node, where_alloc where) {
1892 assert (node->op == op_Alloc);
1893 node->attr.a.where = where;
1898 get_Free_mem (ir_node *node) {
1899 assert (node->op == op_Free);
1900 return get_irn_n(node, 0);
1904 set_Free_mem (ir_node *node, ir_node *mem) {
1905 assert (node->op == op_Free);
1906 set_irn_n(node, 0, mem);
1910 get_Free_ptr (ir_node *node) {
1911 assert (node->op == op_Free);
1912 return get_irn_n(node, 1);
1916 set_Free_ptr (ir_node *node, ir_node *ptr) {
1917 assert (node->op == op_Free);
1918 set_irn_n(node, 1, ptr);
1922 get_Free_size (ir_node *node) {
1923 assert (node->op == op_Free);
1924 return get_irn_n(node, 2);
1928 set_Free_size (ir_node *node, ir_node *size) {
1929 assert (node->op == op_Free);
1930 set_irn_n(node, 2, size);
1934 get_Free_type (ir_node *node) {
1935 assert (node->op == op_Free);
1936 return node->attr.f = skip_tid(node->attr.f);
1940 set_Free_type (ir_node *node, type *tp) {
1941 assert (node->op == op_Free);
1946 get_Sync_preds_arr (ir_node *node) {
1947 assert (node->op == op_Sync);
1948 return (ir_node **)&(get_irn_in(node)[1]);
1952 get_Sync_n_preds (ir_node *node) {
1953 assert (node->op == op_Sync);
1954 return (get_irn_arity(node));
1959 set_Sync_n_preds (ir_node *node, int n_preds) {
1960 assert (node->op == op_Sync);
1965 get_Sync_pred (ir_node *node, int pos) {
1966 assert (node->op == op_Sync);
1967 return get_irn_n(node, pos);
1971 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1972 assert (node->op == op_Sync);
1973 set_irn_n(node, pos, pred);
1977 get_Proj_pred (ir_node *node) {
1978 assert (is_Proj(node));
1979 return get_irn_n(node, 0);
1983 set_Proj_pred (ir_node *node, ir_node *pred) {
1984 assert (is_Proj(node));
1985 set_irn_n(node, 0, pred);
1989 get_Proj_proj (ir_node *node) {
1990 assert (is_Proj(node));
1991 if (get_irn_opcode(node) == iro_Proj) {
1992 return node->attr.proj;
1994 assert(get_irn_opcode(node) == iro_Filter);
1995 return node->attr.filter.proj;
2000 set_Proj_proj (ir_node *node, long proj) {
2001 assert (node->op == op_Proj);
2002 node->attr.proj = proj;
2006 get_Tuple_preds_arr (ir_node *node) {
2007 assert (node->op == op_Tuple);
2008 return (ir_node **)&(get_irn_in(node)[1]);
2012 get_Tuple_n_preds (ir_node *node) {
2013 assert (node->op == op_Tuple);
2014 return (get_irn_arity(node));
2019 set_Tuple_n_preds (ir_node *node, int n_preds) {
2020 assert (node->op == op_Tuple);
2025 get_Tuple_pred (ir_node *node, int pos) {
2026 assert (node->op == op_Tuple);
2027 return get_irn_n(node, pos);
2031 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2032 assert (node->op == op_Tuple);
2033 set_irn_n(node, pos, pred);
2037 get_Id_pred (ir_node *node) {
2038 assert (node->op == op_Id);
2039 return get_irn_n(node, 0);
2043 set_Id_pred (ir_node *node, ir_node *pred) {
2044 assert (node->op == op_Id);
2045 set_irn_n(node, 0, pred);
2050 get_Filter_pred (ir_node *node) {
2051 assert(node->op == op_Filter);
2055 set_Filter_pred (ir_node *node, ir_node *pred) {
2056 assert(node->op == op_Filter);
2060 get_Filter_proj(ir_node *node) {
2061 assert(node->op == op_Filter);
2062 return node->attr.filter.proj;
2065 set_Filter_proj (ir_node *node, long proj) {
2066 assert(node->op == op_Filter);
2067 node->attr.filter.proj = proj;
2070 /* Don't use get_irn_arity, get_irn_n in implementation as access
2071 shall work independent of view!!! */
2072 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2073 assert(node->op == op_Filter);
2074 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2075 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2076 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2077 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2078 node->attr.filter.in_cg[0] = node->in[0];
2080 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2083 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2084 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2085 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2086 node->attr.filter.in_cg[pos + 1] = pred;
2088 int get_Filter_n_cg_preds(ir_node *node) {
2089 assert(node->op == op_Filter && node->attr.filter.in_cg);
2090 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2092 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2094 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2096 arity = ARR_LEN(node->attr.filter.in_cg);
2097 assert(pos < arity - 1);
2098 return node->attr.filter.in_cg[pos + 1];
2103 get_irn_irg(ir_node *node) {
2104 if (get_irn_op(node) == op_CallBegin) {
2105 return node->attr.callbegin.irg;
2106 } else if (get_irn_op(node) == op_EndReg ||
2107 get_irn_op(node) == op_EndExcept) {
2108 return node->attr.end.irg;
2110 assert(0 && "no irg attr");
2115 /******************************************************************/
2116 /* Auxiliary routines */
2117 /******************************************************************/
2120 skip_Proj (ir_node *node) {
2121 /* don't assert node !!! */
2122 if (node && is_Proj(node)) {
2123 return get_Proj_pred(node);
2130 skip_Tuple (ir_node *node) {
2133 if (!get_opt_normalize()) return node;
2135 node = skip_nop(node);
2136 if (get_irn_op(node) == op_Proj) {
2137 pred = skip_nop(get_Proj_pred(node));
2138 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2139 pred = skip_nop(skip_Tuple(pred));
2140 if (get_irn_op(pred) == op_Tuple)
2141 return get_Tuple_pred(pred, get_Proj_proj(node));
2147 skip_nop (ir_node *node) {
2148 /* don't assert node !!! */
2150 if (!get_opt_normalize()) return node;
2152 /* Don't use get_Id_pred: We get into an endless loop for
2153 self-referencing Ids. */
2154 if (node && (node->op == op_Id) && (node != node->in[0+1])) {
2155 assert (get_irn_arity (node) > 0);
2156 return node->in[0+1];
2163 skip_Id (ir_node *node) {
2164 return skip_nop(node);
2168 is_Bad (ir_node *node) {
2170 if ((node) && get_irn_opcode(node) == iro_Bad)
2176 is_no_Block (ir_node *node) {
2178 return (get_irn_opcode(node) != iro_Block);
2182 is_Block (ir_node *node) {
2184 return (get_irn_opcode(node) == iro_Block);
2188 is_Proj (const ir_node *node) {
2190 return node->op == op_Proj
2191 || (!interprocedural_view && node->op == op_Filter);
2194 /* Returns true if the operation manipulates control flow. */
2196 is_cfop(ir_node *node) {
2197 return is_cfopcode(get_irn_op(node));
2200 /* Returns true if the operation manipulates interprocedural control flow:
2201 CallBegin, EndReg, EndExcept */
2202 INLINE int is_ip_cfop(ir_node *node) {
2203 return is_ip_cfopcode(get_irn_op(node));
2206 ir_graph *get_ip_cfop_irg(ir_node *n) {
2207 switch (get_irn_opcode(n)) {
2209 return get_EndReg_irg(n);
2211 return get_EndExcept_irg(n);
2213 return get_CallBegin_irg(n);
2215 assert(is_ip_cfop(n));
2217 return NULL; /* should never be reached */
2220 /* Returns true if the operation can change the control flow because
2223 is_fragile_op(ir_node *node) {
2224 return ( (get_irn_opcode(node) == iro_Call)
2225 || (get_irn_opcode(node) == iro_Quot)
2226 || (get_irn_opcode(node) == iro_DivMod)
2227 || (get_irn_opcode(node) == iro_Div)
2228 || (get_irn_opcode(node) == iro_Mod)
2229 || (get_irn_opcode(node) == iro_Load)
2230 || (get_irn_opcode(node) == iro_Store)
2231 || (get_irn_opcode(node) == iro_Alloc)
2232 || (get_irn_opcode(node) == iro_Bad)
2233 || (get_irn_opcode(node) == iro_Unknown));
2237 /* Returns the memory operand of fragile operations. */
2238 ir_node *get_fragile_op_mem(ir_node *node) {
2239 assert(node && is_fragile_op(node));
2241 switch (get_irn_opcode (node)) {
2250 return get_irn_n(node, 0);
2255 assert(0 && "not reached");