3 * File name: ir/ir/irnode.c
4 * Purpose: Representation of an intermediate operation.
5 * Author: Martin Trapp, Christian Schaefer
6 * Modified by: Goetz Lindenmaier
9 * Copyright: (c) 1998-2003 Universität Karlsruhe
10 * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
20 #include "irgraph_t.h"
24 #include "irbackedge_t.h"
32 /* some constants fixing the positions of nodes predecessors
34 #define CALL_PARAM_OFFSET 2
35 #define SEL_INDEX_OFFSET 2
36 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
37 #define END_KEEPALIVE_OFFSET 0
39 /* Declarations for inlineing */
40 INLINE ir_node ** get_irn_in (const ir_node *node);
41 INLINE ir_mode *get_irn_mode (const ir_node *node);
42 INLINE ir_op *get_irn_op (const ir_node *node);
43 INLINE opcode get_irn_opcode (const ir_node *node);
44 INLINE ident *get_irn_opident (const ir_node *node);
45 INLINE type *get_SymConst_type (ir_node *node);
46 INLINE ir_node *skip_nop (ir_node *node);
47 INLINE int is_Proj (const ir_node *node);
50 static const char *pnc_name_arr [] = {
51 "False", "Eq", "Lt", "Le",
52 "Gt", "Ge", "Lg", "Leg", "Uo",
53 "Ue", "Ul", "Ule", "Ug", "Uge",
57 INLINE const char *get_pnc_string(int pnc) {
58 return pnc_name_arr[pnc];
63 get_negated_pnc(int pnc) {
65 case False: return True; break;
66 case Eq: return Ne; break;
67 case Lt: return Uge; break;
68 case Le: return Ug; break;
69 case Gt: return Ule; break;
70 case Ge: return Ul; break;
71 case Lg: return Ue; break;
72 case Leg: return Uo; break;
73 case Uo: return Leg; break;
74 case Ue: return Lg; break;
75 case Ul: return Ge; break;
76 case Ule: return Gt; break;
77 case Ug: return Le; break;
78 case Uge: return Lt; break;
79 case Ne: return Eq; break;
80 case True: return False; break;
82 return 99; /* to shut up gcc */
85 const char *pns_name_arr [] = {
86 "initial_exec", "global_store",
87 "frame_base", "globals", "args"
90 const char *symconst_name_arr [] = {
91 "type_tag", "size", "linkage_ptr_info"
99 /* irnode constructor */
100 /* create a new irnode in irg, with an op, mode, arity and */
101 /* some incoming irnodes */
102 /* this constructor is used in every specified irnode constructor */
104 new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
105 int arity, ir_node **in)
108 int node_size = offsetof (ir_node, attr) + op->attr_size;
110 res = (ir_node *) obstack_alloc (irg->obst, node_size);
112 res->kind = k_ir_node;
118 res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
120 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
121 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
124 set_irn_dbg_info(res, db);
128 res->node_nr = get_irp_new_node_nr();
134 /* Copies all attributes stored in the old node to the new node.
135 Assumes both have the same opcode and sufficient size. */
137 copy_attrs (ir_node *old, ir_node *new) {
138 assert (get_irn_op(old) == get_irn_op(new));
139 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
142 /** getting some parameters from ir_nodes **/
145 is_ir_node (void *thing) {
147 if (get_kind(thing) == k_ir_node)
153 /* returns the number of predecessors without the block predecessor. */
155 get_irn_intra_arity (const ir_node *node) {
157 return ARR_LEN(node->in) - 1;
160 /* returns the number of predecessors without the block predecessor. */
162 get_irn_inter_arity (const ir_node *node) {
164 if (get_irn_opcode(node) == iro_Filter) {
165 assert(node->attr.filter.in_cg);
166 return ARR_LEN(node->attr.filter.in_cg) - 1;
167 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
168 return ARR_LEN(node->attr.block.in_cg) - 1;
170 return get_irn_intra_arity(node);
173 /* returns the number of predecessors without the block predecessor. */
175 get_irn_arity (const ir_node *node) {
177 if (interprocedural_view) return get_irn_inter_arity(node);
178 return get_irn_intra_arity(node);
181 /* Returns the array with ins. This array is shifted with respect to the
182 array accessed by get_irn_n: The block operand is at position 0 not -1.
183 (@@@ This should be changed.)
184 The order of the predecessors in this array is not guaranteed, except that
185 lists of operands as predecessors of Block or arguments of a Call are
188 get_irn_in (const ir_node *node) {
190 if (interprocedural_view) { /* handle Filter and Block specially */
191 if (get_irn_opcode(node) == iro_Filter) {
192 assert(node->attr.filter.in_cg);
193 return node->attr.filter.in_cg;
194 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
195 return node->attr.block.in_cg;
197 /* else fall through */
203 set_irn_in (ir_node *node, int arity, ir_node **in) {
206 if (interprocedural_view) { /* handle Filter and Block specially */
207 if (get_irn_opcode(node) == iro_Filter) {
208 assert(node->attr.filter.in_cg);
209 arr = &node->attr.filter.in_cg;
210 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
211 arr = &node->attr.block.in_cg;
218 if (arity != ARR_LEN(*arr) - 1) {
219 ir_node * block = (*arr)[0];
220 *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
223 fix_backedges(current_ir_graph->obst, node);
224 memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
228 get_irn_intra_n (ir_node *node, int n) {
229 return (node->in[n + 1] = skip_nop(node->in[n + 1]));
233 get_irn_inter_n (ir_node *node, int n) {
234 /* handle Filter and Block specially */
235 if (get_irn_opcode(node) == iro_Filter) {
236 assert(node->attr.filter.in_cg);
237 return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
238 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
239 return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
242 return get_irn_intra_n (node, n);
245 /* to iterate through the predecessors without touching the array */
246 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
247 to iterate includind the Block predecessor iterate from i = -1 to
249 If it is a block, the entry -1 is NULL. */
251 get_irn_n (ir_node *node, int n) {
253 if (-1 > n || get_irn_arity(node) <= n) {
254 printf("pos: %d, arity: %d ", n, get_irn_arity(node));
257 assert(node); assert(-1 <= n && n < get_irn_arity(node));
258 if (interprocedural_view) return get_irn_inter_n (node, n);
259 return get_irn_intra_n (node, n);
264 set_irn_n (ir_node *node, int n, ir_node *in) {
265 assert(node && -1 <= n && n < get_irn_arity(node));
266 if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
267 /* Change block pred in both views! */
268 node->in[n + 1] = in;
269 assert(node->attr.filter.in_cg);
270 node->attr.filter.in_cg[n + 1] = in;
273 if (interprocedural_view) { /* handle Filter and Block specially */
274 if (get_irn_opcode(node) == iro_Filter) {
275 assert(node->attr.filter.in_cg);
276 node->attr.filter.in_cg[n + 1] = in;
278 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
279 node->attr.block.in_cg[n + 1] = in;
282 /* else fall through */
284 node->in[n + 1] = in;
288 get_irn_mode (const ir_node *node)
295 set_irn_mode (ir_node *node, ir_mode *mode)
303 get_irn_modecode (const ir_node *node)
306 return node->mode->code;
309 /** Gets the string representation of the mode .*/
311 get_irn_modename (const ir_node *node)
314 return get_mode_name(node->mode);
318 get_irn_modeident (const ir_node *node)
321 return get_mode_ident(node->mode);
325 get_irn_op (const ir_node *node)
331 /* should be private to the library: */
333 set_irn_op (ir_node *node, ir_op *op)
340 get_irn_opcode (const ir_node *node)
343 assert (k_ir_node == get_kind(node));
345 return node->op->code;
349 get_irn_opname (const ir_node *node)
352 return get_id_str(node->op->name);
356 get_irn_opident (const ir_node *node)
359 return node->op->name;
363 get_irn_visited (const ir_node *node)
366 return node->visited;
370 set_irn_visited (ir_node *node, unsigned long visited)
373 node->visited = visited;
377 mark_irn_visited (ir_node *node) {
379 node->visited = current_ir_graph->visited;
383 irn_not_visited (const ir_node *node) {
385 return (node->visited < current_ir_graph->visited);
389 irn_visited (const ir_node *node) {
391 return (node->visited >= current_ir_graph->visited);
395 set_irn_link (ir_node *node, void *link) {
397 /* Link field is used for Phi construction and various optimizations
399 assert(get_irg_phase_state(current_ir_graph) != phase_building);
405 get_irn_link (const ir_node *node) {
410 /* Outputs a unique number for this node */
412 get_irn_node_nr(const ir_node *node) {
415 return node->node_nr;
422 get_irn_const_attr (ir_node *node)
424 assert (node->op == op_Const);
425 return node->attr.con;
429 get_irn_proj_attr (ir_node *node)
431 assert (node->op == op_Proj);
432 return node->attr.proj;
436 get_irn_alloc_attr (ir_node *node)
438 assert (node->op == op_Alloc);
443 get_irn_free_attr (ir_node *node)
445 assert (node->op == op_Free);
446 return node->attr.f = skip_tid(node->attr.f);
450 get_irn_symconst_attr (ir_node *node)
452 assert (node->op == op_SymConst);
457 get_irn_call_attr (ir_node *node)
459 assert (node->op == op_Call);
460 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
464 get_irn_sel_attr (ir_node *node)
466 assert (node->op == op_Sel);
471 get_irn_phi_attr (ir_node *node)
473 assert (node->op == op_Phi);
474 return node->attr.phi0_pos;
478 get_irn_block_attr (ir_node *node)
480 assert (node->op == op_Block);
481 return node->attr.block;
484 /** manipulate fields of individual nodes **/
486 /* this works for all except Block */
488 get_nodes_Block (ir_node *node) {
489 assert (!(node->op == op_Block));
490 return get_irn_n(node, -1);
494 set_nodes_Block (ir_node *node, ir_node *block) {
495 assert (!(node->op == op_Block));
496 set_irn_n(node, -1, block);
499 /* Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
500 * from Start. If so returns frame type, else Null. */
501 type *is_frame_pointer(ir_node *n) {
502 if ((get_irn_op(n) == op_Proj) &&
503 (get_Proj_proj(n) == pn_Start_P_frame_base)) {
504 ir_node *start = get_Proj_pred(n);
505 if (get_irn_op(start) == op_Start) {
506 return get_irg_frame_type(get_irn_irg(start));
512 /* Test whether arbitrary node is globals pointer, i.e. Proj(pn_Start_P_globals)
513 * from Start. If so returns global type, else Null. */
514 type *is_globals_pointer(ir_node *n) {
515 if ((get_irn_op(n) == op_Proj) &&
516 (get_Proj_proj(n) == pn_Start_P_globals)) {
517 ir_node *start = get_Proj_pred(n);
518 if (get_irn_op(start) == op_Start) {
519 return get_glob_type();
525 /* Test whether arbitrary node is value arg base, i.e. Proj(pn_Start_P_value_arg_base)
526 * from Start. If so returns 1, else 0. */
527 int is_value_arg_pointer(ir_node *n) {
528 if ((get_irn_op(n) == op_Proj) &&
529 (get_Proj_proj(n) == pn_Start_P_value_arg_base) &&
530 (get_irn_op(get_Proj_pred(n)) == op_Start))
535 /* Returns an array with the predecessors of the Block. Depending on
536 the implementation of the graph datastructure this can be a copy of
537 the internal representation of predecessors as well as the internal
538 array itself. Therefore writing to this array might obstruct the ir. */
540 get_Block_cfgpred_arr (ir_node *node)
542 assert ((node->op == op_Block));
543 return (ir_node **)&(get_irn_in(node)[1]);
548 get_Block_n_cfgpreds (ir_node *node) {
549 assert ((node->op == op_Block));
550 return (get_irn_arity(node));
554 get_Block_cfgpred (ir_node *node, int pos) {
555 assert (node->op == op_Block);
557 if (-1 > pos || get_irn_arity(node) <= pos) {
558 dump_ir_block_graph(current_ir_graph);
559 printf("pos: %d, arity: %d ", pos, get_irn_arity(node));
562 assert(node); assert(-1 <= pos && pos < get_irn_arity(node));
563 return get_irn_n(node, pos);
567 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
568 assert (node->op == op_Block);
569 set_irn_n(node, pos, pred);
573 get_Block_matured (ir_node *node) {
574 assert (node->op == op_Block);
575 return node->attr.block.matured;
579 set_Block_matured (ir_node *node, bool matured) {
580 assert (node->op == op_Block);
581 node->attr.block.matured = matured;
584 get_Block_block_visited (ir_node *node) {
585 assert (node->op == op_Block);
586 return node->attr.block.block_visited;
590 set_Block_block_visited (ir_node *node, unsigned long visit) {
591 assert (node->op == op_Block);
592 node->attr.block.block_visited = visit;
595 /* For this current_ir_graph must be set. */
597 mark_Block_block_visited (ir_node *node) {
598 assert (node->op == op_Block);
599 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
603 Block_not_block_visited(ir_node *node) {
604 assert (node->op == op_Block);
605 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
609 get_Block_graph_arr (ir_node *node, int pos) {
610 assert (node->op == op_Block);
611 return node->attr.block.graph_arr[pos+1];
615 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
616 assert (node->op == op_Block);
617 node->attr.block.graph_arr[pos+1] = value;
620 /* handler handling for Blocks * /
622 set_Block_handler (ir_node *block, ir_node *handler) {
623 assert ((block->op == op_Block));
624 assert ((handler->op == op_Block));
625 block->attr.block.handler_entry = handler;
629 get_Block_handler (ir_node *block) {
630 assert ((block->op == op_Block));
631 return (block->attr.block.handler_entry);
634 / * handler handling for Nodes * /
636 set_Node_handler (ir_node *node, ir_node *handler) {
637 set_Block_handler (get_nodes_Block (node), handler);
641 get_Node_handler (ir_node *node) {
642 return (get_Block_handler (get_nodes_Block (node)));
645 / * exc_t handling for Blocks * /
646 void set_Block_exc (ir_node *block, exc_t exc) {
647 assert ((block->op == op_Block));
648 block->attr.block.exc = exc;
651 exc_t get_Block_exc (ir_node *block) {
652 assert ((block->op == op_Block));
653 return (block->attr.block.exc);
656 / * exc_t handling for Nodes * /
657 void set_Node_exc (ir_node *node, exc_t exc) {
658 set_Block_exc (get_nodes_Block (node), exc);
661 exc_t get_Node_exc (ir_node *node) {
662 return (get_Block_exc (get_nodes_Block (node)));
666 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
667 assert(node->op == op_Block);
668 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
669 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
670 node->attr.block.in_cg[0] = NULL;
671 node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
673 /* Fix backedge array. fix_backedges operates depending on
674 interprocedural_view. */
675 bool ipv = interprocedural_view;
676 interprocedural_view = true;
677 fix_backedges(current_ir_graph->obst, node);
678 interprocedural_view = ipv;
681 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
684 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
685 assert(node->op == op_Block &&
686 node->attr.block.in_cg &&
687 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
688 node->attr.block.in_cg[pos + 1] = pred;
691 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
692 assert(node->op == op_Block);
693 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
696 int get_Block_cg_n_cfgpreds(ir_node * node) {
697 assert(node->op == op_Block);
698 return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
701 ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
702 assert(node->op == op_Block && node->attr.block.in_cg);
703 return node->attr.block.in_cg[pos + 1];
706 void remove_Block_cg_cfgpred_arr(ir_node * node) {
707 assert(node->op == op_Block);
708 node->attr.block.in_cg = NULL;
711 /* Start references the irg it is in. */
713 get_Start_irg(ir_node *node) {
714 return get_irn_irg(node);
718 set_Start_irg(ir_node *node, ir_graph *irg) {
719 assert(node->op == op_Start);
720 assert(is_ir_graph(irg));
721 assert(0 && " Why set irg? ");
722 //node->attr.start.irg = irg;
726 get_End_n_keepalives(ir_node *end) {
727 assert (end->op == op_End);
728 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
732 get_End_keepalive(ir_node *end, int pos) {
733 assert (end->op == op_End);
734 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
738 add_End_keepalive (ir_node *end, ir_node *ka) {
739 assert (end->op == op_End);
740 ARR_APP1 (ir_node *, end->in, ka);
744 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
745 assert (end->op == op_End);
746 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
750 free_End (ir_node *end) {
751 assert (end->op == op_End);
753 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
754 end->in = NULL; /* @@@ make sure we get an error if we use the
755 in array afterwards ... */
758 ir_graph *get_EndReg_irg (ir_node *end) {
759 return get_irn_irg(end);
762 ir_graph *get_EndExcept_irg (ir_node *end) {
763 return get_irn_irg(end);
767 > Implementing the case construct (which is where the constant Proj node is
768 > important) involves far more than simply determining the constant values.
769 > We could argue that this is more properly a function of the translator from
770 > Firm to the target machine. That could be done if there was some way of
771 > projecting "default" out of the Cond node.
772 I know it's complicated.
773 Basically there are two proglems:
774 - determining the gaps between the projs
775 - determining the biggest case constant to konw the proj number for
777 I see several solutions:
778 1. Introduce a ProjDefault node. Solves both problems.
779 This means to extend all optimizations executed during construction.
780 2. Give the Cond node for switch two flavors:
781 a) there are no gaps in the projs (existing flavor)
782 b) gaps may exist, default proj is still the Proj with the largest
783 projection number. This covers also the gaps.
784 3. Fix the semantic of the Cond to that of 2b)
786 Solution 2 seems to be the best:
787 Computing the gaps in the Firm representation is not too hard, i.e.,
788 libfirm can implement a routine that transforms betweeen the two
789 flavours. This is also possible for 1) but 2) does not require to
790 change any existing optimization.
791 Further it should be far simpler to determine the biggest constant than
793 I don't want to choose 3) as 2a) seems to have advantages for
794 dataflow analysis and 3) does not allow to convert the representation to
798 get_Cond_selector (ir_node *node) {
799 assert (node->op == op_Cond);
800 return get_irn_n(node, 0);
804 set_Cond_selector (ir_node *node, ir_node *selector) {
805 assert (node->op == op_Cond);
806 set_irn_n(node, 0, selector);
810 get_Cond_kind (ir_node *node) {
811 assert (node->op == op_Cond);
812 return node->attr.c.kind;
816 set_Cond_kind (ir_node *node, cond_kind kind) {
817 assert (node->op == op_Cond);
818 node->attr.c.kind = kind;
822 get_Return_mem (ir_node *node) {
823 assert (node->op == op_Return);
824 return get_irn_n(node, 0);
828 set_Return_mem (ir_node *node, ir_node *mem) {
829 assert (node->op == op_Return);
830 set_irn_n(node, 0, mem);
834 get_Return_n_ress (ir_node *node) {
835 assert (node->op == op_Return);
836 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
840 get_Return_res_arr (ir_node *node)
842 assert ((node->op == op_Return));
843 if (get_Return_n_ress(node) > 0)
844 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
851 set_Return_n_res (ir_node *node, int results) {
852 assert (node->op == op_Return);
857 get_Return_res (ir_node *node, int pos) {
858 assert (node->op == op_Return);
859 assert (get_Return_n_ress(node) > pos);
860 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
864 set_Return_res (ir_node *node, int pos, ir_node *res){
865 assert (node->op == op_Return);
866 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
870 get_Raise_mem (ir_node *node) {
871 assert (node->op == op_Raise);
872 return get_irn_n(node, 0);
876 set_Raise_mem (ir_node *node, ir_node *mem) {
877 assert (node->op == op_Raise);
878 set_irn_n(node, 0, mem);
882 get_Raise_exo_ptr (ir_node *node) {
883 assert (node->op == op_Raise);
884 return get_irn_n(node, 1);
888 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
889 assert (node->op == op_Raise);
890 set_irn_n(node, 1, exo_ptr);
893 INLINE tarval *get_Const_tarval (ir_node *node) {
894 assert (node->op == op_Const);
895 return node->attr.con.tv;
899 set_Const_tarval (ir_node *node, tarval *con) {
900 assert (node->op == op_Const);
901 node->attr.con.tv = con;
905 /* The source language type. Must be an atomic type. Mode of type must
906 be mode of node. For tarvals from entities type must be pointer to
909 get_Const_type (ir_node *node) {
910 assert (node->op == op_Const);
911 return node->attr.con.tp;
915 set_Const_type (ir_node *node, type *tp) {
916 assert (node->op == op_Const);
917 if (tp != unknown_type) {
918 assert (is_atomic_type(tp));
919 assert (get_type_mode(tp) == get_irn_mode(node));
920 assert (!tarval_is_entity(get_Const_tarval(node)) ||
921 (is_pointer_type(tp) &&
922 (get_pointer_points_to_type(tp) ==
923 get_entity_type(get_tarval_entity(get_Const_tarval(node))))));
926 node->attr.con.tp = tp;
931 get_SymConst_kind (const ir_node *node) {
932 assert (node->op == op_SymConst);
933 return node->attr.i.num;
937 set_SymConst_kind (ir_node *node, symconst_kind num) {
938 assert (node->op == op_SymConst);
939 node->attr.i.num = num;
943 get_SymConst_type (ir_node *node) {
944 assert ( (node->op == op_SymConst)
945 && ( get_SymConst_kind(node) == type_tag
946 || get_SymConst_kind(node) == size));
947 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
951 set_SymConst_type (ir_node *node, type *tp) {
952 assert ( (node->op == op_SymConst)
953 && ( get_SymConst_kind(node) == type_tag
954 || get_SymConst_kind(node) == size));
955 node->attr.i.tori.typ = tp;
959 get_SymConst_ptrinfo (ir_node *node) {
960 assert ( (node->op == op_SymConst)
961 && (get_SymConst_kind(node) == linkage_ptr_info));
962 return node->attr.i.tori.ptrinfo;
966 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
967 assert ( (node->op == op_SymConst)
968 && (get_SymConst_kind(node) == linkage_ptr_info));
969 node->attr.i.tori.ptrinfo = ptrinfo;
973 get_SymConst_type_or_id (ir_node *node) {
974 assert (node->op == op_SymConst);
975 return &(node->attr.i.tori);
979 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
980 assert (node->op == op_SymConst);
981 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
985 get_Sel_mem (ir_node *node) {
986 assert (node->op == op_Sel);
987 return get_irn_n(node, 0);
991 set_Sel_mem (ir_node *node, ir_node *mem) {
992 assert (node->op == op_Sel);
993 set_irn_n(node, 0, mem);
997 get_Sel_ptr (ir_node *node) {
998 assert (node->op == op_Sel);
999 return get_irn_n(node, 1);
1003 set_Sel_ptr (ir_node *node, ir_node *ptr) {
1004 assert (node->op == op_Sel);
1005 set_irn_n(node, 1, ptr);
1009 get_Sel_n_indexs (ir_node *node) {
1010 assert (node->op == op_Sel);
1011 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
1015 get_Sel_index_arr (ir_node *node)
1017 assert ((node->op == op_Sel));
1018 if (get_Sel_n_indexs(node) > 0)
1019 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
1025 get_Sel_index (ir_node *node, int pos) {
1026 assert (node->op == op_Sel);
1027 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
1031 set_Sel_index (ir_node *node, int pos, ir_node *index) {
1032 assert (node->op == op_Sel);
1033 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
1037 get_Sel_entity (ir_node *node) {
1038 assert (node->op == op_Sel);
1039 return node->attr.s.ent;
1043 set_Sel_entity (ir_node *node, entity *ent) {
1044 assert (node->op == op_Sel);
1045 node->attr.s.ent = ent;
1049 get_InstOf_ent (ir_node *node) {
1050 assert (node->op = op_InstOf);
1051 return (node->attr.io.ent);
1055 set_InstOf_ent (ir_node *node, type *ent) {
1056 assert (node->op = op_InstOf);
1057 node->attr.io.ent = ent;
1061 get_InstOf_store (ir_node *node) {
1062 assert (node->op = op_InstOf);
1063 return (get_irn_n (node, 0));
1067 set_InstOf_store (ir_node *node, ir_node *obj) {
1068 assert (node->op = op_InstOf);
1069 set_irn_n (node, 0, obj);
1073 get_InstOf_obj (ir_node *node) {
1074 assert (node->op = op_InstOf);
1075 return (get_irn_n (node, 1));
1079 set_InstOf_obj (ir_node *node, ir_node *obj) {
1080 assert (node->op = op_InstOf);
1081 set_irn_n (node, 1, obj);
1085 /* For unary and binary arithmetic operations the access to the
1086 operands can be factored out. Left is the first, right the
1087 second arithmetic value as listed in tech report 0999-33.
1088 unops are: Minus, Abs, Not, Conv, Cast
1089 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1090 Shr, Shrs, Rotate, Cmp */
1094 get_Call_mem (ir_node *node) {
1095 assert (node->op == op_Call);
1096 return get_irn_n(node, 0);
1100 set_Call_mem (ir_node *node, ir_node *mem) {
1101 assert (node->op == op_Call);
1102 set_irn_n(node, 0, mem);
1106 get_Call_ptr (ir_node *node) {
1107 assert (node->op == op_Call);
1108 return get_irn_n(node, 1);
1112 set_Call_ptr (ir_node *node, ir_node *ptr) {
1113 assert (node->op == op_Call);
1114 set_irn_n(node, 1, ptr);
1118 get_Call_param_arr (ir_node *node) {
1119 assert (node->op == op_Call);
1120 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1124 get_Call_n_params (ir_node *node) {
1125 assert (node->op == op_Call);
1126 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1130 get_Call_arity (ir_node *node) {
1131 assert (node->op == op_Call);
1132 return get_Call_n_params(node);
1136 set_Call_arity (ir_node *node, ir_node *arity) {
1137 assert (node->op == op_Call);
1142 get_Call_param (ir_node *node, int pos) {
1143 assert (node->op == op_Call);
1144 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1148 set_Call_param (ir_node *node, int pos, ir_node *param) {
1149 assert (node->op == op_Call);
1150 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1154 get_Call_type (ir_node *node) {
1155 assert (node->op == op_Call);
1156 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1160 set_Call_type (ir_node *node, type *tp) {
1161 assert (node->op == op_Call);
1162 assert (is_method_type(tp));
1163 node->attr.call.cld_tp = tp;
1166 int Call_has_callees(ir_node *node) {
1167 return (node->attr.call.callee_arr != NULL);
1170 int get_Call_n_callees(ir_node * node) {
1171 assert(node->op == op_Call && node->attr.call.callee_arr);
1172 return ARR_LEN(node->attr.call.callee_arr);
1175 entity * get_Call_callee(ir_node * node, int pos) {
1176 assert(node->op == op_Call && node->attr.call.callee_arr);
1177 return node->attr.call.callee_arr[pos];
1180 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1181 assert(node->op == op_Call);
1182 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1183 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1185 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1188 void remove_Call_callee_arr(ir_node * node) {
1189 assert(node->op == op_Call);
1190 node->attr.call.callee_arr = NULL;
1193 ir_node * get_CallBegin_ptr (ir_node *node) {
1194 assert(node->op == op_CallBegin);
1195 return get_irn_n(node, 0);
1197 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1198 assert(node->op == op_CallBegin);
1199 set_irn_n(node, 0, ptr);
1201 ir_graph * get_CallBegin_irg (ir_node *node) {
1202 return get_irn_irg(node);
1204 ir_node * get_CallBegin_call (ir_node *node) {
1205 assert(node->op == op_CallBegin);
1206 return node->attr.callbegin.call;
1208 void set_CallBegin_call (ir_node *node, ir_node *call) {
1209 assert(node->op == op_CallBegin);
1210 node->attr.callbegin.call = call;
1214 get_Add_left (ir_node *node) {
1215 assert (node->op == op_Add);
1216 return get_irn_n(node, 0);
1220 set_Add_left (ir_node *node, ir_node *left) {
1221 assert (node->op == op_Add);
1222 set_irn_n(node, 0, left);
1226 get_Add_right (ir_node *node) {
1227 assert (node->op == op_Add);
1228 return get_irn_n(node, 1);
1232 set_Add_right (ir_node *node, ir_node *right) {
1233 assert (node->op == op_Add);
1234 set_irn_n(node, 1, right);
1238 get_Sub_left (ir_node *node) {
1239 assert (node->op == op_Sub);
1240 return get_irn_n(node, 0);
1244 set_Sub_left (ir_node *node, ir_node *left) {
1245 assert (node->op == op_Sub);
1246 set_irn_n(node, 0, left);
1250 get_Sub_right (ir_node *node) {
1251 assert (node->op == op_Sub);
1252 return get_irn_n(node, 1);
1256 set_Sub_right (ir_node *node, ir_node *right) {
1257 assert (node->op == op_Sub);
1258 set_irn_n(node, 1, right);
1263 get_Minus_op (ir_node *node) {
1264 assert (node->op == op_Minus);
1265 return get_irn_n(node, 0);
1269 set_Minus_op (ir_node *node, ir_node *op) {
1270 assert (node->op == op_Minus);
1271 set_irn_n(node, 0, op);
1276 get_Mul_left (ir_node *node) {
1277 assert (node->op == op_Mul);
1278 return get_irn_n(node, 0);
1282 set_Mul_left (ir_node *node, ir_node *left) {
1283 assert (node->op == op_Mul);
1284 set_irn_n(node, 0, left);
1288 get_Mul_right (ir_node *node) {
1289 assert (node->op == op_Mul);
1290 return get_irn_n(node, 1);
1294 set_Mul_right (ir_node *node, ir_node *right) {
1295 assert (node->op == op_Mul);
1296 set_irn_n(node, 1, right);
1300 get_Quot_left (ir_node *node) {
1301 assert (node->op == op_Quot);
1302 return get_irn_n(node, 1);
1306 set_Quot_left (ir_node *node, ir_node *left) {
1307 assert (node->op == op_Quot);
1308 set_irn_n(node, 1, left);
1312 get_Quot_right (ir_node *node) {
1313 assert (node->op == op_Quot);
1314 return get_irn_n(node, 2);
1318 set_Quot_right (ir_node *node, ir_node *right) {
1319 assert (node->op == op_Quot);
1320 set_irn_n(node, 2, right);
1324 get_Quot_mem (ir_node *node) {
1325 assert (node->op == op_Quot);
1326 return get_irn_n(node, 0);
1330 set_Quot_mem (ir_node *node, ir_node *mem) {
1331 assert (node->op == op_Quot);
1332 set_irn_n(node, 0, mem);
1336 get_DivMod_left (ir_node *node) {
1337 assert (node->op == op_DivMod);
1338 return get_irn_n(node, 1);
1342 set_DivMod_left (ir_node *node, ir_node *left) {
1343 assert (node->op == op_DivMod);
1344 set_irn_n(node, 1, left);
1348 get_DivMod_right (ir_node *node) {
1349 assert (node->op == op_DivMod);
1350 return get_irn_n(node, 2);
1354 set_DivMod_right (ir_node *node, ir_node *right) {
1355 assert (node->op == op_DivMod);
1356 set_irn_n(node, 2, right);
1360 get_DivMod_mem (ir_node *node) {
1361 assert (node->op == op_DivMod);
1362 return get_irn_n(node, 0);
1366 set_DivMod_mem (ir_node *node, ir_node *mem) {
1367 assert (node->op == op_DivMod);
1368 set_irn_n(node, 0, mem);
1372 get_Div_left (ir_node *node) {
1373 assert (node->op == op_Div);
1374 return get_irn_n(node, 1);
1378 set_Div_left (ir_node *node, ir_node *left) {
1379 assert (node->op == op_Div);
1380 set_irn_n(node, 1, left);
1384 get_Div_right (ir_node *node) {
1385 assert (node->op == op_Div);
1386 return get_irn_n(node, 2);
1390 set_Div_right (ir_node *node, ir_node *right) {
1391 assert (node->op == op_Div);
1392 set_irn_n(node, 2, right);
1396 get_Div_mem (ir_node *node) {
1397 assert (node->op == op_Div);
1398 return get_irn_n(node, 0);
1402 set_Div_mem (ir_node *node, ir_node *mem) {
1403 assert (node->op == op_Div);
1404 set_irn_n(node, 0, mem);
1408 get_Mod_left (ir_node *node) {
1409 assert (node->op == op_Mod);
1410 return get_irn_n(node, 1);
1414 set_Mod_left (ir_node *node, ir_node *left) {
1415 assert (node->op == op_Mod);
1416 set_irn_n(node, 1, left);
1420 get_Mod_right (ir_node *node) {
1421 assert (node->op == op_Mod);
1422 return get_irn_n(node, 2);
1426 set_Mod_right (ir_node *node, ir_node *right) {
1427 assert (node->op == op_Mod);
1428 set_irn_n(node, 2, right);
1432 get_Mod_mem (ir_node *node) {
1433 assert (node->op == op_Mod);
1434 return get_irn_n(node, 0);
1438 set_Mod_mem (ir_node *node, ir_node *mem) {
1439 assert (node->op == op_Mod);
1440 set_irn_n(node, 0, mem);
1444 get_Abs_op (ir_node *node) {
1445 assert (node->op == op_Abs);
1446 return get_irn_n(node, 0);
1450 set_Abs_op (ir_node *node, ir_node *op) {
1451 assert (node->op == op_Abs);
1452 set_irn_n(node, 0, op);
1456 get_And_left (ir_node *node) {
1457 assert (node->op == op_And);
1458 return get_irn_n(node, 0);
1462 set_And_left (ir_node *node, ir_node *left) {
1463 assert (node->op == op_And);
1464 set_irn_n(node, 0, left);
1468 get_And_right (ir_node *node) {
1469 assert (node->op == op_And);
1470 return get_irn_n(node, 1);
1474 set_And_right (ir_node *node, ir_node *right) {
1475 assert (node->op == op_And);
1476 set_irn_n(node, 1, right);
1480 get_Or_left (ir_node *node) {
1481 assert (node->op == op_Or);
1482 return get_irn_n(node, 0);
1486 set_Or_left (ir_node *node, ir_node *left) {
1487 assert (node->op == op_Or);
1488 set_irn_n(node, 0, left);
1492 get_Or_right (ir_node *node) {
1493 assert (node->op == op_Or);
1494 return get_irn_n(node, 1);
1498 set_Or_right (ir_node *node, ir_node *right) {
1499 assert (node->op == op_Or);
1500 set_irn_n(node, 1, right);
1504 get_Eor_left (ir_node *node) {
1505 assert (node->op == op_Eor);
1506 return get_irn_n(node, 0);
1510 set_Eor_left (ir_node *node, ir_node *left) {
1511 assert (node->op == op_Eor);
1512 set_irn_n(node, 0, left);
1516 get_Eor_right (ir_node *node) {
1517 assert (node->op == op_Eor);
1518 return get_irn_n(node, 1);
1522 set_Eor_right (ir_node *node, ir_node *right) {
1523 assert (node->op == op_Eor);
1524 set_irn_n(node, 1, right);
1529 get_Not_op (ir_node *node) {
1530 assert (node->op == op_Not);
1531 return get_irn_n(node, 0);
1535 set_Not_op (ir_node *node, ir_node *op) {
1536 assert (node->op == op_Not);
1537 set_irn_n(node, 0, op);
1542 get_Shl_left (ir_node *node) {
1543 assert (node->op == op_Shl);
1544 return get_irn_n(node, 0);
1548 set_Shl_left (ir_node *node, ir_node *left) {
1549 assert (node->op == op_Shl);
1550 set_irn_n(node, 0, left);
1554 get_Shl_right (ir_node *node) {
1555 assert (node->op == op_Shl);
1556 return get_irn_n(node, 1);
1560 set_Shl_right (ir_node *node, ir_node *right) {
1561 assert (node->op == op_Shl);
1562 set_irn_n(node, 1, right);
1566 get_Shr_left (ir_node *node) {
1567 assert (node->op == op_Shr);
1568 return get_irn_n(node, 0);
1572 set_Shr_left (ir_node *node, ir_node *left) {
1573 assert (node->op == op_Shr);
1574 set_irn_n(node, 0, left);
1578 get_Shr_right (ir_node *node) {
1579 assert (node->op == op_Shr);
1580 return get_irn_n(node, 1);
1584 set_Shr_right (ir_node *node, ir_node *right) {
1585 assert (node->op == op_Shr);
1586 set_irn_n(node, 1, right);
1590 get_Shrs_left (ir_node *node) {
1591 assert (node->op == op_Shrs);
1592 return get_irn_n(node, 0);
1596 set_Shrs_left (ir_node *node, ir_node *left) {
1597 assert (node->op == op_Shrs);
1598 set_irn_n(node, 0, left);
1602 get_Shrs_right (ir_node *node) {
1603 assert (node->op == op_Shrs);
1604 return get_irn_n(node, 1);
1608 set_Shrs_right (ir_node *node, ir_node *right) {
1609 assert (node->op == op_Shrs);
1610 set_irn_n(node, 1, right);
1614 get_Rot_left (ir_node *node) {
1615 assert (node->op == op_Rot);
1616 return get_irn_n(node, 0);
1620 set_Rot_left (ir_node *node, ir_node *left) {
1621 assert (node->op == op_Rot);
1622 set_irn_n(node, 0, left);
1626 get_Rot_right (ir_node *node) {
1627 assert (node->op == op_Rot);
1628 return get_irn_n(node, 1);
1632 set_Rot_right (ir_node *node, ir_node *right) {
1633 assert (node->op == op_Rot);
1634 set_irn_n(node, 1, right);
1638 get_Cmp_left (ir_node *node) {
1639 assert (node->op == op_Cmp);
1640 return get_irn_n(node, 0);
1644 set_Cmp_left (ir_node *node, ir_node *left) {
1645 assert (node->op == op_Cmp);
1646 set_irn_n(node, 0, left);
1650 get_Cmp_right (ir_node *node) {
1651 assert (node->op == op_Cmp);
1652 return get_irn_n(node, 1);
1656 set_Cmp_right (ir_node *node, ir_node *right) {
1657 assert (node->op == op_Cmp);
1658 set_irn_n(node, 1, right);
1662 get_Conv_op (ir_node *node) {
1663 assert (node->op == op_Conv);
1664 return get_irn_n(node, 0);
1668 set_Conv_op (ir_node *node, ir_node *op) {
1669 assert (node->op == op_Conv);
1670 set_irn_n(node, 0, op);
1674 get_Cast_op (ir_node *node) {
1675 assert (node->op == op_Cast);
1676 return get_irn_n(node, 0);
1680 set_Cast_op (ir_node *node, ir_node *op) {
1681 assert (node->op == op_Cast);
1682 set_irn_n(node, 0, op);
1686 get_Cast_type (ir_node *node) {
1687 assert (node->op == op_Cast);
1688 return node->attr.cast.totype;
1692 set_Cast_type (ir_node *node, type *to_tp) {
1693 assert (node->op == op_Cast);
1694 node->attr.cast.totype = to_tp;
1698 is_unop (ir_node *node) {
1699 return ( node->op == op_Minus ||
1700 node->op == op_Abs ||
1701 node->op == op_Not ||
1702 node->op == op_Conv ||
1703 node->op == op_Cast );
1707 get_unop_op (ir_node *node) {
1708 assert (is_unop(node));
1709 switch (get_irn_opcode (node)) {
1710 case iro_Minus: return get_Minus_op(node); break;
1711 case iro_Abs: return get_Abs_op(node); break;
1712 case iro_Not: return get_Not_op(node); break;
1713 case iro_Conv: return get_Conv_op(node); break;
1714 case iro_Cast: return get_Cast_op(node); break;
1715 default: return NULL;
1720 set_unop_op (ir_node *node, ir_node *op) {
1721 assert (is_unop(node));
1722 switch (get_irn_opcode (node)) {
1723 case iro_Minus: set_Minus_op(node, op); break;
1724 case iro_Abs: set_Abs_op(node, op); break;
1725 case iro_Not: set_Not_op(node, op); break;
1726 case iro_Conv: set_Conv_op(node, op); break;
1727 case iro_Cast: set_Cast_op(node, op); break;
1734 is_binop (ir_node *node) {
1735 return (node->op == op_Add ||
1736 node->op == op_Sub ||
1737 node->op == op_Mul ||
1738 node->op == op_Quot ||
1739 node->op == op_DivMod ||
1740 node->op == op_Div ||
1741 node->op == op_Mod ||
1742 node->op == op_And ||
1743 node->op == op_Or ||
1744 node->op == op_Eor ||
1745 node->op == op_Shl ||
1746 node->op == op_Shr ||
1747 node->op == op_Shrs ||
1748 node->op == op_Rot ||
1749 node->op == op_Cmp );
1753 get_binop_left (ir_node *node) {
1754 assert (node->op == op_Add ||
1755 node->op == op_Sub ||
1756 node->op == op_Mul ||
1757 node->op == op_Quot ||
1758 node->op == op_DivMod ||
1759 node->op == op_Div ||
1760 node->op == op_Mod ||
1761 node->op == op_And ||
1762 node->op == op_Or ||
1763 node->op == op_Eor ||
1764 node->op == op_Shl ||
1765 node->op == op_Shr ||
1766 node->op == op_Shrs ||
1767 node->op == op_Rot ||
1768 node->op == op_Cmp );
1770 switch (get_irn_opcode (node)) {
1771 case iro_Add : return get_Add_left(node); break;
1772 case iro_Sub : return get_Sub_left(node); break;
1773 case iro_Mul : return get_Mul_left(node); break;
1774 case iro_Quot : return get_Quot_left(node); break;
1775 case iro_DivMod: return get_DivMod_left(node); break;
1776 case iro_Div : return get_Div_left(node); break;
1777 case iro_Mod : return get_Mod_left(node); break;
1778 case iro_And : return get_And_left(node); break;
1779 case iro_Or : return get_Or_left(node); break;
1780 case iro_Eor : return get_Eor_left(node); break;
1781 case iro_Shl : return get_Shl_left(node); break;
1782 case iro_Shr : return get_Shr_left(node); break;
1783 case iro_Shrs : return get_Shrs_left(node); break;
1784 case iro_Rot : return get_Rot_left(node); break;
1785 case iro_Cmp : return get_Cmp_left(node); break;
1786 default: return NULL;
1791 set_binop_left (ir_node *node, ir_node *left) {
1792 assert (node->op == op_Add ||
1793 node->op == op_Sub ||
1794 node->op == op_Mul ||
1795 node->op == op_Quot ||
1796 node->op == op_DivMod ||
1797 node->op == op_Div ||
1798 node->op == op_Mod ||
1799 node->op == op_And ||
1800 node->op == op_Or ||
1801 node->op == op_Eor ||
1802 node->op == op_Shl ||
1803 node->op == op_Shr ||
1804 node->op == op_Shrs ||
1805 node->op == op_Rot ||
1806 node->op == op_Cmp );
1808 switch (get_irn_opcode (node)) {
1809 case iro_Add : set_Add_left(node, left); break;
1810 case iro_Sub : set_Sub_left(node, left); break;
1811 case iro_Mul : set_Mul_left(node, left); break;
1812 case iro_Quot : set_Quot_left(node, left); break;
1813 case iro_DivMod: set_DivMod_left(node, left); break;
1814 case iro_Div : set_Div_left(node, left); break;
1815 case iro_Mod : set_Mod_left(node, left); break;
1816 case iro_And : set_And_left(node, left); break;
1817 case iro_Or : set_Or_left(node, left); break;
1818 case iro_Eor : set_Eor_left(node, left); break;
1819 case iro_Shl : set_Shl_left(node, left); break;
1820 case iro_Shr : set_Shr_left(node, left); break;
1821 case iro_Shrs : set_Shrs_left(node, left); break;
1822 case iro_Rot : set_Rot_left(node, left); break;
1823 case iro_Cmp : set_Cmp_left(node, left); break;
1829 get_binop_right (ir_node *node) {
1830 assert (node->op == op_Add ||
1831 node->op == op_Sub ||
1832 node->op == op_Mul ||
1833 node->op == op_Quot ||
1834 node->op == op_DivMod ||
1835 node->op == op_Div ||
1836 node->op == op_Mod ||
1837 node->op == op_And ||
1838 node->op == op_Or ||
1839 node->op == op_Eor ||
1840 node->op == op_Shl ||
1841 node->op == op_Shr ||
1842 node->op == op_Shrs ||
1843 node->op == op_Rot ||
1844 node->op == op_Cmp );
1846 switch (get_irn_opcode (node)) {
1847 case iro_Add : return get_Add_right(node); break;
1848 case iro_Sub : return get_Sub_right(node); break;
1849 case iro_Mul : return get_Mul_right(node); break;
1850 case iro_Quot : return get_Quot_right(node); break;
1851 case iro_DivMod: return get_DivMod_right(node); break;
1852 case iro_Div : return get_Div_right(node); break;
1853 case iro_Mod : return get_Mod_right(node); break;
1854 case iro_And : return get_And_right(node); break;
1855 case iro_Or : return get_Or_right(node); break;
1856 case iro_Eor : return get_Eor_right(node); break;
1857 case iro_Shl : return get_Shl_right(node); break;
1858 case iro_Shr : return get_Shr_right(node); break;
1859 case iro_Shrs : return get_Shrs_right(node); break;
1860 case iro_Rot : return get_Rot_right(node); break;
1861 case iro_Cmp : return get_Cmp_right(node); break;
1862 default: return NULL;
1867 set_binop_right (ir_node *node, ir_node *right) {
1868 assert (node->op == op_Add ||
1869 node->op == op_Sub ||
1870 node->op == op_Mul ||
1871 node->op == op_Quot ||
1872 node->op == op_DivMod ||
1873 node->op == op_Div ||
1874 node->op == op_Mod ||
1875 node->op == op_And ||
1876 node->op == op_Or ||
1877 node->op == op_Eor ||
1878 node->op == op_Shl ||
1879 node->op == op_Shr ||
1880 node->op == op_Shrs ||
1881 node->op == op_Rot ||
1882 node->op == op_Cmp );
1884 switch (get_irn_opcode (node)) {
1885 case iro_Add : set_Add_right(node, right); break;
1886 case iro_Sub : set_Sub_right(node, right); break;
1887 case iro_Mul : set_Mul_right(node, right); break;
1888 case iro_Quot : set_Quot_right(node, right); break;
1889 case iro_DivMod: set_DivMod_right(node, right); break;
1890 case iro_Div : set_Div_right(node, right); break;
1891 case iro_Mod : set_Mod_right(node, right); break;
1892 case iro_And : set_And_right(node, right); break;
1893 case iro_Or : set_Or_right(node, right); break;
1894 case iro_Eor : set_Eor_right(node, right); break;
1895 case iro_Shl : set_Shl_right(node, right); break;
1896 case iro_Shr : set_Shr_right(node, right); break;
1897 case iro_Shrs : set_Shrs_right(node, right); break;
1898 case iro_Rot : set_Rot_right(node, right); break;
1899 case iro_Cmp : set_Cmp_right(node, right); break;
1904 INLINE int is_Phi (ir_node *n) {
1906 return ((get_irn_op(n) == op_Phi) ||
1907 (get_irn_op(n) == op_Filter && interprocedural_view));
1911 get_Phi_preds_arr (ir_node *node) {
1912 assert (node->op == op_Phi);
1913 return (ir_node **)&(get_irn_in(node)[1]);
1917 get_Phi_n_preds (ir_node *node) {
1918 assert (is_Phi(node));
1919 return (get_irn_arity(node));
1923 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1924 assert (node->op == op_Phi);
1929 get_Phi_pred (ir_node *node, int pos) {
1930 assert (is_Phi(node));
1931 return get_irn_n(node, pos);
1935 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1936 assert (is_Phi(node));
1937 set_irn_n(node, pos, pred);
1941 get_Load_mem (ir_node *node) {
1942 assert (node->op == op_Load);
1943 return get_irn_n(node, 0);
1947 set_Load_mem (ir_node *node, ir_node *mem) {
1948 assert (node->op == op_Load);
1949 set_irn_n(node, 0, mem);
1953 get_Load_ptr (ir_node *node) {
1954 assert (node->op == op_Load);
1955 return get_irn_n(node, 1);
1959 set_Load_ptr (ir_node *node, ir_node *ptr) {
1960 assert (node->op == op_Load);
1961 set_irn_n(node, 1, ptr);
1966 get_Store_mem (ir_node *node) {
1967 assert (node->op == op_Store);
1968 return get_irn_n(node, 0);
1972 set_Store_mem (ir_node *node, ir_node *mem) {
1973 assert (node->op == op_Store);
1974 set_irn_n(node, 0, mem);
1978 get_Store_ptr (ir_node *node) {
1979 assert (node->op == op_Store);
1980 return get_irn_n(node, 1);
1984 set_Store_ptr (ir_node *node, ir_node *ptr) {
1985 assert (node->op == op_Store);
1986 set_irn_n(node, 1, ptr);
1990 get_Store_value (ir_node *node) {
1991 assert (node->op == op_Store);
1992 return get_irn_n(node, 2);
1996 set_Store_value (ir_node *node, ir_node *value) {
1997 assert (node->op == op_Store);
1998 set_irn_n(node, 2, value);
2002 get_Alloc_mem (ir_node *node) {
2003 assert (node->op == op_Alloc);
2004 return get_irn_n(node, 0);
2008 set_Alloc_mem (ir_node *node, ir_node *mem) {
2009 assert (node->op == op_Alloc);
2010 set_irn_n(node, 0, mem);
2014 get_Alloc_size (ir_node *node) {
2015 assert (node->op == op_Alloc);
2016 return get_irn_n(node, 1);
2020 set_Alloc_size (ir_node *node, ir_node *size) {
2021 assert (node->op == op_Alloc);
2022 set_irn_n(node, 1, size);
2026 get_Alloc_type (ir_node *node) {
2027 assert (node->op == op_Alloc);
2028 return node->attr.a.type = skip_tid(node->attr.a.type);
2032 set_Alloc_type (ir_node *node, type *tp) {
2033 assert (node->op == op_Alloc);
2034 node->attr.a.type = tp;
2038 get_Alloc_where (ir_node *node) {
2039 assert (node->op == op_Alloc);
2040 return node->attr.a.where;
2044 set_Alloc_where (ir_node *node, where_alloc where) {
2045 assert (node->op == op_Alloc);
2046 node->attr.a.where = where;
2051 get_Free_mem (ir_node *node) {
2052 assert (node->op == op_Free);
2053 return get_irn_n(node, 0);
2057 set_Free_mem (ir_node *node, ir_node *mem) {
2058 assert (node->op == op_Free);
2059 set_irn_n(node, 0, mem);
2063 get_Free_ptr (ir_node *node) {
2064 assert (node->op == op_Free);
2065 return get_irn_n(node, 1);
2069 set_Free_ptr (ir_node *node, ir_node *ptr) {
2070 assert (node->op == op_Free);
2071 set_irn_n(node, 1, ptr);
2075 get_Free_size (ir_node *node) {
2076 assert (node->op == op_Free);
2077 return get_irn_n(node, 2);
2081 set_Free_size (ir_node *node, ir_node *size) {
2082 assert (node->op == op_Free);
2083 set_irn_n(node, 2, size);
2087 get_Free_type (ir_node *node) {
2088 assert (node->op == op_Free);
2089 return node->attr.f = skip_tid(node->attr.f);
2093 set_Free_type (ir_node *node, type *tp) {
2094 assert (node->op == op_Free);
2099 get_Sync_preds_arr (ir_node *node) {
2100 assert (node->op == op_Sync);
2101 return (ir_node **)&(get_irn_in(node)[1]);
2105 get_Sync_n_preds (ir_node *node) {
2106 assert (node->op == op_Sync);
2107 return (get_irn_arity(node));
2112 set_Sync_n_preds (ir_node *node, int n_preds) {
2113 assert (node->op == op_Sync);
2118 get_Sync_pred (ir_node *node, int pos) {
2119 assert (node->op == op_Sync);
2120 return get_irn_n(node, pos);
2124 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
2125 assert (node->op == op_Sync);
2126 set_irn_n(node, pos, pred);
2130 get_Proj_pred (ir_node *node) {
2131 assert (is_Proj(node));
2132 return get_irn_n(node, 0);
2136 set_Proj_pred (ir_node *node, ir_node *pred) {
2137 assert (is_Proj(node));
2138 set_irn_n(node, 0, pred);
2142 get_Proj_proj (ir_node *node) {
2143 assert (is_Proj(node));
2144 if (get_irn_opcode(node) == iro_Proj) {
2145 return node->attr.proj;
2147 assert(get_irn_opcode(node) == iro_Filter);
2148 return node->attr.filter.proj;
2153 set_Proj_proj (ir_node *node, long proj) {
2154 assert (node->op == op_Proj);
2155 node->attr.proj = proj;
2159 get_Tuple_preds_arr (ir_node *node) {
2160 assert (node->op == op_Tuple);
2161 return (ir_node **)&(get_irn_in(node)[1]);
2165 get_Tuple_n_preds (ir_node *node) {
2166 assert (node->op == op_Tuple);
2167 return (get_irn_arity(node));
2172 set_Tuple_n_preds (ir_node *node, int n_preds) {
2173 assert (node->op == op_Tuple);
2178 get_Tuple_pred (ir_node *node, int pos) {
2179 assert (node->op == op_Tuple);
2180 return get_irn_n(node, pos);
2184 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2185 assert (node->op == op_Tuple);
2186 set_irn_n(node, pos, pred);
2190 get_Id_pred (ir_node *node) {
2191 assert (node->op == op_Id);
2192 return get_irn_n(node, 0);
2196 set_Id_pred (ir_node *node, ir_node *pred) {
2197 assert (node->op == op_Id);
2198 set_irn_n(node, 0, pred);
2201 INLINE ir_node *get_Confirm_value (ir_node *node) {
2202 assert (node->op == op_Confirm);
2203 return get_irn_n(node, 0);
2205 INLINE void set_Confirm_value (ir_node *node, ir_node *value) {
2206 assert (node->op == op_Confirm);
2207 set_irn_n(node, 0, value);
2209 INLINE ir_node *get_Confirm_bound (ir_node *node) {
2210 assert (node->op == op_Confirm);
2211 return get_irn_n(node, 1);
2213 INLINE void set_Confirm_bound (ir_node *node, ir_node *bound) {
2214 assert (node->op == op_Confirm);
2215 set_irn_n(node, 0, bound);
2217 INLINE pn_Cmp get_Confirm_cmp (ir_node *node) {
2218 assert (node->op == op_Confirm);
2219 return node->attr.confirm_cmp;
2221 INLINE void set_Confirm_cmp (ir_node *node, pn_Cmp cmp) {
2222 assert (node->op == op_Confirm);
2223 node->attr.confirm_cmp = cmp;
2228 get_Filter_pred (ir_node *node) {
2229 assert(node->op == op_Filter);
2233 set_Filter_pred (ir_node *node, ir_node *pred) {
2234 assert(node->op == op_Filter);
2238 get_Filter_proj(ir_node *node) {
2239 assert(node->op == op_Filter);
2240 return node->attr.filter.proj;
2243 set_Filter_proj (ir_node *node, long proj) {
2244 assert(node->op == op_Filter);
2245 node->attr.filter.proj = proj;
2248 /* Don't use get_irn_arity, get_irn_n in implementation as access
2249 shall work independent of view!!! */
2250 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2251 assert(node->op == op_Filter);
2252 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2253 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2254 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2255 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2256 node->attr.filter.in_cg[0] = node->in[0];
2258 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2261 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2262 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2263 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2264 node->attr.filter.in_cg[pos + 1] = pred;
2266 int get_Filter_n_cg_preds(ir_node *node) {
2267 assert(node->op == op_Filter && node->attr.filter.in_cg);
2268 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2270 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2272 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2274 arity = ARR_LEN(node->attr.filter.in_cg);
2275 assert(pos < arity - 1);
2276 return node->attr.filter.in_cg[pos + 1];
2281 get_irn_irg(ir_node *node) {
2282 if (get_irn_op(node) != op_Block)
2283 node = get_nodes_block(node);
2284 assert(get_irn_op(node) == op_Block);
2285 return node->attr.block.irg;
2289 /******************************************************************/
2290 /* Auxiliary routines */
2291 /******************************************************************/
2294 skip_Proj (ir_node *node) {
2295 /* don't assert node !!! */
2296 if (node && is_Proj(node)) {
2297 return get_Proj_pred(node);
2304 skip_Tuple (ir_node *node) {
2307 if (!get_opt_normalize()) return node;
2309 node = skip_nop(node);
2310 if (get_irn_op(node) == op_Proj) {
2311 pred = skip_nop(get_Proj_pred(node));
2312 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2313 pred = skip_nop(skip_Tuple(pred));
2314 if (get_irn_op(pred) == op_Tuple)
2315 return get_Tuple_pred(pred, get_Proj_proj(node));
2320 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2321 than any other approach, as Id chains are resolved and all point to the real node, or
2322 all id's are self loops. */
2324 skip_nop (ir_node *node) {
2325 /* don't assert node !!! */
2327 if (!get_opt_normalize()) return node;
2329 /* Don't use get_Id_pred: We get into an endless loop for
2330 self-referencing Ids. */
2331 if (node && (node->op == op_Id) && (node != node->in[0+1])) {
2332 ir_node *rem_pred = node->in[0+1];
2335 assert (get_irn_arity (node) > 0);
2337 node->in[0+1] = node;
2338 res = skip_nop(rem_pred);
2339 if (res->op == op_Id) /* self-loop */ return node;
2341 node->in[0+1] = res;
2349 skip_Id (ir_node *node) {
2350 return skip_nop(node);
2354 is_Bad (ir_node *node) {
2356 if ((node) && get_irn_opcode(node) == iro_Bad)
2362 is_no_Block (ir_node *node) {
2364 return (get_irn_opcode(node) != iro_Block);
2368 is_Block (ir_node *node) {
2370 return (get_irn_opcode(node) == iro_Block);
2373 /* returns true if node is a Unknown node. */
2375 is_Unknown (ir_node *node) {
2377 return (get_irn_opcode(node) == iro_Unknown);
2381 is_Proj (const ir_node *node) {
2383 return node->op == op_Proj
2384 || (!interprocedural_view && node->op == op_Filter);
2387 /* Returns true if the operation manipulates control flow. */
2389 is_cfop(ir_node *node) {
2390 return is_cfopcode(get_irn_op(node));
2393 /* Returns true if the operation manipulates interprocedural control flow:
2394 CallBegin, EndReg, EndExcept */
2395 INLINE int is_ip_cfop(ir_node *node) {
2396 return is_ip_cfopcode(get_irn_op(node));
2399 ir_graph *get_ip_cfop_irg(ir_node *n) {
2400 return get_irn_irg(n);
2403 /* Returns true if the operation can change the control flow because
2406 is_fragile_op(ir_node *node) {
2407 return ( (get_irn_opcode(node) == iro_Call)
2408 || (get_irn_opcode(node) == iro_Quot)
2409 || (get_irn_opcode(node) == iro_DivMod)
2410 || (get_irn_opcode(node) == iro_Div)
2411 || (get_irn_opcode(node) == iro_Mod)
2412 || (get_irn_opcode(node) == iro_Load)
2413 || (get_irn_opcode(node) == iro_Store)
2414 || (get_irn_opcode(node) == iro_Alloc)
2415 || (get_irn_opcode(node) == iro_Bad)
2416 || (get_irn_opcode(node) == iro_Unknown));
2420 /* Returns the memory operand of fragile operations. */
2421 ir_node *get_fragile_op_mem(ir_node *node) {
2422 assert(node && is_fragile_op(node));
2424 switch (get_irn_opcode (node)) {
2433 return get_irn_n(node, 0);
2438 assert(0 && "not reached");