1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
16 #include "irgraph_t.h"
19 #include "typegmod_t.h"
26 /* some constants fixing the positions of nodes predecessors
28 #define CALL_PARAM_OFFSET 2
29 #define SEL_INDEX_OFFSET 2
30 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
31 #define END_KEEPALIVE_OFFSET 0
33 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
34 "Gt", "Ge", "Lg", "Leg", "Uo",
35 "Ue", "Ul", "Ule", "Ug", "Uge",
38 inline char *get_pnc_string(int pnc) {
39 return pnc_name_arr[pnc];
44 get_negated_pnc(int pnc) {
46 case False: return True; break;
47 case Eq: return Ne; break;
48 case Lt: return Uge; break;
49 case Le: return Ug; break;
50 case Gt: return Ule; break;
51 case Ge: return Ul; break;
52 case Lg: return Ue; break;
53 case Leg: return Uo; break;
54 case Uo: return Leg; break;
55 case Ue: return Lg; break;
56 case Ul: return Ge; break;
57 case Ule: return Gt; break;
58 case Ug: return Le; break;
59 case Uge: return Lt; break;
60 case Ne: return Eq; break;
61 case True: return False; break;
63 return 99; /* to shut up gcc */
66 static char *pns_name_arr [] = {"initial_exec", "global_store",
67 "frame_base", "globals", "args"};
69 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
76 /* irnode constructor */
77 /* create a new irnode in irg, with an op, mode, arity and */
78 /* some incoming irnodes */
79 /* this constructor is used in every specified irnode constructor */
81 new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
82 int arity, ir_node **in)
85 int node_size = offsetof (ir_node, attr) + op->attr_size;
87 res = (ir_node *) obstack_alloc (irg->obst, node_size);
89 res->kind = k_ir_node;
95 res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
97 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
98 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
101 set_irn_dbg_info(res, db);
105 res->node_nr = get_irp_new_node_nr();
111 /* Copies all attributes stored in the old node to the new node.
112 Assumes both have the same opcode and sufficient size. */
114 copy_attrs (ir_node *old, ir_node *new) {
115 assert (get_irn_opcode(old) == get_irn_opcode(new));
116 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
119 /* IR-Nodes with attributes */
121 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
124 ir_node *np = XP_GETARG (ir_node *, 0);
127 XPS ("<null ir_node>");
131 XPF1 ("%I", get_irn_opident(np));
133 switch (get_irn_opcode (np)) { /* node label */
135 XPF1 ("%I", get_irn_mode(np)->name);
137 XPF1 ("%v", get_irn_const_attr);
140 if (get_irn_modecode (np) == irm_b) {
142 XP (pnc_name_arr[get_irn_proj_attr(np)]);
143 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
145 XP (pns_name_arr[get_irn_proj_attr(np)]);
147 XPF1 ("%I", get_irn_mode(np)->name);
149 XPF1 ("%d", get_irn_proj_attr(np));
153 XPF1 ("%I", get_irn_mode(np)->name);
155 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
156 XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
158 case iro_Start: /* don't dump mode of these */
171 XPF1 ("%I", get_irn_mode(np)->name);
177 /** getting some parameters from ir_nodes **/
179 /* returns the number of predecessors without the block predecessor. */
181 get_irn_arity (ir_node *node) {
183 if (interprocedural_view) { /* handle Filter and Block specially */
184 if (get_irn_opcode(node) == iro_Filter) {
185 assert(node->attr.filter.in_cg);
186 return ARR_LEN(node->attr.filter.in_cg) - 1;
187 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
188 return ARR_LEN(node->attr.block.in_cg) - 1;
190 /* else fall through */
192 return ARR_LEN(node->in) - 1;
195 /* Returns the array with ins. This array is shifted with respect to the
196 array accessed by get_irn_n: The block operand is at position 0 not -1.
197 (@@@ This should be changed.)
198 The order of the predecessors in this array is not guaranteed, except that
199 lists of operands as predecessors of Block or arguments of a Call are
202 get_irn_in (ir_node *node) {
204 if (interprocedural_view) { /* handle Filter and Block specially */
205 if (get_irn_opcode(node) == iro_Filter) {
206 assert(node->attr.filter.in_cg);
207 return node->attr.filter.in_cg;
208 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
209 return node->attr.block.in_cg;
211 /* else fall through */
217 set_irn_in (ir_node *node, int arity, ir_node **in) {
220 if (interprocedural_view) { /* handle Filter and Block specially */
221 if (get_irn_opcode(node) == iro_Filter) {
222 assert(node->attr.filter.in_cg);
223 arr = &node->attr.filter.in_cg;
224 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
225 arr = &node->attr.block.in_cg;
232 if (arity != ARR_LEN(*arr) - 1) {
233 ir_node * block = (*arr)[0];
234 *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
237 memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
240 /* to iterate through the predecessors without touching the array */
241 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
242 to iterate includind the Block predecessor iterate from i = -1 to
244 If it is a block, the entry -1 is NULL. */
246 get_irn_n (ir_node *node, int n) {
247 assert(node && -1 <= n && n < get_irn_arity(node));
248 if (interprocedural_view) { /* handle Filter and Block specially */
249 if (get_irn_opcode(node) == iro_Filter) {
250 assert(node->attr.filter.in_cg);
251 return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
252 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
253 return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
255 /* else fall through */
257 return (node->in[n + 1] = skip_nop(node->in[n + 1]));
261 set_irn_n (ir_node *node, int n, ir_node *in) {
262 assert(node && -1 <= n && n < get_irn_arity(node));
263 if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
264 /* Change block pred in both views! */
265 node->in[n + 1] = in;
266 assert(node->attr.filter.in_cg);
267 node->attr.filter.in_cg[n + 1] = in;
270 if (interprocedural_view) { /* handle Filter and Block specially */
271 if (get_irn_opcode(node) == iro_Filter) {
272 assert(node->attr.filter.in_cg);
273 node->attr.filter.in_cg[n + 1] = in;
275 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
276 node->attr.block.in_cg[n + 1] = in;
279 /* else fall through */
281 node->in[n + 1] = in;
285 get_irn_mode (ir_node *node)
292 get_irn_modecode (ir_node *node)
295 return node->mode->code;
300 get_irn_modeident (ir_node *node)
303 return node->mode->name;
307 get_irn_op (ir_node *node)
313 /* should be private to the library: */
315 set_irn_op (ir_node *node, ir_op *op)
322 get_irn_opcode (ir_node *node)
325 return node->op->code;
329 get_irn_opname (ir_node *node)
332 return id_to_str(node->op->name);
336 get_irn_opident (ir_node *node)
339 return node->op->name;
343 get_irn_visited (ir_node *node)
346 return node->visited;
350 set_irn_visited (ir_node *node, unsigned long visited)
353 node->visited = visited;
357 mark_irn_visited (ir_node *node) {
359 node->visited = current_ir_graph->visited;
363 irn_not_visited (ir_node *node) {
365 return (node->visited < current_ir_graph->visited);
369 set_irn_link (ir_node *node, ir_node *link) {
375 get_irn_link (ir_node *node) {
380 /* Outputs a unique number for this node */
382 get_irn_node_nr(ir_node *node) {
385 return node->node_nr;
392 get_irn_const_attr (ir_node *node)
394 assert (node->op == op_Const);
395 return node->attr.con;
399 get_irn_proj_attr (ir_node *node)
401 assert (node->op == op_Proj);
402 return node->attr.proj;
406 get_irn_alloc_attr (ir_node *node)
408 assert (node->op == op_Alloc);
413 get_irn_free_attr (ir_node *node)
415 assert (node->op == op_Free);
416 return node->attr.f = skip_tid(node->attr.f);
420 get_irn_symconst_attr (ir_node *node)
422 assert (node->op == op_SymConst);
427 get_irn_call_attr (ir_node *node)
429 assert (node->op == op_Call);
430 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
434 get_irn_sel_attr (ir_node *node)
436 assert (node->op == op_Sel);
441 get_irn_phi_attr (ir_node *node)
443 assert (node->op == op_Phi);
444 return node->attr.phi0_pos;
448 get_irn_block_attr (ir_node *node)
450 assert (node->op == op_Block);
451 return node->attr.block;
454 /** manipulate fields of individual nodes **/
456 /* this works for all except Block */
458 get_nodes_Block (ir_node *node) {
459 assert (!(node->op == op_Block));
460 return get_irn_n(node, -1);
464 set_nodes_Block (ir_node *node, ir_node *block) {
465 assert (!(node->op == op_Block));
466 set_irn_n(node, -1, block);
469 /* Returns an array with the predecessors of the Block. Depending on
470 the implementation of the graph datastructure this can be a copy of
471 the internal representation of predecessors as well as the internal
472 array itself. Therefore writing to this array might obstruct the ir. */
474 get_Block_cfgpred_arr (ir_node *node)
476 assert ((node->op == op_Block));
477 return (ir_node **)&(get_irn_in(node)[1]);
482 get_Block_n_cfgpreds (ir_node *node) {
483 assert ((node->op == op_Block));
484 return (get_irn_arity(node));
489 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
490 assert ((node->op == op_Block));
495 get_Block_cfgpred (ir_node *node, int pos) {
496 assert (node->op == op_Block);
497 return get_irn_n(node, pos);
501 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
502 assert (node->op == op_Block);
503 set_irn_n(node, pos, pred);
507 get_Block_matured (ir_node *node) {
508 assert (node->op == op_Block);
509 return node->attr.block.matured;
513 set_Block_matured (ir_node *node, bool matured) {
514 assert (node->op == op_Block);
515 node->attr.block.matured = matured;
518 get_Block_block_visited (ir_node *node) {
519 assert (node->op == op_Block);
520 return node->attr.block.block_visited;
524 set_Block_block_visited (ir_node *node, unsigned long visit) {
525 assert (node->op == op_Block);
526 node->attr.block.block_visited = visit;
529 /* For this current_ir_graph must be set. */
530 inline void mark_Block_block_visited (ir_node *node) {
531 assert (node->op == op_Block);
532 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
535 inline int Block_not_block_visited(ir_node *node) {
536 assert (node->op == op_Block);
537 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
541 get_Block_graph_arr (ir_node *node, int pos) {
542 assert (node->op == op_Block);
543 return node->attr.block.graph_arr[pos+1];
547 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
548 assert (node->op == op_Block);
549 node->attr.block.graph_arr[pos+1] = value;
552 /* handler handling for Blocks */
553 void set_Block_handler (ir_node *block, ir_node *handler)
555 assert ((block->op == op_Block));
556 assert ((handler->op == op_Block));
558 block->attr.block.handler_entry = handler;
561 ir_node *get_Block_handler (ir_node *block)
563 assert ((block->op == op_Block));
565 return (block->attr.block.handler_entry);
568 /* handler handling for Nodes */
569 void set_Node_handler (ir_node *node, ir_node *handler)
571 set_Block_handler (get_nodes_Block (node), handler);
574 ir_node *get_Node_handler (ir_node *node)
576 return (get_Block_handler (get_nodes_Block (node)));
580 /* exc_t handling for Blocks */
581 void set_Block_exc (ir_node *block, exc_t exc)
583 assert ((block->op == op_Block));
584 block->attr.block.exc = exc;
587 exc_t get_Block_exc (ir_node *block)
589 assert ((block->op == op_Block));
591 return (block->attr.block.exc);
594 /* exc_t handling for Nodes */
595 void set_Node_exc (ir_node *node, exc_t exc)
597 set_Block_exc (get_nodes_Block (node), exc);
600 exc_t get_Node_exc (ir_node *node)
602 return (get_Block_exc (get_nodes_Block (node)));
605 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
606 assert(node->op == op_Block);
607 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
608 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
609 node->attr.block.in_cg[0] = NULL;
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 && node->attr.block.in_cg);
628 return ARR_LEN(node->attr.block.in_cg) - 1;
631 void remove_Block_cg_cfgpred_arr(ir_node * node) {
632 assert(node->op == op_Block);
633 node->attr.block.in_cg = NULL;
637 get_End_n_keepalives(ir_node *end) {
638 assert (end->op == op_End);
639 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
643 get_End_keepalive(ir_node *end, int pos) {
644 assert (end->op == op_End);
645 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
649 add_End_keepalive (ir_node *end, ir_node *ka) {
650 assert (end->op == op_End);
651 ARR_APP1 (ir_node *, end->in, ka);
655 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
656 assert (end->op == op_End);
657 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
661 free_End (ir_node *end) {
662 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
663 end->in = NULL; /* @@@ make sure we get an error if we use the in array afterwards ... */
667 > Implementing the case construct (which is where the constant Proj node is
668 > important) involves far more than simply determining the constant values.
669 > We could argue that this is more properly a function of the translator from
670 > Firm to the target machine. That could be done if there was some way of
671 > projecting "default" out of the Cond node.
672 I know it's complicated.
673 Basically there are two proglems:
674 - determining the gaps between the projs
675 - determining the biggest case constant to konw the proj number for
677 I see several solutions:
678 1. Introduce a ProjDefault node. Solves both problems.
679 This means to extend all optimizations executed during construction.
680 2. Give the Cond node for switch two flavors:
681 a) there are no gaps in the projs (existing flavor)
682 b) gaps may exist, default proj is still the Proj with the largest
683 projection number. This covers also the gaps.
684 3. Fix the semantic of the Cond to that of 2b)
686 Solution 2 seems to be the best:
687 Computing the gaps in the Firm representation is not too hard, i.e.,
688 libfirm can implement a routine that transforms betweeen the two
689 flavours. This is also possible for 1) but 2) does not require to
690 change any existing optimization.
691 Further it should be far simpler to determine the biggest constant than
693 I don't want to choose 3) as 2a) seems to have advantages for
694 dataflow analysis and 3) does not allow to convert the representation to
698 get_Cond_selector (ir_node *node) {
699 assert (node->op == op_Cond);
700 return get_irn_n(node, 0);
704 set_Cond_selector (ir_node *node, ir_node *selector) {
705 assert (node->op == op_Cond);
706 set_irn_n(node, 0, selector);
710 get_Cond_kind (ir_node *node) {
711 assert (node->op == op_Cond);
712 return node->attr.c.kind;
716 set_Cond_kind (ir_node *node, cond_kind kind) {
717 assert (node->op == op_Cond);
718 node->attr.c.kind = kind;
722 get_Return_mem (ir_node *node) {
723 assert (node->op == op_Return);
724 return get_irn_n(node, 0);
728 set_Return_mem (ir_node *node, ir_node *mem) {
729 assert (node->op == op_Return);
730 set_irn_n(node, 0, mem);
734 get_Return_res_arr (ir_node *node)
736 assert ((node->op == op_Return));
737 if (get_Return_n_res(node) > 0)
738 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
744 get_Return_n_res (ir_node *node) {
745 assert (node->op == op_Return);
746 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
751 set_Return_n_res (ir_node *node, int results) {
752 assert (node->op == op_Return);
757 get_Return_res (ir_node *node, int pos) {
758 assert (node->op == op_Return);
759 assert (get_Return_n_res(node) > pos);
760 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
764 set_Return_res (ir_node *node, int pos, ir_node *res){
765 assert (node->op == op_Return);
766 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
770 get_Raise_mem (ir_node *node) {
771 assert (node->op == op_Return);
772 return get_irn_n(node, 0);
776 set_Raise_mem (ir_node *node, ir_node *mem) {
777 assert (node->op == op_Raise);
778 set_irn_n(node, 0, mem);
782 get_Raise_exo_ptr (ir_node *node) {
783 assert (node->op == op_Raise);
784 return get_irn_n(node, 1);
788 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
789 assert (node->op == op_Raise);
790 set_irn_n(node, 1, exo_ptr);
793 inline tarval *get_Const_tarval (ir_node *node) {
794 assert (node->op == op_Const);
795 return get_irn_const_attr(node);
799 set_Const_tarval (ir_node *node, tarval *con) {
800 assert (node->op == op_Const);
801 node->attr.con = con;
805 get_SymConst_kind (ir_node *node) {
806 assert (node->op == op_SymConst);
807 return node->attr.i.num;
811 set_SymConst_kind (ir_node *node, symconst_kind num) {
812 assert (node->op == op_SymConst);
813 node->attr.i.num = num;
817 get_SymConst_type (ir_node *node) {
818 assert ( (node->op == op_SymConst)
819 && ( get_SymConst_kind(node) == type_tag
820 || get_SymConst_kind(node) == size));
821 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
825 set_SymConst_type (ir_node *node, type *type) {
826 assert ( (node->op == op_SymConst)
827 && ( get_SymConst_kind(node) == type_tag
828 || get_SymConst_kind(node) == size));
829 node->attr.i.tori.typ = type;
833 get_SymConst_ptrinfo (ir_node *node) {
834 assert ( (node->op == op_SymConst)
835 && (get_SymConst_kind(node) == linkage_ptr_info));
836 return node->attr.i.tori.ptrinfo;
840 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
841 assert ( (node->op == op_SymConst)
842 && (get_SymConst_kind(node) == linkage_ptr_info));
843 node->attr.i.tori.ptrinfo = ptrinfo;
847 get_SymConst_type_or_id (ir_node *node) {
848 assert (node->op == op_SymConst);
849 return &(node->attr.i.tori);
853 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
854 assert (node->op == op_SymConst);
855 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
859 get_Sel_mem (ir_node *node) {
860 assert (node->op == op_Sel);
861 return get_irn_n(node, 0);
865 set_Sel_mem (ir_node *node, ir_node *mem) {
866 assert (node->op == op_Sel);
867 set_irn_n(node, 0, mem);
871 get_Sel_ptr (ir_node *node) {
872 assert (node->op == op_Sel);
873 return get_irn_n(node, 1);
877 set_Sel_ptr (ir_node *node, ir_node *ptr) {
878 assert (node->op == op_Sel);
879 set_irn_n(node, 1, ptr);
883 get_Sel_index_arr (ir_node *node)
885 assert ((node->op == op_Sel));
886 if (get_Sel_n_index(node) > 0)
887 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
893 get_Sel_n_index (ir_node *node) {
894 assert (node->op == op_Sel);
895 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
900 set_Sel_n_index (ir_node *node, int n_index) {
901 assert (node->op == op_Sel);
906 get_Sel_index (ir_node *node, int pos) {
907 assert (node->op == op_Sel);
908 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
912 set_Sel_index (ir_node *node, int pos, ir_node *index) {
913 assert (node->op == op_Sel);
914 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
918 get_Sel_entity (ir_node *node) {
919 assert (node->op == op_Sel);
920 return node->attr.s.ent;
924 set_Sel_entity (ir_node *node, entity *ent) {
925 assert (node->op == op_Sel);
926 node->attr.s.ent = ent;
930 get_Sel_linkage_type (ir_node *node) {
931 assert (node->op == op_Sel);
932 return node->attr.s.ltyp;
936 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
937 assert (node->op == op_Sel);
938 node->attr.s.ltyp = lt;
942 get_InstOf_ent (ir_node *node) {
943 assert (node->op = op_InstOf);
944 return (node->attr.io.ent);
948 set_InstOf_ent (ir_node *node, type *ent) {
949 assert (node->op = op_InstOf);
950 node->attr.io.ent = ent;
954 get_InstOf_store (ir_node *node) {
955 assert (node->op = op_InstOf);
956 return (get_irn_n (node, 0));
960 set_InstOf_store (ir_node *node, ir_node *obj) {
961 assert (node->op = op_InstOf);
962 set_irn_n (node, 0, obj);
966 get_InstOf_obj (ir_node *node) {
967 assert (node->op = op_InstOf);
968 return (get_irn_n (node, 1));
972 set_InstOf_obj (ir_node *node, ir_node *obj) {
973 assert (node->op = op_InstOf);
974 set_irn_n (node, 1, obj);
978 get_Call_mem (ir_node *node) {
979 assert (node->op == op_Call);
980 return get_irn_n(node, 0);
984 set_Call_mem (ir_node *node, ir_node *mem) {
985 assert (node->op == op_Call);
986 set_irn_n(node, 0, mem);
990 get_Call_ptr (ir_node *node) {
991 assert (node->op == op_Call);
992 return get_irn_n(node, 1);
996 set_Call_ptr (ir_node *node, ir_node *ptr) {
997 assert (node->op == op_Call);
998 set_irn_n(node, 1, ptr);
1002 get_Call_param_arr (ir_node *node) {
1003 assert (node->op == op_Call);
1004 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1008 get_Call_n_params (ir_node *node) {
1009 assert (node->op == op_Call);
1010 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1014 get_Call_arity (ir_node *node) {
1015 assert (node->op == op_Call);
1016 return get_Call_n_params(node);
1020 set_Call_arity (ir_node *node, ir_node *arity) {
1021 assert (node->op == op_Call);
1026 get_Call_param (ir_node *node, int pos) {
1027 assert (node->op == op_Call);
1028 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1032 set_Call_param (ir_node *node, int pos, ir_node *param) {
1033 assert (node->op == op_Call);
1034 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1038 get_Call_type (ir_node *node) {
1039 assert (node->op == op_Call);
1040 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1044 set_Call_type (ir_node *node, type *type) {
1045 assert (node->op == op_Call);
1046 assert (is_method_type(type));
1047 node->attr.call.cld_tp = type;
1050 int get_Call_n_callees(ir_node * node) {
1051 assert(node->op == op_Call && node->attr.call.callee_arr);
1052 return ARR_LEN(node->attr.call.callee_arr);
1055 entity * get_Call_callee(ir_node * node, int pos) {
1056 assert(node->op == op_Call && node->attr.call.callee_arr);
1057 return node->attr.call.callee_arr[pos];
1060 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1061 assert(node->op == op_Call);
1062 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1063 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1065 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1068 void remove_Call_callee_arr(ir_node * node) {
1069 assert(node->op == op_Call);
1070 node->attr.call.callee_arr = NULL;
1073 /* For unary and binary arithmetic operations the access to the
1074 operands can be factored out. Left is the first, right the
1075 second arithmetic value as listed in tech report 0999-33.
1076 unops are: Minus, Abs, Not, Conv
1077 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1078 Shr, Shrs, Rotate, Cmp */
1081 is_unop (ir_node *node) {
1082 return ( node->op == op_Minus ||
1083 node->op == op_Abs ||
1084 node->op == op_Not ||
1085 node->op == op_Conv );
1089 get_unop_op (ir_node *node) {
1090 assert ( node->op == op_Minus ||
1091 node->op == op_Abs ||
1092 node->op == op_Not ||
1093 node->op == op_Conv );
1094 switch (get_irn_opcode (node)) {
1095 case iro_Minus: return get_Minus_op(node); break;
1096 case iro_Abs: return get_Abs_op(node); break;
1097 case iro_Not: return get_Not_op(node); break;
1098 case iro_Conv: return get_Conv_op(node); break;
1099 default: return NULL;
1104 set_unop_op (ir_node *node, ir_node *op) {
1105 assert (node->op == op_Minus ||
1106 node->op == op_Abs ||
1107 node->op == op_Not ||
1108 node->op == op_Conv );
1109 switch (get_irn_opcode (node)) {
1110 case iro_Minus: set_Minus_op(node, op); break;
1111 case iro_Abs: set_Abs_op(node, op); break;
1112 case iro_Not: set_Not_op(node, op); break;
1113 case iro_Conv: set_Conv_op(node, op); break;
1120 is_binop (ir_node *node) {
1121 return (node->op == op_Add ||
1122 node->op == op_Sub ||
1123 node->op == op_Mul ||
1124 node->op == op_Quot ||
1125 node->op == op_DivMod ||
1126 node->op == op_Div ||
1127 node->op == op_Mod ||
1128 node->op == op_And ||
1129 node->op == op_Or ||
1130 node->op == op_Eor ||
1131 node->op == op_Shl ||
1132 node->op == op_Shr ||
1133 node->op == op_Shrs ||
1134 node->op == op_Rot ||
1135 node->op == op_Cmp );
1139 get_binop_left (ir_node *node) {
1140 assert (node->op == op_Add ||
1141 node->op == op_Sub ||
1142 node->op == op_Mul ||
1143 node->op == op_Quot ||
1144 node->op == op_DivMod ||
1145 node->op == op_Div ||
1146 node->op == op_Mod ||
1147 node->op == op_And ||
1148 node->op == op_Or ||
1149 node->op == op_Eor ||
1150 node->op == op_Shl ||
1151 node->op == op_Shr ||
1152 node->op == op_Shrs ||
1153 node->op == op_Rot ||
1154 node->op == op_Cmp );
1156 switch (get_irn_opcode (node)) {
1157 case iro_Add : return get_Add_left(node); break;
1158 case iro_Sub : return get_Sub_left(node); break;
1159 case iro_Mul : return get_Mul_left(node); break;
1160 case iro_Quot : return get_Quot_left(node); break;
1161 case iro_DivMod: return get_DivMod_left(node); break;
1162 case iro_Div : return get_Div_left(node); break;
1163 case iro_Mod : return get_Mod_left(node); break;
1164 case iro_And : return get_And_left(node); break;
1165 case iro_Or : return get_Or_left(node); break;
1166 case iro_Eor : return get_Eor_left(node); break;
1167 case iro_Shl : return get_Shl_left(node); break;
1168 case iro_Shr : return get_Shr_left(node); break;
1169 case iro_Shrs : return get_Shrs_left(node); break;
1170 case iro_Rot : return get_Rot_left(node); break;
1171 case iro_Cmp : return get_Cmp_left(node); break;
1172 default: return NULL;
1177 set_binop_left (ir_node *node, ir_node *left) {
1178 assert (node->op == op_Add ||
1179 node->op == op_Sub ||
1180 node->op == op_Mul ||
1181 node->op == op_Quot ||
1182 node->op == op_DivMod ||
1183 node->op == op_Div ||
1184 node->op == op_Mod ||
1185 node->op == op_And ||
1186 node->op == op_Or ||
1187 node->op == op_Eor ||
1188 node->op == op_Shl ||
1189 node->op == op_Shr ||
1190 node->op == op_Shrs ||
1191 node->op == op_Rot ||
1192 node->op == op_Cmp );
1194 switch (get_irn_opcode (node)) {
1195 case iro_Add : set_Add_left(node, left); break;
1196 case iro_Sub : set_Sub_left(node, left); break;
1197 case iro_Mul : set_Mul_left(node, left); break;
1198 case iro_Quot : set_Quot_left(node, left); break;
1199 case iro_DivMod: set_DivMod_left(node, left); break;
1200 case iro_Div : set_Div_left(node, left); break;
1201 case iro_Mod : set_Mod_left(node, left); break;
1202 case iro_And : set_And_left(node, left); break;
1203 case iro_Or : set_Or_left(node, left); break;
1204 case iro_Eor : set_Eor_left(node, left); break;
1205 case iro_Shl : set_Shl_left(node, left); break;
1206 case iro_Shr : set_Shr_left(node, left); break;
1207 case iro_Shrs : set_Shrs_left(node, left); break;
1208 case iro_Rot : set_Rot_left(node, left); break;
1209 case iro_Cmp : set_Cmp_left(node, left); break;
1215 get_binop_right (ir_node *node) {
1216 assert (node->op == op_Add ||
1217 node->op == op_Sub ||
1218 node->op == op_Mul ||
1219 node->op == op_Quot ||
1220 node->op == op_DivMod ||
1221 node->op == op_Div ||
1222 node->op == op_Mod ||
1223 node->op == op_And ||
1224 node->op == op_Or ||
1225 node->op == op_Eor ||
1226 node->op == op_Shl ||
1227 node->op == op_Shr ||
1228 node->op == op_Shrs ||
1229 node->op == op_Rot ||
1230 node->op == op_Cmp );
1232 switch (get_irn_opcode (node)) {
1233 case iro_Add : return get_Add_right(node); break;
1234 case iro_Sub : return get_Sub_right(node); break;
1235 case iro_Mul : return get_Mul_right(node); break;
1236 case iro_Quot : return get_Quot_right(node); break;
1237 case iro_DivMod: return get_DivMod_right(node); break;
1238 case iro_Div : return get_Div_right(node); break;
1239 case iro_Mod : return get_Mod_right(node); break;
1240 case iro_And : return get_And_right(node); break;
1241 case iro_Or : return get_Or_right(node); break;
1242 case iro_Eor : return get_Eor_right(node); break;
1243 case iro_Shl : return get_Shl_right(node); break;
1244 case iro_Shr : return get_Shr_right(node); break;
1245 case iro_Shrs : return get_Shrs_right(node); break;
1246 case iro_Rot : return get_Rot_right(node); break;
1247 case iro_Cmp : return get_Cmp_right(node); break;
1248 default: return NULL;
1253 set_binop_right (ir_node *node, ir_node *right) {
1254 assert (node->op == op_Add ||
1255 node->op == op_Sub ||
1256 node->op == op_Mul ||
1257 node->op == op_Quot ||
1258 node->op == op_DivMod ||
1259 node->op == op_Div ||
1260 node->op == op_Mod ||
1261 node->op == op_And ||
1262 node->op == op_Or ||
1263 node->op == op_Eor ||
1264 node->op == op_Shl ||
1265 node->op == op_Shr ||
1266 node->op == op_Shrs ||
1267 node->op == op_Rot ||
1268 node->op == op_Cmp );
1270 switch (get_irn_opcode (node)) {
1271 case iro_Add : set_Add_right(node, right); break;
1272 case iro_Sub : set_Sub_right(node, right); break;
1273 case iro_Mul : set_Mul_right(node, right); break;
1274 case iro_Quot : set_Quot_right(node, right); break;
1275 case iro_DivMod: set_DivMod_right(node, right); break;
1276 case iro_Div : set_Div_right(node, right); break;
1277 case iro_Mod : set_Mod_right(node, right); break;
1278 case iro_And : set_And_right(node, right); break;
1279 case iro_Or : set_Or_right(node, right); break;
1280 case iro_Eor : set_Eor_right(node, right); break;
1281 case iro_Shl : set_Shl_right(node, right); break;
1282 case iro_Shr : set_Shr_right(node, right); break;
1283 case iro_Shrs : set_Shrs_right(node, right); break;
1284 case iro_Rot : set_Rot_right(node, right); break;
1285 case iro_Cmp : set_Cmp_right(node, right); break;
1291 get_Add_left (ir_node *node) {
1292 assert (node->op == op_Add);
1293 return get_irn_n(node, 0);
1297 set_Add_left (ir_node *node, ir_node *left) {
1298 assert (node->op == op_Add);
1299 set_irn_n(node, 0, left);
1303 get_Add_right (ir_node *node) {
1304 assert (node->op == op_Add);
1305 return get_irn_n(node, 1);
1309 set_Add_right (ir_node *node, ir_node *right) {
1310 assert (node->op == op_Add);
1311 set_irn_n(node, 1, right);
1315 get_Sub_left (ir_node *node) {
1316 assert (node->op == op_Sub);
1317 return get_irn_n(node, 0);
1321 set_Sub_left (ir_node *node, ir_node *left) {
1322 assert (node->op == op_Sub);
1323 set_irn_n(node, 0, left);
1327 get_Sub_right (ir_node *node) {
1328 assert (node->op == op_Sub);
1329 return get_irn_n(node, 1);
1333 set_Sub_right (ir_node *node, ir_node *right) {
1334 assert (node->op == op_Sub);
1335 set_irn_n(node, 1, right);
1340 get_Minus_op (ir_node *node) {
1341 assert (node->op == op_Minus);
1342 return get_irn_n(node, 0);
1346 set_Minus_op (ir_node *node, ir_node *op) {
1347 assert (node->op == op_Minus);
1348 set_irn_n(node, 0, op);
1353 get_Mul_left (ir_node *node) {
1354 assert (node->op == op_Mul);
1355 return get_irn_n(node, 0);
1359 set_Mul_left (ir_node *node, ir_node *left) {
1360 assert (node->op == op_Mul);
1361 set_irn_n(node, 0, left);
1365 get_Mul_right (ir_node *node) {
1366 assert (node->op == op_Mul);
1367 return get_irn_n(node, 1);
1371 set_Mul_right (ir_node *node, ir_node *right) {
1372 assert (node->op == op_Mul);
1373 set_irn_n(node, 1, right);
1377 get_Quot_left (ir_node *node) {
1378 assert (node->op == op_Quot);
1379 return get_irn_n(node, 1);
1383 set_Quot_left (ir_node *node, ir_node *left) {
1384 assert (node->op == op_Quot);
1385 set_irn_n(node, 1, left);
1389 get_Quot_right (ir_node *node) {
1390 assert (node->op == op_Quot);
1391 return get_irn_n(node, 2);
1395 set_Quot_right (ir_node *node, ir_node *right) {
1396 assert (node->op == op_Quot);
1397 set_irn_n(node, 2, right);
1401 get_Quot_mem (ir_node *node) {
1402 assert (node->op == op_Quot);
1403 return get_irn_n(node, 0);
1407 set_Quot_mem (ir_node *node, ir_node *mem) {
1408 assert (node->op == op_Quot);
1409 set_irn_n(node, 0, mem);
1413 get_DivMod_left (ir_node *node) {
1414 assert (node->op == op_DivMod);
1415 return get_irn_n(node, 1);
1419 set_DivMod_left (ir_node *node, ir_node *left) {
1420 assert (node->op == op_DivMod);
1421 set_irn_n(node, 1, left);
1425 get_DivMod_right (ir_node *node) {
1426 assert (node->op == op_DivMod);
1427 return get_irn_n(node, 2);
1431 set_DivMod_right (ir_node *node, ir_node *right) {
1432 assert (node->op == op_DivMod);
1433 set_irn_n(node, 2, right);
1437 get_DivMod_mem (ir_node *node) {
1438 assert (node->op == op_DivMod);
1439 return get_irn_n(node, 0);
1443 set_DivMod_mem (ir_node *node, ir_node *mem) {
1444 assert (node->op == op_DivMod);
1445 set_irn_n(node, 0, mem);
1449 get_Div_left (ir_node *node) {
1450 assert (node->op == op_Div);
1451 return get_irn_n(node, 1);
1455 set_Div_left (ir_node *node, ir_node *left) {
1456 assert (node->op == op_Div);
1457 set_irn_n(node, 1, left);
1461 get_Div_right (ir_node *node) {
1462 assert (node->op == op_Div);
1463 return get_irn_n(node, 2);
1467 set_Div_right (ir_node *node, ir_node *right) {
1468 assert (node->op == op_Div);
1469 set_irn_n(node, 2, right);
1473 get_Div_mem (ir_node *node) {
1474 assert (node->op == op_Div);
1475 return get_irn_n(node, 0);
1479 set_Div_mem (ir_node *node, ir_node *mem) {
1480 assert (node->op == op_Div);
1481 set_irn_n(node, 0, mem);
1485 get_Mod_left (ir_node *node) {
1486 assert (node->op == op_Mod);
1487 return get_irn_n(node, 1);
1491 set_Mod_left (ir_node *node, ir_node *left) {
1492 assert (node->op == op_Mod);
1493 set_irn_n(node, 1, left);
1497 get_Mod_right (ir_node *node) {
1498 assert (node->op == op_Mod);
1499 return get_irn_n(node, 2);
1503 set_Mod_right (ir_node *node, ir_node *right) {
1504 assert (node->op == op_Mod);
1505 set_irn_n(node, 2, right);
1509 get_Mod_mem (ir_node *node) {
1510 assert (node->op == op_Mod);
1511 return get_irn_n(node, 0);
1515 set_Mod_mem (ir_node *node, ir_node *mem) {
1516 assert (node->op == op_Mod);
1517 set_irn_n(node, 0, mem);
1521 get_Abs_op (ir_node *node) {
1522 assert (node->op == op_Abs);
1523 return get_irn_n(node, 0);
1527 set_Abs_op (ir_node *node, ir_node *op) {
1528 assert (node->op == op_Abs);
1529 set_irn_n(node, 0, op);
1533 get_And_left (ir_node *node) {
1534 assert (node->op == op_And);
1535 return get_irn_n(node, 0);
1539 set_And_left (ir_node *node, ir_node *left) {
1540 assert (node->op == op_And);
1541 set_irn_n(node, 0, left);
1545 get_And_right (ir_node *node) {
1546 assert (node->op == op_And);
1547 return get_irn_n(node, 1);
1551 set_And_right (ir_node *node, ir_node *right) {
1552 assert (node->op == op_And);
1553 set_irn_n(node, 1, right);
1557 get_Or_left (ir_node *node) {
1558 assert (node->op == op_Or);
1559 return get_irn_n(node, 0);
1563 set_Or_left (ir_node *node, ir_node *left) {
1564 assert (node->op == op_Or);
1565 set_irn_n(node, 0, left);
1569 get_Or_right (ir_node *node) {
1570 assert (node->op == op_Or);
1571 return get_irn_n(node, 1);
1575 set_Or_right (ir_node *node, ir_node *right) {
1576 assert (node->op == op_Or);
1577 set_irn_n(node, 1, right);
1581 get_Eor_left (ir_node *node) {
1582 assert (node->op == op_Eor);
1583 return get_irn_n(node, 0);
1587 set_Eor_left (ir_node *node, ir_node *left) {
1588 assert (node->op == op_Eor);
1589 set_irn_n(node, 0, left);
1593 get_Eor_right (ir_node *node) {
1594 assert (node->op == op_Eor);
1595 return get_irn_n(node, 1);
1599 set_Eor_right (ir_node *node, ir_node *right) {
1600 assert (node->op == op_Eor);
1601 set_irn_n(node, 1, right);
1606 get_Not_op (ir_node *node) {
1607 assert (node->op == op_Not);
1608 return get_irn_n(node, 0);
1612 set_Not_op (ir_node *node, ir_node *op) {
1613 assert (node->op == op_Not);
1614 set_irn_n(node, 0, op);
1619 get_Shl_left (ir_node *node) {
1620 assert (node->op == op_Shl);
1621 return get_irn_n(node, 0);
1625 set_Shl_left (ir_node *node, ir_node *left) {
1626 assert (node->op == op_Shl);
1627 set_irn_n(node, 0, left);
1631 get_Shl_right (ir_node *node) {
1632 assert (node->op == op_Shl);
1633 return get_irn_n(node, 1);
1637 set_Shl_right (ir_node *node, ir_node *right) {
1638 assert (node->op == op_Shl);
1639 set_irn_n(node, 1, right);
1643 get_Shr_left (ir_node *node) {
1644 assert (node->op == op_Shr);
1645 return get_irn_n(node, 0);
1649 set_Shr_left (ir_node *node, ir_node *left) {
1650 assert (node->op == op_Shr);
1651 set_irn_n(node, 0, left);
1655 get_Shr_right (ir_node *node) {
1656 assert (node->op == op_Shr);
1657 return get_irn_n(node, 1);
1661 set_Shr_right (ir_node *node, ir_node *right) {
1662 assert (node->op == op_Shr);
1663 set_irn_n(node, 1, right);
1667 get_Shrs_left (ir_node *node) {
1668 assert (node->op == op_Shrs);
1669 return get_irn_n(node, 0);
1673 set_Shrs_left (ir_node *node, ir_node *left) {
1674 assert (node->op == op_Shrs);
1675 set_irn_n(node, 0, left);
1679 get_Shrs_right (ir_node *node) {
1680 assert (node->op == op_Shrs);
1681 return get_irn_n(node, 1);
1685 set_Shrs_right (ir_node *node, ir_node *right) {
1686 assert (node->op == op_Shrs);
1687 set_irn_n(node, 1, right);
1691 get_Rot_left (ir_node *node) {
1692 assert (node->op == op_Rot);
1693 return get_irn_n(node, 0);
1697 set_Rot_left (ir_node *node, ir_node *left) {
1698 assert (node->op == op_Rot);
1699 set_irn_n(node, 0, left);
1703 get_Rot_right (ir_node *node) {
1704 assert (node->op == op_Rot);
1705 return get_irn_n(node, 1);
1709 set_Rot_right (ir_node *node, ir_node *right) {
1710 assert (node->op == op_Rot);
1711 set_irn_n(node, 1, right);
1715 get_Cmp_left (ir_node *node) {
1716 assert (node->op == op_Cmp);
1717 return get_irn_n(node, 0);
1721 set_Cmp_left (ir_node *node, ir_node *left) {
1722 assert (node->op == op_Cmp);
1723 set_irn_n(node, 0, left);
1727 get_Cmp_right (ir_node *node) {
1728 assert (node->op == op_Cmp);
1729 return get_irn_n(node, 1);
1733 set_Cmp_right (ir_node *node, ir_node *right) {
1734 assert (node->op == op_Cmp);
1735 set_irn_n(node, 1, right);
1739 get_Conv_op (ir_node *node) {
1740 assert (node->op == op_Conv);
1741 return get_irn_n(node, 0);
1745 set_Conv_op (ir_node *node, ir_node *op) {
1746 assert (node->op == op_Conv);
1747 set_irn_n(node, 0, op);
1751 get_Phi_preds_arr (ir_node *node) {
1752 assert (node->op == op_Phi);
1753 return (ir_node **)&(get_irn_in(node)[1]);
1757 get_Phi_n_preds (ir_node *node) {
1758 assert (node->op == op_Phi);
1759 return (get_irn_arity(node));
1763 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1764 assert (node->op == op_Phi);
1769 get_Phi_pred (ir_node *node, int pos) {
1770 assert (node->op == op_Phi);
1771 return get_irn_n(node, pos);
1775 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1776 assert (node->op == op_Phi);
1777 set_irn_n(node, pos, pred);
1781 get_Load_mem (ir_node *node) {
1782 assert (node->op == op_Load);
1783 return get_irn_n(node, 0);
1787 set_Load_mem (ir_node *node, ir_node *mem) {
1788 assert (node->op == op_Load);
1789 set_irn_n(node, 0, mem);
1793 get_Load_ptr (ir_node *node) {
1794 assert (node->op == op_Load);
1795 return get_irn_n(node, 1);
1799 set_Load_ptr (ir_node *node, ir_node *ptr) {
1800 assert (node->op == op_Load);
1801 set_irn_n(node, 1, ptr);
1806 get_Store_mem (ir_node *node) {
1807 assert (node->op == op_Store);
1808 return get_irn_n(node, 0);
1812 set_Store_mem (ir_node *node, ir_node *mem) {
1813 assert (node->op == op_Store);
1814 set_irn_n(node, 0, mem);
1818 get_Store_ptr (ir_node *node) {
1819 assert (node->op == op_Store);
1820 return get_irn_n(node, 1);
1824 set_Store_ptr (ir_node *node, ir_node *ptr) {
1825 assert (node->op == op_Store);
1826 set_irn_n(node, 1, ptr);
1830 get_Store_value (ir_node *node) {
1831 assert (node->op == op_Store);
1832 return get_irn_n(node, 2);
1836 set_Store_value (ir_node *node, ir_node *value) {
1837 assert (node->op == op_Store);
1838 set_irn_n(node, 2, value);
1842 get_Alloc_mem (ir_node *node) {
1843 assert (node->op == op_Alloc);
1844 return get_irn_n(node, 0);
1848 set_Alloc_mem (ir_node *node, ir_node *mem) {
1849 assert (node->op == op_Alloc);
1850 set_irn_n(node, 0, mem);
1854 get_Alloc_size (ir_node *node) {
1855 assert (node->op == op_Alloc);
1856 return get_irn_n(node, 1);
1860 set_Alloc_size (ir_node *node, ir_node *size) {
1861 assert (node->op == op_Alloc);
1862 set_irn_n(node, 1, size);
1866 get_Alloc_type (ir_node *node) {
1867 assert (node->op == op_Alloc);
1868 return node->attr.a.type = skip_tid(node->attr.a.type);
1872 set_Alloc_type (ir_node *node, type *type) {
1873 assert (node->op == op_Alloc);
1874 node->attr.a.type = type;
1878 get_Alloc_where (ir_node *node) {
1879 assert (node->op == op_Alloc);
1880 return node->attr.a.where;
1884 set_Alloc_where (ir_node *node, where_alloc where) {
1885 assert (node->op == op_Alloc);
1886 node->attr.a.where = where;
1891 get_Free_mem (ir_node *node) {
1892 assert (node->op == op_Free);
1893 return get_irn_n(node, 0);
1897 set_Free_mem (ir_node *node, ir_node *mem) {
1898 assert (node->op == op_Free);
1899 set_irn_n(node, 0, mem);
1903 get_Free_ptr (ir_node *node) {
1904 assert (node->op == op_Free);
1905 return get_irn_n(node, 1);
1909 set_Free_ptr (ir_node *node, ir_node *ptr) {
1910 assert (node->op == op_Free);
1911 set_irn_n(node, 1, ptr);
1915 get_Free_size (ir_node *node) {
1916 assert (node->op == op_Free);
1917 return get_irn_n(node, 2);
1921 set_Free_size (ir_node *node, ir_node *size) {
1922 assert (node->op == op_Free);
1923 set_irn_n(node, 2, size);
1927 get_Free_type (ir_node *node) {
1928 assert (node->op == op_Free);
1929 return node->attr.f = skip_tid(node->attr.f);
1933 set_Free_type (ir_node *node, type *type) {
1934 assert (node->op == op_Free);
1935 node->attr.f = type;
1939 get_Sync_preds_arr (ir_node *node) {
1940 assert (node->op == op_Sync);
1941 return (ir_node **)&(get_irn_in(node)[1]);
1945 get_Sync_n_preds (ir_node *node) {
1946 assert (node->op == op_Sync);
1947 return (get_irn_arity(node));
1952 set_Sync_n_preds (ir_node *node, int n_preds) {
1953 assert (node->op == op_Sync);
1958 get_Sync_pred (ir_node *node, int pos) {
1959 assert (node->op == op_Sync);
1960 return get_irn_n(node, pos);
1964 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1965 assert (node->op == op_Sync);
1966 set_irn_n(node, pos, pred);
1970 get_Proj_pred (ir_node *node) {
1971 assert (is_Proj(node));
1972 return get_irn_n(node, 0);
1976 set_Proj_pred (ir_node *node, ir_node *pred) {
1977 assert (is_Proj(node));
1978 set_irn_n(node, 0, pred);
1982 get_Proj_proj (ir_node *node) {
1983 assert (is_Proj(node));
1984 if (get_irn_opcode(node) == iro_Proj) {
1985 return node->attr.proj;
1987 assert(get_irn_opcode(node) == iro_Filter);
1988 return node->attr.filter.proj;
1993 set_Proj_proj (ir_node *node, long proj) {
1994 assert (node->op == op_Proj);
1995 node->attr.proj = proj;
1999 get_Tuple_preds_arr (ir_node *node) {
2000 assert (node->op == op_Tuple);
2001 return (ir_node **)&(get_irn_in(node)[1]);
2005 get_Tuple_n_preds (ir_node *node) {
2006 assert (node->op == op_Tuple);
2007 return (get_irn_arity(node));
2012 set_Tuple_n_preds (ir_node *node, int n_preds) {
2013 assert (node->op == op_Tuple);
2018 get_Tuple_pred (ir_node *node, int pos) {
2019 assert (node->op == op_Tuple);
2020 return get_irn_n(node, pos);
2024 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2025 assert (node->op == op_Tuple);
2026 set_irn_n(node, pos, pred);
2030 get_Id_pred (ir_node *node) {
2031 assert (node->op == op_Id);
2032 return get_irn_n(node, 0);
2036 set_Id_pred (ir_node *node, ir_node *pred) {
2037 assert (node->op == op_Id);
2038 set_irn_n(node, 0, pred);
2043 get_Filter_pred(ir_node *node) {
2044 assert(node->op == op_Filter);
2049 get_Filter_proj(ir_node *node) {
2050 assert(node->op == op_Filter);
2051 return node->attr.filter.proj;
2054 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2055 assert(node->op == op_Filter);
2056 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2057 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2058 node->attr.filter.in_cg[0] = node->in[0];
2060 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2063 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2064 assert(node->op == op_Filter && node->attr.filter.in_cg && 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2065 node->attr.filter.in_cg[pos + 1] = pred;
2070 get_irn_irg(ir_node *node) {
2071 if (get_irn_op(node) == op_CallBegin) {
2072 return node->attr.callbegin.irg;
2073 } else if (get_irn_op(node) == op_EndReg || get_irn_op(node) == op_EndExcept) {
2074 return node->attr.end.irg;
2076 assert(0 && "no irg attr");
2081 /******************************************************************/
2082 /* Auxiliary routines */
2083 /******************************************************************/
2086 skip_Proj (ir_node *node) {
2087 /* don't assert node !!! */
2088 if (node && is_Proj(node)) {
2089 return get_Proj_pred(node);
2096 skip_Tuple (ir_node *node) {
2099 node = skip_nop(node);
2100 if (get_irn_op(node) == op_Proj) {
2101 pred = skip_nop(get_Proj_pred(node));
2102 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2103 pred = skip_nop(skip_Tuple(pred));
2104 if (get_irn_op(pred) == op_Tuple)
2105 return get_Tuple_pred(pred, get_Proj_proj(node));
2111 skip_nop (ir_node *node) {
2112 /* don't assert node !!! */
2114 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
2115 /* Don't use get_Id_pred: We get into an endless loop for
2116 self-referencing Ids. */
2117 assert (get_irn_arity (node) > 0);
2118 return node->in[0+1];
2125 skip_Id (ir_node *node) {
2126 return skip_nop(node);
2130 is_Bad (ir_node *node) {
2132 if ((node) && get_irn_opcode(node) == iro_Bad)
2138 is_no_Block (ir_node *node) {
2140 return (get_irn_opcode(node) != iro_Block);
2144 is_Proj (ir_node *node) {
2146 return node->op == op_Proj
2147 || (!interprocedural_view && node->op == op_Filter);
2150 /* Returns true if the operation manipulates control flow. */
2152 is_cfop(ir_node *node) {
2153 return is_cfopcode(get_irn_op(node));
2156 /* Returns true if the operation can change the control flow because
2159 is_fragile_op(ir_node *node) {
2160 return ( (get_irn_opcode(node) == iro_Call)
2161 || (get_irn_opcode(node) == iro_Quot)
2162 || (get_irn_opcode(node) == iro_DivMod)
2163 || (get_irn_opcode(node) == iro_Div)
2164 || (get_irn_opcode(node) == iro_Mod)
2165 || (get_irn_opcode(node) == iro_Load)
2166 || (get_irn_opcode(node) == iro_Store)
2167 || (get_irn_opcode(node) == iro_Alloc)
2168 || (get_irn_opcode(node) == iro_Bad)
2169 || (get_irn_opcode(node) == iro_Unknown));
2173 /* Returns the memory operand of fragile operations. */
2174 ir_node *get_fragile_op_mem(ir_node *node) {
2175 assert(node && is_fragile_op(node));
2177 switch (get_irn_opcode (node)) {
2186 return get_irn_n(node, 0);
2191 assert(0 && "not reached");