1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
15 #include "irgraph_t.h"
18 #include "typegmod_t.h"
25 /* some constants fixing the positions of nodes predecessors
27 #define CALL_PARAM_OFFSET 2
28 #define SEL_INDEX_OFFSET 2
29 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
30 #define END_KEEPALIVE_OFFSET 0
32 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
33 "Gt", "Ge", "Lg", "Leg", "Uo",
34 "Ue", "Ul", "Ule", "Ug", "Uge",
37 inline char *get_pnc_string(int pnc) {
38 return pnc_name_arr[pnc];
43 get_negated_pnc(int pnc) {
45 case False: return True; break;
46 case Eq: return Ne; break;
47 case Lt: return Uge; break;
48 case Le: return Ug; break;
49 case Gt: return Ule; break;
50 case Ge: return Ul; break;
51 case Lg: return Ue; break;
52 case Leg: return Uo; break;
53 case Uo: return Leg; break;
54 case Ue: return Lg; break;
55 case Ul: return Ge; break;
56 case Ule: return Gt; break;
57 case Ug: return Le; break;
58 case Uge: return Lt; break;
59 case Ne: return Eq; break;
60 case True: return False; break;
62 return 99; /* to shut up gcc */
65 static char *pns_name_arr [] = {"initial_exec", "global_store",
66 "frame_base", "globals", "args"};
68 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
75 /* irnode constructor */
76 /* create a new irnode in irg, with an op, mode, arity and */
77 /* some incoming irnodes */
78 /* this constructor is used in every specified irnode constructor */
80 new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
81 int arity, ir_node **in)
84 int node_size = offsetof (ir_node, attr) + op->attr_size;
86 res = (ir_node *) obstack_alloc (irg->obst, node_size);
88 res->kind = k_ir_node;
94 res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
96 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
97 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
100 set_irn_dbg_info(res, db);
104 res->node_nr = get_irp_new_node_nr();
110 /* Copies all attributes stored in the old node to the new node.
111 Assumes both have the same opcode and sufficient size. */
113 copy_attrs (ir_node *old, ir_node *new) {
114 assert (get_irn_opcode(old) == get_irn_opcode(new));
115 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
118 /* IR-Nodes with attributes */
120 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
123 ir_node *np = XP_GETARG (ir_node *, 0);
126 XPS ("<null ir_node>");
130 XPF1 ("%I", get_irn_opident(np));
132 switch (get_irn_opcode (np)) { /* node label */
134 XPF1 ("%I", get_irn_mode(np)->name);
136 XPF1 ("%v", get_irn_const_attr);
139 if (get_irn_modecode (np) == irm_b) {
141 XP (pnc_name_arr[get_irn_proj_attr(np)]);
142 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
144 XP (pns_name_arr[get_irn_proj_attr(np)]);
146 XPF1 ("%I", get_irn_mode(np)->name);
148 XPF1 ("%d", get_irn_proj_attr(np));
152 XPF1 ("%I", get_irn_mode(np)->name);
154 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
155 XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
157 case iro_Start: /* don't dump mode of these */
170 XPF1 ("%I", get_irn_mode(np)->name);
176 /** getting some parameters from ir_nodes **/
178 /* returns the number of predecessors without the block predecessor. */
180 get_irn_arity (ir_node *node) {
182 if (interprocedural_view) { /* handle Filter and Block specially */
183 if (get_irn_opcode(node) == iro_Filter) {
184 assert(node->attr.filter.in_cg);
185 return ARR_LEN(node->attr.filter.in_cg) - 1;
186 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
187 return ARR_LEN(node->attr.block.in_cg) - 1;
189 /* else fall through */
191 return ARR_LEN(node->in) - 1;
194 /* Returns the array with ins. This array is shifted with respect to the
195 array accessed by get_irn_n: The block operand is at position 0 not -1.
196 (@@@ This should be changed.)
197 The order of the predecessors in this array is not guaranteed, except that
198 lists of operands as predecessors of Block or arguments of a Call are
201 get_irn_in (ir_node *node) {
203 if (interprocedural_view) { /* handle Filter and Block specially */
204 if (get_irn_opcode(node) == iro_Filter) {
205 assert(node->attr.filter.in_cg);
206 return node->attr.filter.in_cg;
207 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
208 return node->attr.block.in_cg;
210 /* else fall through */
216 set_irn_in (ir_node *node, int arity, ir_node **in) {
219 if (interprocedural_view) { /* handle Filter and Block specially */
220 if (get_irn_opcode(node) == iro_Filter) {
221 assert(node->attr.filter.in_cg);
222 arr = &node->attr.filter.in_cg;
223 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
224 arr = &node->attr.block.in_cg;
231 if (arity != ARR_LEN(*arr) - 1) {
232 ir_node * block = (*arr)[0];
233 *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
236 memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
239 /* to iterate through the predecessors without touching the array */
240 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
241 to iterate includind the Block predecessor iterate from i = -1 to
243 If it is a block, the entry -1 is NULL. */
245 get_irn_n (ir_node *node, int n) {
246 assert(node && -1 <= n && n < get_irn_arity(node));
247 if (interprocedural_view) { /* handle Filter and Block specially */
248 if (get_irn_opcode(node) == iro_Filter) {
249 assert(node->attr.filter.in_cg);
250 return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
251 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
252 return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
254 /* else fall through */
256 return (node->in[n + 1] = skip_nop(node->in[n + 1]));
260 set_irn_n (ir_node *node, int n, ir_node *in) {
261 assert(node && -1 <= n && n < get_irn_arity(node));
262 if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
263 /* Change block pred in both views! */
264 node->in[n + 1] = in;
265 assert(node->attr.filter.in_cg);
266 node->attr.filter.in_cg[n + 1] = in;
269 if (interprocedural_view) { /* handle Filter and Block specially */
270 if (get_irn_opcode(node) == iro_Filter) {
271 assert(node->attr.filter.in_cg);
272 node->attr.filter.in_cg[n + 1] = in;
274 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
275 node->attr.block.in_cg[n + 1] = in;
278 /* else fall through */
280 node->in[n + 1] = in;
284 get_irn_mode (ir_node *node)
291 get_irn_modecode (ir_node *node)
294 return node->mode->code;
299 get_irn_modeident (ir_node *node)
302 return node->mode->name;
306 get_irn_op (ir_node *node)
312 /* should be private to the library: */
314 set_irn_op (ir_node *node, ir_op *op)
321 get_irn_opcode (ir_node *node)
324 return node->op->code;
328 get_irn_opname (ir_node *node)
331 return id_to_str(node->op->name);
335 get_irn_opident (ir_node *node)
338 return node->op->name;
342 get_irn_visited (ir_node *node)
345 return node->visited;
349 set_irn_visited (ir_node *node, unsigned long visited)
352 node->visited = visited;
356 mark_irn_visited (ir_node *node) {
358 node->visited = current_ir_graph->visited;
362 irn_not_visited (ir_node *node) {
364 return (node->visited < current_ir_graph->visited);
368 set_irn_link (ir_node *node, ir_node *link) {
374 get_irn_link (ir_node *node) {
379 /* Outputs a unique number for this node */
381 get_irn_node_nr(ir_node *node) {
384 return node->node_nr;
391 get_irn_const_attr (ir_node *node)
393 assert (node->op == op_Const);
394 return node->attr.con;
398 get_irn_proj_attr (ir_node *node)
400 assert (node->op == op_Proj);
401 return node->attr.proj;
405 get_irn_alloc_attr (ir_node *node)
407 assert (node->op == op_Alloc);
412 get_irn_free_attr (ir_node *node)
414 assert (node->op == op_Free);
415 return node->attr.f = skip_tid(node->attr.f);
419 get_irn_symconst_attr (ir_node *node)
421 assert (node->op == op_SymConst);
426 get_irn_call_attr (ir_node *node)
428 assert (node->op == op_Call);
429 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
433 get_irn_sel_attr (ir_node *node)
435 assert (node->op == op_Sel);
440 get_irn_phi_attr (ir_node *node)
442 assert (node->op == op_Phi);
443 return node->attr.phi0_pos;
447 get_irn_block_attr (ir_node *node)
449 assert (node->op == op_Block);
450 return node->attr.block;
453 /** manipulate fields of individual nodes **/
455 /* this works for all except Block */
457 get_nodes_Block (ir_node *node) {
458 assert (!(node->op == op_Block));
459 return get_irn_n(node, -1);
463 set_nodes_Block (ir_node *node, ir_node *block) {
464 assert (!(node->op == op_Block));
465 set_irn_n(node, -1, block);
468 /* Returns an array with the predecessors of the Block. Depending on
469 the implementation of the graph datastructure this can be a copy of
470 the internal representation of predecessors as well as the internal
471 array itself. Therefore writing to this array might obstruct the ir. */
473 get_Block_cfgpred_arr (ir_node *node)
475 assert ((node->op == op_Block));
476 return (ir_node **)&(get_irn_in(node)[1]);
481 get_Block_n_cfgpreds (ir_node *node) {
482 assert ((node->op == op_Block));
483 return (get_irn_arity(node));
488 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
489 assert ((node->op == op_Block));
494 get_Block_cfgpred (ir_node *node, int pos) {
495 assert (node->op == op_Block);
496 return get_irn_n(node, pos);
500 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
501 assert (node->op == op_Block);
502 set_irn_n(node, pos, pred);
506 get_Block_matured (ir_node *node) {
507 assert (node->op == op_Block);
508 return node->attr.block.matured;
512 set_Block_matured (ir_node *node, bool matured) {
513 assert (node->op == op_Block);
514 node->attr.block.matured = matured;
517 get_Block_block_visited (ir_node *node) {
518 assert (node->op == op_Block);
519 return node->attr.block.block_visited;
523 set_Block_block_visited (ir_node *node, unsigned long visit) {
524 assert (node->op == op_Block);
525 node->attr.block.block_visited = visit;
528 /* For this current_ir_graph must be set. */
529 inline void mark_Block_block_visited (ir_node *node) {
530 assert (node->op == op_Block);
531 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
534 inline int Block_not_block_visited(ir_node *node) {
535 assert (node->op == op_Block);
536 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
540 get_Block_graph_arr (ir_node *node, int pos) {
541 assert (node->op == op_Block);
542 return node->attr.block.graph_arr[pos+1];
546 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
547 assert (node->op == op_Block);
548 node->attr.block.graph_arr[pos+1] = value;
551 /* handler handling for Blocks */
552 void set_Block_handler (ir_node *block, ir_node *handler)
554 assert ((block->op == op_Block));
555 assert ((handler->op == op_Block));
557 block->attr.block.handler_entry = handler;
560 ir_node *get_Block_handler (ir_node *block)
562 assert ((block->op == op_Block));
564 return (block->attr.block.handler_entry);
567 /* handler handling for Nodes */
568 void set_Node_handler (ir_node *node, ir_node *handler)
570 set_Block_handler (get_nodes_Block (node), handler);
573 ir_node *get_Node_handler (ir_node *node)
575 return (get_Block_handler (get_nodes_Block (node)));
579 /* exc_t handling for Blocks */
580 void set_Block_exc (ir_node *block, exc_t exc)
582 assert ((block->op == op_Block));
583 block->attr.block.exc = exc;
586 exc_t get_Block_exc (ir_node *block)
588 assert ((block->op == op_Block));
590 return (block->attr.block.exc);
593 /* exc_t handling for Nodes */
594 void set_Node_exc (ir_node *node, exc_t exc)
596 set_Block_exc (get_nodes_Block (node), exc);
599 exc_t get_Node_exc (ir_node *node)
601 return (get_Block_exc (get_nodes_Block (node)));
604 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
605 assert(node->op == op_Block);
606 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
607 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
608 node->attr.block.in_cg[0] = NULL;
610 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
613 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
614 assert(node->op == op_Block && node->attr.block.in_cg && 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
615 node->attr.block.in_cg[pos + 1] = pred;
618 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
619 assert(node->op == op_Block);
620 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
623 int get_Block_cg_n_cfgpreds(ir_node * node) {
624 assert(node->op == op_Block && node->attr.block.in_cg);
625 return ARR_LEN(node->attr.block.in_cg) - 1;
628 void remove_Block_cg_cfgpred_arr(ir_node * node) {
629 assert(node->op == op_Block);
630 node->attr.block.in_cg = NULL;
634 get_End_n_keepalives(ir_node *end) {
635 assert (end->op == op_End);
636 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
640 get_End_keepalive(ir_node *end, int pos) {
641 assert (end->op == op_End);
642 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
646 add_End_keepalive (ir_node *end, ir_node *ka) {
647 assert (end->op == op_End);
648 ARR_APP1 (ir_node *, end->in, ka);
652 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
653 assert (end->op == op_End);
654 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
658 free_End (ir_node *end) {
659 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
660 end->in = NULL; /* @@@ make sure we get an error if we use the in array afterwards ... */
664 > Implementing the case construct (which is where the constant Proj node is
665 > important) involves far more than simply determining the constant values.
666 > We could argue that this is more properly a function of the translator from
667 > Firm to the target machine. That could be done if there was some way of
668 > projecting "default" out of the Cond node.
669 I know it's complicated.
670 Basically there are two proglems:
671 - determining the gaps between the projs
672 - determining the biggest case constant to konw the proj number for
674 I see several solutions:
675 1. Introduce a ProjDefault node. Solves both problems.
676 This means to extend all optimizations executed during construction.
677 2. Give the Cond node for switch two flavors:
678 a) there are no gaps in the projs (existing flavor)
679 b) gaps may exist, default proj is still the Proj with the largest
680 projection number. This covers also the gaps.
681 3. Fix the semantic of the Cond to that of 2b)
683 Solution 2 seems to be the best:
684 Computing the gaps in the Firm representation is not too hard, i.e.,
685 libfirm can implement a routine that transforms betweeen the two
686 flavours. This is also possible for 1) but 2) does not require to
687 change any existing optimization.
688 Further it should be far simpler to determine the biggest constant than
690 I don't want to choose 3) as 2a) seems to have advantages for
691 dataflow analysis and 3) does not allow to convert the representation to
695 get_Cond_selector (ir_node *node) {
696 assert (node->op == op_Cond);
697 return get_irn_n(node, 0);
701 set_Cond_selector (ir_node *node, ir_node *selector) {
702 assert (node->op == op_Cond);
703 set_irn_n(node, 0, selector);
707 get_Cond_kind (ir_node *node) {
708 assert (node->op == op_Cond);
709 return node->attr.c.kind;
713 set_Cond_kind (ir_node *node, cond_kind kind) {
714 assert (node->op == op_Cond);
715 node->attr.c.kind = kind;
719 get_Return_mem (ir_node *node) {
720 assert (node->op == op_Return);
721 return get_irn_n(node, 0);
725 set_Return_mem (ir_node *node, ir_node *mem) {
726 assert (node->op == op_Return);
727 set_irn_n(node, 0, mem);
731 get_Return_res_arr (ir_node *node)
733 assert ((node->op == op_Return));
734 if (get_Return_n_res(node) > 0)
735 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
741 get_Return_n_res (ir_node *node) {
742 assert (node->op == op_Return);
743 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
748 set_Return_n_res (ir_node *node, int results) {
749 assert (node->op == op_Return);
754 get_Return_res (ir_node *node, int pos) {
755 assert (node->op == op_Return);
756 assert (get_Return_n_res(node) > pos);
757 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
761 set_Return_res (ir_node *node, int pos, ir_node *res){
762 assert (node->op == op_Return);
763 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
767 get_Raise_mem (ir_node *node) {
768 assert (node->op == op_Return);
769 return get_irn_n(node, 0);
773 set_Raise_mem (ir_node *node, ir_node *mem) {
774 assert (node->op == op_Raise);
775 set_irn_n(node, 0, mem);
779 get_Raise_exo_ptr (ir_node *node) {
780 assert (node->op == op_Raise);
781 return get_irn_n(node, 1);
785 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
786 assert (node->op == op_Raise);
787 set_irn_n(node, 1, exo_ptr);
790 inline tarval *get_Const_tarval (ir_node *node) {
791 assert (node->op == op_Const);
792 return get_irn_const_attr(node);
796 set_Const_tarval (ir_node *node, tarval *con) {
797 assert (node->op == op_Const);
798 node->attr.con = con;
802 get_SymConst_kind (ir_node *node) {
803 assert (node->op == op_SymConst);
804 return node->attr.i.num;
808 set_SymConst_kind (ir_node *node, symconst_kind num) {
809 assert (node->op == op_SymConst);
810 node->attr.i.num = num;
814 get_SymConst_type (ir_node *node) {
815 assert ( (node->op == op_SymConst)
816 && ( get_SymConst_kind(node) == type_tag
817 || get_SymConst_kind(node) == size));
818 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
822 set_SymConst_type (ir_node *node, type *type) {
823 assert ( (node->op == op_SymConst)
824 && ( get_SymConst_kind(node) == type_tag
825 || get_SymConst_kind(node) == size));
826 node->attr.i.tori.typ = type;
830 get_SymConst_ptrinfo (ir_node *node) {
831 assert ( (node->op == op_SymConst)
832 && (get_SymConst_kind(node) == linkage_ptr_info));
833 return node->attr.i.tori.ptrinfo;
837 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
838 assert ( (node->op == op_SymConst)
839 && (get_SymConst_kind(node) == linkage_ptr_info));
840 node->attr.i.tori.ptrinfo = ptrinfo;
844 get_SymConst_type_or_id (ir_node *node) {
845 assert (node->op == op_SymConst);
846 return &(node->attr.i.tori);
850 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
851 assert (node->op == op_SymConst);
852 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
856 get_Sel_mem (ir_node *node) {
857 assert (node->op == op_Sel);
858 return get_irn_n(node, 0);
862 set_Sel_mem (ir_node *node, ir_node *mem) {
863 assert (node->op == op_Sel);
864 set_irn_n(node, 0, mem);
868 get_Sel_ptr (ir_node *node) {
869 assert (node->op == op_Sel);
870 return get_irn_n(node, 1);
874 set_Sel_ptr (ir_node *node, ir_node *ptr) {
875 assert (node->op == op_Sel);
876 set_irn_n(node, 1, ptr);
880 get_Sel_index_arr (ir_node *node)
882 assert ((node->op == op_Sel));
883 if (get_Sel_n_index(node) > 0)
884 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
890 get_Sel_n_index (ir_node *node) {
891 assert (node->op == op_Sel);
892 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
897 set_Sel_n_index (ir_node *node, int n_index) {
898 assert (node->op == op_Sel);
903 get_Sel_index (ir_node *node, int pos) {
904 assert (node->op == op_Sel);
905 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
909 set_Sel_index (ir_node *node, int pos, ir_node *index) {
910 assert (node->op == op_Sel);
911 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
915 get_Sel_entity (ir_node *node) {
916 assert (node->op == op_Sel);
917 return node->attr.s.ent;
921 set_Sel_entity (ir_node *node, entity *ent) {
922 assert (node->op == op_Sel);
923 node->attr.s.ent = ent;
927 get_Sel_linkage_type (ir_node *node) {
928 assert (node->op == op_Sel);
929 return node->attr.s.ltyp;
933 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
934 assert (node->op == op_Sel);
935 node->attr.s.ltyp = lt;
939 get_InstOf_ent (ir_node *node) {
940 assert (node->op = op_InstOf);
941 return (node->attr.io.ent);
945 set_InstOf_ent (ir_node *node, type *ent) {
946 assert (node->op = op_InstOf);
947 node->attr.io.ent = ent;
951 get_InstOf_store (ir_node *node) {
952 assert (node->op = op_InstOf);
953 return (get_irn_n (node, 0));
957 set_InstOf_store (ir_node *node, ir_node *obj) {
958 assert (node->op = op_InstOf);
959 set_irn_n (node, 0, obj);
963 get_InstOf_obj (ir_node *node) {
964 assert (node->op = op_InstOf);
965 return (get_irn_n (node, 1));
969 set_InstOf_obj (ir_node *node, ir_node *obj) {
970 assert (node->op = op_InstOf);
971 set_irn_n (node, 1, obj);
975 get_Call_mem (ir_node *node) {
976 assert (node->op == op_Call);
977 return get_irn_n(node, 0);
981 set_Call_mem (ir_node *node, ir_node *mem) {
982 assert (node->op == op_Call);
983 set_irn_n(node, 0, mem);
987 get_Call_ptr (ir_node *node) {
988 assert (node->op == op_Call);
989 return get_irn_n(node, 1);
993 set_Call_ptr (ir_node *node, ir_node *ptr) {
994 assert (node->op == op_Call);
995 set_irn_n(node, 1, ptr);
999 get_Call_param_arr (ir_node *node) {
1000 assert (node->op == op_Call);
1001 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1005 get_Call_n_params (ir_node *node) {
1006 assert (node->op == op_Call);
1007 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1011 get_Call_arity (ir_node *node) {
1012 assert (node->op == op_Call);
1013 return get_Call_n_params(node);
1017 set_Call_arity (ir_node *node, ir_node *arity) {
1018 assert (node->op == op_Call);
1023 get_Call_param (ir_node *node, int pos) {
1024 assert (node->op == op_Call);
1025 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1029 set_Call_param (ir_node *node, int pos, ir_node *param) {
1030 assert (node->op == op_Call);
1031 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1035 get_Call_type (ir_node *node) {
1036 assert (node->op == op_Call);
1037 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1041 set_Call_type (ir_node *node, type *type) {
1042 assert (node->op == op_Call);
1043 assert (is_method_type(type));
1044 node->attr.call.cld_tp = type;
1047 int get_Call_n_callees(ir_node * node) {
1048 assert(node->op == op_Call && node->attr.call.callee_arr);
1049 return ARR_LEN(node->attr.call.callee_arr);
1052 entity * get_Call_callee(ir_node * node, int pos) {
1053 assert(node->op == op_Call && node->attr.call.callee_arr);
1054 return node->attr.call.callee_arr[pos];
1057 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1058 assert(node->op == op_Call);
1059 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1060 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1062 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1065 void remove_Call_callee_arr(ir_node * node) {
1066 assert(node->op == op_Call);
1067 node->attr.call.callee_arr = NULL;
1070 /* For unary and binary arithmetic operations the access to the
1071 operands can be factored out. Left is the first, right the
1072 second arithmetic value as listed in tech report 0999-33.
1073 unops are: Minus, Abs, Not, Conv
1074 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1075 Shr, Shrs, Rotate, Cmp */
1078 is_unop (ir_node *node) {
1079 return ( node->op == op_Minus ||
1080 node->op == op_Abs ||
1081 node->op == op_Not ||
1082 node->op == op_Conv );
1086 get_unop_op (ir_node *node) {
1087 assert ( node->op == op_Minus ||
1088 node->op == op_Abs ||
1089 node->op == op_Not ||
1090 node->op == op_Conv );
1091 switch (get_irn_opcode (node)) {
1092 case iro_Minus: return get_Minus_op(node); break;
1093 case iro_Abs: return get_Abs_op(node); break;
1094 case iro_Not: return get_Not_op(node); break;
1095 case iro_Conv: return get_Conv_op(node); break;
1096 default: return NULL;
1101 set_unop_op (ir_node *node, ir_node *op) {
1102 assert (node->op == op_Minus ||
1103 node->op == op_Abs ||
1104 node->op == op_Not ||
1105 node->op == op_Conv );
1106 switch (get_irn_opcode (node)) {
1107 case iro_Minus: set_Minus_op(node, op); break;
1108 case iro_Abs: set_Abs_op(node, op); break;
1109 case iro_Not: set_Not_op(node, op); break;
1110 case iro_Conv: set_Conv_op(node, op); break;
1117 is_binop (ir_node *node) {
1118 return (node->op == op_Add ||
1119 node->op == op_Sub ||
1120 node->op == op_Mul ||
1121 node->op == op_Quot ||
1122 node->op == op_DivMod ||
1123 node->op == op_Div ||
1124 node->op == op_Mod ||
1125 node->op == op_And ||
1126 node->op == op_Or ||
1127 node->op == op_Eor ||
1128 node->op == op_Shl ||
1129 node->op == op_Shr ||
1130 node->op == op_Shrs ||
1131 node->op == op_Rot ||
1132 node->op == op_Cmp );
1136 get_binop_left (ir_node *node) {
1137 assert (node->op == op_Add ||
1138 node->op == op_Sub ||
1139 node->op == op_Mul ||
1140 node->op == op_Quot ||
1141 node->op == op_DivMod ||
1142 node->op == op_Div ||
1143 node->op == op_Mod ||
1144 node->op == op_And ||
1145 node->op == op_Or ||
1146 node->op == op_Eor ||
1147 node->op == op_Shl ||
1148 node->op == op_Shr ||
1149 node->op == op_Shrs ||
1150 node->op == op_Rot ||
1151 node->op == op_Cmp );
1153 switch (get_irn_opcode (node)) {
1154 case iro_Add : return get_Add_left(node); break;
1155 case iro_Sub : return get_Sub_left(node); break;
1156 case iro_Mul : return get_Mul_left(node); break;
1157 case iro_Quot : return get_Quot_left(node); break;
1158 case iro_DivMod: return get_DivMod_left(node); break;
1159 case iro_Div : return get_Div_left(node); break;
1160 case iro_Mod : return get_Mod_left(node); break;
1161 case iro_And : return get_And_left(node); break;
1162 case iro_Or : return get_Or_left(node); break;
1163 case iro_Eor : return get_Eor_left(node); break;
1164 case iro_Shl : return get_Shl_left(node); break;
1165 case iro_Shr : return get_Shr_left(node); break;
1166 case iro_Shrs : return get_Shrs_left(node); break;
1167 case iro_Rot : return get_Rot_left(node); break;
1168 case iro_Cmp : return get_Cmp_left(node); break;
1169 default: return NULL;
1174 set_binop_left (ir_node *node, ir_node *left) {
1175 assert (node->op == op_Add ||
1176 node->op == op_Sub ||
1177 node->op == op_Mul ||
1178 node->op == op_Quot ||
1179 node->op == op_DivMod ||
1180 node->op == op_Div ||
1181 node->op == op_Mod ||
1182 node->op == op_And ||
1183 node->op == op_Or ||
1184 node->op == op_Eor ||
1185 node->op == op_Shl ||
1186 node->op == op_Shr ||
1187 node->op == op_Shrs ||
1188 node->op == op_Rot ||
1189 node->op == op_Cmp );
1191 switch (get_irn_opcode (node)) {
1192 case iro_Add : set_Add_left(node, left); break;
1193 case iro_Sub : set_Sub_left(node, left); break;
1194 case iro_Mul : set_Mul_left(node, left); break;
1195 case iro_Quot : set_Quot_left(node, left); break;
1196 case iro_DivMod: set_DivMod_left(node, left); break;
1197 case iro_Div : set_Div_left(node, left); break;
1198 case iro_Mod : set_Mod_left(node, left); break;
1199 case iro_And : set_And_left(node, left); break;
1200 case iro_Or : set_Or_left(node, left); break;
1201 case iro_Eor : set_Eor_left(node, left); break;
1202 case iro_Shl : set_Shl_left(node, left); break;
1203 case iro_Shr : set_Shr_left(node, left); break;
1204 case iro_Shrs : set_Shrs_left(node, left); break;
1205 case iro_Rot : set_Rot_left(node, left); break;
1206 case iro_Cmp : set_Cmp_left(node, left); break;
1212 get_binop_right (ir_node *node) {
1213 assert (node->op == op_Add ||
1214 node->op == op_Sub ||
1215 node->op == op_Mul ||
1216 node->op == op_Quot ||
1217 node->op == op_DivMod ||
1218 node->op == op_Div ||
1219 node->op == op_Mod ||
1220 node->op == op_And ||
1221 node->op == op_Or ||
1222 node->op == op_Eor ||
1223 node->op == op_Shl ||
1224 node->op == op_Shr ||
1225 node->op == op_Shrs ||
1226 node->op == op_Rot ||
1227 node->op == op_Cmp );
1229 switch (get_irn_opcode (node)) {
1230 case iro_Add : return get_Add_right(node); break;
1231 case iro_Sub : return get_Sub_right(node); break;
1232 case iro_Mul : return get_Mul_right(node); break;
1233 case iro_Quot : return get_Quot_right(node); break;
1234 case iro_DivMod: return get_DivMod_right(node); break;
1235 case iro_Div : return get_Div_right(node); break;
1236 case iro_Mod : return get_Mod_right(node); break;
1237 case iro_And : return get_And_right(node); break;
1238 case iro_Or : return get_Or_right(node); break;
1239 case iro_Eor : return get_Eor_right(node); break;
1240 case iro_Shl : return get_Shl_right(node); break;
1241 case iro_Shr : return get_Shr_right(node); break;
1242 case iro_Shrs : return get_Shrs_right(node); break;
1243 case iro_Rot : return get_Rot_right(node); break;
1244 case iro_Cmp : return get_Cmp_right(node); break;
1245 default: return NULL;
1250 set_binop_right (ir_node *node, ir_node *right) {
1251 assert (node->op == op_Add ||
1252 node->op == op_Sub ||
1253 node->op == op_Mul ||
1254 node->op == op_Quot ||
1255 node->op == op_DivMod ||
1256 node->op == op_Div ||
1257 node->op == op_Mod ||
1258 node->op == op_And ||
1259 node->op == op_Or ||
1260 node->op == op_Eor ||
1261 node->op == op_Shl ||
1262 node->op == op_Shr ||
1263 node->op == op_Shrs ||
1264 node->op == op_Rot ||
1265 node->op == op_Cmp );
1267 switch (get_irn_opcode (node)) {
1268 case iro_Add : set_Add_right(node, right); break;
1269 case iro_Sub : set_Sub_right(node, right); break;
1270 case iro_Mul : set_Mul_right(node, right); break;
1271 case iro_Quot : set_Quot_right(node, right); break;
1272 case iro_DivMod: set_DivMod_right(node, right); break;
1273 case iro_Div : set_Div_right(node, right); break;
1274 case iro_Mod : set_Mod_right(node, right); break;
1275 case iro_And : set_And_right(node, right); break;
1276 case iro_Or : set_Or_right(node, right); break;
1277 case iro_Eor : set_Eor_right(node, right); break;
1278 case iro_Shl : set_Shl_right(node, right); break;
1279 case iro_Shr : set_Shr_right(node, right); break;
1280 case iro_Shrs : set_Shrs_right(node, right); break;
1281 case iro_Rot : set_Rot_right(node, right); break;
1282 case iro_Cmp : set_Cmp_right(node, right); break;
1288 get_Add_left (ir_node *node) {
1289 assert (node->op == op_Add);
1290 return get_irn_n(node, 0);
1294 set_Add_left (ir_node *node, ir_node *left) {
1295 assert (node->op == op_Add);
1296 set_irn_n(node, 0, left);
1300 get_Add_right (ir_node *node) {
1301 assert (node->op == op_Add);
1302 return get_irn_n(node, 1);
1306 set_Add_right (ir_node *node, ir_node *right) {
1307 assert (node->op == op_Add);
1308 set_irn_n(node, 1, right);
1312 get_Sub_left (ir_node *node) {
1313 assert (node->op == op_Sub);
1314 return get_irn_n(node, 0);
1318 set_Sub_left (ir_node *node, ir_node *left) {
1319 assert (node->op == op_Sub);
1320 set_irn_n(node, 0, left);
1324 get_Sub_right (ir_node *node) {
1325 assert (node->op == op_Sub);
1326 return get_irn_n(node, 1);
1330 set_Sub_right (ir_node *node, ir_node *right) {
1331 assert (node->op == op_Sub);
1332 set_irn_n(node, 1, right);
1337 get_Minus_op (ir_node *node) {
1338 assert (node->op == op_Minus);
1339 return get_irn_n(node, 0);
1343 set_Minus_op (ir_node *node, ir_node *op) {
1344 assert (node->op == op_Minus);
1345 set_irn_n(node, 0, op);
1350 get_Mul_left (ir_node *node) {
1351 assert (node->op == op_Mul);
1352 return get_irn_n(node, 0);
1356 set_Mul_left (ir_node *node, ir_node *left) {
1357 assert (node->op == op_Mul);
1358 set_irn_n(node, 0, left);
1362 get_Mul_right (ir_node *node) {
1363 assert (node->op == op_Mul);
1364 return get_irn_n(node, 1);
1368 set_Mul_right (ir_node *node, ir_node *right) {
1369 assert (node->op == op_Mul);
1370 set_irn_n(node, 1, right);
1374 get_Quot_left (ir_node *node) {
1375 assert (node->op == op_Quot);
1376 return get_irn_n(node, 1);
1380 set_Quot_left (ir_node *node, ir_node *left) {
1381 assert (node->op == op_Quot);
1382 set_irn_n(node, 1, left);
1386 get_Quot_right (ir_node *node) {
1387 assert (node->op == op_Quot);
1388 return get_irn_n(node, 2);
1392 set_Quot_right (ir_node *node, ir_node *right) {
1393 assert (node->op == op_Quot);
1394 set_irn_n(node, 2, right);
1398 get_Quot_mem (ir_node *node) {
1399 assert (node->op == op_Quot);
1400 return get_irn_n(node, 0);
1404 set_Quot_mem (ir_node *node, ir_node *mem) {
1405 assert (node->op == op_Quot);
1406 set_irn_n(node, 0, mem);
1410 get_DivMod_left (ir_node *node) {
1411 assert (node->op == op_DivMod);
1412 return get_irn_n(node, 1);
1416 set_DivMod_left (ir_node *node, ir_node *left) {
1417 assert (node->op == op_DivMod);
1418 set_irn_n(node, 1, left);
1422 get_DivMod_right (ir_node *node) {
1423 assert (node->op == op_DivMod);
1424 return get_irn_n(node, 2);
1428 set_DivMod_right (ir_node *node, ir_node *right) {
1429 assert (node->op == op_DivMod);
1430 set_irn_n(node, 2, right);
1434 get_DivMod_mem (ir_node *node) {
1435 assert (node->op == op_DivMod);
1436 return get_irn_n(node, 0);
1440 set_DivMod_mem (ir_node *node, ir_node *mem) {
1441 assert (node->op == op_DivMod);
1442 set_irn_n(node, 0, mem);
1446 get_Div_left (ir_node *node) {
1447 assert (node->op == op_Div);
1448 return get_irn_n(node, 1);
1452 set_Div_left (ir_node *node, ir_node *left) {
1453 assert (node->op == op_Div);
1454 set_irn_n(node, 1, left);
1458 get_Div_right (ir_node *node) {
1459 assert (node->op == op_Div);
1460 return get_irn_n(node, 2);
1464 set_Div_right (ir_node *node, ir_node *right) {
1465 assert (node->op == op_Div);
1466 set_irn_n(node, 2, right);
1470 get_Div_mem (ir_node *node) {
1471 assert (node->op == op_Div);
1472 return get_irn_n(node, 0);
1476 set_Div_mem (ir_node *node, ir_node *mem) {
1477 assert (node->op == op_Div);
1478 set_irn_n(node, 0, mem);
1482 get_Mod_left (ir_node *node) {
1483 assert (node->op == op_Mod);
1484 return get_irn_n(node, 1);
1488 set_Mod_left (ir_node *node, ir_node *left) {
1489 assert (node->op == op_Mod);
1490 set_irn_n(node, 1, left);
1494 get_Mod_right (ir_node *node) {
1495 assert (node->op == op_Mod);
1496 return get_irn_n(node, 2);
1500 set_Mod_right (ir_node *node, ir_node *right) {
1501 assert (node->op == op_Mod);
1502 set_irn_n(node, 2, right);
1506 get_Mod_mem (ir_node *node) {
1507 assert (node->op == op_Mod);
1508 return get_irn_n(node, 0);
1512 set_Mod_mem (ir_node *node, ir_node *mem) {
1513 assert (node->op == op_Mod);
1514 set_irn_n(node, 0, mem);
1518 get_Abs_op (ir_node *node) {
1519 assert (node->op == op_Abs);
1520 return get_irn_n(node, 0);
1524 set_Abs_op (ir_node *node, ir_node *op) {
1525 assert (node->op == op_Abs);
1526 set_irn_n(node, 0, op);
1530 get_And_left (ir_node *node) {
1531 assert (node->op == op_And);
1532 return get_irn_n(node, 0);
1536 set_And_left (ir_node *node, ir_node *left) {
1537 assert (node->op == op_And);
1538 set_irn_n(node, 0, left);
1542 get_And_right (ir_node *node) {
1543 assert (node->op == op_And);
1544 return get_irn_n(node, 1);
1548 set_And_right (ir_node *node, ir_node *right) {
1549 assert (node->op == op_And);
1550 set_irn_n(node, 1, right);
1554 get_Or_left (ir_node *node) {
1555 assert (node->op == op_Or);
1556 return get_irn_n(node, 0);
1560 set_Or_left (ir_node *node, ir_node *left) {
1561 assert (node->op == op_Or);
1562 set_irn_n(node, 0, left);
1566 get_Or_right (ir_node *node) {
1567 assert (node->op == op_Or);
1568 return get_irn_n(node, 1);
1572 set_Or_right (ir_node *node, ir_node *right) {
1573 assert (node->op == op_Or);
1574 set_irn_n(node, 1, right);
1578 get_Eor_left (ir_node *node) {
1579 assert (node->op == op_Eor);
1580 return get_irn_n(node, 0);
1584 set_Eor_left (ir_node *node, ir_node *left) {
1585 assert (node->op == op_Eor);
1586 set_irn_n(node, 0, left);
1590 get_Eor_right (ir_node *node) {
1591 assert (node->op == op_Eor);
1592 return get_irn_n(node, 1);
1596 set_Eor_right (ir_node *node, ir_node *right) {
1597 assert (node->op == op_Eor);
1598 set_irn_n(node, 1, right);
1603 get_Not_op (ir_node *node) {
1604 assert (node->op == op_Not);
1605 return get_irn_n(node, 0);
1609 set_Not_op (ir_node *node, ir_node *op) {
1610 assert (node->op == op_Not);
1611 set_irn_n(node, 0, op);
1616 get_Shl_left (ir_node *node) {
1617 assert (node->op == op_Shl);
1618 return get_irn_n(node, 0);
1622 set_Shl_left (ir_node *node, ir_node *left) {
1623 assert (node->op == op_Shl);
1624 set_irn_n(node, 0, left);
1628 get_Shl_right (ir_node *node) {
1629 assert (node->op == op_Shl);
1630 return get_irn_n(node, 1);
1634 set_Shl_right (ir_node *node, ir_node *right) {
1635 assert (node->op == op_Shl);
1636 set_irn_n(node, 1, right);
1640 get_Shr_left (ir_node *node) {
1641 assert (node->op == op_Shr);
1642 return get_irn_n(node, 0);
1646 set_Shr_left (ir_node *node, ir_node *left) {
1647 assert (node->op == op_Shr);
1648 set_irn_n(node, 0, left);
1652 get_Shr_right (ir_node *node) {
1653 assert (node->op == op_Shr);
1654 return get_irn_n(node, 1);
1658 set_Shr_right (ir_node *node, ir_node *right) {
1659 assert (node->op == op_Shr);
1660 set_irn_n(node, 1, right);
1664 get_Shrs_left (ir_node *node) {
1665 assert (node->op == op_Shrs);
1666 return get_irn_n(node, 0);
1670 set_Shrs_left (ir_node *node, ir_node *left) {
1671 assert (node->op == op_Shrs);
1672 set_irn_n(node, 0, left);
1676 get_Shrs_right (ir_node *node) {
1677 assert (node->op == op_Shrs);
1678 return get_irn_n(node, 1);
1682 set_Shrs_right (ir_node *node, ir_node *right) {
1683 assert (node->op == op_Shrs);
1684 set_irn_n(node, 1, right);
1688 get_Rot_left (ir_node *node) {
1689 assert (node->op == op_Rot);
1690 return get_irn_n(node, 0);
1694 set_Rot_left (ir_node *node, ir_node *left) {
1695 assert (node->op == op_Rot);
1696 set_irn_n(node, 0, left);
1700 get_Rot_right (ir_node *node) {
1701 assert (node->op == op_Rot);
1702 return get_irn_n(node, 1);
1706 set_Rot_right (ir_node *node, ir_node *right) {
1707 assert (node->op == op_Rot);
1708 set_irn_n(node, 1, right);
1712 get_Cmp_left (ir_node *node) {
1713 assert (node->op == op_Cmp);
1714 return get_irn_n(node, 0);
1718 set_Cmp_left (ir_node *node, ir_node *left) {
1719 assert (node->op == op_Cmp);
1720 set_irn_n(node, 0, left);
1724 get_Cmp_right (ir_node *node) {
1725 assert (node->op == op_Cmp);
1726 return get_irn_n(node, 1);
1730 set_Cmp_right (ir_node *node, ir_node *right) {
1731 assert (node->op == op_Cmp);
1732 set_irn_n(node, 1, right);
1736 get_Conv_op (ir_node *node) {
1737 assert (node->op == op_Conv);
1738 return get_irn_n(node, 0);
1742 set_Conv_op (ir_node *node, ir_node *op) {
1743 assert (node->op == op_Conv);
1744 set_irn_n(node, 0, op);
1748 get_Phi_preds_arr (ir_node *node) {
1749 assert (node->op == op_Phi);
1750 return (ir_node **)&(get_irn_in(node)[1]);
1754 get_Phi_n_preds (ir_node *node) {
1755 assert (node->op == op_Phi);
1756 return (get_irn_arity(node));
1760 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1761 assert (node->op == op_Phi);
1766 get_Phi_pred (ir_node *node, int pos) {
1767 assert (node->op == op_Phi);
1768 return get_irn_n(node, pos);
1772 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1773 assert (node->op == op_Phi);
1774 set_irn_n(node, pos, pred);
1778 get_Load_mem (ir_node *node) {
1779 assert (node->op == op_Load);
1780 return get_irn_n(node, 0);
1784 set_Load_mem (ir_node *node, ir_node *mem) {
1785 assert (node->op == op_Load);
1786 set_irn_n(node, 0, mem);
1790 get_Load_ptr (ir_node *node) {
1791 assert (node->op == op_Load);
1792 return get_irn_n(node, 1);
1796 set_Load_ptr (ir_node *node, ir_node *ptr) {
1797 assert (node->op == op_Load);
1798 set_irn_n(node, 1, ptr);
1803 get_Store_mem (ir_node *node) {
1804 assert (node->op == op_Store);
1805 return get_irn_n(node, 0);
1809 set_Store_mem (ir_node *node, ir_node *mem) {
1810 assert (node->op == op_Store);
1811 set_irn_n(node, 0, mem);
1815 get_Store_ptr (ir_node *node) {
1816 assert (node->op == op_Store);
1817 return get_irn_n(node, 1);
1821 set_Store_ptr (ir_node *node, ir_node *ptr) {
1822 assert (node->op == op_Store);
1823 set_irn_n(node, 1, ptr);
1827 get_Store_value (ir_node *node) {
1828 assert (node->op == op_Store);
1829 return get_irn_n(node, 2);
1833 set_Store_value (ir_node *node, ir_node *value) {
1834 assert (node->op == op_Store);
1835 set_irn_n(node, 2, value);
1839 get_Alloc_mem (ir_node *node) {
1840 assert (node->op == op_Alloc);
1841 return get_irn_n(node, 0);
1845 set_Alloc_mem (ir_node *node, ir_node *mem) {
1846 assert (node->op == op_Alloc);
1847 set_irn_n(node, 0, mem);
1851 get_Alloc_size (ir_node *node) {
1852 assert (node->op == op_Alloc);
1853 return get_irn_n(node, 1);
1857 set_Alloc_size (ir_node *node, ir_node *size) {
1858 assert (node->op == op_Alloc);
1859 set_irn_n(node, 1, size);
1863 get_Alloc_type (ir_node *node) {
1864 assert (node->op == op_Alloc);
1865 return node->attr.a.type = skip_tid(node->attr.a.type);
1869 set_Alloc_type (ir_node *node, type *type) {
1870 assert (node->op == op_Alloc);
1871 node->attr.a.type = type;
1875 get_Alloc_where (ir_node *node) {
1876 assert (node->op == op_Alloc);
1877 return node->attr.a.where;
1881 set_Alloc_where (ir_node *node, where_alloc where) {
1882 assert (node->op == op_Alloc);
1883 node->attr.a.where = where;
1888 get_Free_mem (ir_node *node) {
1889 assert (node->op == op_Free);
1890 return get_irn_n(node, 0);
1894 set_Free_mem (ir_node *node, ir_node *mem) {
1895 assert (node->op == op_Free);
1896 set_irn_n(node, 0, mem);
1900 get_Free_ptr (ir_node *node) {
1901 assert (node->op == op_Free);
1902 return get_irn_n(node, 1);
1906 set_Free_ptr (ir_node *node, ir_node *ptr) {
1907 assert (node->op == op_Free);
1908 set_irn_n(node, 1, ptr);
1912 get_Free_size (ir_node *node) {
1913 assert (node->op == op_Free);
1914 return get_irn_n(node, 2);
1918 set_Free_size (ir_node *node, ir_node *size) {
1919 assert (node->op == op_Free);
1920 set_irn_n(node, 2, size);
1924 get_Free_type (ir_node *node) {
1925 assert (node->op == op_Free);
1926 return node->attr.f = skip_tid(node->attr.f);
1930 set_Free_type (ir_node *node, type *type) {
1931 assert (node->op == op_Free);
1932 node->attr.f = type;
1936 get_Sync_preds_arr (ir_node *node) {
1937 assert (node->op == op_Sync);
1938 return (ir_node **)&(get_irn_in(node)[1]);
1942 get_Sync_n_preds (ir_node *node) {
1943 assert (node->op == op_Sync);
1944 return (get_irn_arity(node));
1949 set_Sync_n_preds (ir_node *node, int n_preds) {
1950 assert (node->op == op_Sync);
1955 get_Sync_pred (ir_node *node, int pos) {
1956 assert (node->op == op_Sync);
1957 return get_irn_n(node, pos);
1961 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1962 assert (node->op == op_Sync);
1963 set_irn_n(node, pos, pred);
1967 get_Proj_pred (ir_node *node) {
1968 assert (is_Proj(node));
1969 return get_irn_n(node, 0);
1973 set_Proj_pred (ir_node *node, ir_node *pred) {
1974 assert (is_Proj(node));
1975 set_irn_n(node, 0, pred);
1979 get_Proj_proj (ir_node *node) {
1980 assert (is_Proj(node));
1981 if (get_irn_opcode(node) == iro_Proj) {
1982 return node->attr.proj;
1984 assert(get_irn_opcode(node) == iro_Filter);
1985 return node->attr.filter.proj;
1990 set_Proj_proj (ir_node *node, long proj) {
1991 assert (node->op == op_Proj);
1992 node->attr.proj = proj;
1996 get_Tuple_preds_arr (ir_node *node) {
1997 assert (node->op == op_Tuple);
1998 return (ir_node **)&(get_irn_in(node)[1]);
2002 get_Tuple_n_preds (ir_node *node) {
2003 assert (node->op == op_Tuple);
2004 return (get_irn_arity(node));
2009 set_Tuple_n_preds (ir_node *node, int n_preds) {
2010 assert (node->op == op_Tuple);
2015 get_Tuple_pred (ir_node *node, int pos) {
2016 assert (node->op == op_Tuple);
2017 return get_irn_n(node, pos);
2021 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2022 assert (node->op == op_Tuple);
2023 set_irn_n(node, pos, pred);
2027 get_Id_pred (ir_node *node) {
2028 assert (node->op == op_Id);
2029 return get_irn_n(node, 0);
2033 set_Id_pred (ir_node *node, ir_node *pred) {
2034 assert (node->op == op_Id);
2035 set_irn_n(node, 0, pred);
2040 get_Filter_pred(ir_node *node) {
2041 assert(node->op == op_Filter);
2046 get_Filter_proj(ir_node *node) {
2047 assert(node->op == op_Filter);
2048 return node->attr.filter.proj;
2051 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2052 assert(node->op == op_Filter);
2053 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2054 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2055 node->attr.filter.in_cg[0] = node->in[0];
2057 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2060 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2061 assert(node->op == op_Filter && node->attr.filter.in_cg && 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2062 node->attr.filter.in_cg[pos + 1] = pred;
2067 get_irn_irg(ir_node *node) {
2068 if (get_irn_op(node) == op_CallBegin) {
2069 return node->attr.callbegin.irg;
2070 } else if (get_irn_op(node) == op_EndReg || get_irn_op(node) == op_EndExcept) {
2071 return node->attr.end.irg;
2073 assert(0 && "no irg attr");
2078 /******************************************************************/
2079 /* Auxiliary routines */
2080 /******************************************************************/
2083 skip_Proj (ir_node *node) {
2084 /* don't assert node !!! */
2085 if (node && is_Proj(node)) {
2086 return get_Proj_pred(node);
2093 skip_Tuple (ir_node *node) {
2096 node = skip_nop(node);
2097 if (get_irn_op(node) == op_Proj) {
2098 pred = skip_nop(get_Proj_pred(node));
2099 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2100 pred = skip_nop(skip_Tuple(pred));
2101 if (get_irn_op(pred) == op_Tuple)
2102 return get_Tuple_pred(pred, get_Proj_proj(node));
2108 skip_nop (ir_node *node) {
2109 /* don't assert node !!! */
2111 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
2112 /* Don't use get_Id_pred: We get into an endless loop for
2113 self-referencing Ids. */
2114 assert (get_irn_arity (node) > 0);
2115 return node->in[0+1];
2122 skip_Id (ir_node *node) {
2123 return skip_nop(node);
2127 is_Bad (ir_node *node) {
2129 if ((node) && get_irn_opcode(node) == iro_Bad)
2135 is_no_Block (ir_node *node) {
2137 return (get_irn_opcode(node) != iro_Block);
2141 is_Proj (ir_node *node) {
2143 return node->op == op_Proj
2144 || (!interprocedural_view && node->op == op_Filter);
2147 /* Returns true if the operation manipulates control flow. */
2149 is_cfop(ir_node *node) {
2150 return is_cfopcode(get_irn_op(node));
2153 /* Returns true if the operation can change the control flow because
2156 is_fragile_op(ir_node *node) {
2157 return ( (get_irn_opcode(node) == iro_Call)
2158 || (get_irn_opcode(node) == iro_Quot)
2159 || (get_irn_opcode(node) == iro_DivMod)
2160 || (get_irn_opcode(node) == iro_Div)
2161 || (get_irn_opcode(node) == iro_Mod)
2162 || (get_irn_opcode(node) == iro_Load)
2163 || (get_irn_opcode(node) == iro_Store)
2164 || (get_irn_opcode(node) == iro_Alloc)
2165 || (get_irn_opcode(node) == iro_Bad)
2166 || (get_irn_opcode(node) == iro_Unknown));
2170 /* Returns the memory operand of fragile operations. */
2171 ir_node *get_fragile_op_mem(ir_node *node) {
2172 assert(node && is_fragile_op(node));
2174 switch (get_irn_opcode (node)) {
2183 return get_irn_n(node, 0);
2188 assert(0 && "not reached");