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_arity (const ir_node *node) {
157 if (interprocedural_view) { /* handle Filter and Block specially */
158 if (get_irn_opcode(node) == iro_Filter) {
159 assert(node->attr.filter.in_cg);
160 return ARR_LEN(node->attr.filter.in_cg) - 1;
161 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
162 return ARR_LEN(node->attr.block.in_cg) - 1;
164 /* else fall through */
166 return ARR_LEN(node->in) - 1;
169 /* Returns the array with ins. This array is shifted with respect to the
170 array accessed by get_irn_n: The block operand is at position 0 not -1.
171 (@@@ This should be changed.)
172 The order of the predecessors in this array is not guaranteed, except that
173 lists of operands as predecessors of Block or arguments of a Call are
176 get_irn_in (const ir_node *node) {
178 if (interprocedural_view) { /* handle Filter and Block specially */
179 if (get_irn_opcode(node) == iro_Filter) {
180 assert(node->attr.filter.in_cg);
181 return node->attr.filter.in_cg;
182 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
183 return node->attr.block.in_cg;
185 /* else fall through */
191 set_irn_in (ir_node *node, int arity, ir_node **in) {
194 if (interprocedural_view) { /* handle Filter and Block specially */
195 if (get_irn_opcode(node) == iro_Filter) {
196 assert(node->attr.filter.in_cg);
197 arr = &node->attr.filter.in_cg;
198 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
199 arr = &node->attr.block.in_cg;
206 if (arity != ARR_LEN(*arr) - 1) {
207 ir_node * block = (*arr)[0];
208 *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
211 fix_backedges(current_ir_graph->obst, node);
212 memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
215 /* to iterate through the predecessors without touching the array */
216 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
217 to iterate includind the Block predecessor iterate from i = -1 to
219 If it is a block, the entry -1 is NULL. */
221 get_irn_n (ir_node *node, int n) {
223 if (-1 > n || get_irn_arity(node) <= n) {
224 printf("pos: %d, arity: %d ", n, get_irn_arity(node));
227 assert(node); assert(-1 <= n && n < get_irn_arity(node));
228 if (interprocedural_view) { /* handle Filter and Block specially */
229 if (get_irn_opcode(node) == iro_Filter) {
230 assert(node->attr.filter.in_cg);
231 return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
232 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
233 return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
235 /* else fall through */
237 return (node->in[n + 1] = skip_nop(node->in[n + 1]));
241 set_irn_n (ir_node *node, int n, ir_node *in) {
242 assert(node && -1 <= n && n < get_irn_arity(node));
243 if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
244 /* Change block pred in both views! */
245 node->in[n + 1] = in;
246 assert(node->attr.filter.in_cg);
247 node->attr.filter.in_cg[n + 1] = in;
250 if (interprocedural_view) { /* handle Filter and Block specially */
251 if (get_irn_opcode(node) == iro_Filter) {
252 assert(node->attr.filter.in_cg);
253 node->attr.filter.in_cg[n + 1] = in;
255 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
256 node->attr.block.in_cg[n + 1] = in;
259 /* else fall through */
261 node->in[n + 1] = in;
265 get_irn_mode (const ir_node *node)
272 set_irn_mode (ir_node *node, ir_mode *mode)
280 get_irn_modecode (const ir_node *node)
283 return node->mode->code;
288 get_irn_modeident (const ir_node *node)
291 return get_mode_ident(node->mode);
295 get_irn_op (const ir_node *node)
301 /* should be private to the library: */
303 set_irn_op (ir_node *node, ir_op *op)
310 get_irn_opcode (const ir_node *node)
313 assert (k_ir_node == get_kind(node));
315 return node->op->code;
319 get_irn_opname (const ir_node *node)
322 return get_id_str(node->op->name);
326 get_irn_opident (const ir_node *node)
329 return node->op->name;
333 get_irn_visited (const ir_node *node)
336 return node->visited;
340 set_irn_visited (ir_node *node, unsigned long visited)
343 node->visited = visited;
347 mark_irn_visited (ir_node *node) {
349 node->visited = current_ir_graph->visited;
353 irn_not_visited (const ir_node *node) {
355 return (node->visited < current_ir_graph->visited);
359 irn_visited (const ir_node *node) {
361 return (node->visited >= current_ir_graph->visited);
365 set_irn_link (ir_node *node, void *link) {
367 /* Link field is used for Phi construction and various optimizations
369 assert(get_irg_phase_state(current_ir_graph) != phase_building);
375 get_irn_link (const ir_node *node) {
380 /* Outputs a unique number for this node */
382 get_irn_node_nr(const ir_node *node) {
385 return node->node_nr;
392 get_irn_const_attr (ir_node *node)
394 assert (node->op == op_Const);
395 return node->attr.con;
399 get_irn_proj_attr (ir_node *node)
401 assert (node->op == op_Proj);
402 return node->attr.proj;
406 get_irn_alloc_attr (ir_node *node)
408 assert (node->op == op_Alloc);
413 get_irn_free_attr (ir_node *node)
415 assert (node->op == op_Free);
416 return node->attr.f = skip_tid(node->attr.f);
420 get_irn_symconst_attr (ir_node *node)
422 assert (node->op == op_SymConst);
427 get_irn_call_attr (ir_node *node)
429 assert (node->op == op_Call);
430 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
434 get_irn_sel_attr (ir_node *node)
436 assert (node->op == op_Sel);
441 get_irn_phi_attr (ir_node *node)
443 assert (node->op == op_Phi);
444 return node->attr.phi0_pos;
448 get_irn_block_attr (ir_node *node)
450 assert (node->op == op_Block);
451 return node->attr.block;
454 /** manipulate fields of individual nodes **/
456 /* this works for all except Block */
458 get_nodes_Block (ir_node *node) {
459 assert (!(node->op == op_Block));
460 return get_irn_n(node, -1);
464 set_nodes_Block (ir_node *node, ir_node *block) {
465 assert (!(node->op == op_Block));
466 set_irn_n(node, -1, block);
469 /* Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
470 * from Start. If so returns frame type, else Null. */
471 type *is_frame_pointer(ir_node *n) {
472 if ((get_irn_op(n) == op_Proj) &&
473 (get_Proj_proj(n) == pn_Start_P_frame_base)) {
474 ir_node *start = get_Proj_pred(n);
475 if (get_irn_op(start) == op_Start) {
476 return get_irg_frame_type(get_irn_irg(start));
482 /* Test whether arbitrary node is globals pointer, i.e. Proj(pn_Start_P_globals)
483 * from Start. If so returns global type, else Null. */
484 type *is_globals_pointer(ir_node *n) {
485 if ((get_irn_op(n) == op_Proj) &&
486 (get_Proj_proj(n) == pn_Start_P_globals)) {
487 ir_node *start = get_Proj_pred(n);
488 if (get_irn_op(start) == op_Start) {
489 return get_glob_type();
495 /* Test whether arbitrary node is value arg base, i.e. Proj(pn_Start_P_value_arg_base)
496 * from Start. If so returns 1, else 0. */
497 int is_value_arg_pointer(ir_node *n) {
498 if ((get_irn_op(n) == op_Proj) &&
499 (get_Proj_proj(n) == pn_Start_P_value_arg_base) &&
500 (get_irn_op(get_Proj_pred(n)) == op_Start))
505 /* Returns an array with the predecessors of the Block. Depending on
506 the implementation of the graph datastructure this can be a copy of
507 the internal representation of predecessors as well as the internal
508 array itself. Therefore writing to this array might obstruct the ir. */
510 get_Block_cfgpred_arr (ir_node *node)
512 assert ((node->op == op_Block));
513 return (ir_node **)&(get_irn_in(node)[1]);
518 get_Block_n_cfgpreds (ir_node *node) {
519 assert ((node->op == op_Block));
520 return (get_irn_arity(node));
524 get_Block_cfgpred (ir_node *node, int pos) {
525 assert (node->op == op_Block);
527 if (-1 > pos || get_irn_arity(node) <= pos) {
528 dump_ir_block_graph(current_ir_graph);
529 printf("pos: %d, arity: %d ", pos, get_irn_arity(node));
532 assert(node); assert(-1 <= pos && pos < get_irn_arity(node));
533 return get_irn_n(node, pos);
537 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
538 assert (node->op == op_Block);
539 set_irn_n(node, pos, pred);
543 get_Block_matured (ir_node *node) {
544 assert (node->op == op_Block);
545 return node->attr.block.matured;
549 set_Block_matured (ir_node *node, bool matured) {
550 assert (node->op == op_Block);
551 node->attr.block.matured = matured;
554 get_Block_block_visited (ir_node *node) {
555 assert (node->op == op_Block);
556 return node->attr.block.block_visited;
560 set_Block_block_visited (ir_node *node, unsigned long visit) {
561 assert (node->op == op_Block);
562 node->attr.block.block_visited = visit;
565 /* For this current_ir_graph must be set. */
567 mark_Block_block_visited (ir_node *node) {
568 assert (node->op == op_Block);
569 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
573 Block_not_block_visited(ir_node *node) {
574 assert (node->op == op_Block);
575 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
579 get_Block_graph_arr (ir_node *node, int pos) {
580 assert (node->op == op_Block);
581 return node->attr.block.graph_arr[pos+1];
585 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
586 assert (node->op == op_Block);
587 node->attr.block.graph_arr[pos+1] = value;
590 /* handler handling for Blocks */
592 set_Block_handler (ir_node *block, ir_node *handler) {
593 assert ((block->op == op_Block));
594 assert ((handler->op == op_Block));
595 block->attr.block.handler_entry = handler;
599 get_Block_handler (ir_node *block) {
600 assert ((block->op == op_Block));
601 return (block->attr.block.handler_entry);
604 /* handler handling for Nodes */
606 set_Node_handler (ir_node *node, ir_node *handler) {
607 set_Block_handler (get_nodes_Block (node), handler);
611 get_Node_handler (ir_node *node) {
612 return (get_Block_handler (get_nodes_Block (node)));
615 /* exc_t handling for Blocks */
616 void set_Block_exc (ir_node *block, exc_t exc) {
617 assert ((block->op == op_Block));
618 block->attr.block.exc = exc;
621 exc_t get_Block_exc (ir_node *block) {
622 assert ((block->op == op_Block));
624 return (block->attr.block.exc);
627 /* exc_t handling for Nodes */
628 void set_Node_exc (ir_node *node, exc_t exc) {
629 set_Block_exc (get_nodes_Block (node), exc);
632 exc_t get_Node_exc (ir_node *node) {
633 return (get_Block_exc (get_nodes_Block (node)));
636 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
637 assert(node->op == op_Block);
638 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
639 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
640 node->attr.block.in_cg[0] = NULL;
641 node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
643 /* Fix backedge array. fix_backedges operates depending on
644 interprocedural_view. */
645 bool ipv = interprocedural_view;
646 interprocedural_view = true;
647 fix_backedges(current_ir_graph->obst, node);
648 interprocedural_view = ipv;
651 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
654 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
655 assert(node->op == op_Block &&
656 node->attr.block.in_cg &&
657 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
658 node->attr.block.in_cg[pos + 1] = pred;
661 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
662 assert(node->op == op_Block);
663 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
666 int get_Block_cg_n_cfgpreds(ir_node * node) {
667 assert(node->op == op_Block);
668 return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
671 ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
672 assert(node->op == op_Block && node->attr.block.in_cg);
673 return node->attr.block.in_cg[pos + 1];
676 void remove_Block_cg_cfgpred_arr(ir_node * node) {
677 assert(node->op == op_Block);
678 node->attr.block.in_cg = NULL;
681 /* Start references the irg it is in. */
683 get_Start_irg(ir_node *node) {
684 assert(node->op == op_Start);
685 return node->attr.start.irg;
689 set_Start_irg(ir_node *node, ir_graph *irg) {
690 assert(node->op == op_Start);
691 assert(is_ir_graph(irg));
692 node->attr.start.irg = irg;
696 get_End_n_keepalives(ir_node *end) {
697 assert (end->op == op_End);
698 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
702 get_End_keepalive(ir_node *end, int pos) {
703 assert (end->op == op_End);
704 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
708 add_End_keepalive (ir_node *end, ir_node *ka) {
709 assert (end->op == op_End);
710 ARR_APP1 (ir_node *, end->in, ka);
714 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
715 assert (end->op == op_End);
716 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
720 free_End (ir_node *end) {
721 assert (end->op == op_End);
723 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
724 end->in = NULL; /* @@@ make sure we get an error if we use the
725 in array afterwards ... */
728 ir_graph *get_EndReg_irg (const ir_node *end) {
729 assert (end->op == op_EndReg);
730 return end->attr.end.irg;
733 ir_graph *get_EndExcept_irg (const ir_node *end) {
734 assert (end->op == op_EndReg);
735 return end->attr.end.irg;
739 > Implementing the case construct (which is where the constant Proj node is
740 > important) involves far more than simply determining the constant values.
741 > We could argue that this is more properly a function of the translator from
742 > Firm to the target machine. That could be done if there was some way of
743 > projecting "default" out of the Cond node.
744 I know it's complicated.
745 Basically there are two proglems:
746 - determining the gaps between the projs
747 - determining the biggest case constant to konw the proj number for
749 I see several solutions:
750 1. Introduce a ProjDefault node. Solves both problems.
751 This means to extend all optimizations executed during construction.
752 2. Give the Cond node for switch two flavors:
753 a) there are no gaps in the projs (existing flavor)
754 b) gaps may exist, default proj is still the Proj with the largest
755 projection number. This covers also the gaps.
756 3. Fix the semantic of the Cond to that of 2b)
758 Solution 2 seems to be the best:
759 Computing the gaps in the Firm representation is not too hard, i.e.,
760 libfirm can implement a routine that transforms betweeen the two
761 flavours. This is also possible for 1) but 2) does not require to
762 change any existing optimization.
763 Further it should be far simpler to determine the biggest constant than
765 I don't want to choose 3) as 2a) seems to have advantages for
766 dataflow analysis and 3) does not allow to convert the representation to
770 get_Cond_selector (ir_node *node) {
771 assert (node->op == op_Cond);
772 return get_irn_n(node, 0);
776 set_Cond_selector (ir_node *node, ir_node *selector) {
777 assert (node->op == op_Cond);
778 set_irn_n(node, 0, selector);
782 get_Cond_kind (ir_node *node) {
783 assert (node->op == op_Cond);
784 return node->attr.c.kind;
788 set_Cond_kind (ir_node *node, cond_kind kind) {
789 assert (node->op == op_Cond);
790 node->attr.c.kind = kind;
794 get_Return_mem (ir_node *node) {
795 assert (node->op == op_Return);
796 return get_irn_n(node, 0);
800 set_Return_mem (ir_node *node, ir_node *mem) {
801 assert (node->op == op_Return);
802 set_irn_n(node, 0, mem);
806 get_Return_n_ress (ir_node *node) {
807 assert (node->op == op_Return);
808 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
812 get_Return_res_arr (ir_node *node)
814 assert ((node->op == op_Return));
815 if (get_Return_n_ress(node) > 0)
816 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
823 set_Return_n_res (ir_node *node, int results) {
824 assert (node->op == op_Return);
829 get_Return_res (ir_node *node, int pos) {
830 assert (node->op == op_Return);
831 assert (get_Return_n_ress(node) > pos);
832 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
836 set_Return_res (ir_node *node, int pos, ir_node *res){
837 assert (node->op == op_Return);
838 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
842 get_Raise_mem (ir_node *node) {
843 assert (node->op == op_Raise);
844 return get_irn_n(node, 0);
848 set_Raise_mem (ir_node *node, ir_node *mem) {
849 assert (node->op == op_Raise);
850 set_irn_n(node, 0, mem);
854 get_Raise_exo_ptr (ir_node *node) {
855 assert (node->op == op_Raise);
856 return get_irn_n(node, 1);
860 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
861 assert (node->op == op_Raise);
862 set_irn_n(node, 1, exo_ptr);
865 INLINE tarval *get_Const_tarval (ir_node *node) {
866 assert (node->op == op_Const);
867 return node->attr.con.tv;
871 set_Const_tarval (ir_node *node, tarval *con) {
872 assert (node->op == op_Const);
873 node->attr.con.tv = con;
877 /* The source language type. Must be an atomic type. Mode of type must
878 be mode of node. For tarvals from entities type must be pointer to
881 get_Const_type (ir_node *node) {
882 assert (node->op == op_Const);
883 return node->attr.con.tp;
887 set_Const_type (ir_node *node, type *tp) {
888 assert (node->op == op_Const);
889 if (tp != unknown_type) {
890 assert (is_atomic_type(tp));
891 assert (get_type_mode(tp) == get_irn_mode(node));
892 assert (!tarval_is_entity(get_Const_tarval(node)) ||
893 (is_pointer_type(tp) &&
894 (get_pointer_points_to_type(tp) ==
895 get_entity_type(get_tarval_entity(get_Const_tarval(node))))));
898 node->attr.con.tp = tp;
903 get_SymConst_kind (const ir_node *node) {
904 assert (node->op == op_SymConst);
905 return node->attr.i.num;
909 set_SymConst_kind (ir_node *node, symconst_kind num) {
910 assert (node->op == op_SymConst);
911 node->attr.i.num = num;
915 get_SymConst_type (ir_node *node) {
916 assert ( (node->op == op_SymConst)
917 && ( get_SymConst_kind(node) == type_tag
918 || get_SymConst_kind(node) == size));
919 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
923 set_SymConst_type (ir_node *node, type *tp) {
924 assert ( (node->op == op_SymConst)
925 && ( get_SymConst_kind(node) == type_tag
926 || get_SymConst_kind(node) == size));
927 node->attr.i.tori.typ = tp;
931 get_SymConst_ptrinfo (ir_node *node) {
932 assert ( (node->op == op_SymConst)
933 && (get_SymConst_kind(node) == linkage_ptr_info));
934 return node->attr.i.tori.ptrinfo;
938 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
939 assert ( (node->op == op_SymConst)
940 && (get_SymConst_kind(node) == linkage_ptr_info));
941 node->attr.i.tori.ptrinfo = ptrinfo;
945 get_SymConst_type_or_id (ir_node *node) {
946 assert (node->op == op_SymConst);
947 return &(node->attr.i.tori);
951 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
952 assert (node->op == op_SymConst);
953 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
957 get_Sel_mem (ir_node *node) {
958 assert (node->op == op_Sel);
959 return get_irn_n(node, 0);
963 set_Sel_mem (ir_node *node, ir_node *mem) {
964 assert (node->op == op_Sel);
965 set_irn_n(node, 0, mem);
969 get_Sel_ptr (ir_node *node) {
970 assert (node->op == op_Sel);
971 return get_irn_n(node, 1);
975 set_Sel_ptr (ir_node *node, ir_node *ptr) {
976 assert (node->op == op_Sel);
977 set_irn_n(node, 1, ptr);
981 get_Sel_n_indexs (ir_node *node) {
982 assert (node->op == op_Sel);
983 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
987 get_Sel_index_arr (ir_node *node)
989 assert ((node->op == op_Sel));
990 if (get_Sel_n_indexs(node) > 0)
991 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
997 get_Sel_index (ir_node *node, int pos) {
998 assert (node->op == op_Sel);
999 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
1003 set_Sel_index (ir_node *node, int pos, ir_node *index) {
1004 assert (node->op == op_Sel);
1005 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
1009 get_Sel_entity (ir_node *node) {
1010 assert (node->op == op_Sel);
1011 return node->attr.s.ent;
1015 set_Sel_entity (ir_node *node, entity *ent) {
1016 assert (node->op == op_Sel);
1017 node->attr.s.ent = ent;
1021 get_InstOf_ent (ir_node *node) {
1022 assert (node->op = op_InstOf);
1023 return (node->attr.io.ent);
1027 set_InstOf_ent (ir_node *node, type *ent) {
1028 assert (node->op = op_InstOf);
1029 node->attr.io.ent = ent;
1033 get_InstOf_store (ir_node *node) {
1034 assert (node->op = op_InstOf);
1035 return (get_irn_n (node, 0));
1039 set_InstOf_store (ir_node *node, ir_node *obj) {
1040 assert (node->op = op_InstOf);
1041 set_irn_n (node, 0, obj);
1045 get_InstOf_obj (ir_node *node) {
1046 assert (node->op = op_InstOf);
1047 return (get_irn_n (node, 1));
1051 set_InstOf_obj (ir_node *node, ir_node *obj) {
1052 assert (node->op = op_InstOf);
1053 set_irn_n (node, 1, obj);
1057 /* For unary and binary arithmetic operations the access to the
1058 operands can be factored out. Left is the first, right the
1059 second arithmetic value as listed in tech report 0999-33.
1060 unops are: Minus, Abs, Not, Conv, Cast
1061 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1062 Shr, Shrs, Rotate, Cmp */
1066 get_Call_mem (ir_node *node) {
1067 assert (node->op == op_Call);
1068 return get_irn_n(node, 0);
1072 set_Call_mem (ir_node *node, ir_node *mem) {
1073 assert (node->op == op_Call);
1074 set_irn_n(node, 0, mem);
1078 get_Call_ptr (ir_node *node) {
1079 assert (node->op == op_Call);
1080 return get_irn_n(node, 1);
1084 set_Call_ptr (ir_node *node, ir_node *ptr) {
1085 assert (node->op == op_Call);
1086 set_irn_n(node, 1, ptr);
1090 get_Call_param_arr (ir_node *node) {
1091 assert (node->op == op_Call);
1092 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1096 get_Call_n_params (ir_node *node) {
1097 assert (node->op == op_Call);
1098 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1102 get_Call_arity (ir_node *node) {
1103 assert (node->op == op_Call);
1104 return get_Call_n_params(node);
1108 set_Call_arity (ir_node *node, ir_node *arity) {
1109 assert (node->op == op_Call);
1114 get_Call_param (ir_node *node, int pos) {
1115 assert (node->op == op_Call);
1116 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1120 set_Call_param (ir_node *node, int pos, ir_node *param) {
1121 assert (node->op == op_Call);
1122 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1126 get_Call_type (ir_node *node) {
1127 assert (node->op == op_Call);
1128 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1132 set_Call_type (ir_node *node, type *tp) {
1133 assert (node->op == op_Call);
1134 assert (is_method_type(tp));
1135 node->attr.call.cld_tp = tp;
1138 int get_Call_n_callees(ir_node * node) {
1139 assert(node->op == op_Call && node->attr.call.callee_arr);
1140 return ARR_LEN(node->attr.call.callee_arr);
1143 entity * get_Call_callee(ir_node * node, int pos) {
1144 assert(node->op == op_Call && node->attr.call.callee_arr);
1145 return node->attr.call.callee_arr[pos];
1148 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1149 assert(node->op == op_Call);
1150 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1151 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1153 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1156 void remove_Call_callee_arr(ir_node * node) {
1157 assert(node->op == op_Call);
1158 node->attr.call.callee_arr = NULL;
1161 ir_node * get_CallBegin_ptr (ir_node *node) {
1162 assert(node->op == op_CallBegin);
1163 return get_irn_n(node, 0);
1165 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1166 assert(node->op == op_CallBegin);
1167 set_irn_n(node, 0, ptr);
1169 ir_graph * get_CallBegin_irg (ir_node *node) {
1170 assert(node->op == op_CallBegin);
1171 return node->attr.callbegin.irg;
1173 ir_node * get_CallBegin_call (ir_node *node) {
1174 assert(node->op == op_CallBegin);
1175 return node->attr.callbegin.call;
1177 void set_CallBegin_call (ir_node *node, ir_node *call) {
1178 assert(node->op == op_CallBegin);
1179 node->attr.callbegin.call = call;
1183 get_Add_left (ir_node *node) {
1184 assert (node->op == op_Add);
1185 return get_irn_n(node, 0);
1189 set_Add_left (ir_node *node, ir_node *left) {
1190 assert (node->op == op_Add);
1191 set_irn_n(node, 0, left);
1195 get_Add_right (ir_node *node) {
1196 assert (node->op == op_Add);
1197 return get_irn_n(node, 1);
1201 set_Add_right (ir_node *node, ir_node *right) {
1202 assert (node->op == op_Add);
1203 set_irn_n(node, 1, right);
1207 get_Sub_left (ir_node *node) {
1208 assert (node->op == op_Sub);
1209 return get_irn_n(node, 0);
1213 set_Sub_left (ir_node *node, ir_node *left) {
1214 assert (node->op == op_Sub);
1215 set_irn_n(node, 0, left);
1219 get_Sub_right (ir_node *node) {
1220 assert (node->op == op_Sub);
1221 return get_irn_n(node, 1);
1225 set_Sub_right (ir_node *node, ir_node *right) {
1226 assert (node->op == op_Sub);
1227 set_irn_n(node, 1, right);
1232 get_Minus_op (ir_node *node) {
1233 assert (node->op == op_Minus);
1234 return get_irn_n(node, 0);
1238 set_Minus_op (ir_node *node, ir_node *op) {
1239 assert (node->op == op_Minus);
1240 set_irn_n(node, 0, op);
1245 get_Mul_left (ir_node *node) {
1246 assert (node->op == op_Mul);
1247 return get_irn_n(node, 0);
1251 set_Mul_left (ir_node *node, ir_node *left) {
1252 assert (node->op == op_Mul);
1253 set_irn_n(node, 0, left);
1257 get_Mul_right (ir_node *node) {
1258 assert (node->op == op_Mul);
1259 return get_irn_n(node, 1);
1263 set_Mul_right (ir_node *node, ir_node *right) {
1264 assert (node->op == op_Mul);
1265 set_irn_n(node, 1, right);
1269 get_Quot_left (ir_node *node) {
1270 assert (node->op == op_Quot);
1271 return get_irn_n(node, 1);
1275 set_Quot_left (ir_node *node, ir_node *left) {
1276 assert (node->op == op_Quot);
1277 set_irn_n(node, 1, left);
1281 get_Quot_right (ir_node *node) {
1282 assert (node->op == op_Quot);
1283 return get_irn_n(node, 2);
1287 set_Quot_right (ir_node *node, ir_node *right) {
1288 assert (node->op == op_Quot);
1289 set_irn_n(node, 2, right);
1293 get_Quot_mem (ir_node *node) {
1294 assert (node->op == op_Quot);
1295 return get_irn_n(node, 0);
1299 set_Quot_mem (ir_node *node, ir_node *mem) {
1300 assert (node->op == op_Quot);
1301 set_irn_n(node, 0, mem);
1305 get_DivMod_left (ir_node *node) {
1306 assert (node->op == op_DivMod);
1307 return get_irn_n(node, 1);
1311 set_DivMod_left (ir_node *node, ir_node *left) {
1312 assert (node->op == op_DivMod);
1313 set_irn_n(node, 1, left);
1317 get_DivMod_right (ir_node *node) {
1318 assert (node->op == op_DivMod);
1319 return get_irn_n(node, 2);
1323 set_DivMod_right (ir_node *node, ir_node *right) {
1324 assert (node->op == op_DivMod);
1325 set_irn_n(node, 2, right);
1329 get_DivMod_mem (ir_node *node) {
1330 assert (node->op == op_DivMod);
1331 return get_irn_n(node, 0);
1335 set_DivMod_mem (ir_node *node, ir_node *mem) {
1336 assert (node->op == op_DivMod);
1337 set_irn_n(node, 0, mem);
1341 get_Div_left (ir_node *node) {
1342 assert (node->op == op_Div);
1343 return get_irn_n(node, 1);
1347 set_Div_left (ir_node *node, ir_node *left) {
1348 assert (node->op == op_Div);
1349 set_irn_n(node, 1, left);
1353 get_Div_right (ir_node *node) {
1354 assert (node->op == op_Div);
1355 return get_irn_n(node, 2);
1359 set_Div_right (ir_node *node, ir_node *right) {
1360 assert (node->op == op_Div);
1361 set_irn_n(node, 2, right);
1365 get_Div_mem (ir_node *node) {
1366 assert (node->op == op_Div);
1367 return get_irn_n(node, 0);
1371 set_Div_mem (ir_node *node, ir_node *mem) {
1372 assert (node->op == op_Div);
1373 set_irn_n(node, 0, mem);
1377 get_Mod_left (ir_node *node) {
1378 assert (node->op == op_Mod);
1379 return get_irn_n(node, 1);
1383 set_Mod_left (ir_node *node, ir_node *left) {
1384 assert (node->op == op_Mod);
1385 set_irn_n(node, 1, left);
1389 get_Mod_right (ir_node *node) {
1390 assert (node->op == op_Mod);
1391 return get_irn_n(node, 2);
1395 set_Mod_right (ir_node *node, ir_node *right) {
1396 assert (node->op == op_Mod);
1397 set_irn_n(node, 2, right);
1401 get_Mod_mem (ir_node *node) {
1402 assert (node->op == op_Mod);
1403 return get_irn_n(node, 0);
1407 set_Mod_mem (ir_node *node, ir_node *mem) {
1408 assert (node->op == op_Mod);
1409 set_irn_n(node, 0, mem);
1413 get_Abs_op (ir_node *node) {
1414 assert (node->op == op_Abs);
1415 return get_irn_n(node, 0);
1419 set_Abs_op (ir_node *node, ir_node *op) {
1420 assert (node->op == op_Abs);
1421 set_irn_n(node, 0, op);
1425 get_And_left (ir_node *node) {
1426 assert (node->op == op_And);
1427 return get_irn_n(node, 0);
1431 set_And_left (ir_node *node, ir_node *left) {
1432 assert (node->op == op_And);
1433 set_irn_n(node, 0, left);
1437 get_And_right (ir_node *node) {
1438 assert (node->op == op_And);
1439 return get_irn_n(node, 1);
1443 set_And_right (ir_node *node, ir_node *right) {
1444 assert (node->op == op_And);
1445 set_irn_n(node, 1, right);
1449 get_Or_left (ir_node *node) {
1450 assert (node->op == op_Or);
1451 return get_irn_n(node, 0);
1455 set_Or_left (ir_node *node, ir_node *left) {
1456 assert (node->op == op_Or);
1457 set_irn_n(node, 0, left);
1461 get_Or_right (ir_node *node) {
1462 assert (node->op == op_Or);
1463 return get_irn_n(node, 1);
1467 set_Or_right (ir_node *node, ir_node *right) {
1468 assert (node->op == op_Or);
1469 set_irn_n(node, 1, right);
1473 get_Eor_left (ir_node *node) {
1474 assert (node->op == op_Eor);
1475 return get_irn_n(node, 0);
1479 set_Eor_left (ir_node *node, ir_node *left) {
1480 assert (node->op == op_Eor);
1481 set_irn_n(node, 0, left);
1485 get_Eor_right (ir_node *node) {
1486 assert (node->op == op_Eor);
1487 return get_irn_n(node, 1);
1491 set_Eor_right (ir_node *node, ir_node *right) {
1492 assert (node->op == op_Eor);
1493 set_irn_n(node, 1, right);
1498 get_Not_op (ir_node *node) {
1499 assert (node->op == op_Not);
1500 return get_irn_n(node, 0);
1504 set_Not_op (ir_node *node, ir_node *op) {
1505 assert (node->op == op_Not);
1506 set_irn_n(node, 0, op);
1511 get_Shl_left (ir_node *node) {
1512 assert (node->op == op_Shl);
1513 return get_irn_n(node, 0);
1517 set_Shl_left (ir_node *node, ir_node *left) {
1518 assert (node->op == op_Shl);
1519 set_irn_n(node, 0, left);
1523 get_Shl_right (ir_node *node) {
1524 assert (node->op == op_Shl);
1525 return get_irn_n(node, 1);
1529 set_Shl_right (ir_node *node, ir_node *right) {
1530 assert (node->op == op_Shl);
1531 set_irn_n(node, 1, right);
1535 get_Shr_left (ir_node *node) {
1536 assert (node->op == op_Shr);
1537 return get_irn_n(node, 0);
1541 set_Shr_left (ir_node *node, ir_node *left) {
1542 assert (node->op == op_Shr);
1543 set_irn_n(node, 0, left);
1547 get_Shr_right (ir_node *node) {
1548 assert (node->op == op_Shr);
1549 return get_irn_n(node, 1);
1553 set_Shr_right (ir_node *node, ir_node *right) {
1554 assert (node->op == op_Shr);
1555 set_irn_n(node, 1, right);
1559 get_Shrs_left (ir_node *node) {
1560 assert (node->op == op_Shrs);
1561 return get_irn_n(node, 0);
1565 set_Shrs_left (ir_node *node, ir_node *left) {
1566 assert (node->op == op_Shrs);
1567 set_irn_n(node, 0, left);
1571 get_Shrs_right (ir_node *node) {
1572 assert (node->op == op_Shrs);
1573 return get_irn_n(node, 1);
1577 set_Shrs_right (ir_node *node, ir_node *right) {
1578 assert (node->op == op_Shrs);
1579 set_irn_n(node, 1, right);
1583 get_Rot_left (ir_node *node) {
1584 assert (node->op == op_Rot);
1585 return get_irn_n(node, 0);
1589 set_Rot_left (ir_node *node, ir_node *left) {
1590 assert (node->op == op_Rot);
1591 set_irn_n(node, 0, left);
1595 get_Rot_right (ir_node *node) {
1596 assert (node->op == op_Rot);
1597 return get_irn_n(node, 1);
1601 set_Rot_right (ir_node *node, ir_node *right) {
1602 assert (node->op == op_Rot);
1603 set_irn_n(node, 1, right);
1607 get_Cmp_left (ir_node *node) {
1608 assert (node->op == op_Cmp);
1609 return get_irn_n(node, 0);
1613 set_Cmp_left (ir_node *node, ir_node *left) {
1614 assert (node->op == op_Cmp);
1615 set_irn_n(node, 0, left);
1619 get_Cmp_right (ir_node *node) {
1620 assert (node->op == op_Cmp);
1621 return get_irn_n(node, 1);
1625 set_Cmp_right (ir_node *node, ir_node *right) {
1626 assert (node->op == op_Cmp);
1627 set_irn_n(node, 1, right);
1631 get_Conv_op (ir_node *node) {
1632 assert (node->op == op_Conv);
1633 return get_irn_n(node, 0);
1637 set_Conv_op (ir_node *node, ir_node *op) {
1638 assert (node->op == op_Conv);
1639 set_irn_n(node, 0, op);
1643 get_Cast_op (ir_node *node) {
1644 assert (node->op == op_Cast);
1645 return get_irn_n(node, 0);
1649 set_Cast_op (ir_node *node, ir_node *op) {
1650 assert (node->op == op_Cast);
1651 set_irn_n(node, 0, op);
1655 get_Cast_type (ir_node *node) {
1656 assert (node->op == op_Cast);
1657 return node->attr.cast.totype;
1661 set_Cast_type (ir_node *node, type *to_tp) {
1662 assert (node->op == op_Cast);
1663 node->attr.cast.totype = to_tp;
1667 is_unop (ir_node *node) {
1668 return ( node->op == op_Minus ||
1669 node->op == op_Abs ||
1670 node->op == op_Not ||
1671 node->op == op_Conv ||
1672 node->op == op_Cast );
1676 get_unop_op (ir_node *node) {
1677 assert (is_unop(node));
1678 switch (get_irn_opcode (node)) {
1679 case iro_Minus: return get_Minus_op(node); break;
1680 case iro_Abs: return get_Abs_op(node); break;
1681 case iro_Not: return get_Not_op(node); break;
1682 case iro_Conv: return get_Conv_op(node); break;
1683 case iro_Cast: return get_Cast_op(node); break;
1684 default: return NULL;
1689 set_unop_op (ir_node *node, ir_node *op) {
1690 assert (is_unop(node));
1691 switch (get_irn_opcode (node)) {
1692 case iro_Minus: set_Minus_op(node, op); break;
1693 case iro_Abs: set_Abs_op(node, op); break;
1694 case iro_Not: set_Not_op(node, op); break;
1695 case iro_Conv: set_Conv_op(node, op); break;
1696 case iro_Cast: set_Cast_op(node, op); break;
1703 is_binop (ir_node *node) {
1704 return (node->op == op_Add ||
1705 node->op == op_Sub ||
1706 node->op == op_Mul ||
1707 node->op == op_Quot ||
1708 node->op == op_DivMod ||
1709 node->op == op_Div ||
1710 node->op == op_Mod ||
1711 node->op == op_And ||
1712 node->op == op_Or ||
1713 node->op == op_Eor ||
1714 node->op == op_Shl ||
1715 node->op == op_Shr ||
1716 node->op == op_Shrs ||
1717 node->op == op_Rot ||
1718 node->op == op_Cmp );
1722 get_binop_left (ir_node *node) {
1723 assert (node->op == op_Add ||
1724 node->op == op_Sub ||
1725 node->op == op_Mul ||
1726 node->op == op_Quot ||
1727 node->op == op_DivMod ||
1728 node->op == op_Div ||
1729 node->op == op_Mod ||
1730 node->op == op_And ||
1731 node->op == op_Or ||
1732 node->op == op_Eor ||
1733 node->op == op_Shl ||
1734 node->op == op_Shr ||
1735 node->op == op_Shrs ||
1736 node->op == op_Rot ||
1737 node->op == op_Cmp );
1739 switch (get_irn_opcode (node)) {
1740 case iro_Add : return get_Add_left(node); break;
1741 case iro_Sub : return get_Sub_left(node); break;
1742 case iro_Mul : return get_Mul_left(node); break;
1743 case iro_Quot : return get_Quot_left(node); break;
1744 case iro_DivMod: return get_DivMod_left(node); break;
1745 case iro_Div : return get_Div_left(node); break;
1746 case iro_Mod : return get_Mod_left(node); break;
1747 case iro_And : return get_And_left(node); break;
1748 case iro_Or : return get_Or_left(node); break;
1749 case iro_Eor : return get_Eor_left(node); break;
1750 case iro_Shl : return get_Shl_left(node); break;
1751 case iro_Shr : return get_Shr_left(node); break;
1752 case iro_Shrs : return get_Shrs_left(node); break;
1753 case iro_Rot : return get_Rot_left(node); break;
1754 case iro_Cmp : return get_Cmp_left(node); break;
1755 default: return NULL;
1760 set_binop_left (ir_node *node, ir_node *left) {
1761 assert (node->op == op_Add ||
1762 node->op == op_Sub ||
1763 node->op == op_Mul ||
1764 node->op == op_Quot ||
1765 node->op == op_DivMod ||
1766 node->op == op_Div ||
1767 node->op == op_Mod ||
1768 node->op == op_And ||
1769 node->op == op_Or ||
1770 node->op == op_Eor ||
1771 node->op == op_Shl ||
1772 node->op == op_Shr ||
1773 node->op == op_Shrs ||
1774 node->op == op_Rot ||
1775 node->op == op_Cmp );
1777 switch (get_irn_opcode (node)) {
1778 case iro_Add : set_Add_left(node, left); break;
1779 case iro_Sub : set_Sub_left(node, left); break;
1780 case iro_Mul : set_Mul_left(node, left); break;
1781 case iro_Quot : set_Quot_left(node, left); break;
1782 case iro_DivMod: set_DivMod_left(node, left); break;
1783 case iro_Div : set_Div_left(node, left); break;
1784 case iro_Mod : set_Mod_left(node, left); break;
1785 case iro_And : set_And_left(node, left); break;
1786 case iro_Or : set_Or_left(node, left); break;
1787 case iro_Eor : set_Eor_left(node, left); break;
1788 case iro_Shl : set_Shl_left(node, left); break;
1789 case iro_Shr : set_Shr_left(node, left); break;
1790 case iro_Shrs : set_Shrs_left(node, left); break;
1791 case iro_Rot : set_Rot_left(node, left); break;
1792 case iro_Cmp : set_Cmp_left(node, left); break;
1798 get_binop_right (ir_node *node) {
1799 assert (node->op == op_Add ||
1800 node->op == op_Sub ||
1801 node->op == op_Mul ||
1802 node->op == op_Quot ||
1803 node->op == op_DivMod ||
1804 node->op == op_Div ||
1805 node->op == op_Mod ||
1806 node->op == op_And ||
1807 node->op == op_Or ||
1808 node->op == op_Eor ||
1809 node->op == op_Shl ||
1810 node->op == op_Shr ||
1811 node->op == op_Shrs ||
1812 node->op == op_Rot ||
1813 node->op == op_Cmp );
1815 switch (get_irn_opcode (node)) {
1816 case iro_Add : return get_Add_right(node); break;
1817 case iro_Sub : return get_Sub_right(node); break;
1818 case iro_Mul : return get_Mul_right(node); break;
1819 case iro_Quot : return get_Quot_right(node); break;
1820 case iro_DivMod: return get_DivMod_right(node); break;
1821 case iro_Div : return get_Div_right(node); break;
1822 case iro_Mod : return get_Mod_right(node); break;
1823 case iro_And : return get_And_right(node); break;
1824 case iro_Or : return get_Or_right(node); break;
1825 case iro_Eor : return get_Eor_right(node); break;
1826 case iro_Shl : return get_Shl_right(node); break;
1827 case iro_Shr : return get_Shr_right(node); break;
1828 case iro_Shrs : return get_Shrs_right(node); break;
1829 case iro_Rot : return get_Rot_right(node); break;
1830 case iro_Cmp : return get_Cmp_right(node); break;
1831 default: return NULL;
1836 set_binop_right (ir_node *node, ir_node *right) {
1837 assert (node->op == op_Add ||
1838 node->op == op_Sub ||
1839 node->op == op_Mul ||
1840 node->op == op_Quot ||
1841 node->op == op_DivMod ||
1842 node->op == op_Div ||
1843 node->op == op_Mod ||
1844 node->op == op_And ||
1845 node->op == op_Or ||
1846 node->op == op_Eor ||
1847 node->op == op_Shl ||
1848 node->op == op_Shr ||
1849 node->op == op_Shrs ||
1850 node->op == op_Rot ||
1851 node->op == op_Cmp );
1853 switch (get_irn_opcode (node)) {
1854 case iro_Add : set_Add_right(node, right); break;
1855 case iro_Sub : set_Sub_right(node, right); break;
1856 case iro_Mul : set_Mul_right(node, right); break;
1857 case iro_Quot : set_Quot_right(node, right); break;
1858 case iro_DivMod: set_DivMod_right(node, right); break;
1859 case iro_Div : set_Div_right(node, right); break;
1860 case iro_Mod : set_Mod_right(node, right); break;
1861 case iro_And : set_And_right(node, right); break;
1862 case iro_Or : set_Or_right(node, right); break;
1863 case iro_Eor : set_Eor_right(node, right); break;
1864 case iro_Shl : set_Shl_right(node, right); break;
1865 case iro_Shr : set_Shr_right(node, right); break;
1866 case iro_Shrs : set_Shrs_right(node, right); break;
1867 case iro_Rot : set_Rot_right(node, right); break;
1868 case iro_Cmp : set_Cmp_right(node, right); break;
1875 get_Phi_preds_arr (ir_node *node) {
1876 assert (node->op == op_Phi);
1877 return (ir_node **)&(get_irn_in(node)[1]);
1881 get_Phi_n_preds (ir_node *node) {
1882 assert (node->op == op_Phi);
1883 return (get_irn_arity(node));
1887 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1888 assert (node->op == op_Phi);
1893 get_Phi_pred (ir_node *node, int pos) {
1894 assert (node->op == op_Phi);
1895 return get_irn_n(node, pos);
1899 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1900 assert (node->op == op_Phi);
1901 set_irn_n(node, pos, pred);
1905 get_Load_mem (ir_node *node) {
1906 assert (node->op == op_Load);
1907 return get_irn_n(node, 0);
1911 set_Load_mem (ir_node *node, ir_node *mem) {
1912 assert (node->op == op_Load);
1913 set_irn_n(node, 0, mem);
1917 get_Load_ptr (ir_node *node) {
1918 assert (node->op == op_Load);
1919 return get_irn_n(node, 1);
1923 set_Load_ptr (ir_node *node, ir_node *ptr) {
1924 assert (node->op == op_Load);
1925 set_irn_n(node, 1, ptr);
1930 get_Store_mem (ir_node *node) {
1931 assert (node->op == op_Store);
1932 return get_irn_n(node, 0);
1936 set_Store_mem (ir_node *node, ir_node *mem) {
1937 assert (node->op == op_Store);
1938 set_irn_n(node, 0, mem);
1942 get_Store_ptr (ir_node *node) {
1943 assert (node->op == op_Store);
1944 return get_irn_n(node, 1);
1948 set_Store_ptr (ir_node *node, ir_node *ptr) {
1949 assert (node->op == op_Store);
1950 set_irn_n(node, 1, ptr);
1954 get_Store_value (ir_node *node) {
1955 assert (node->op == op_Store);
1956 return get_irn_n(node, 2);
1960 set_Store_value (ir_node *node, ir_node *value) {
1961 assert (node->op == op_Store);
1962 set_irn_n(node, 2, value);
1966 get_Alloc_mem (ir_node *node) {
1967 assert (node->op == op_Alloc);
1968 return get_irn_n(node, 0);
1972 set_Alloc_mem (ir_node *node, ir_node *mem) {
1973 assert (node->op == op_Alloc);
1974 set_irn_n(node, 0, mem);
1978 get_Alloc_size (ir_node *node) {
1979 assert (node->op == op_Alloc);
1980 return get_irn_n(node, 1);
1984 set_Alloc_size (ir_node *node, ir_node *size) {
1985 assert (node->op == op_Alloc);
1986 set_irn_n(node, 1, size);
1990 get_Alloc_type (ir_node *node) {
1991 assert (node->op == op_Alloc);
1992 return node->attr.a.type = skip_tid(node->attr.a.type);
1996 set_Alloc_type (ir_node *node, type *tp) {
1997 assert (node->op == op_Alloc);
1998 node->attr.a.type = tp;
2002 get_Alloc_where (ir_node *node) {
2003 assert (node->op == op_Alloc);
2004 return node->attr.a.where;
2008 set_Alloc_where (ir_node *node, where_alloc where) {
2009 assert (node->op == op_Alloc);
2010 node->attr.a.where = where;
2015 get_Free_mem (ir_node *node) {
2016 assert (node->op == op_Free);
2017 return get_irn_n(node, 0);
2021 set_Free_mem (ir_node *node, ir_node *mem) {
2022 assert (node->op == op_Free);
2023 set_irn_n(node, 0, mem);
2027 get_Free_ptr (ir_node *node) {
2028 assert (node->op == op_Free);
2029 return get_irn_n(node, 1);
2033 set_Free_ptr (ir_node *node, ir_node *ptr) {
2034 assert (node->op == op_Free);
2035 set_irn_n(node, 1, ptr);
2039 get_Free_size (ir_node *node) {
2040 assert (node->op == op_Free);
2041 return get_irn_n(node, 2);
2045 set_Free_size (ir_node *node, ir_node *size) {
2046 assert (node->op == op_Free);
2047 set_irn_n(node, 2, size);
2051 get_Free_type (ir_node *node) {
2052 assert (node->op == op_Free);
2053 return node->attr.f = skip_tid(node->attr.f);
2057 set_Free_type (ir_node *node, type *tp) {
2058 assert (node->op == op_Free);
2063 get_Sync_preds_arr (ir_node *node) {
2064 assert (node->op == op_Sync);
2065 return (ir_node **)&(get_irn_in(node)[1]);
2069 get_Sync_n_preds (ir_node *node) {
2070 assert (node->op == op_Sync);
2071 return (get_irn_arity(node));
2076 set_Sync_n_preds (ir_node *node, int n_preds) {
2077 assert (node->op == op_Sync);
2082 get_Sync_pred (ir_node *node, int pos) {
2083 assert (node->op == op_Sync);
2084 return get_irn_n(node, pos);
2088 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
2089 assert (node->op == op_Sync);
2090 set_irn_n(node, pos, pred);
2094 get_Proj_pred (ir_node *node) {
2095 assert (is_Proj(node));
2096 return get_irn_n(node, 0);
2100 set_Proj_pred (ir_node *node, ir_node *pred) {
2101 assert (is_Proj(node));
2102 set_irn_n(node, 0, pred);
2106 get_Proj_proj (ir_node *node) {
2107 assert (is_Proj(node));
2108 if (get_irn_opcode(node) == iro_Proj) {
2109 return node->attr.proj;
2111 assert(get_irn_opcode(node) == iro_Filter);
2112 return node->attr.filter.proj;
2117 set_Proj_proj (ir_node *node, long proj) {
2118 assert (node->op == op_Proj);
2119 node->attr.proj = proj;
2123 get_Tuple_preds_arr (ir_node *node) {
2124 assert (node->op == op_Tuple);
2125 return (ir_node **)&(get_irn_in(node)[1]);
2129 get_Tuple_n_preds (ir_node *node) {
2130 assert (node->op == op_Tuple);
2131 return (get_irn_arity(node));
2136 set_Tuple_n_preds (ir_node *node, int n_preds) {
2137 assert (node->op == op_Tuple);
2142 get_Tuple_pred (ir_node *node, int pos) {
2143 assert (node->op == op_Tuple);
2144 return get_irn_n(node, pos);
2148 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2149 assert (node->op == op_Tuple);
2150 set_irn_n(node, pos, pred);
2154 get_Id_pred (ir_node *node) {
2155 assert (node->op == op_Id);
2156 return get_irn_n(node, 0);
2160 set_Id_pred (ir_node *node, ir_node *pred) {
2161 assert (node->op == op_Id);
2162 set_irn_n(node, 0, pred);
2165 INLINE ir_node *get_Confirm_value (ir_node *node) {
2166 assert (node->op == op_Confirm);
2167 return get_irn_n(node, 0);
2169 INLINE void set_Confirm_value (ir_node *node, ir_node *value) {
2170 assert (node->op == op_Confirm);
2171 set_irn_n(node, 0, value);
2173 INLINE ir_node *get_Confirm_bound (ir_node *node) {
2174 assert (node->op == op_Confirm);
2175 return get_irn_n(node, 1);
2177 INLINE void set_Confirm_bound (ir_node *node, ir_node *bound) {
2178 assert (node->op == op_Confirm);
2179 set_irn_n(node, 0, bound);
2181 INLINE pn_Cmp get_Confirm_cmp (ir_node *node) {
2182 assert (node->op == op_Confirm);
2183 return node->attr.confirm_cmp;
2185 INLINE void set_Confirm_cmp (ir_node *node, pn_Cmp cmp) {
2186 assert (node->op == op_Confirm);
2187 node->attr.confirm_cmp = cmp;
2192 get_Filter_pred (ir_node *node) {
2193 assert(node->op == op_Filter);
2197 set_Filter_pred (ir_node *node, ir_node *pred) {
2198 assert(node->op == op_Filter);
2202 get_Filter_proj(ir_node *node) {
2203 assert(node->op == op_Filter);
2204 return node->attr.filter.proj;
2207 set_Filter_proj (ir_node *node, long proj) {
2208 assert(node->op == op_Filter);
2209 node->attr.filter.proj = proj;
2212 /* Don't use get_irn_arity, get_irn_n in implementation as access
2213 shall work independent of view!!! */
2214 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2215 assert(node->op == op_Filter);
2216 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2217 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2218 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2219 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2220 node->attr.filter.in_cg[0] = node->in[0];
2222 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2225 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2226 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2227 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2228 node->attr.filter.in_cg[pos + 1] = pred;
2230 int get_Filter_n_cg_preds(ir_node *node) {
2231 assert(node->op == op_Filter && node->attr.filter.in_cg);
2232 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2234 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2236 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2238 arity = ARR_LEN(node->attr.filter.in_cg);
2239 assert(pos < arity - 1);
2240 return node->attr.filter.in_cg[pos + 1];
2245 get_irn_irg(ir_node *node) {
2246 if (get_irn_op(node) == op_CallBegin) {
2247 return node->attr.callbegin.irg;
2248 } else if (get_irn_op(node) == op_EndReg ||
2249 get_irn_op(node) == op_EndExcept) {
2250 return node->attr.end.irg;
2251 } else if (get_irn_op(node) == op_Start) {
2252 return node->attr.start.irg;
2254 assert(0 && "no irg attr");
2260 /******************************************************************/
2261 /* Auxiliary routines */
2262 /******************************************************************/
2265 skip_Proj (ir_node *node) {
2266 /* don't assert node !!! */
2267 if (node && is_Proj(node)) {
2268 return get_Proj_pred(node);
2275 skip_Tuple (ir_node *node) {
2278 if (!get_opt_normalize()) return node;
2280 node = skip_nop(node);
2281 if (get_irn_op(node) == op_Proj) {
2282 pred = skip_nop(get_Proj_pred(node));
2283 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2284 pred = skip_nop(skip_Tuple(pred));
2285 if (get_irn_op(pred) == op_Tuple)
2286 return get_Tuple_pred(pred, get_Proj_proj(node));
2291 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2292 than any other approach, as Id chains are resolved and all point to the real node, or
2293 all id's are self loops. */
2295 skip_nop (ir_node *node) {
2296 /* don't assert node !!! */
2298 if (!get_opt_normalize()) return node;
2300 /* Don't use get_Id_pred: We get into an endless loop for
2301 self-referencing Ids. */
2302 if (node && (node->op == op_Id) && (node != node->in[0+1])) {
2303 ir_node *rem_pred = node->in[0+1];
2306 assert (get_irn_arity (node) > 0);
2308 node->in[0+1] = node;
2309 res = skip_nop(rem_pred);
2310 if (res->op == op_Id) /* self-loop */ return node;
2312 node->in[0+1] = res;
2320 skip_Id (ir_node *node) {
2321 return skip_nop(node);
2325 is_Bad (ir_node *node) {
2327 if ((node) && get_irn_opcode(node) == iro_Bad)
2333 is_no_Block (ir_node *node) {
2335 return (get_irn_opcode(node) != iro_Block);
2339 is_Block (ir_node *node) {
2341 return (get_irn_opcode(node) == iro_Block);
2345 is_Proj (const ir_node *node) {
2347 return node->op == op_Proj
2348 || (!interprocedural_view && node->op == op_Filter);
2351 /* Returns true if the operation manipulates control flow. */
2353 is_cfop(ir_node *node) {
2354 return is_cfopcode(get_irn_op(node));
2357 /* Returns true if the operation manipulates interprocedural control flow:
2358 CallBegin, EndReg, EndExcept */
2359 INLINE int is_ip_cfop(ir_node *node) {
2360 return is_ip_cfopcode(get_irn_op(node));
2363 ir_graph *get_ip_cfop_irg(ir_node *n) {
2364 switch (get_irn_opcode(n)) {
2366 return get_EndReg_irg(n);
2368 return get_EndExcept_irg(n);
2370 return get_CallBegin_irg(n);
2372 assert(is_ip_cfop(n));
2374 return NULL; /* should never be reached */
2377 /* Returns true if the operation can change the control flow because
2380 is_fragile_op(ir_node *node) {
2381 return ( (get_irn_opcode(node) == iro_Call)
2382 || (get_irn_opcode(node) == iro_Quot)
2383 || (get_irn_opcode(node) == iro_DivMod)
2384 || (get_irn_opcode(node) == iro_Div)
2385 || (get_irn_opcode(node) == iro_Mod)
2386 || (get_irn_opcode(node) == iro_Load)
2387 || (get_irn_opcode(node) == iro_Store)
2388 || (get_irn_opcode(node) == iro_Alloc)
2389 || (get_irn_opcode(node) == iro_Bad)
2390 || (get_irn_opcode(node) == iro_Unknown));
2394 /* Returns the memory operand of fragile operations. */
2395 ir_node *get_fragile_op_mem(ir_node *node) {
2396 assert(node && is_fragile_op(node));
2398 switch (get_irn_opcode (node)) {
2407 return get_irn_n(node, 0);
2412 assert(0 && "not reached");