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 const char *pns_name_arr [] = {
82 "initial_exec", "global_store",
83 "frame_base", "globals", "args"
86 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 **/
141 is_ir_node (void *thing) {
143 if (get_kind(thing) == k_ir_node)
149 /* returns the number of predecessors without the block predecessor. */
151 get_irn_arity (const ir_node *node) {
153 if (interprocedural_view) { /* handle Filter and Block specially */
154 if (get_irn_opcode(node) == iro_Filter) {
155 assert(node->attr.filter.in_cg);
156 return ARR_LEN(node->attr.filter.in_cg) - 1;
157 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
158 return ARR_LEN(node->attr.block.in_cg) - 1;
160 /* else fall through */
162 return ARR_LEN(node->in) - 1;
165 /* Returns the array with ins. This array is shifted with respect to the
166 array accessed by get_irn_n: The block operand is at position 0 not -1.
167 (@@@ This should be changed.)
168 The order of the predecessors in this array is not guaranteed, except that
169 lists of operands as predecessors of Block or arguments of a Call are
172 get_irn_in (const ir_node *node) {
174 if (interprocedural_view) { /* handle Filter and Block specially */
175 if (get_irn_opcode(node) == iro_Filter) {
176 assert(node->attr.filter.in_cg);
177 return node->attr.filter.in_cg;
178 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
179 return node->attr.block.in_cg;
181 /* else fall through */
187 set_irn_in (ir_node *node, int arity, ir_node **in) {
190 if (interprocedural_view) { /* handle Filter and Block specially */
191 if (get_irn_opcode(node) == iro_Filter) {
192 assert(node->attr.filter.in_cg);
193 arr = &node->attr.filter.in_cg;
194 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
195 arr = &node->attr.block.in_cg;
202 if (arity != ARR_LEN(*arr) - 1) {
203 ir_node * block = (*arr)[0];
204 *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
207 fix_backedges(current_ir_graph->obst, node);
208 memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
211 /* to iterate through the predecessors without touching the array */
212 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
213 to iterate includind the Block predecessor iterate from i = -1 to
215 If it is a block, the entry -1 is NULL. */
217 get_irn_n (ir_node *node, int n) {
219 if (-1 > n || get_irn_arity(node) <= n) {
220 printf("pos: %d, arity: %d ", n, get_irn_arity(node));
223 assert(node); assert(-1 <= n && n < get_irn_arity(node));
224 if (interprocedural_view) { /* handle Filter and Block specially */
225 if (get_irn_opcode(node) == iro_Filter) {
226 assert(node->attr.filter.in_cg);
227 return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
228 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
229 return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
231 /* else fall through */
233 return (node->in[n + 1] = skip_nop(node->in[n + 1]));
237 set_irn_n (ir_node *node, int n, ir_node *in) {
238 assert(node && -1 <= n && n < get_irn_arity(node));
239 if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
240 /* Change block pred in both views! */
241 node->in[n + 1] = in;
242 assert(node->attr.filter.in_cg);
243 node->attr.filter.in_cg[n + 1] = in;
246 if (interprocedural_view) { /* handle Filter and Block specially */
247 if (get_irn_opcode(node) == iro_Filter) {
248 assert(node->attr.filter.in_cg);
249 node->attr.filter.in_cg[n + 1] = in;
251 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
252 node->attr.block.in_cg[n + 1] = in;
255 /* else fall through */
257 node->in[n + 1] = in;
261 get_irn_mode (const ir_node *node)
268 set_irn_mode (ir_node *node, ir_mode *mode)
276 get_irn_modecode (const ir_node *node)
279 return node->mode->code;
284 get_irn_modeident (const ir_node *node)
287 return get_mode_ident(node->mode);
291 get_irn_op (const ir_node *node)
297 /* should be private to the library: */
299 set_irn_op (ir_node *node, ir_op *op)
306 get_irn_opcode (const ir_node *node)
309 assert (k_ir_node == get_kind(node));
311 return node->op->code;
315 get_irn_opname (const ir_node *node)
318 return id_to_str(node->op->name);
322 get_irn_opident (const ir_node *node)
325 return node->op->name;
329 get_irn_visited (const ir_node *node)
332 return node->visited;
336 set_irn_visited (ir_node *node, unsigned long visited)
339 node->visited = visited;
343 mark_irn_visited (ir_node *node) {
345 node->visited = current_ir_graph->visited;
349 irn_not_visited (const ir_node *node) {
351 return (node->visited < current_ir_graph->visited);
355 irn_visited (const ir_node *node) {
357 return (node->visited >= current_ir_graph->visited);
361 set_irn_link (ir_node *node, void *link) {
363 /* Link field is used for Phi construction and various optimizations
365 assert(get_irg_phase_state(current_ir_graph) != phase_building);
371 get_irn_link (const ir_node *node) {
376 /* Outputs a unique number for this node */
378 get_irn_node_nr(const ir_node *node) {
381 return node->node_nr;
388 get_irn_const_attr (ir_node *node)
390 assert (node->op == op_Const);
391 return node->attr.con;
395 get_irn_proj_attr (ir_node *node)
397 assert (node->op == op_Proj);
398 return node->attr.proj;
402 get_irn_alloc_attr (ir_node *node)
404 assert (node->op == op_Alloc);
409 get_irn_free_attr (ir_node *node)
411 assert (node->op == op_Free);
412 return node->attr.f = skip_tid(node->attr.f);
416 get_irn_symconst_attr (ir_node *node)
418 assert (node->op == op_SymConst);
423 get_irn_call_attr (ir_node *node)
425 assert (node->op == op_Call);
426 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
430 get_irn_sel_attr (ir_node *node)
432 assert (node->op == op_Sel);
437 get_irn_phi_attr (ir_node *node)
439 assert (node->op == op_Phi);
440 return node->attr.phi0_pos;
444 get_irn_block_attr (ir_node *node)
446 assert (node->op == op_Block);
447 return node->attr.block;
450 /** manipulate fields of individual nodes **/
452 /* this works for all except Block */
454 get_nodes_Block (ir_node *node) {
455 assert (!(node->op == op_Block));
456 return get_irn_n(node, -1);
460 set_nodes_Block (ir_node *node, ir_node *block) {
461 assert (!(node->op == op_Block));
462 set_irn_n(node, -1, block);
465 /* Returns an array with the predecessors of the Block. Depending on
466 the implementation of the graph datastructure this can be a copy of
467 the internal representation of predecessors as well as the internal
468 array itself. Therefore writing to this array might obstruct the ir. */
470 get_Block_cfgpred_arr (ir_node *node)
472 assert ((node->op == op_Block));
473 return (ir_node **)&(get_irn_in(node)[1]);
478 get_Block_n_cfgpreds (ir_node *node) {
479 assert ((node->op == op_Block));
480 return (get_irn_arity(node));
484 get_Block_cfgpred (ir_node *node, int pos) {
485 assert (node->op == op_Block);
487 if (-1 > pos || get_irn_arity(node) <= pos) {
488 dump_ir_block_graph(current_ir_graph);
489 printf("pos: %d, arity: %d ", pos, get_irn_arity(node));
492 assert(node); assert(-1 <= pos && pos < get_irn_arity(node));
493 return get_irn_n(node, pos);
497 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
498 assert (node->op == op_Block);
499 set_irn_n(node, pos, pred);
503 get_Block_matured (ir_node *node) {
504 assert (node->op == op_Block);
505 return node->attr.block.matured;
509 set_Block_matured (ir_node *node, bool matured) {
510 assert (node->op == op_Block);
511 node->attr.block.matured = matured;
514 get_Block_block_visited (ir_node *node) {
515 assert (node->op == op_Block);
516 return node->attr.block.block_visited;
520 set_Block_block_visited (ir_node *node, unsigned long visit) {
521 assert (node->op == op_Block);
522 node->attr.block.block_visited = visit;
525 /* For this current_ir_graph must be set. */
527 mark_Block_block_visited (ir_node *node) {
528 assert (node->op == op_Block);
529 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
533 Block_not_block_visited(ir_node *node) {
534 assert (node->op == op_Block);
535 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
539 get_Block_graph_arr (ir_node *node, int pos) {
540 assert (node->op == op_Block);
541 return node->attr.block.graph_arr[pos+1];
545 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
546 assert (node->op == op_Block);
547 node->attr.block.graph_arr[pos+1] = value;
550 /* handler handling for Blocks */
552 set_Block_handler (ir_node *block, ir_node *handler) {
553 assert ((block->op == op_Block));
554 assert ((handler->op == op_Block));
555 block->attr.block.handler_entry = handler;
559 get_Block_handler (ir_node *block) {
560 assert ((block->op == op_Block));
561 return (block->attr.block.handler_entry);
564 /* handler handling for Nodes */
566 set_Node_handler (ir_node *node, ir_node *handler) {
567 set_Block_handler (get_nodes_Block (node), handler);
571 get_Node_handler (ir_node *node) {
572 return (get_Block_handler (get_nodes_Block (node)));
575 /* exc_t handling for Blocks */
576 void set_Block_exc (ir_node *block, exc_t exc) {
577 assert ((block->op == op_Block));
578 block->attr.block.exc = exc;
581 exc_t get_Block_exc (ir_node *block) {
582 assert ((block->op == op_Block));
584 return (block->attr.block.exc);
587 /* exc_t handling for Nodes */
588 void set_Node_exc (ir_node *node, exc_t exc) {
589 set_Block_exc (get_nodes_Block (node), exc);
592 exc_t get_Node_exc (ir_node *node) {
593 return (get_Block_exc (get_nodes_Block (node)));
596 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
597 assert(node->op == op_Block);
598 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
599 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
600 node->attr.block.in_cg[0] = NULL;
601 node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
603 /* Fix backedge array. fix_backedges operates depending on
604 interprocedural_view. */
605 bool ipv = interprocedural_view;
606 interprocedural_view = true;
607 fix_backedges(current_ir_graph->obst, node);
608 interprocedural_view = ipv;
611 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
614 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
615 assert(node->op == op_Block &&
616 node->attr.block.in_cg &&
617 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
618 node->attr.block.in_cg[pos + 1] = pred;
621 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
622 assert(node->op == op_Block);
623 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
626 int get_Block_cg_n_cfgpreds(ir_node * node) {
627 assert(node->op == op_Block);
628 return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
631 ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
632 assert(node->op == op_Block && node->attr.block.in_cg);
633 return node->attr.block.in_cg[pos + 1];
636 void remove_Block_cg_cfgpred_arr(ir_node * node) {
637 assert(node->op == op_Block);
638 node->attr.block.in_cg = NULL;
642 get_End_n_keepalives(ir_node *end) {
643 assert (end->op == op_End);
644 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
648 get_End_keepalive(ir_node *end, int pos) {
649 assert (end->op == op_End);
650 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
654 add_End_keepalive (ir_node *end, ir_node *ka) {
655 assert (end->op == op_End);
656 ARR_APP1 (ir_node *, end->in, ka);
660 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
661 assert (end->op == op_End);
662 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
666 free_End (ir_node *end) {
667 assert (end->op == op_End);
668 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
669 end->in = NULL; /* @@@ make sure we get an error if we use the
670 in array afterwards ... */
673 ir_graph *get_EndReg_irg (const ir_node *end) {
674 assert (end->op == op_EndReg);
675 return end->attr.end.irg;
678 ir_graph *get_EndExcept_irg (const ir_node *end) {
679 assert (end->op == op_EndReg);
680 return end->attr.end.irg;
684 > Implementing the case construct (which is where the constant Proj node is
685 > important) involves far more than simply determining the constant values.
686 > We could argue that this is more properly a function of the translator from
687 > Firm to the target machine. That could be done if there was some way of
688 > projecting "default" out of the Cond node.
689 I know it's complicated.
690 Basically there are two proglems:
691 - determining the gaps between the projs
692 - determining the biggest case constant to konw the proj number for
694 I see several solutions:
695 1. Introduce a ProjDefault node. Solves both problems.
696 This means to extend all optimizations executed during construction.
697 2. Give the Cond node for switch two flavors:
698 a) there are no gaps in the projs (existing flavor)
699 b) gaps may exist, default proj is still the Proj with the largest
700 projection number. This covers also the gaps.
701 3. Fix the semantic of the Cond to that of 2b)
703 Solution 2 seems to be the best:
704 Computing the gaps in the Firm representation is not too hard, i.e.,
705 libfirm can implement a routine that transforms betweeen the two
706 flavours. This is also possible for 1) but 2) does not require to
707 change any existing optimization.
708 Further it should be far simpler to determine the biggest constant than
710 I don't want to choose 3) as 2a) seems to have advantages for
711 dataflow analysis and 3) does not allow to convert the representation to
715 get_Cond_selector (ir_node *node) {
716 assert (node->op == op_Cond);
717 return get_irn_n(node, 0);
721 set_Cond_selector (ir_node *node, ir_node *selector) {
722 assert (node->op == op_Cond);
723 set_irn_n(node, 0, selector);
727 get_Cond_kind (ir_node *node) {
728 assert (node->op == op_Cond);
729 return node->attr.c.kind;
733 set_Cond_kind (ir_node *node, cond_kind kind) {
734 assert (node->op == op_Cond);
735 node->attr.c.kind = kind;
739 get_Return_mem (ir_node *node) {
740 assert (node->op == op_Return);
741 return get_irn_n(node, 0);
745 set_Return_mem (ir_node *node, ir_node *mem) {
746 assert (node->op == op_Return);
747 set_irn_n(node, 0, mem);
751 get_Return_n_ress (ir_node *node) {
752 assert (node->op == op_Return);
753 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
757 get_Return_res_arr (ir_node *node)
759 assert ((node->op == op_Return));
760 if (get_Return_n_ress(node) > 0)
761 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
768 set_Return_n_res (ir_node *node, int results) {
769 assert (node->op == op_Return);
774 get_Return_res (ir_node *node, int pos) {
775 assert (node->op == op_Return);
776 assert (get_Return_n_ress(node) > pos);
777 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
781 set_Return_res (ir_node *node, int pos, ir_node *res){
782 assert (node->op == op_Return);
783 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
787 get_Raise_mem (ir_node *node) {
788 assert (node->op == op_Return);
789 return get_irn_n(node, 0);
793 set_Raise_mem (ir_node *node, ir_node *mem) {
794 assert (node->op == op_Raise);
795 set_irn_n(node, 0, mem);
799 get_Raise_exo_ptr (ir_node *node) {
800 assert (node->op == op_Raise);
801 return get_irn_n(node, 1);
805 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
806 assert (node->op == op_Raise);
807 set_irn_n(node, 1, exo_ptr);
810 INLINE tarval *get_Const_tarval (ir_node *node) {
811 assert (node->op == op_Const);
812 return get_irn_const_attr(node);
816 set_Const_tarval (ir_node *node, tarval *con) {
817 assert (node->op == op_Const);
818 node->attr.con = con;
822 get_SymConst_kind (const ir_node *node) {
823 assert (node->op == op_SymConst);
824 return node->attr.i.num;
828 set_SymConst_kind (ir_node *node, symconst_kind num) {
829 assert (node->op == op_SymConst);
830 node->attr.i.num = num;
834 get_SymConst_type (ir_node *node) {
835 assert ( (node->op == op_SymConst)
836 && ( get_SymConst_kind(node) == type_tag
837 || get_SymConst_kind(node) == size));
838 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
842 set_SymConst_type (ir_node *node, type *tp) {
843 assert ( (node->op == op_SymConst)
844 && ( get_SymConst_kind(node) == type_tag
845 || get_SymConst_kind(node) == size));
846 node->attr.i.tori.typ = tp;
850 get_SymConst_ptrinfo (ir_node *node) {
851 assert ( (node->op == op_SymConst)
852 && (get_SymConst_kind(node) == linkage_ptr_info));
853 return node->attr.i.tori.ptrinfo;
857 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
858 assert ( (node->op == op_SymConst)
859 && (get_SymConst_kind(node) == linkage_ptr_info));
860 node->attr.i.tori.ptrinfo = ptrinfo;
864 get_SymConst_type_or_id (ir_node *node) {
865 assert (node->op == op_SymConst);
866 return &(node->attr.i.tori);
870 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
871 assert (node->op == op_SymConst);
872 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
876 get_Sel_mem (ir_node *node) {
877 assert (node->op == op_Sel);
878 return get_irn_n(node, 0);
882 set_Sel_mem (ir_node *node, ir_node *mem) {
883 assert (node->op == op_Sel);
884 set_irn_n(node, 0, mem);
888 get_Sel_ptr (ir_node *node) {
889 assert (node->op == op_Sel);
890 return get_irn_n(node, 1);
894 set_Sel_ptr (ir_node *node, ir_node *ptr) {
895 assert (node->op == op_Sel);
896 set_irn_n(node, 1, ptr);
900 get_Sel_n_indexs (ir_node *node) {
901 assert (node->op == op_Sel);
902 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
906 get_Sel_index_arr (ir_node *node)
908 assert ((node->op == op_Sel));
909 if (get_Sel_n_indexs(node) > 0)
910 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
916 get_Sel_index (ir_node *node, int pos) {
917 assert (node->op == op_Sel);
918 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
922 set_Sel_index (ir_node *node, int pos, ir_node *index) {
923 assert (node->op == op_Sel);
924 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
928 get_Sel_entity (ir_node *node) {
929 assert (node->op == op_Sel);
930 return node->attr.s.ent;
934 set_Sel_entity (ir_node *node, entity *ent) {
935 assert (node->op == op_Sel);
936 node->attr.s.ent = ent;
940 get_InstOf_ent (ir_node *node) {
941 assert (node->op = op_InstOf);
942 return (node->attr.io.ent);
946 set_InstOf_ent (ir_node *node, type *ent) {
947 assert (node->op = op_InstOf);
948 node->attr.io.ent = ent;
952 get_InstOf_store (ir_node *node) {
953 assert (node->op = op_InstOf);
954 return (get_irn_n (node, 0));
958 set_InstOf_store (ir_node *node, ir_node *obj) {
959 assert (node->op = op_InstOf);
960 set_irn_n (node, 0, obj);
964 get_InstOf_obj (ir_node *node) {
965 assert (node->op = op_InstOf);
966 return (get_irn_n (node, 1));
970 set_InstOf_obj (ir_node *node, ir_node *obj) {
971 assert (node->op = op_InstOf);
972 set_irn_n (node, 1, obj);
976 /* For unary and binary arithmetic operations the access to the
977 operands can be factored out. Left is the first, right the
978 second arithmetic value as listed in tech report 0999-33.
979 unops are: Minus, Abs, Not, Conv
980 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
981 Shr, Shrs, Rotate, Cmp */
985 get_Call_mem (ir_node *node) {
986 assert (node->op == op_Call);
987 return get_irn_n(node, 0);
991 set_Call_mem (ir_node *node, ir_node *mem) {
992 assert (node->op == op_Call);
993 set_irn_n(node, 0, mem);
997 get_Call_ptr (ir_node *node) {
998 assert (node->op == op_Call);
999 return get_irn_n(node, 1);
1003 set_Call_ptr (ir_node *node, ir_node *ptr) {
1004 assert (node->op == op_Call);
1005 set_irn_n(node, 1, ptr);
1009 get_Call_param_arr (ir_node *node) {
1010 assert (node->op == op_Call);
1011 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1015 get_Call_n_params (ir_node *node) {
1016 assert (node->op == op_Call);
1017 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1021 get_Call_arity (ir_node *node) {
1022 assert (node->op == op_Call);
1023 return get_Call_n_params(node);
1027 set_Call_arity (ir_node *node, ir_node *arity) {
1028 assert (node->op == op_Call);
1033 get_Call_param (ir_node *node, int pos) {
1034 assert (node->op == op_Call);
1035 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1039 set_Call_param (ir_node *node, int pos, ir_node *param) {
1040 assert (node->op == op_Call);
1041 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1045 get_Call_type (ir_node *node) {
1046 assert (node->op == op_Call);
1047 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1051 set_Call_type (ir_node *node, type *tp) {
1052 assert (node->op == op_Call);
1053 assert (is_method_type(tp));
1054 node->attr.call.cld_tp = tp;
1057 int get_Call_n_callees(ir_node * node) {
1058 assert(node->op == op_Call && node->attr.call.callee_arr);
1059 return ARR_LEN(node->attr.call.callee_arr);
1062 entity * get_Call_callee(ir_node * node, int pos) {
1063 assert(node->op == op_Call && node->attr.call.callee_arr);
1064 return node->attr.call.callee_arr[pos];
1067 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1068 assert(node->op == op_Call);
1069 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1070 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1072 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1075 void remove_Call_callee_arr(ir_node * node) {
1076 assert(node->op == op_Call);
1077 node->attr.call.callee_arr = NULL;
1080 ir_node * get_CallBegin_ptr (ir_node *node) {
1081 assert(node->op == op_CallBegin);
1082 return get_irn_n(node, 0);
1084 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1085 assert(node->op == op_CallBegin);
1086 set_irn_n(node, 0, ptr);
1088 ir_graph * get_CallBegin_irg (ir_node *node) {
1089 assert(node->op == op_CallBegin);
1090 return node->attr.callbegin.irg;
1092 ir_node * get_CallBegin_call (ir_node *node) {
1093 assert(node->op == op_CallBegin);
1094 return node->attr.callbegin.call;
1096 void set_CallBegin_call (ir_node *node, ir_node *call) {
1097 assert(node->op == op_CallBegin);
1098 node->attr.callbegin.call = call;
1102 get_Add_left (ir_node *node) {
1103 assert (node->op == op_Add);
1104 return get_irn_n(node, 0);
1108 set_Add_left (ir_node *node, ir_node *left) {
1109 assert (node->op == op_Add);
1110 set_irn_n(node, 0, left);
1114 get_Add_right (ir_node *node) {
1115 assert (node->op == op_Add);
1116 return get_irn_n(node, 1);
1120 set_Add_right (ir_node *node, ir_node *right) {
1121 assert (node->op == op_Add);
1122 set_irn_n(node, 1, right);
1126 get_Sub_left (ir_node *node) {
1127 assert (node->op == op_Sub);
1128 return get_irn_n(node, 0);
1132 set_Sub_left (ir_node *node, ir_node *left) {
1133 assert (node->op == op_Sub);
1134 set_irn_n(node, 0, left);
1138 get_Sub_right (ir_node *node) {
1139 assert (node->op == op_Sub);
1140 return get_irn_n(node, 1);
1144 set_Sub_right (ir_node *node, ir_node *right) {
1145 assert (node->op == op_Sub);
1146 set_irn_n(node, 1, right);
1151 get_Minus_op (ir_node *node) {
1152 assert (node->op == op_Minus);
1153 return get_irn_n(node, 0);
1157 set_Minus_op (ir_node *node, ir_node *op) {
1158 assert (node->op == op_Minus);
1159 set_irn_n(node, 0, op);
1164 get_Mul_left (ir_node *node) {
1165 assert (node->op == op_Mul);
1166 return get_irn_n(node, 0);
1170 set_Mul_left (ir_node *node, ir_node *left) {
1171 assert (node->op == op_Mul);
1172 set_irn_n(node, 0, left);
1176 get_Mul_right (ir_node *node) {
1177 assert (node->op == op_Mul);
1178 return get_irn_n(node, 1);
1182 set_Mul_right (ir_node *node, ir_node *right) {
1183 assert (node->op == op_Mul);
1184 set_irn_n(node, 1, right);
1188 get_Quot_left (ir_node *node) {
1189 assert (node->op == op_Quot);
1190 return get_irn_n(node, 1);
1194 set_Quot_left (ir_node *node, ir_node *left) {
1195 assert (node->op == op_Quot);
1196 set_irn_n(node, 1, left);
1200 get_Quot_right (ir_node *node) {
1201 assert (node->op == op_Quot);
1202 return get_irn_n(node, 2);
1206 set_Quot_right (ir_node *node, ir_node *right) {
1207 assert (node->op == op_Quot);
1208 set_irn_n(node, 2, right);
1212 get_Quot_mem (ir_node *node) {
1213 assert (node->op == op_Quot);
1214 return get_irn_n(node, 0);
1218 set_Quot_mem (ir_node *node, ir_node *mem) {
1219 assert (node->op == op_Quot);
1220 set_irn_n(node, 0, mem);
1224 get_DivMod_left (ir_node *node) {
1225 assert (node->op == op_DivMod);
1226 return get_irn_n(node, 1);
1230 set_DivMod_left (ir_node *node, ir_node *left) {
1231 assert (node->op == op_DivMod);
1232 set_irn_n(node, 1, left);
1236 get_DivMod_right (ir_node *node) {
1237 assert (node->op == op_DivMod);
1238 return get_irn_n(node, 2);
1242 set_DivMod_right (ir_node *node, ir_node *right) {
1243 assert (node->op == op_DivMod);
1244 set_irn_n(node, 2, right);
1248 get_DivMod_mem (ir_node *node) {
1249 assert (node->op == op_DivMod);
1250 return get_irn_n(node, 0);
1254 set_DivMod_mem (ir_node *node, ir_node *mem) {
1255 assert (node->op == op_DivMod);
1256 set_irn_n(node, 0, mem);
1260 get_Div_left (ir_node *node) {
1261 assert (node->op == op_Div);
1262 return get_irn_n(node, 1);
1266 set_Div_left (ir_node *node, ir_node *left) {
1267 assert (node->op == op_Div);
1268 set_irn_n(node, 1, left);
1272 get_Div_right (ir_node *node) {
1273 assert (node->op == op_Div);
1274 return get_irn_n(node, 2);
1278 set_Div_right (ir_node *node, ir_node *right) {
1279 assert (node->op == op_Div);
1280 set_irn_n(node, 2, right);
1284 get_Div_mem (ir_node *node) {
1285 assert (node->op == op_Div);
1286 return get_irn_n(node, 0);
1290 set_Div_mem (ir_node *node, ir_node *mem) {
1291 assert (node->op == op_Div);
1292 set_irn_n(node, 0, mem);
1296 get_Mod_left (ir_node *node) {
1297 assert (node->op == op_Mod);
1298 return get_irn_n(node, 1);
1302 set_Mod_left (ir_node *node, ir_node *left) {
1303 assert (node->op == op_Mod);
1304 set_irn_n(node, 1, left);
1308 get_Mod_right (ir_node *node) {
1309 assert (node->op == op_Mod);
1310 return get_irn_n(node, 2);
1314 set_Mod_right (ir_node *node, ir_node *right) {
1315 assert (node->op == op_Mod);
1316 set_irn_n(node, 2, right);
1320 get_Mod_mem (ir_node *node) {
1321 assert (node->op == op_Mod);
1322 return get_irn_n(node, 0);
1326 set_Mod_mem (ir_node *node, ir_node *mem) {
1327 assert (node->op == op_Mod);
1328 set_irn_n(node, 0, mem);
1332 get_Abs_op (ir_node *node) {
1333 assert (node->op == op_Abs);
1334 return get_irn_n(node, 0);
1338 set_Abs_op (ir_node *node, ir_node *op) {
1339 assert (node->op == op_Abs);
1340 set_irn_n(node, 0, op);
1344 get_And_left (ir_node *node) {
1345 assert (node->op == op_And);
1346 return get_irn_n(node, 0);
1350 set_And_left (ir_node *node, ir_node *left) {
1351 assert (node->op == op_And);
1352 set_irn_n(node, 0, left);
1356 get_And_right (ir_node *node) {
1357 assert (node->op == op_And);
1358 return get_irn_n(node, 1);
1362 set_And_right (ir_node *node, ir_node *right) {
1363 assert (node->op == op_And);
1364 set_irn_n(node, 1, right);
1368 get_Or_left (ir_node *node) {
1369 assert (node->op == op_Or);
1370 return get_irn_n(node, 0);
1374 set_Or_left (ir_node *node, ir_node *left) {
1375 assert (node->op == op_Or);
1376 set_irn_n(node, 0, left);
1380 get_Or_right (ir_node *node) {
1381 assert (node->op == op_Or);
1382 return get_irn_n(node, 1);
1386 set_Or_right (ir_node *node, ir_node *right) {
1387 assert (node->op == op_Or);
1388 set_irn_n(node, 1, right);
1392 get_Eor_left (ir_node *node) {
1393 assert (node->op == op_Eor);
1394 return get_irn_n(node, 0);
1398 set_Eor_left (ir_node *node, ir_node *left) {
1399 assert (node->op == op_Eor);
1400 set_irn_n(node, 0, left);
1404 get_Eor_right (ir_node *node) {
1405 assert (node->op == op_Eor);
1406 return get_irn_n(node, 1);
1410 set_Eor_right (ir_node *node, ir_node *right) {
1411 assert (node->op == op_Eor);
1412 set_irn_n(node, 1, right);
1417 get_Not_op (ir_node *node) {
1418 assert (node->op == op_Not);
1419 return get_irn_n(node, 0);
1423 set_Not_op (ir_node *node, ir_node *op) {
1424 assert (node->op == op_Not);
1425 set_irn_n(node, 0, op);
1430 get_Shl_left (ir_node *node) {
1431 assert (node->op == op_Shl);
1432 return get_irn_n(node, 0);
1436 set_Shl_left (ir_node *node, ir_node *left) {
1437 assert (node->op == op_Shl);
1438 set_irn_n(node, 0, left);
1442 get_Shl_right (ir_node *node) {
1443 assert (node->op == op_Shl);
1444 return get_irn_n(node, 1);
1448 set_Shl_right (ir_node *node, ir_node *right) {
1449 assert (node->op == op_Shl);
1450 set_irn_n(node, 1, right);
1454 get_Shr_left (ir_node *node) {
1455 assert (node->op == op_Shr);
1456 return get_irn_n(node, 0);
1460 set_Shr_left (ir_node *node, ir_node *left) {
1461 assert (node->op == op_Shr);
1462 set_irn_n(node, 0, left);
1466 get_Shr_right (ir_node *node) {
1467 assert (node->op == op_Shr);
1468 return get_irn_n(node, 1);
1472 set_Shr_right (ir_node *node, ir_node *right) {
1473 assert (node->op == op_Shr);
1474 set_irn_n(node, 1, right);
1478 get_Shrs_left (ir_node *node) {
1479 assert (node->op == op_Shrs);
1480 return get_irn_n(node, 0);
1484 set_Shrs_left (ir_node *node, ir_node *left) {
1485 assert (node->op == op_Shrs);
1486 set_irn_n(node, 0, left);
1490 get_Shrs_right (ir_node *node) {
1491 assert (node->op == op_Shrs);
1492 return get_irn_n(node, 1);
1496 set_Shrs_right (ir_node *node, ir_node *right) {
1497 assert (node->op == op_Shrs);
1498 set_irn_n(node, 1, right);
1502 get_Rot_left (ir_node *node) {
1503 assert (node->op == op_Rot);
1504 return get_irn_n(node, 0);
1508 set_Rot_left (ir_node *node, ir_node *left) {
1509 assert (node->op == op_Rot);
1510 set_irn_n(node, 0, left);
1514 get_Rot_right (ir_node *node) {
1515 assert (node->op == op_Rot);
1516 return get_irn_n(node, 1);
1520 set_Rot_right (ir_node *node, ir_node *right) {
1521 assert (node->op == op_Rot);
1522 set_irn_n(node, 1, right);
1526 get_Cmp_left (ir_node *node) {
1527 assert (node->op == op_Cmp);
1528 return get_irn_n(node, 0);
1532 set_Cmp_left (ir_node *node, ir_node *left) {
1533 assert (node->op == op_Cmp);
1534 set_irn_n(node, 0, left);
1538 get_Cmp_right (ir_node *node) {
1539 assert (node->op == op_Cmp);
1540 return get_irn_n(node, 1);
1544 set_Cmp_right (ir_node *node, ir_node *right) {
1545 assert (node->op == op_Cmp);
1546 set_irn_n(node, 1, right);
1550 get_Conv_op (ir_node *node) {
1551 assert (node->op == op_Conv);
1552 return get_irn_n(node, 0);
1556 set_Conv_op (ir_node *node, ir_node *op) {
1557 assert (node->op == op_Conv);
1558 set_irn_n(node, 0, op);
1564 is_unop (ir_node *node) {
1565 return ( node->op == op_Minus ||
1566 node->op == op_Abs ||
1567 node->op == op_Not ||
1568 node->op == op_Conv );
1572 get_unop_op (ir_node *node) {
1573 assert ( node->op == op_Minus ||
1574 node->op == op_Abs ||
1575 node->op == op_Not ||
1576 node->op == op_Conv );
1577 switch (get_irn_opcode (node)) {
1578 case iro_Minus: return get_Minus_op(node); break;
1579 case iro_Abs: return get_Abs_op(node); break;
1580 case iro_Not: return get_Not_op(node); break;
1581 case iro_Conv: return get_Conv_op(node); break;
1582 default: return NULL;
1587 set_unop_op (ir_node *node, ir_node *op) {
1588 assert (node->op == op_Minus ||
1589 node->op == op_Abs ||
1590 node->op == op_Not ||
1591 node->op == op_Conv );
1592 switch (get_irn_opcode (node)) {
1593 case iro_Minus: set_Minus_op(node, op); break;
1594 case iro_Abs: set_Abs_op(node, op); break;
1595 case iro_Not: set_Not_op(node, op); break;
1596 case iro_Conv: set_Conv_op(node, op); break;
1603 is_binop (ir_node *node) {
1604 return (node->op == op_Add ||
1605 node->op == op_Sub ||
1606 node->op == op_Mul ||
1607 node->op == op_Quot ||
1608 node->op == op_DivMod ||
1609 node->op == op_Div ||
1610 node->op == op_Mod ||
1611 node->op == op_And ||
1612 node->op == op_Or ||
1613 node->op == op_Eor ||
1614 node->op == op_Shl ||
1615 node->op == op_Shr ||
1616 node->op == op_Shrs ||
1617 node->op == op_Rot ||
1618 node->op == op_Cmp );
1622 get_binop_left (ir_node *node) {
1623 assert (node->op == op_Add ||
1624 node->op == op_Sub ||
1625 node->op == op_Mul ||
1626 node->op == op_Quot ||
1627 node->op == op_DivMod ||
1628 node->op == op_Div ||
1629 node->op == op_Mod ||
1630 node->op == op_And ||
1631 node->op == op_Or ||
1632 node->op == op_Eor ||
1633 node->op == op_Shl ||
1634 node->op == op_Shr ||
1635 node->op == op_Shrs ||
1636 node->op == op_Rot ||
1637 node->op == op_Cmp );
1639 switch (get_irn_opcode (node)) {
1640 case iro_Add : return get_Add_left(node); break;
1641 case iro_Sub : return get_Sub_left(node); break;
1642 case iro_Mul : return get_Mul_left(node); break;
1643 case iro_Quot : return get_Quot_left(node); break;
1644 case iro_DivMod: return get_DivMod_left(node); break;
1645 case iro_Div : return get_Div_left(node); break;
1646 case iro_Mod : return get_Mod_left(node); break;
1647 case iro_And : return get_And_left(node); break;
1648 case iro_Or : return get_Or_left(node); break;
1649 case iro_Eor : return get_Eor_left(node); break;
1650 case iro_Shl : return get_Shl_left(node); break;
1651 case iro_Shr : return get_Shr_left(node); break;
1652 case iro_Shrs : return get_Shrs_left(node); break;
1653 case iro_Rot : return get_Rot_left(node); break;
1654 case iro_Cmp : return get_Cmp_left(node); break;
1655 default: return NULL;
1660 set_binop_left (ir_node *node, ir_node *left) {
1661 assert (node->op == op_Add ||
1662 node->op == op_Sub ||
1663 node->op == op_Mul ||
1664 node->op == op_Quot ||
1665 node->op == op_DivMod ||
1666 node->op == op_Div ||
1667 node->op == op_Mod ||
1668 node->op == op_And ||
1669 node->op == op_Or ||
1670 node->op == op_Eor ||
1671 node->op == op_Shl ||
1672 node->op == op_Shr ||
1673 node->op == op_Shrs ||
1674 node->op == op_Rot ||
1675 node->op == op_Cmp );
1677 switch (get_irn_opcode (node)) {
1678 case iro_Add : set_Add_left(node, left); break;
1679 case iro_Sub : set_Sub_left(node, left); break;
1680 case iro_Mul : set_Mul_left(node, left); break;
1681 case iro_Quot : set_Quot_left(node, left); break;
1682 case iro_DivMod: set_DivMod_left(node, left); break;
1683 case iro_Div : set_Div_left(node, left); break;
1684 case iro_Mod : set_Mod_left(node, left); break;
1685 case iro_And : set_And_left(node, left); break;
1686 case iro_Or : set_Or_left(node, left); break;
1687 case iro_Eor : set_Eor_left(node, left); break;
1688 case iro_Shl : set_Shl_left(node, left); break;
1689 case iro_Shr : set_Shr_left(node, left); break;
1690 case iro_Shrs : set_Shrs_left(node, left); break;
1691 case iro_Rot : set_Rot_left(node, left); break;
1692 case iro_Cmp : set_Cmp_left(node, left); break;
1698 get_binop_right (ir_node *node) {
1699 assert (node->op == op_Add ||
1700 node->op == op_Sub ||
1701 node->op == op_Mul ||
1702 node->op == op_Quot ||
1703 node->op == op_DivMod ||
1704 node->op == op_Div ||
1705 node->op == op_Mod ||
1706 node->op == op_And ||
1707 node->op == op_Or ||
1708 node->op == op_Eor ||
1709 node->op == op_Shl ||
1710 node->op == op_Shr ||
1711 node->op == op_Shrs ||
1712 node->op == op_Rot ||
1713 node->op == op_Cmp );
1715 switch (get_irn_opcode (node)) {
1716 case iro_Add : return get_Add_right(node); break;
1717 case iro_Sub : return get_Sub_right(node); break;
1718 case iro_Mul : return get_Mul_right(node); break;
1719 case iro_Quot : return get_Quot_right(node); break;
1720 case iro_DivMod: return get_DivMod_right(node); break;
1721 case iro_Div : return get_Div_right(node); break;
1722 case iro_Mod : return get_Mod_right(node); break;
1723 case iro_And : return get_And_right(node); break;
1724 case iro_Or : return get_Or_right(node); break;
1725 case iro_Eor : return get_Eor_right(node); break;
1726 case iro_Shl : return get_Shl_right(node); break;
1727 case iro_Shr : return get_Shr_right(node); break;
1728 case iro_Shrs : return get_Shrs_right(node); break;
1729 case iro_Rot : return get_Rot_right(node); break;
1730 case iro_Cmp : return get_Cmp_right(node); break;
1731 default: return NULL;
1736 set_binop_right (ir_node *node, ir_node *right) {
1737 assert (node->op == op_Add ||
1738 node->op == op_Sub ||
1739 node->op == op_Mul ||
1740 node->op == op_Quot ||
1741 node->op == op_DivMod ||
1742 node->op == op_Div ||
1743 node->op == op_Mod ||
1744 node->op == op_And ||
1745 node->op == op_Or ||
1746 node->op == op_Eor ||
1747 node->op == op_Shl ||
1748 node->op == op_Shr ||
1749 node->op == op_Shrs ||
1750 node->op == op_Rot ||
1751 node->op == op_Cmp );
1753 switch (get_irn_opcode (node)) {
1754 case iro_Add : set_Add_right(node, right); break;
1755 case iro_Sub : set_Sub_right(node, right); break;
1756 case iro_Mul : set_Mul_right(node, right); break;
1757 case iro_Quot : set_Quot_right(node, right); break;
1758 case iro_DivMod: set_DivMod_right(node, right); break;
1759 case iro_Div : set_Div_right(node, right); break;
1760 case iro_Mod : set_Mod_right(node, right); break;
1761 case iro_And : set_And_right(node, right); break;
1762 case iro_Or : set_Or_right(node, right); break;
1763 case iro_Eor : set_Eor_right(node, right); break;
1764 case iro_Shl : set_Shl_right(node, right); break;
1765 case iro_Shr : set_Shr_right(node, right); break;
1766 case iro_Shrs : set_Shrs_right(node, right); break;
1767 case iro_Rot : set_Rot_right(node, right); break;
1768 case iro_Cmp : set_Cmp_right(node, right); break;
1775 get_Phi_preds_arr (ir_node *node) {
1776 assert (node->op == op_Phi);
1777 return (ir_node **)&(get_irn_in(node)[1]);
1781 get_Phi_n_preds (ir_node *node) {
1782 assert (node->op == op_Phi);
1783 return (get_irn_arity(node));
1787 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1788 assert (node->op == op_Phi);
1793 get_Phi_pred (ir_node *node, int pos) {
1794 assert (node->op == op_Phi);
1795 return get_irn_n(node, pos);
1799 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1800 assert (node->op == op_Phi);
1801 set_irn_n(node, pos, pred);
1805 get_Load_mem (ir_node *node) {
1806 assert (node->op == op_Load);
1807 return get_irn_n(node, 0);
1811 set_Load_mem (ir_node *node, ir_node *mem) {
1812 assert (node->op == op_Load);
1813 set_irn_n(node, 0, mem);
1817 get_Load_ptr (ir_node *node) {
1818 assert (node->op == op_Load);
1819 return get_irn_n(node, 1);
1823 set_Load_ptr (ir_node *node, ir_node *ptr) {
1824 assert (node->op == op_Load);
1825 set_irn_n(node, 1, ptr);
1830 get_Store_mem (ir_node *node) {
1831 assert (node->op == op_Store);
1832 return get_irn_n(node, 0);
1836 set_Store_mem (ir_node *node, ir_node *mem) {
1837 assert (node->op == op_Store);
1838 set_irn_n(node, 0, mem);
1842 get_Store_ptr (ir_node *node) {
1843 assert (node->op == op_Store);
1844 return get_irn_n(node, 1);
1848 set_Store_ptr (ir_node *node, ir_node *ptr) {
1849 assert (node->op == op_Store);
1850 set_irn_n(node, 1, ptr);
1854 get_Store_value (ir_node *node) {
1855 assert (node->op == op_Store);
1856 return get_irn_n(node, 2);
1860 set_Store_value (ir_node *node, ir_node *value) {
1861 assert (node->op == op_Store);
1862 set_irn_n(node, 2, value);
1866 get_Alloc_mem (ir_node *node) {
1867 assert (node->op == op_Alloc);
1868 return get_irn_n(node, 0);
1872 set_Alloc_mem (ir_node *node, ir_node *mem) {
1873 assert (node->op == op_Alloc);
1874 set_irn_n(node, 0, mem);
1878 get_Alloc_size (ir_node *node) {
1879 assert (node->op == op_Alloc);
1880 return get_irn_n(node, 1);
1884 set_Alloc_size (ir_node *node, ir_node *size) {
1885 assert (node->op == op_Alloc);
1886 set_irn_n(node, 1, size);
1890 get_Alloc_type (ir_node *node) {
1891 assert (node->op == op_Alloc);
1892 return node->attr.a.type = skip_tid(node->attr.a.type);
1896 set_Alloc_type (ir_node *node, type *tp) {
1897 assert (node->op == op_Alloc);
1898 node->attr.a.type = tp;
1902 get_Alloc_where (ir_node *node) {
1903 assert (node->op == op_Alloc);
1904 return node->attr.a.where;
1908 set_Alloc_where (ir_node *node, where_alloc where) {
1909 assert (node->op == op_Alloc);
1910 node->attr.a.where = where;
1915 get_Free_mem (ir_node *node) {
1916 assert (node->op == op_Free);
1917 return get_irn_n(node, 0);
1921 set_Free_mem (ir_node *node, ir_node *mem) {
1922 assert (node->op == op_Free);
1923 set_irn_n(node, 0, mem);
1927 get_Free_ptr (ir_node *node) {
1928 assert (node->op == op_Free);
1929 return get_irn_n(node, 1);
1933 set_Free_ptr (ir_node *node, ir_node *ptr) {
1934 assert (node->op == op_Free);
1935 set_irn_n(node, 1, ptr);
1939 get_Free_size (ir_node *node) {
1940 assert (node->op == op_Free);
1941 return get_irn_n(node, 2);
1945 set_Free_size (ir_node *node, ir_node *size) {
1946 assert (node->op == op_Free);
1947 set_irn_n(node, 2, size);
1951 get_Free_type (ir_node *node) {
1952 assert (node->op == op_Free);
1953 return node->attr.f = skip_tid(node->attr.f);
1957 set_Free_type (ir_node *node, type *tp) {
1958 assert (node->op == op_Free);
1963 get_Sync_preds_arr (ir_node *node) {
1964 assert (node->op == op_Sync);
1965 return (ir_node **)&(get_irn_in(node)[1]);
1969 get_Sync_n_preds (ir_node *node) {
1970 assert (node->op == op_Sync);
1971 return (get_irn_arity(node));
1976 set_Sync_n_preds (ir_node *node, int n_preds) {
1977 assert (node->op == op_Sync);
1982 get_Sync_pred (ir_node *node, int pos) {
1983 assert (node->op == op_Sync);
1984 return get_irn_n(node, pos);
1988 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1989 assert (node->op == op_Sync);
1990 set_irn_n(node, pos, pred);
1994 get_Proj_pred (ir_node *node) {
1995 assert (is_Proj(node));
1996 return get_irn_n(node, 0);
2000 set_Proj_pred (ir_node *node, ir_node *pred) {
2001 assert (is_Proj(node));
2002 set_irn_n(node, 0, pred);
2006 get_Proj_proj (ir_node *node) {
2007 assert (is_Proj(node));
2008 if (get_irn_opcode(node) == iro_Proj) {
2009 return node->attr.proj;
2011 assert(get_irn_opcode(node) == iro_Filter);
2012 return node->attr.filter.proj;
2017 set_Proj_proj (ir_node *node, long proj) {
2018 assert (node->op == op_Proj);
2019 node->attr.proj = proj;
2023 get_Tuple_preds_arr (ir_node *node) {
2024 assert (node->op == op_Tuple);
2025 return (ir_node **)&(get_irn_in(node)[1]);
2029 get_Tuple_n_preds (ir_node *node) {
2030 assert (node->op == op_Tuple);
2031 return (get_irn_arity(node));
2036 set_Tuple_n_preds (ir_node *node, int n_preds) {
2037 assert (node->op == op_Tuple);
2042 get_Tuple_pred (ir_node *node, int pos) {
2043 assert (node->op == op_Tuple);
2044 return get_irn_n(node, pos);
2048 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2049 assert (node->op == op_Tuple);
2050 set_irn_n(node, pos, pred);
2054 get_Id_pred (ir_node *node) {
2055 assert (node->op == op_Id);
2056 return get_irn_n(node, 0);
2060 set_Id_pred (ir_node *node, ir_node *pred) {
2061 assert (node->op == op_Id);
2062 set_irn_n(node, 0, pred);
2067 get_Filter_pred (ir_node *node) {
2068 assert(node->op == op_Filter);
2072 set_Filter_pred (ir_node *node, ir_node *pred) {
2073 assert(node->op == op_Filter);
2077 get_Filter_proj(ir_node *node) {
2078 assert(node->op == op_Filter);
2079 return node->attr.filter.proj;
2082 set_Filter_proj (ir_node *node, long proj) {
2083 assert(node->op == op_Filter);
2084 node->attr.filter.proj = proj;
2087 /* Don't use get_irn_arity, get_irn_n in implementation as access
2088 shall work independent of view!!! */
2089 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2090 assert(node->op == op_Filter);
2091 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2092 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2093 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2094 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2095 node->attr.filter.in_cg[0] = node->in[0];
2097 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2100 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2101 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2102 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2103 node->attr.filter.in_cg[pos + 1] = pred;
2105 int get_Filter_n_cg_preds(ir_node *node) {
2106 assert(node->op == op_Filter && node->attr.filter.in_cg);
2107 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2109 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2111 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2113 arity = ARR_LEN(node->attr.filter.in_cg);
2114 assert(pos < arity - 1);
2115 return node->attr.filter.in_cg[pos + 1];
2120 get_irn_irg(ir_node *node) {
2121 if (get_irn_op(node) == op_CallBegin) {
2122 return node->attr.callbegin.irg;
2123 } else if (get_irn_op(node) == op_EndReg ||
2124 get_irn_op(node) == op_EndExcept) {
2125 return node->attr.end.irg;
2127 assert(0 && "no irg attr");
2133 /******************************************************************/
2134 /* Auxiliary routines */
2135 /******************************************************************/
2138 skip_Proj (ir_node *node) {
2139 /* don't assert node !!! */
2140 if (node && is_Proj(node)) {
2141 return get_Proj_pred(node);
2148 skip_Tuple (ir_node *node) {
2151 if (!get_opt_normalize()) return node;
2153 node = skip_nop(node);
2154 if (get_irn_op(node) == op_Proj) {
2155 pred = skip_nop(get_Proj_pred(node));
2156 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2157 pred = skip_nop(skip_Tuple(pred));
2158 if (get_irn_op(pred) == op_Tuple)
2159 return get_Tuple_pred(pred, get_Proj_proj(node));
2164 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2165 than any other approach, as Id chains are resolved and all point to the real node, or
2166 all id's are self loops. */
2168 skip_nop (ir_node *node) {
2169 /* don't assert node !!! */
2171 if (!get_opt_normalize()) return node;
2173 /* Don't use get_Id_pred: We get into an endless loop for
2174 self-referencing Ids. */
2175 if (node && (node->op == op_Id) && (node != node->in[0+1])) {
2176 ir_node *rem_pred = node->in[0+1];
2179 assert (get_irn_arity (node) > 0);
2181 node->in[0+1] = node;
2182 res = skip_nop(rem_pred);
2183 if (res->op == op_Id) /* self-loop */ return node;
2185 node->in[0+1] = res;
2193 skip_Id (ir_node *node) {
2194 return skip_nop(node);
2198 is_Bad (ir_node *node) {
2200 if ((node) && get_irn_opcode(node) == iro_Bad)
2206 is_no_Block (ir_node *node) {
2208 return (get_irn_opcode(node) != iro_Block);
2212 is_Block (ir_node *node) {
2214 return (get_irn_opcode(node) == iro_Block);
2218 is_Proj (const ir_node *node) {
2220 return node->op == op_Proj
2221 || (!interprocedural_view && node->op == op_Filter);
2224 /* Returns true if the operation manipulates control flow. */
2226 is_cfop(ir_node *node) {
2227 return is_cfopcode(get_irn_op(node));
2230 /* Returns true if the operation manipulates interprocedural control flow:
2231 CallBegin, EndReg, EndExcept */
2232 INLINE int is_ip_cfop(ir_node *node) {
2233 return is_ip_cfopcode(get_irn_op(node));
2236 ir_graph *get_ip_cfop_irg(ir_node *n) {
2237 switch (get_irn_opcode(n)) {
2239 return get_EndReg_irg(n);
2241 return get_EndExcept_irg(n);
2243 return get_CallBegin_irg(n);
2245 assert(is_ip_cfop(n));
2247 return NULL; /* should never be reached */
2250 /* Returns true if the operation can change the control flow because
2253 is_fragile_op(ir_node *node) {
2254 return ( (get_irn_opcode(node) == iro_Call)
2255 || (get_irn_opcode(node) == iro_Quot)
2256 || (get_irn_opcode(node) == iro_DivMod)
2257 || (get_irn_opcode(node) == iro_Div)
2258 || (get_irn_opcode(node) == iro_Mod)
2259 || (get_irn_opcode(node) == iro_Load)
2260 || (get_irn_opcode(node) == iro_Store)
2261 || (get_irn_opcode(node) == iro_Alloc)
2262 || (get_irn_opcode(node) == iro_Bad)
2263 || (get_irn_opcode(node) == iro_Unknown));
2267 /* Returns the memory operand of fragile operations. */
2268 ir_node *get_fragile_op_mem(ir_node *node) {
2269 assert(node && is_fragile_op(node));
2271 switch (get_irn_opcode (node)) {
2280 return get_irn_n(node, 0);
2285 assert(0 && "not reached");