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 get_Call_n_callees(ir_node * node) {
1167 assert(node->op == op_Call && node->attr.call.callee_arr);
1168 return ARR_LEN(node->attr.call.callee_arr);
1171 entity * get_Call_callee(ir_node * node, int pos) {
1172 assert(node->op == op_Call && node->attr.call.callee_arr);
1173 return node->attr.call.callee_arr[pos];
1176 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1177 assert(node->op == op_Call);
1178 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1179 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1181 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1184 void remove_Call_callee_arr(ir_node * node) {
1185 assert(node->op == op_Call);
1186 node->attr.call.callee_arr = NULL;
1189 ir_node * get_CallBegin_ptr (ir_node *node) {
1190 assert(node->op == op_CallBegin);
1191 return get_irn_n(node, 0);
1193 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1194 assert(node->op == op_CallBegin);
1195 set_irn_n(node, 0, ptr);
1197 ir_graph * get_CallBegin_irg (ir_node *node) {
1198 return get_irn_irg(node);
1200 ir_node * get_CallBegin_call (ir_node *node) {
1201 assert(node->op == op_CallBegin);
1202 return node->attr.callbegin.call;
1204 void set_CallBegin_call (ir_node *node, ir_node *call) {
1205 assert(node->op == op_CallBegin);
1206 node->attr.callbegin.call = call;
1210 get_Add_left (ir_node *node) {
1211 assert (node->op == op_Add);
1212 return get_irn_n(node, 0);
1216 set_Add_left (ir_node *node, ir_node *left) {
1217 assert (node->op == op_Add);
1218 set_irn_n(node, 0, left);
1222 get_Add_right (ir_node *node) {
1223 assert (node->op == op_Add);
1224 return get_irn_n(node, 1);
1228 set_Add_right (ir_node *node, ir_node *right) {
1229 assert (node->op == op_Add);
1230 set_irn_n(node, 1, right);
1234 get_Sub_left (ir_node *node) {
1235 assert (node->op == op_Sub);
1236 return get_irn_n(node, 0);
1240 set_Sub_left (ir_node *node, ir_node *left) {
1241 assert (node->op == op_Sub);
1242 set_irn_n(node, 0, left);
1246 get_Sub_right (ir_node *node) {
1247 assert (node->op == op_Sub);
1248 return get_irn_n(node, 1);
1252 set_Sub_right (ir_node *node, ir_node *right) {
1253 assert (node->op == op_Sub);
1254 set_irn_n(node, 1, right);
1259 get_Minus_op (ir_node *node) {
1260 assert (node->op == op_Minus);
1261 return get_irn_n(node, 0);
1265 set_Minus_op (ir_node *node, ir_node *op) {
1266 assert (node->op == op_Minus);
1267 set_irn_n(node, 0, op);
1272 get_Mul_left (ir_node *node) {
1273 assert (node->op == op_Mul);
1274 return get_irn_n(node, 0);
1278 set_Mul_left (ir_node *node, ir_node *left) {
1279 assert (node->op == op_Mul);
1280 set_irn_n(node, 0, left);
1284 get_Mul_right (ir_node *node) {
1285 assert (node->op == op_Mul);
1286 return get_irn_n(node, 1);
1290 set_Mul_right (ir_node *node, ir_node *right) {
1291 assert (node->op == op_Mul);
1292 set_irn_n(node, 1, right);
1296 get_Quot_left (ir_node *node) {
1297 assert (node->op == op_Quot);
1298 return get_irn_n(node, 1);
1302 set_Quot_left (ir_node *node, ir_node *left) {
1303 assert (node->op == op_Quot);
1304 set_irn_n(node, 1, left);
1308 get_Quot_right (ir_node *node) {
1309 assert (node->op == op_Quot);
1310 return get_irn_n(node, 2);
1314 set_Quot_right (ir_node *node, ir_node *right) {
1315 assert (node->op == op_Quot);
1316 set_irn_n(node, 2, right);
1320 get_Quot_mem (ir_node *node) {
1321 assert (node->op == op_Quot);
1322 return get_irn_n(node, 0);
1326 set_Quot_mem (ir_node *node, ir_node *mem) {
1327 assert (node->op == op_Quot);
1328 set_irn_n(node, 0, mem);
1332 get_DivMod_left (ir_node *node) {
1333 assert (node->op == op_DivMod);
1334 return get_irn_n(node, 1);
1338 set_DivMod_left (ir_node *node, ir_node *left) {
1339 assert (node->op == op_DivMod);
1340 set_irn_n(node, 1, left);
1344 get_DivMod_right (ir_node *node) {
1345 assert (node->op == op_DivMod);
1346 return get_irn_n(node, 2);
1350 set_DivMod_right (ir_node *node, ir_node *right) {
1351 assert (node->op == op_DivMod);
1352 set_irn_n(node, 2, right);
1356 get_DivMod_mem (ir_node *node) {
1357 assert (node->op == op_DivMod);
1358 return get_irn_n(node, 0);
1362 set_DivMod_mem (ir_node *node, ir_node *mem) {
1363 assert (node->op == op_DivMod);
1364 set_irn_n(node, 0, mem);
1368 get_Div_left (ir_node *node) {
1369 assert (node->op == op_Div);
1370 return get_irn_n(node, 1);
1374 set_Div_left (ir_node *node, ir_node *left) {
1375 assert (node->op == op_Div);
1376 set_irn_n(node, 1, left);
1380 get_Div_right (ir_node *node) {
1381 assert (node->op == op_Div);
1382 return get_irn_n(node, 2);
1386 set_Div_right (ir_node *node, ir_node *right) {
1387 assert (node->op == op_Div);
1388 set_irn_n(node, 2, right);
1392 get_Div_mem (ir_node *node) {
1393 assert (node->op == op_Div);
1394 return get_irn_n(node, 0);
1398 set_Div_mem (ir_node *node, ir_node *mem) {
1399 assert (node->op == op_Div);
1400 set_irn_n(node, 0, mem);
1404 get_Mod_left (ir_node *node) {
1405 assert (node->op == op_Mod);
1406 return get_irn_n(node, 1);
1410 set_Mod_left (ir_node *node, ir_node *left) {
1411 assert (node->op == op_Mod);
1412 set_irn_n(node, 1, left);
1416 get_Mod_right (ir_node *node) {
1417 assert (node->op == op_Mod);
1418 return get_irn_n(node, 2);
1422 set_Mod_right (ir_node *node, ir_node *right) {
1423 assert (node->op == op_Mod);
1424 set_irn_n(node, 2, right);
1428 get_Mod_mem (ir_node *node) {
1429 assert (node->op == op_Mod);
1430 return get_irn_n(node, 0);
1434 set_Mod_mem (ir_node *node, ir_node *mem) {
1435 assert (node->op == op_Mod);
1436 set_irn_n(node, 0, mem);
1440 get_Abs_op (ir_node *node) {
1441 assert (node->op == op_Abs);
1442 return get_irn_n(node, 0);
1446 set_Abs_op (ir_node *node, ir_node *op) {
1447 assert (node->op == op_Abs);
1448 set_irn_n(node, 0, op);
1452 get_And_left (ir_node *node) {
1453 assert (node->op == op_And);
1454 return get_irn_n(node, 0);
1458 set_And_left (ir_node *node, ir_node *left) {
1459 assert (node->op == op_And);
1460 set_irn_n(node, 0, left);
1464 get_And_right (ir_node *node) {
1465 assert (node->op == op_And);
1466 return get_irn_n(node, 1);
1470 set_And_right (ir_node *node, ir_node *right) {
1471 assert (node->op == op_And);
1472 set_irn_n(node, 1, right);
1476 get_Or_left (ir_node *node) {
1477 assert (node->op == op_Or);
1478 return get_irn_n(node, 0);
1482 set_Or_left (ir_node *node, ir_node *left) {
1483 assert (node->op == op_Or);
1484 set_irn_n(node, 0, left);
1488 get_Or_right (ir_node *node) {
1489 assert (node->op == op_Or);
1490 return get_irn_n(node, 1);
1494 set_Or_right (ir_node *node, ir_node *right) {
1495 assert (node->op == op_Or);
1496 set_irn_n(node, 1, right);
1500 get_Eor_left (ir_node *node) {
1501 assert (node->op == op_Eor);
1502 return get_irn_n(node, 0);
1506 set_Eor_left (ir_node *node, ir_node *left) {
1507 assert (node->op == op_Eor);
1508 set_irn_n(node, 0, left);
1512 get_Eor_right (ir_node *node) {
1513 assert (node->op == op_Eor);
1514 return get_irn_n(node, 1);
1518 set_Eor_right (ir_node *node, ir_node *right) {
1519 assert (node->op == op_Eor);
1520 set_irn_n(node, 1, right);
1525 get_Not_op (ir_node *node) {
1526 assert (node->op == op_Not);
1527 return get_irn_n(node, 0);
1531 set_Not_op (ir_node *node, ir_node *op) {
1532 assert (node->op == op_Not);
1533 set_irn_n(node, 0, op);
1538 get_Shl_left (ir_node *node) {
1539 assert (node->op == op_Shl);
1540 return get_irn_n(node, 0);
1544 set_Shl_left (ir_node *node, ir_node *left) {
1545 assert (node->op == op_Shl);
1546 set_irn_n(node, 0, left);
1550 get_Shl_right (ir_node *node) {
1551 assert (node->op == op_Shl);
1552 return get_irn_n(node, 1);
1556 set_Shl_right (ir_node *node, ir_node *right) {
1557 assert (node->op == op_Shl);
1558 set_irn_n(node, 1, right);
1562 get_Shr_left (ir_node *node) {
1563 assert (node->op == op_Shr);
1564 return get_irn_n(node, 0);
1568 set_Shr_left (ir_node *node, ir_node *left) {
1569 assert (node->op == op_Shr);
1570 set_irn_n(node, 0, left);
1574 get_Shr_right (ir_node *node) {
1575 assert (node->op == op_Shr);
1576 return get_irn_n(node, 1);
1580 set_Shr_right (ir_node *node, ir_node *right) {
1581 assert (node->op == op_Shr);
1582 set_irn_n(node, 1, right);
1586 get_Shrs_left (ir_node *node) {
1587 assert (node->op == op_Shrs);
1588 return get_irn_n(node, 0);
1592 set_Shrs_left (ir_node *node, ir_node *left) {
1593 assert (node->op == op_Shrs);
1594 set_irn_n(node, 0, left);
1598 get_Shrs_right (ir_node *node) {
1599 assert (node->op == op_Shrs);
1600 return get_irn_n(node, 1);
1604 set_Shrs_right (ir_node *node, ir_node *right) {
1605 assert (node->op == op_Shrs);
1606 set_irn_n(node, 1, right);
1610 get_Rot_left (ir_node *node) {
1611 assert (node->op == op_Rot);
1612 return get_irn_n(node, 0);
1616 set_Rot_left (ir_node *node, ir_node *left) {
1617 assert (node->op == op_Rot);
1618 set_irn_n(node, 0, left);
1622 get_Rot_right (ir_node *node) {
1623 assert (node->op == op_Rot);
1624 return get_irn_n(node, 1);
1628 set_Rot_right (ir_node *node, ir_node *right) {
1629 assert (node->op == op_Rot);
1630 set_irn_n(node, 1, right);
1634 get_Cmp_left (ir_node *node) {
1635 assert (node->op == op_Cmp);
1636 return get_irn_n(node, 0);
1640 set_Cmp_left (ir_node *node, ir_node *left) {
1641 assert (node->op == op_Cmp);
1642 set_irn_n(node, 0, left);
1646 get_Cmp_right (ir_node *node) {
1647 assert (node->op == op_Cmp);
1648 return get_irn_n(node, 1);
1652 set_Cmp_right (ir_node *node, ir_node *right) {
1653 assert (node->op == op_Cmp);
1654 set_irn_n(node, 1, right);
1658 get_Conv_op (ir_node *node) {
1659 assert (node->op == op_Conv);
1660 return get_irn_n(node, 0);
1664 set_Conv_op (ir_node *node, ir_node *op) {
1665 assert (node->op == op_Conv);
1666 set_irn_n(node, 0, op);
1670 get_Cast_op (ir_node *node) {
1671 assert (node->op == op_Cast);
1672 return get_irn_n(node, 0);
1676 set_Cast_op (ir_node *node, ir_node *op) {
1677 assert (node->op == op_Cast);
1678 set_irn_n(node, 0, op);
1682 get_Cast_type (ir_node *node) {
1683 assert (node->op == op_Cast);
1684 return node->attr.cast.totype;
1688 set_Cast_type (ir_node *node, type *to_tp) {
1689 assert (node->op == op_Cast);
1690 node->attr.cast.totype = to_tp;
1694 is_unop (ir_node *node) {
1695 return ( node->op == op_Minus ||
1696 node->op == op_Abs ||
1697 node->op == op_Not ||
1698 node->op == op_Conv ||
1699 node->op == op_Cast );
1703 get_unop_op (ir_node *node) {
1704 assert (is_unop(node));
1705 switch (get_irn_opcode (node)) {
1706 case iro_Minus: return get_Minus_op(node); break;
1707 case iro_Abs: return get_Abs_op(node); break;
1708 case iro_Not: return get_Not_op(node); break;
1709 case iro_Conv: return get_Conv_op(node); break;
1710 case iro_Cast: return get_Cast_op(node); break;
1711 default: return NULL;
1716 set_unop_op (ir_node *node, ir_node *op) {
1717 assert (is_unop(node));
1718 switch (get_irn_opcode (node)) {
1719 case iro_Minus: set_Minus_op(node, op); break;
1720 case iro_Abs: set_Abs_op(node, op); break;
1721 case iro_Not: set_Not_op(node, op); break;
1722 case iro_Conv: set_Conv_op(node, op); break;
1723 case iro_Cast: set_Cast_op(node, op); break;
1730 is_binop (ir_node *node) {
1731 return (node->op == op_Add ||
1732 node->op == op_Sub ||
1733 node->op == op_Mul ||
1734 node->op == op_Quot ||
1735 node->op == op_DivMod ||
1736 node->op == op_Div ||
1737 node->op == op_Mod ||
1738 node->op == op_And ||
1739 node->op == op_Or ||
1740 node->op == op_Eor ||
1741 node->op == op_Shl ||
1742 node->op == op_Shr ||
1743 node->op == op_Shrs ||
1744 node->op == op_Rot ||
1745 node->op == op_Cmp );
1749 get_binop_left (ir_node *node) {
1750 assert (node->op == op_Add ||
1751 node->op == op_Sub ||
1752 node->op == op_Mul ||
1753 node->op == op_Quot ||
1754 node->op == op_DivMod ||
1755 node->op == op_Div ||
1756 node->op == op_Mod ||
1757 node->op == op_And ||
1758 node->op == op_Or ||
1759 node->op == op_Eor ||
1760 node->op == op_Shl ||
1761 node->op == op_Shr ||
1762 node->op == op_Shrs ||
1763 node->op == op_Rot ||
1764 node->op == op_Cmp );
1766 switch (get_irn_opcode (node)) {
1767 case iro_Add : return get_Add_left(node); break;
1768 case iro_Sub : return get_Sub_left(node); break;
1769 case iro_Mul : return get_Mul_left(node); break;
1770 case iro_Quot : return get_Quot_left(node); break;
1771 case iro_DivMod: return get_DivMod_left(node); break;
1772 case iro_Div : return get_Div_left(node); break;
1773 case iro_Mod : return get_Mod_left(node); break;
1774 case iro_And : return get_And_left(node); break;
1775 case iro_Or : return get_Or_left(node); break;
1776 case iro_Eor : return get_Eor_left(node); break;
1777 case iro_Shl : return get_Shl_left(node); break;
1778 case iro_Shr : return get_Shr_left(node); break;
1779 case iro_Shrs : return get_Shrs_left(node); break;
1780 case iro_Rot : return get_Rot_left(node); break;
1781 case iro_Cmp : return get_Cmp_left(node); break;
1782 default: return NULL;
1787 set_binop_left (ir_node *node, ir_node *left) {
1788 assert (node->op == op_Add ||
1789 node->op == op_Sub ||
1790 node->op == op_Mul ||
1791 node->op == op_Quot ||
1792 node->op == op_DivMod ||
1793 node->op == op_Div ||
1794 node->op == op_Mod ||
1795 node->op == op_And ||
1796 node->op == op_Or ||
1797 node->op == op_Eor ||
1798 node->op == op_Shl ||
1799 node->op == op_Shr ||
1800 node->op == op_Shrs ||
1801 node->op == op_Rot ||
1802 node->op == op_Cmp );
1804 switch (get_irn_opcode (node)) {
1805 case iro_Add : set_Add_left(node, left); break;
1806 case iro_Sub : set_Sub_left(node, left); break;
1807 case iro_Mul : set_Mul_left(node, left); break;
1808 case iro_Quot : set_Quot_left(node, left); break;
1809 case iro_DivMod: set_DivMod_left(node, left); break;
1810 case iro_Div : set_Div_left(node, left); break;
1811 case iro_Mod : set_Mod_left(node, left); break;
1812 case iro_And : set_And_left(node, left); break;
1813 case iro_Or : set_Or_left(node, left); break;
1814 case iro_Eor : set_Eor_left(node, left); break;
1815 case iro_Shl : set_Shl_left(node, left); break;
1816 case iro_Shr : set_Shr_left(node, left); break;
1817 case iro_Shrs : set_Shrs_left(node, left); break;
1818 case iro_Rot : set_Rot_left(node, left); break;
1819 case iro_Cmp : set_Cmp_left(node, left); break;
1825 get_binop_right (ir_node *node) {
1826 assert (node->op == op_Add ||
1827 node->op == op_Sub ||
1828 node->op == op_Mul ||
1829 node->op == op_Quot ||
1830 node->op == op_DivMod ||
1831 node->op == op_Div ||
1832 node->op == op_Mod ||
1833 node->op == op_And ||
1834 node->op == op_Or ||
1835 node->op == op_Eor ||
1836 node->op == op_Shl ||
1837 node->op == op_Shr ||
1838 node->op == op_Shrs ||
1839 node->op == op_Rot ||
1840 node->op == op_Cmp );
1842 switch (get_irn_opcode (node)) {
1843 case iro_Add : return get_Add_right(node); break;
1844 case iro_Sub : return get_Sub_right(node); break;
1845 case iro_Mul : return get_Mul_right(node); break;
1846 case iro_Quot : return get_Quot_right(node); break;
1847 case iro_DivMod: return get_DivMod_right(node); break;
1848 case iro_Div : return get_Div_right(node); break;
1849 case iro_Mod : return get_Mod_right(node); break;
1850 case iro_And : return get_And_right(node); break;
1851 case iro_Or : return get_Or_right(node); break;
1852 case iro_Eor : return get_Eor_right(node); break;
1853 case iro_Shl : return get_Shl_right(node); break;
1854 case iro_Shr : return get_Shr_right(node); break;
1855 case iro_Shrs : return get_Shrs_right(node); break;
1856 case iro_Rot : return get_Rot_right(node); break;
1857 case iro_Cmp : return get_Cmp_right(node); break;
1858 default: return NULL;
1863 set_binop_right (ir_node *node, ir_node *right) {
1864 assert (node->op == op_Add ||
1865 node->op == op_Sub ||
1866 node->op == op_Mul ||
1867 node->op == op_Quot ||
1868 node->op == op_DivMod ||
1869 node->op == op_Div ||
1870 node->op == op_Mod ||
1871 node->op == op_And ||
1872 node->op == op_Or ||
1873 node->op == op_Eor ||
1874 node->op == op_Shl ||
1875 node->op == op_Shr ||
1876 node->op == op_Shrs ||
1877 node->op == op_Rot ||
1878 node->op == op_Cmp );
1880 switch (get_irn_opcode (node)) {
1881 case iro_Add : set_Add_right(node, right); break;
1882 case iro_Sub : set_Sub_right(node, right); break;
1883 case iro_Mul : set_Mul_right(node, right); break;
1884 case iro_Quot : set_Quot_right(node, right); break;
1885 case iro_DivMod: set_DivMod_right(node, right); break;
1886 case iro_Div : set_Div_right(node, right); break;
1887 case iro_Mod : set_Mod_right(node, right); break;
1888 case iro_And : set_And_right(node, right); break;
1889 case iro_Or : set_Or_right(node, right); break;
1890 case iro_Eor : set_Eor_right(node, right); break;
1891 case iro_Shl : set_Shl_right(node, right); break;
1892 case iro_Shr : set_Shr_right(node, right); break;
1893 case iro_Shrs : set_Shrs_right(node, right); break;
1894 case iro_Rot : set_Rot_right(node, right); break;
1895 case iro_Cmp : set_Cmp_right(node, right); break;
1902 get_Phi_preds_arr (ir_node *node) {
1903 assert (node->op == op_Phi);
1904 return (ir_node **)&(get_irn_in(node)[1]);
1908 get_Phi_n_preds (ir_node *node) {
1909 assert (node->op == op_Phi);
1910 return (get_irn_arity(node));
1914 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1915 assert (node->op == op_Phi);
1920 get_Phi_pred (ir_node *node, int pos) {
1921 assert (node->op == op_Phi);
1922 return get_irn_n(node, pos);
1926 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1927 assert (node->op == op_Phi);
1928 set_irn_n(node, pos, pred);
1932 get_Load_mem (ir_node *node) {
1933 assert (node->op == op_Load);
1934 return get_irn_n(node, 0);
1938 set_Load_mem (ir_node *node, ir_node *mem) {
1939 assert (node->op == op_Load);
1940 set_irn_n(node, 0, mem);
1944 get_Load_ptr (ir_node *node) {
1945 assert (node->op == op_Load);
1946 return get_irn_n(node, 1);
1950 set_Load_ptr (ir_node *node, ir_node *ptr) {
1951 assert (node->op == op_Load);
1952 set_irn_n(node, 1, ptr);
1957 get_Store_mem (ir_node *node) {
1958 assert (node->op == op_Store);
1959 return get_irn_n(node, 0);
1963 set_Store_mem (ir_node *node, ir_node *mem) {
1964 assert (node->op == op_Store);
1965 set_irn_n(node, 0, mem);
1969 get_Store_ptr (ir_node *node) {
1970 assert (node->op == op_Store);
1971 return get_irn_n(node, 1);
1975 set_Store_ptr (ir_node *node, ir_node *ptr) {
1976 assert (node->op == op_Store);
1977 set_irn_n(node, 1, ptr);
1981 get_Store_value (ir_node *node) {
1982 assert (node->op == op_Store);
1983 return get_irn_n(node, 2);
1987 set_Store_value (ir_node *node, ir_node *value) {
1988 assert (node->op == op_Store);
1989 set_irn_n(node, 2, value);
1993 get_Alloc_mem (ir_node *node) {
1994 assert (node->op == op_Alloc);
1995 return get_irn_n(node, 0);
1999 set_Alloc_mem (ir_node *node, ir_node *mem) {
2000 assert (node->op == op_Alloc);
2001 set_irn_n(node, 0, mem);
2005 get_Alloc_size (ir_node *node) {
2006 assert (node->op == op_Alloc);
2007 return get_irn_n(node, 1);
2011 set_Alloc_size (ir_node *node, ir_node *size) {
2012 assert (node->op == op_Alloc);
2013 set_irn_n(node, 1, size);
2017 get_Alloc_type (ir_node *node) {
2018 assert (node->op == op_Alloc);
2019 return node->attr.a.type = skip_tid(node->attr.a.type);
2023 set_Alloc_type (ir_node *node, type *tp) {
2024 assert (node->op == op_Alloc);
2025 node->attr.a.type = tp;
2029 get_Alloc_where (ir_node *node) {
2030 assert (node->op == op_Alloc);
2031 return node->attr.a.where;
2035 set_Alloc_where (ir_node *node, where_alloc where) {
2036 assert (node->op == op_Alloc);
2037 node->attr.a.where = where;
2042 get_Free_mem (ir_node *node) {
2043 assert (node->op == op_Free);
2044 return get_irn_n(node, 0);
2048 set_Free_mem (ir_node *node, ir_node *mem) {
2049 assert (node->op == op_Free);
2050 set_irn_n(node, 0, mem);
2054 get_Free_ptr (ir_node *node) {
2055 assert (node->op == op_Free);
2056 return get_irn_n(node, 1);
2060 set_Free_ptr (ir_node *node, ir_node *ptr) {
2061 assert (node->op == op_Free);
2062 set_irn_n(node, 1, ptr);
2066 get_Free_size (ir_node *node) {
2067 assert (node->op == op_Free);
2068 return get_irn_n(node, 2);
2072 set_Free_size (ir_node *node, ir_node *size) {
2073 assert (node->op == op_Free);
2074 set_irn_n(node, 2, size);
2078 get_Free_type (ir_node *node) {
2079 assert (node->op == op_Free);
2080 return node->attr.f = skip_tid(node->attr.f);
2084 set_Free_type (ir_node *node, type *tp) {
2085 assert (node->op == op_Free);
2090 get_Sync_preds_arr (ir_node *node) {
2091 assert (node->op == op_Sync);
2092 return (ir_node **)&(get_irn_in(node)[1]);
2096 get_Sync_n_preds (ir_node *node) {
2097 assert (node->op == op_Sync);
2098 return (get_irn_arity(node));
2103 set_Sync_n_preds (ir_node *node, int n_preds) {
2104 assert (node->op == op_Sync);
2109 get_Sync_pred (ir_node *node, int pos) {
2110 assert (node->op == op_Sync);
2111 return get_irn_n(node, pos);
2115 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
2116 assert (node->op == op_Sync);
2117 set_irn_n(node, pos, pred);
2121 get_Proj_pred (ir_node *node) {
2122 assert (is_Proj(node));
2123 return get_irn_n(node, 0);
2127 set_Proj_pred (ir_node *node, ir_node *pred) {
2128 assert (is_Proj(node));
2129 set_irn_n(node, 0, pred);
2133 get_Proj_proj (ir_node *node) {
2134 assert (is_Proj(node));
2135 if (get_irn_opcode(node) == iro_Proj) {
2136 return node->attr.proj;
2138 assert(get_irn_opcode(node) == iro_Filter);
2139 return node->attr.filter.proj;
2144 set_Proj_proj (ir_node *node, long proj) {
2145 assert (node->op == op_Proj);
2146 node->attr.proj = proj;
2150 get_Tuple_preds_arr (ir_node *node) {
2151 assert (node->op == op_Tuple);
2152 return (ir_node **)&(get_irn_in(node)[1]);
2156 get_Tuple_n_preds (ir_node *node) {
2157 assert (node->op == op_Tuple);
2158 return (get_irn_arity(node));
2163 set_Tuple_n_preds (ir_node *node, int n_preds) {
2164 assert (node->op == op_Tuple);
2169 get_Tuple_pred (ir_node *node, int pos) {
2170 assert (node->op == op_Tuple);
2171 return get_irn_n(node, pos);
2175 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2176 assert (node->op == op_Tuple);
2177 set_irn_n(node, pos, pred);
2181 get_Id_pred (ir_node *node) {
2182 assert (node->op == op_Id);
2183 return get_irn_n(node, 0);
2187 set_Id_pred (ir_node *node, ir_node *pred) {
2188 assert (node->op == op_Id);
2189 set_irn_n(node, 0, pred);
2192 INLINE ir_node *get_Confirm_value (ir_node *node) {
2193 assert (node->op == op_Confirm);
2194 return get_irn_n(node, 0);
2196 INLINE void set_Confirm_value (ir_node *node, ir_node *value) {
2197 assert (node->op == op_Confirm);
2198 set_irn_n(node, 0, value);
2200 INLINE ir_node *get_Confirm_bound (ir_node *node) {
2201 assert (node->op == op_Confirm);
2202 return get_irn_n(node, 1);
2204 INLINE void set_Confirm_bound (ir_node *node, ir_node *bound) {
2205 assert (node->op == op_Confirm);
2206 set_irn_n(node, 0, bound);
2208 INLINE pn_Cmp get_Confirm_cmp (ir_node *node) {
2209 assert (node->op == op_Confirm);
2210 return node->attr.confirm_cmp;
2212 INLINE void set_Confirm_cmp (ir_node *node, pn_Cmp cmp) {
2213 assert (node->op == op_Confirm);
2214 node->attr.confirm_cmp = cmp;
2219 get_Filter_pred (ir_node *node) {
2220 assert(node->op == op_Filter);
2224 set_Filter_pred (ir_node *node, ir_node *pred) {
2225 assert(node->op == op_Filter);
2229 get_Filter_proj(ir_node *node) {
2230 assert(node->op == op_Filter);
2231 return node->attr.filter.proj;
2234 set_Filter_proj (ir_node *node, long proj) {
2235 assert(node->op == op_Filter);
2236 node->attr.filter.proj = proj;
2239 /* Don't use get_irn_arity, get_irn_n in implementation as access
2240 shall work independent of view!!! */
2241 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2242 assert(node->op == op_Filter);
2243 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2244 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2245 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2246 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2247 node->attr.filter.in_cg[0] = node->in[0];
2249 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2252 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2253 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2254 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2255 node->attr.filter.in_cg[pos + 1] = pred;
2257 int get_Filter_n_cg_preds(ir_node *node) {
2258 assert(node->op == op_Filter && node->attr.filter.in_cg);
2259 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2261 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2263 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2265 arity = ARR_LEN(node->attr.filter.in_cg);
2266 assert(pos < arity - 1);
2267 return node->attr.filter.in_cg[pos + 1];
2272 get_irn_irg(ir_node *node) {
2273 if (get_irn_op(node) != op_Block)
2274 node = get_nodes_block(node);
2275 assert(get_irn_op(node) == op_Block);
2276 return node->attr.block.irg;
2280 /******************************************************************/
2281 /* Auxiliary routines */
2282 /******************************************************************/
2285 skip_Proj (ir_node *node) {
2286 /* don't assert node !!! */
2287 if (node && is_Proj(node)) {
2288 return get_Proj_pred(node);
2295 skip_Tuple (ir_node *node) {
2298 if (!get_opt_normalize()) return node;
2300 node = skip_nop(node);
2301 if (get_irn_op(node) == op_Proj) {
2302 pred = skip_nop(get_Proj_pred(node));
2303 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2304 pred = skip_nop(skip_Tuple(pred));
2305 if (get_irn_op(pred) == op_Tuple)
2306 return get_Tuple_pred(pred, get_Proj_proj(node));
2311 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2312 than any other approach, as Id chains are resolved and all point to the real node, or
2313 all id's are self loops. */
2315 skip_nop (ir_node *node) {
2316 /* don't assert node !!! */
2318 if (!get_opt_normalize()) return node;
2320 /* Don't use get_Id_pred: We get into an endless loop for
2321 self-referencing Ids. */
2322 if (node && (node->op == op_Id) && (node != node->in[0+1])) {
2323 ir_node *rem_pred = node->in[0+1];
2326 assert (get_irn_arity (node) > 0);
2328 node->in[0+1] = node;
2329 res = skip_nop(rem_pred);
2330 if (res->op == op_Id) /* self-loop */ return node;
2332 node->in[0+1] = res;
2340 skip_Id (ir_node *node) {
2341 return skip_nop(node);
2345 is_Bad (ir_node *node) {
2347 if ((node) && get_irn_opcode(node) == iro_Bad)
2353 is_no_Block (ir_node *node) {
2355 return (get_irn_opcode(node) != iro_Block);
2359 is_Block (ir_node *node) {
2361 return (get_irn_opcode(node) == iro_Block);
2365 is_Proj (const ir_node *node) {
2367 return node->op == op_Proj
2368 || (!interprocedural_view && node->op == op_Filter);
2371 /* Returns true if the operation manipulates control flow. */
2373 is_cfop(ir_node *node) {
2374 return is_cfopcode(get_irn_op(node));
2377 /* Returns true if the operation manipulates interprocedural control flow:
2378 CallBegin, EndReg, EndExcept */
2379 INLINE int is_ip_cfop(ir_node *node) {
2380 return is_ip_cfopcode(get_irn_op(node));
2383 ir_graph *get_ip_cfop_irg(ir_node *n) {
2384 return get_irn_irg(n);
2387 /* Returns true if the operation can change the control flow because
2390 is_fragile_op(ir_node *node) {
2391 return ( (get_irn_opcode(node) == iro_Call)
2392 || (get_irn_opcode(node) == iro_Quot)
2393 || (get_irn_opcode(node) == iro_DivMod)
2394 || (get_irn_opcode(node) == iro_Div)
2395 || (get_irn_opcode(node) == iro_Mod)
2396 || (get_irn_opcode(node) == iro_Load)
2397 || (get_irn_opcode(node) == iro_Store)
2398 || (get_irn_opcode(node) == iro_Alloc)
2399 || (get_irn_opcode(node) == iro_Bad)
2400 || (get_irn_opcode(node) == iro_Unknown));
2404 /* Returns the memory operand of fragile operations. */
2405 ir_node *get_fragile_op_mem(ir_node *node) {
2406 assert(node && is_fragile_op(node));
2408 switch (get_irn_opcode (node)) {
2417 return get_irn_n(node, 0);
2422 assert(0 && "not reached");