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));
623 return (block->attr.block.exc);
626 / * exc_t handling for Nodes * /
627 void set_Node_exc (ir_node *node, exc_t exc) {
628 set_Block_exc (get_nodes_Block (node), exc);
631 exc_t get_Node_exc (ir_node *node) {
632 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 return get_irn_irg(node);
688 set_Start_irg(ir_node *node, ir_graph *irg) {
689 assert(node->op == op_Start);
690 assert(is_ir_graph(irg));
691 assert(0 && " Why set 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 (ir_node *end) {
729 return get_irn_irg(end);
732 ir_graph *get_EndExcept_irg (ir_node *end) {
733 return get_irn_irg(end);
737 > Implementing the case construct (which is where the constant Proj node is
738 > important) involves far more than simply determining the constant values.
739 > We could argue that this is more properly a function of the translator from
740 > Firm to the target machine. That could be done if there was some way of
741 > projecting "default" out of the Cond node.
742 I know it's complicated.
743 Basically there are two proglems:
744 - determining the gaps between the projs
745 - determining the biggest case constant to konw the proj number for
747 I see several solutions:
748 1. Introduce a ProjDefault node. Solves both problems.
749 This means to extend all optimizations executed during construction.
750 2. Give the Cond node for switch two flavors:
751 a) there are no gaps in the projs (existing flavor)
752 b) gaps may exist, default proj is still the Proj with the largest
753 projection number. This covers also the gaps.
754 3. Fix the semantic of the Cond to that of 2b)
756 Solution 2 seems to be the best:
757 Computing the gaps in the Firm representation is not too hard, i.e.,
758 libfirm can implement a routine that transforms betweeen the two
759 flavours. This is also possible for 1) but 2) does not require to
760 change any existing optimization.
761 Further it should be far simpler to determine the biggest constant than
763 I don't want to choose 3) as 2a) seems to have advantages for
764 dataflow analysis and 3) does not allow to convert the representation to
768 get_Cond_selector (ir_node *node) {
769 assert (node->op == op_Cond);
770 return get_irn_n(node, 0);
774 set_Cond_selector (ir_node *node, ir_node *selector) {
775 assert (node->op == op_Cond);
776 set_irn_n(node, 0, selector);
780 get_Cond_kind (ir_node *node) {
781 assert (node->op == op_Cond);
782 return node->attr.c.kind;
786 set_Cond_kind (ir_node *node, cond_kind kind) {
787 assert (node->op == op_Cond);
788 node->attr.c.kind = kind;
792 get_Return_mem (ir_node *node) {
793 assert (node->op == op_Return);
794 return get_irn_n(node, 0);
798 set_Return_mem (ir_node *node, ir_node *mem) {
799 assert (node->op == op_Return);
800 set_irn_n(node, 0, mem);
804 get_Return_n_ress (ir_node *node) {
805 assert (node->op == op_Return);
806 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
810 get_Return_res_arr (ir_node *node)
812 assert ((node->op == op_Return));
813 if (get_Return_n_ress(node) > 0)
814 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
821 set_Return_n_res (ir_node *node, int results) {
822 assert (node->op == op_Return);
827 get_Return_res (ir_node *node, int pos) {
828 assert (node->op == op_Return);
829 assert (get_Return_n_ress(node) > pos);
830 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
834 set_Return_res (ir_node *node, int pos, ir_node *res){
835 assert (node->op == op_Return);
836 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
840 get_Raise_mem (ir_node *node) {
841 assert (node->op == op_Raise);
842 return get_irn_n(node, 0);
846 set_Raise_mem (ir_node *node, ir_node *mem) {
847 assert (node->op == op_Raise);
848 set_irn_n(node, 0, mem);
852 get_Raise_exo_ptr (ir_node *node) {
853 assert (node->op == op_Raise);
854 return get_irn_n(node, 1);
858 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
859 assert (node->op == op_Raise);
860 set_irn_n(node, 1, exo_ptr);
863 INLINE tarval *get_Const_tarval (ir_node *node) {
864 assert (node->op == op_Const);
865 return node->attr.con.tv;
869 set_Const_tarval (ir_node *node, tarval *con) {
870 assert (node->op == op_Const);
871 node->attr.con.tv = con;
875 /* The source language type. Must be an atomic type. Mode of type must
876 be mode of node. For tarvals from entities type must be pointer to
879 get_Const_type (ir_node *node) {
880 assert (node->op == op_Const);
881 return node->attr.con.tp;
885 set_Const_type (ir_node *node, type *tp) {
886 assert (node->op == op_Const);
887 if (tp != unknown_type) {
888 assert (is_atomic_type(tp));
889 assert (get_type_mode(tp) == get_irn_mode(node));
890 assert (!tarval_is_entity(get_Const_tarval(node)) ||
891 (is_pointer_type(tp) &&
892 (get_pointer_points_to_type(tp) ==
893 get_entity_type(get_tarval_entity(get_Const_tarval(node))))));
896 node->attr.con.tp = tp;
901 get_SymConst_kind (const ir_node *node) {
902 assert (node->op == op_SymConst);
903 return node->attr.i.num;
907 set_SymConst_kind (ir_node *node, symconst_kind num) {
908 assert (node->op == op_SymConst);
909 node->attr.i.num = num;
913 get_SymConst_type (ir_node *node) {
914 assert ( (node->op == op_SymConst)
915 && ( get_SymConst_kind(node) == type_tag
916 || get_SymConst_kind(node) == size));
917 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
921 set_SymConst_type (ir_node *node, type *tp) {
922 assert ( (node->op == op_SymConst)
923 && ( get_SymConst_kind(node) == type_tag
924 || get_SymConst_kind(node) == size));
925 node->attr.i.tori.typ = tp;
929 get_SymConst_ptrinfo (ir_node *node) {
930 assert ( (node->op == op_SymConst)
931 && (get_SymConst_kind(node) == linkage_ptr_info));
932 return node->attr.i.tori.ptrinfo;
936 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
937 assert ( (node->op == op_SymConst)
938 && (get_SymConst_kind(node) == linkage_ptr_info));
939 node->attr.i.tori.ptrinfo = ptrinfo;
943 get_SymConst_type_or_id (ir_node *node) {
944 assert (node->op == op_SymConst);
945 return &(node->attr.i.tori);
949 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
950 assert (node->op == op_SymConst);
951 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
955 get_Sel_mem (ir_node *node) {
956 assert (node->op == op_Sel);
957 return get_irn_n(node, 0);
961 set_Sel_mem (ir_node *node, ir_node *mem) {
962 assert (node->op == op_Sel);
963 set_irn_n(node, 0, mem);
967 get_Sel_ptr (ir_node *node) {
968 assert (node->op == op_Sel);
969 return get_irn_n(node, 1);
973 set_Sel_ptr (ir_node *node, ir_node *ptr) {
974 assert (node->op == op_Sel);
975 set_irn_n(node, 1, ptr);
979 get_Sel_n_indexs (ir_node *node) {
980 assert (node->op == op_Sel);
981 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
985 get_Sel_index_arr (ir_node *node)
987 assert ((node->op == op_Sel));
988 if (get_Sel_n_indexs(node) > 0)
989 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
995 get_Sel_index (ir_node *node, int pos) {
996 assert (node->op == op_Sel);
997 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
1001 set_Sel_index (ir_node *node, int pos, ir_node *index) {
1002 assert (node->op == op_Sel);
1003 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
1007 get_Sel_entity (ir_node *node) {
1008 assert (node->op == op_Sel);
1009 return node->attr.s.ent;
1013 set_Sel_entity (ir_node *node, entity *ent) {
1014 assert (node->op == op_Sel);
1015 node->attr.s.ent = ent;
1019 get_InstOf_ent (ir_node *node) {
1020 assert (node->op = op_InstOf);
1021 return (node->attr.io.ent);
1025 set_InstOf_ent (ir_node *node, type *ent) {
1026 assert (node->op = op_InstOf);
1027 node->attr.io.ent = ent;
1031 get_InstOf_store (ir_node *node) {
1032 assert (node->op = op_InstOf);
1033 return (get_irn_n (node, 0));
1037 set_InstOf_store (ir_node *node, ir_node *obj) {
1038 assert (node->op = op_InstOf);
1039 set_irn_n (node, 0, obj);
1043 get_InstOf_obj (ir_node *node) {
1044 assert (node->op = op_InstOf);
1045 return (get_irn_n (node, 1));
1049 set_InstOf_obj (ir_node *node, ir_node *obj) {
1050 assert (node->op = op_InstOf);
1051 set_irn_n (node, 1, obj);
1055 /* For unary and binary arithmetic operations the access to the
1056 operands can be factored out. Left is the first, right the
1057 second arithmetic value as listed in tech report 0999-33.
1058 unops are: Minus, Abs, Not, Conv, Cast
1059 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1060 Shr, Shrs, Rotate, Cmp */
1064 get_Call_mem (ir_node *node) {
1065 assert (node->op == op_Call);
1066 return get_irn_n(node, 0);
1070 set_Call_mem (ir_node *node, ir_node *mem) {
1071 assert (node->op == op_Call);
1072 set_irn_n(node, 0, mem);
1076 get_Call_ptr (ir_node *node) {
1077 assert (node->op == op_Call);
1078 return get_irn_n(node, 1);
1082 set_Call_ptr (ir_node *node, ir_node *ptr) {
1083 assert (node->op == op_Call);
1084 set_irn_n(node, 1, ptr);
1088 get_Call_param_arr (ir_node *node) {
1089 assert (node->op == op_Call);
1090 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1094 get_Call_n_params (ir_node *node) {
1095 assert (node->op == op_Call);
1096 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1100 get_Call_arity (ir_node *node) {
1101 assert (node->op == op_Call);
1102 return get_Call_n_params(node);
1106 set_Call_arity (ir_node *node, ir_node *arity) {
1107 assert (node->op == op_Call);
1112 get_Call_param (ir_node *node, int pos) {
1113 assert (node->op == op_Call);
1114 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1118 set_Call_param (ir_node *node, int pos, ir_node *param) {
1119 assert (node->op == op_Call);
1120 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1124 get_Call_type (ir_node *node) {
1125 assert (node->op == op_Call);
1126 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1130 set_Call_type (ir_node *node, type *tp) {
1131 assert (node->op == op_Call);
1132 assert (is_method_type(tp));
1133 node->attr.call.cld_tp = tp;
1136 int get_Call_n_callees(ir_node * node) {
1137 assert(node->op == op_Call && node->attr.call.callee_arr);
1138 return ARR_LEN(node->attr.call.callee_arr);
1141 entity * get_Call_callee(ir_node * node, int pos) {
1142 assert(node->op == op_Call && node->attr.call.callee_arr);
1143 return node->attr.call.callee_arr[pos];
1146 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1147 assert(node->op == op_Call);
1148 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1149 node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1151 memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1154 void remove_Call_callee_arr(ir_node * node) {
1155 assert(node->op == op_Call);
1156 node->attr.call.callee_arr = NULL;
1159 ir_node * get_CallBegin_ptr (ir_node *node) {
1160 assert(node->op == op_CallBegin);
1161 return get_irn_n(node, 0);
1163 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1164 assert(node->op == op_CallBegin);
1165 set_irn_n(node, 0, ptr);
1167 ir_graph * get_CallBegin_irg (ir_node *node) {
1168 return get_irn_irg(node);
1170 ir_node * get_CallBegin_call (ir_node *node) {
1171 assert(node->op == op_CallBegin);
1172 return node->attr.callbegin.call;
1174 void set_CallBegin_call (ir_node *node, ir_node *call) {
1175 assert(node->op == op_CallBegin);
1176 node->attr.callbegin.call = call;
1180 get_Add_left (ir_node *node) {
1181 assert (node->op == op_Add);
1182 return get_irn_n(node, 0);
1186 set_Add_left (ir_node *node, ir_node *left) {
1187 assert (node->op == op_Add);
1188 set_irn_n(node, 0, left);
1192 get_Add_right (ir_node *node) {
1193 assert (node->op == op_Add);
1194 return get_irn_n(node, 1);
1198 set_Add_right (ir_node *node, ir_node *right) {
1199 assert (node->op == op_Add);
1200 set_irn_n(node, 1, right);
1204 get_Sub_left (ir_node *node) {
1205 assert (node->op == op_Sub);
1206 return get_irn_n(node, 0);
1210 set_Sub_left (ir_node *node, ir_node *left) {
1211 assert (node->op == op_Sub);
1212 set_irn_n(node, 0, left);
1216 get_Sub_right (ir_node *node) {
1217 assert (node->op == op_Sub);
1218 return get_irn_n(node, 1);
1222 set_Sub_right (ir_node *node, ir_node *right) {
1223 assert (node->op == op_Sub);
1224 set_irn_n(node, 1, right);
1229 get_Minus_op (ir_node *node) {
1230 assert (node->op == op_Minus);
1231 return get_irn_n(node, 0);
1235 set_Minus_op (ir_node *node, ir_node *op) {
1236 assert (node->op == op_Minus);
1237 set_irn_n(node, 0, op);
1242 get_Mul_left (ir_node *node) {
1243 assert (node->op == op_Mul);
1244 return get_irn_n(node, 0);
1248 set_Mul_left (ir_node *node, ir_node *left) {
1249 assert (node->op == op_Mul);
1250 set_irn_n(node, 0, left);
1254 get_Mul_right (ir_node *node) {
1255 assert (node->op == op_Mul);
1256 return get_irn_n(node, 1);
1260 set_Mul_right (ir_node *node, ir_node *right) {
1261 assert (node->op == op_Mul);
1262 set_irn_n(node, 1, right);
1266 get_Quot_left (ir_node *node) {
1267 assert (node->op == op_Quot);
1268 return get_irn_n(node, 1);
1272 set_Quot_left (ir_node *node, ir_node *left) {
1273 assert (node->op == op_Quot);
1274 set_irn_n(node, 1, left);
1278 get_Quot_right (ir_node *node) {
1279 assert (node->op == op_Quot);
1280 return get_irn_n(node, 2);
1284 set_Quot_right (ir_node *node, ir_node *right) {
1285 assert (node->op == op_Quot);
1286 set_irn_n(node, 2, right);
1290 get_Quot_mem (ir_node *node) {
1291 assert (node->op == op_Quot);
1292 return get_irn_n(node, 0);
1296 set_Quot_mem (ir_node *node, ir_node *mem) {
1297 assert (node->op == op_Quot);
1298 set_irn_n(node, 0, mem);
1302 get_DivMod_left (ir_node *node) {
1303 assert (node->op == op_DivMod);
1304 return get_irn_n(node, 1);
1308 set_DivMod_left (ir_node *node, ir_node *left) {
1309 assert (node->op == op_DivMod);
1310 set_irn_n(node, 1, left);
1314 get_DivMod_right (ir_node *node) {
1315 assert (node->op == op_DivMod);
1316 return get_irn_n(node, 2);
1320 set_DivMod_right (ir_node *node, ir_node *right) {
1321 assert (node->op == op_DivMod);
1322 set_irn_n(node, 2, right);
1326 get_DivMod_mem (ir_node *node) {
1327 assert (node->op == op_DivMod);
1328 return get_irn_n(node, 0);
1332 set_DivMod_mem (ir_node *node, ir_node *mem) {
1333 assert (node->op == op_DivMod);
1334 set_irn_n(node, 0, mem);
1338 get_Div_left (ir_node *node) {
1339 assert (node->op == op_Div);
1340 return get_irn_n(node, 1);
1344 set_Div_left (ir_node *node, ir_node *left) {
1345 assert (node->op == op_Div);
1346 set_irn_n(node, 1, left);
1350 get_Div_right (ir_node *node) {
1351 assert (node->op == op_Div);
1352 return get_irn_n(node, 2);
1356 set_Div_right (ir_node *node, ir_node *right) {
1357 assert (node->op == op_Div);
1358 set_irn_n(node, 2, right);
1362 get_Div_mem (ir_node *node) {
1363 assert (node->op == op_Div);
1364 return get_irn_n(node, 0);
1368 set_Div_mem (ir_node *node, ir_node *mem) {
1369 assert (node->op == op_Div);
1370 set_irn_n(node, 0, mem);
1374 get_Mod_left (ir_node *node) {
1375 assert (node->op == op_Mod);
1376 return get_irn_n(node, 1);
1380 set_Mod_left (ir_node *node, ir_node *left) {
1381 assert (node->op == op_Mod);
1382 set_irn_n(node, 1, left);
1386 get_Mod_right (ir_node *node) {
1387 assert (node->op == op_Mod);
1388 return get_irn_n(node, 2);
1392 set_Mod_right (ir_node *node, ir_node *right) {
1393 assert (node->op == op_Mod);
1394 set_irn_n(node, 2, right);
1398 get_Mod_mem (ir_node *node) {
1399 assert (node->op == op_Mod);
1400 return get_irn_n(node, 0);
1404 set_Mod_mem (ir_node *node, ir_node *mem) {
1405 assert (node->op == op_Mod);
1406 set_irn_n(node, 0, mem);
1410 get_Abs_op (ir_node *node) {
1411 assert (node->op == op_Abs);
1412 return get_irn_n(node, 0);
1416 set_Abs_op (ir_node *node, ir_node *op) {
1417 assert (node->op == op_Abs);
1418 set_irn_n(node, 0, op);
1422 get_And_left (ir_node *node) {
1423 assert (node->op == op_And);
1424 return get_irn_n(node, 0);
1428 set_And_left (ir_node *node, ir_node *left) {
1429 assert (node->op == op_And);
1430 set_irn_n(node, 0, left);
1434 get_And_right (ir_node *node) {
1435 assert (node->op == op_And);
1436 return get_irn_n(node, 1);
1440 set_And_right (ir_node *node, ir_node *right) {
1441 assert (node->op == op_And);
1442 set_irn_n(node, 1, right);
1446 get_Or_left (ir_node *node) {
1447 assert (node->op == op_Or);
1448 return get_irn_n(node, 0);
1452 set_Or_left (ir_node *node, ir_node *left) {
1453 assert (node->op == op_Or);
1454 set_irn_n(node, 0, left);
1458 get_Or_right (ir_node *node) {
1459 assert (node->op == op_Or);
1460 return get_irn_n(node, 1);
1464 set_Or_right (ir_node *node, ir_node *right) {
1465 assert (node->op == op_Or);
1466 set_irn_n(node, 1, right);
1470 get_Eor_left (ir_node *node) {
1471 assert (node->op == op_Eor);
1472 return get_irn_n(node, 0);
1476 set_Eor_left (ir_node *node, ir_node *left) {
1477 assert (node->op == op_Eor);
1478 set_irn_n(node, 0, left);
1482 get_Eor_right (ir_node *node) {
1483 assert (node->op == op_Eor);
1484 return get_irn_n(node, 1);
1488 set_Eor_right (ir_node *node, ir_node *right) {
1489 assert (node->op == op_Eor);
1490 set_irn_n(node, 1, right);
1495 get_Not_op (ir_node *node) {
1496 assert (node->op == op_Not);
1497 return get_irn_n(node, 0);
1501 set_Not_op (ir_node *node, ir_node *op) {
1502 assert (node->op == op_Not);
1503 set_irn_n(node, 0, op);
1508 get_Shl_left (ir_node *node) {
1509 assert (node->op == op_Shl);
1510 return get_irn_n(node, 0);
1514 set_Shl_left (ir_node *node, ir_node *left) {
1515 assert (node->op == op_Shl);
1516 set_irn_n(node, 0, left);
1520 get_Shl_right (ir_node *node) {
1521 assert (node->op == op_Shl);
1522 return get_irn_n(node, 1);
1526 set_Shl_right (ir_node *node, ir_node *right) {
1527 assert (node->op == op_Shl);
1528 set_irn_n(node, 1, right);
1532 get_Shr_left (ir_node *node) {
1533 assert (node->op == op_Shr);
1534 return get_irn_n(node, 0);
1538 set_Shr_left (ir_node *node, ir_node *left) {
1539 assert (node->op == op_Shr);
1540 set_irn_n(node, 0, left);
1544 get_Shr_right (ir_node *node) {
1545 assert (node->op == op_Shr);
1546 return get_irn_n(node, 1);
1550 set_Shr_right (ir_node *node, ir_node *right) {
1551 assert (node->op == op_Shr);
1552 set_irn_n(node, 1, right);
1556 get_Shrs_left (ir_node *node) {
1557 assert (node->op == op_Shrs);
1558 return get_irn_n(node, 0);
1562 set_Shrs_left (ir_node *node, ir_node *left) {
1563 assert (node->op == op_Shrs);
1564 set_irn_n(node, 0, left);
1568 get_Shrs_right (ir_node *node) {
1569 assert (node->op == op_Shrs);
1570 return get_irn_n(node, 1);
1574 set_Shrs_right (ir_node *node, ir_node *right) {
1575 assert (node->op == op_Shrs);
1576 set_irn_n(node, 1, right);
1580 get_Rot_left (ir_node *node) {
1581 assert (node->op == op_Rot);
1582 return get_irn_n(node, 0);
1586 set_Rot_left (ir_node *node, ir_node *left) {
1587 assert (node->op == op_Rot);
1588 set_irn_n(node, 0, left);
1592 get_Rot_right (ir_node *node) {
1593 assert (node->op == op_Rot);
1594 return get_irn_n(node, 1);
1598 set_Rot_right (ir_node *node, ir_node *right) {
1599 assert (node->op == op_Rot);
1600 set_irn_n(node, 1, right);
1604 get_Cmp_left (ir_node *node) {
1605 assert (node->op == op_Cmp);
1606 return get_irn_n(node, 0);
1610 set_Cmp_left (ir_node *node, ir_node *left) {
1611 assert (node->op == op_Cmp);
1612 set_irn_n(node, 0, left);
1616 get_Cmp_right (ir_node *node) {
1617 assert (node->op == op_Cmp);
1618 return get_irn_n(node, 1);
1622 set_Cmp_right (ir_node *node, ir_node *right) {
1623 assert (node->op == op_Cmp);
1624 set_irn_n(node, 1, right);
1628 get_Conv_op (ir_node *node) {
1629 assert (node->op == op_Conv);
1630 return get_irn_n(node, 0);
1634 set_Conv_op (ir_node *node, ir_node *op) {
1635 assert (node->op == op_Conv);
1636 set_irn_n(node, 0, op);
1640 get_Cast_op (ir_node *node) {
1641 assert (node->op == op_Cast);
1642 return get_irn_n(node, 0);
1646 set_Cast_op (ir_node *node, ir_node *op) {
1647 assert (node->op == op_Cast);
1648 set_irn_n(node, 0, op);
1652 get_Cast_type (ir_node *node) {
1653 assert (node->op == op_Cast);
1654 return node->attr.cast.totype;
1658 set_Cast_type (ir_node *node, type *to_tp) {
1659 assert (node->op == op_Cast);
1660 node->attr.cast.totype = to_tp;
1664 is_unop (ir_node *node) {
1665 return ( node->op == op_Minus ||
1666 node->op == op_Abs ||
1667 node->op == op_Not ||
1668 node->op == op_Conv ||
1669 node->op == op_Cast );
1673 get_unop_op (ir_node *node) {
1674 assert (is_unop(node));
1675 switch (get_irn_opcode (node)) {
1676 case iro_Minus: return get_Minus_op(node); break;
1677 case iro_Abs: return get_Abs_op(node); break;
1678 case iro_Not: return get_Not_op(node); break;
1679 case iro_Conv: return get_Conv_op(node); break;
1680 case iro_Cast: return get_Cast_op(node); break;
1681 default: return NULL;
1686 set_unop_op (ir_node *node, ir_node *op) {
1687 assert (is_unop(node));
1688 switch (get_irn_opcode (node)) {
1689 case iro_Minus: set_Minus_op(node, op); break;
1690 case iro_Abs: set_Abs_op(node, op); break;
1691 case iro_Not: set_Not_op(node, op); break;
1692 case iro_Conv: set_Conv_op(node, op); break;
1693 case iro_Cast: set_Cast_op(node, op); break;
1700 is_binop (ir_node *node) {
1701 return (node->op == op_Add ||
1702 node->op == op_Sub ||
1703 node->op == op_Mul ||
1704 node->op == op_Quot ||
1705 node->op == op_DivMod ||
1706 node->op == op_Div ||
1707 node->op == op_Mod ||
1708 node->op == op_And ||
1709 node->op == op_Or ||
1710 node->op == op_Eor ||
1711 node->op == op_Shl ||
1712 node->op == op_Shr ||
1713 node->op == op_Shrs ||
1714 node->op == op_Rot ||
1715 node->op == op_Cmp );
1719 get_binop_left (ir_node *node) {
1720 assert (node->op == op_Add ||
1721 node->op == op_Sub ||
1722 node->op == op_Mul ||
1723 node->op == op_Quot ||
1724 node->op == op_DivMod ||
1725 node->op == op_Div ||
1726 node->op == op_Mod ||
1727 node->op == op_And ||
1728 node->op == op_Or ||
1729 node->op == op_Eor ||
1730 node->op == op_Shl ||
1731 node->op == op_Shr ||
1732 node->op == op_Shrs ||
1733 node->op == op_Rot ||
1734 node->op == op_Cmp );
1736 switch (get_irn_opcode (node)) {
1737 case iro_Add : return get_Add_left(node); break;
1738 case iro_Sub : return get_Sub_left(node); break;
1739 case iro_Mul : return get_Mul_left(node); break;
1740 case iro_Quot : return get_Quot_left(node); break;
1741 case iro_DivMod: return get_DivMod_left(node); break;
1742 case iro_Div : return get_Div_left(node); break;
1743 case iro_Mod : return get_Mod_left(node); break;
1744 case iro_And : return get_And_left(node); break;
1745 case iro_Or : return get_Or_left(node); break;
1746 case iro_Eor : return get_Eor_left(node); break;
1747 case iro_Shl : return get_Shl_left(node); break;
1748 case iro_Shr : return get_Shr_left(node); break;
1749 case iro_Shrs : return get_Shrs_left(node); break;
1750 case iro_Rot : return get_Rot_left(node); break;
1751 case iro_Cmp : return get_Cmp_left(node); break;
1752 default: return NULL;
1757 set_binop_left (ir_node *node, ir_node *left) {
1758 assert (node->op == op_Add ||
1759 node->op == op_Sub ||
1760 node->op == op_Mul ||
1761 node->op == op_Quot ||
1762 node->op == op_DivMod ||
1763 node->op == op_Div ||
1764 node->op == op_Mod ||
1765 node->op == op_And ||
1766 node->op == op_Or ||
1767 node->op == op_Eor ||
1768 node->op == op_Shl ||
1769 node->op == op_Shr ||
1770 node->op == op_Shrs ||
1771 node->op == op_Rot ||
1772 node->op == op_Cmp );
1774 switch (get_irn_opcode (node)) {
1775 case iro_Add : set_Add_left(node, left); break;
1776 case iro_Sub : set_Sub_left(node, left); break;
1777 case iro_Mul : set_Mul_left(node, left); break;
1778 case iro_Quot : set_Quot_left(node, left); break;
1779 case iro_DivMod: set_DivMod_left(node, left); break;
1780 case iro_Div : set_Div_left(node, left); break;
1781 case iro_Mod : set_Mod_left(node, left); break;
1782 case iro_And : set_And_left(node, left); break;
1783 case iro_Or : set_Or_left(node, left); break;
1784 case iro_Eor : set_Eor_left(node, left); break;
1785 case iro_Shl : set_Shl_left(node, left); break;
1786 case iro_Shr : set_Shr_left(node, left); break;
1787 case iro_Shrs : set_Shrs_left(node, left); break;
1788 case iro_Rot : set_Rot_left(node, left); break;
1789 case iro_Cmp : set_Cmp_left(node, left); break;
1795 get_binop_right (ir_node *node) {
1796 assert (node->op == op_Add ||
1797 node->op == op_Sub ||
1798 node->op == op_Mul ||
1799 node->op == op_Quot ||
1800 node->op == op_DivMod ||
1801 node->op == op_Div ||
1802 node->op == op_Mod ||
1803 node->op == op_And ||
1804 node->op == op_Or ||
1805 node->op == op_Eor ||
1806 node->op == op_Shl ||
1807 node->op == op_Shr ||
1808 node->op == op_Shrs ||
1809 node->op == op_Rot ||
1810 node->op == op_Cmp );
1812 switch (get_irn_opcode (node)) {
1813 case iro_Add : return get_Add_right(node); break;
1814 case iro_Sub : return get_Sub_right(node); break;
1815 case iro_Mul : return get_Mul_right(node); break;
1816 case iro_Quot : return get_Quot_right(node); break;
1817 case iro_DivMod: return get_DivMod_right(node); break;
1818 case iro_Div : return get_Div_right(node); break;
1819 case iro_Mod : return get_Mod_right(node); break;
1820 case iro_And : return get_And_right(node); break;
1821 case iro_Or : return get_Or_right(node); break;
1822 case iro_Eor : return get_Eor_right(node); break;
1823 case iro_Shl : return get_Shl_right(node); break;
1824 case iro_Shr : return get_Shr_right(node); break;
1825 case iro_Shrs : return get_Shrs_right(node); break;
1826 case iro_Rot : return get_Rot_right(node); break;
1827 case iro_Cmp : return get_Cmp_right(node); break;
1828 default: return NULL;
1833 set_binop_right (ir_node *node, ir_node *right) {
1834 assert (node->op == op_Add ||
1835 node->op == op_Sub ||
1836 node->op == op_Mul ||
1837 node->op == op_Quot ||
1838 node->op == op_DivMod ||
1839 node->op == op_Div ||
1840 node->op == op_Mod ||
1841 node->op == op_And ||
1842 node->op == op_Or ||
1843 node->op == op_Eor ||
1844 node->op == op_Shl ||
1845 node->op == op_Shr ||
1846 node->op == op_Shrs ||
1847 node->op == op_Rot ||
1848 node->op == op_Cmp );
1850 switch (get_irn_opcode (node)) {
1851 case iro_Add : set_Add_right(node, right); break;
1852 case iro_Sub : set_Sub_right(node, right); break;
1853 case iro_Mul : set_Mul_right(node, right); break;
1854 case iro_Quot : set_Quot_right(node, right); break;
1855 case iro_DivMod: set_DivMod_right(node, right); break;
1856 case iro_Div : set_Div_right(node, right); break;
1857 case iro_Mod : set_Mod_right(node, right); break;
1858 case iro_And : set_And_right(node, right); break;
1859 case iro_Or : set_Or_right(node, right); break;
1860 case iro_Eor : set_Eor_right(node, right); break;
1861 case iro_Shl : set_Shl_right(node, right); break;
1862 case iro_Shr : set_Shr_right(node, right); break;
1863 case iro_Shrs : set_Shrs_right(node, right); break;
1864 case iro_Rot : set_Rot_right(node, right); break;
1865 case iro_Cmp : set_Cmp_right(node, right); break;
1872 get_Phi_preds_arr (ir_node *node) {
1873 assert (node->op == op_Phi);
1874 return (ir_node **)&(get_irn_in(node)[1]);
1878 get_Phi_n_preds (ir_node *node) {
1879 assert (node->op == op_Phi);
1880 return (get_irn_arity(node));
1884 INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
1885 assert (node->op == op_Phi);
1890 get_Phi_pred (ir_node *node, int pos) {
1891 assert (node->op == op_Phi);
1892 return get_irn_n(node, pos);
1896 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1897 assert (node->op == op_Phi);
1898 set_irn_n(node, pos, pred);
1902 get_Load_mem (ir_node *node) {
1903 assert (node->op == op_Load);
1904 return get_irn_n(node, 0);
1908 set_Load_mem (ir_node *node, ir_node *mem) {
1909 assert (node->op == op_Load);
1910 set_irn_n(node, 0, mem);
1914 get_Load_ptr (ir_node *node) {
1915 assert (node->op == op_Load);
1916 return get_irn_n(node, 1);
1920 set_Load_ptr (ir_node *node, ir_node *ptr) {
1921 assert (node->op == op_Load);
1922 set_irn_n(node, 1, ptr);
1927 get_Store_mem (ir_node *node) {
1928 assert (node->op == op_Store);
1929 return get_irn_n(node, 0);
1933 set_Store_mem (ir_node *node, ir_node *mem) {
1934 assert (node->op == op_Store);
1935 set_irn_n(node, 0, mem);
1939 get_Store_ptr (ir_node *node) {
1940 assert (node->op == op_Store);
1941 return get_irn_n(node, 1);
1945 set_Store_ptr (ir_node *node, ir_node *ptr) {
1946 assert (node->op == op_Store);
1947 set_irn_n(node, 1, ptr);
1951 get_Store_value (ir_node *node) {
1952 assert (node->op == op_Store);
1953 return get_irn_n(node, 2);
1957 set_Store_value (ir_node *node, ir_node *value) {
1958 assert (node->op == op_Store);
1959 set_irn_n(node, 2, value);
1963 get_Alloc_mem (ir_node *node) {
1964 assert (node->op == op_Alloc);
1965 return get_irn_n(node, 0);
1969 set_Alloc_mem (ir_node *node, ir_node *mem) {
1970 assert (node->op == op_Alloc);
1971 set_irn_n(node, 0, mem);
1975 get_Alloc_size (ir_node *node) {
1976 assert (node->op == op_Alloc);
1977 return get_irn_n(node, 1);
1981 set_Alloc_size (ir_node *node, ir_node *size) {
1982 assert (node->op == op_Alloc);
1983 set_irn_n(node, 1, size);
1987 get_Alloc_type (ir_node *node) {
1988 assert (node->op == op_Alloc);
1989 return node->attr.a.type = skip_tid(node->attr.a.type);
1993 set_Alloc_type (ir_node *node, type *tp) {
1994 assert (node->op == op_Alloc);
1995 node->attr.a.type = tp;
1999 get_Alloc_where (ir_node *node) {
2000 assert (node->op == op_Alloc);
2001 return node->attr.a.where;
2005 set_Alloc_where (ir_node *node, where_alloc where) {
2006 assert (node->op == op_Alloc);
2007 node->attr.a.where = where;
2012 get_Free_mem (ir_node *node) {
2013 assert (node->op == op_Free);
2014 return get_irn_n(node, 0);
2018 set_Free_mem (ir_node *node, ir_node *mem) {
2019 assert (node->op == op_Free);
2020 set_irn_n(node, 0, mem);
2024 get_Free_ptr (ir_node *node) {
2025 assert (node->op == op_Free);
2026 return get_irn_n(node, 1);
2030 set_Free_ptr (ir_node *node, ir_node *ptr) {
2031 assert (node->op == op_Free);
2032 set_irn_n(node, 1, ptr);
2036 get_Free_size (ir_node *node) {
2037 assert (node->op == op_Free);
2038 return get_irn_n(node, 2);
2042 set_Free_size (ir_node *node, ir_node *size) {
2043 assert (node->op == op_Free);
2044 set_irn_n(node, 2, size);
2048 get_Free_type (ir_node *node) {
2049 assert (node->op == op_Free);
2050 return node->attr.f = skip_tid(node->attr.f);
2054 set_Free_type (ir_node *node, type *tp) {
2055 assert (node->op == op_Free);
2060 get_Sync_preds_arr (ir_node *node) {
2061 assert (node->op == op_Sync);
2062 return (ir_node **)&(get_irn_in(node)[1]);
2066 get_Sync_n_preds (ir_node *node) {
2067 assert (node->op == op_Sync);
2068 return (get_irn_arity(node));
2073 set_Sync_n_preds (ir_node *node, int n_preds) {
2074 assert (node->op == op_Sync);
2079 get_Sync_pred (ir_node *node, int pos) {
2080 assert (node->op == op_Sync);
2081 return get_irn_n(node, pos);
2085 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
2086 assert (node->op == op_Sync);
2087 set_irn_n(node, pos, pred);
2091 get_Proj_pred (ir_node *node) {
2092 assert (is_Proj(node));
2093 return get_irn_n(node, 0);
2097 set_Proj_pred (ir_node *node, ir_node *pred) {
2098 assert (is_Proj(node));
2099 set_irn_n(node, 0, pred);
2103 get_Proj_proj (ir_node *node) {
2104 assert (is_Proj(node));
2105 if (get_irn_opcode(node) == iro_Proj) {
2106 return node->attr.proj;
2108 assert(get_irn_opcode(node) == iro_Filter);
2109 return node->attr.filter.proj;
2114 set_Proj_proj (ir_node *node, long proj) {
2115 assert (node->op == op_Proj);
2116 node->attr.proj = proj;
2120 get_Tuple_preds_arr (ir_node *node) {
2121 assert (node->op == op_Tuple);
2122 return (ir_node **)&(get_irn_in(node)[1]);
2126 get_Tuple_n_preds (ir_node *node) {
2127 assert (node->op == op_Tuple);
2128 return (get_irn_arity(node));
2133 set_Tuple_n_preds (ir_node *node, int n_preds) {
2134 assert (node->op == op_Tuple);
2139 get_Tuple_pred (ir_node *node, int pos) {
2140 assert (node->op == op_Tuple);
2141 return get_irn_n(node, pos);
2145 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
2146 assert (node->op == op_Tuple);
2147 set_irn_n(node, pos, pred);
2151 get_Id_pred (ir_node *node) {
2152 assert (node->op == op_Id);
2153 return get_irn_n(node, 0);
2157 set_Id_pred (ir_node *node, ir_node *pred) {
2158 assert (node->op == op_Id);
2159 set_irn_n(node, 0, pred);
2162 INLINE ir_node *get_Confirm_value (ir_node *node) {
2163 assert (node->op == op_Confirm);
2164 return get_irn_n(node, 0);
2166 INLINE void set_Confirm_value (ir_node *node, ir_node *value) {
2167 assert (node->op == op_Confirm);
2168 set_irn_n(node, 0, value);
2170 INLINE ir_node *get_Confirm_bound (ir_node *node) {
2171 assert (node->op == op_Confirm);
2172 return get_irn_n(node, 1);
2174 INLINE void set_Confirm_bound (ir_node *node, ir_node *bound) {
2175 assert (node->op == op_Confirm);
2176 set_irn_n(node, 0, bound);
2178 INLINE pn_Cmp get_Confirm_cmp (ir_node *node) {
2179 assert (node->op == op_Confirm);
2180 return node->attr.confirm_cmp;
2182 INLINE void set_Confirm_cmp (ir_node *node, pn_Cmp cmp) {
2183 assert (node->op == op_Confirm);
2184 node->attr.confirm_cmp = cmp;
2189 get_Filter_pred (ir_node *node) {
2190 assert(node->op == op_Filter);
2194 set_Filter_pred (ir_node *node, ir_node *pred) {
2195 assert(node->op == op_Filter);
2199 get_Filter_proj(ir_node *node) {
2200 assert(node->op == op_Filter);
2201 return node->attr.filter.proj;
2204 set_Filter_proj (ir_node *node, long proj) {
2205 assert(node->op == op_Filter);
2206 node->attr.filter.proj = proj;
2209 /* Don't use get_irn_arity, get_irn_n in implementation as access
2210 shall work independent of view!!! */
2211 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2212 assert(node->op == op_Filter);
2213 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2214 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2215 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2216 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2217 node->attr.filter.in_cg[0] = node->in[0];
2219 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2222 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2223 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2224 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2225 node->attr.filter.in_cg[pos + 1] = pred;
2227 int get_Filter_n_cg_preds(ir_node *node) {
2228 assert(node->op == op_Filter && node->attr.filter.in_cg);
2229 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2231 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2233 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2235 arity = ARR_LEN(node->attr.filter.in_cg);
2236 assert(pos < arity - 1);
2237 return node->attr.filter.in_cg[pos + 1];
2242 get_irn_irg(ir_node *node) {
2243 if (get_irn_op(node) != op_Block)
2244 node = get_nodes_block(node);
2245 assert(get_irn_op(node) == op_Block);
2246 return node->attr.block.irg;
2250 /******************************************************************/
2251 /* Auxiliary routines */
2252 /******************************************************************/
2255 skip_Proj (ir_node *node) {
2256 /* don't assert node !!! */
2257 if (node && is_Proj(node)) {
2258 return get_Proj_pred(node);
2265 skip_Tuple (ir_node *node) {
2268 if (!get_opt_normalize()) return node;
2270 node = skip_nop(node);
2271 if (get_irn_op(node) == op_Proj) {
2272 pred = skip_nop(get_Proj_pred(node));
2273 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
2274 pred = skip_nop(skip_Tuple(pred));
2275 if (get_irn_op(pred) == op_Tuple)
2276 return get_Tuple_pred(pred, get_Proj_proj(node));
2281 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2282 than any other approach, as Id chains are resolved and all point to the real node, or
2283 all id's are self loops. */
2285 skip_nop (ir_node *node) {
2286 /* don't assert node !!! */
2288 if (!get_opt_normalize()) return node;
2290 /* Don't use get_Id_pred: We get into an endless loop for
2291 self-referencing Ids. */
2292 if (node && (node->op == op_Id) && (node != node->in[0+1])) {
2293 ir_node *rem_pred = node->in[0+1];
2296 assert (get_irn_arity (node) > 0);
2298 node->in[0+1] = node;
2299 res = skip_nop(rem_pred);
2300 if (res->op == op_Id) /* self-loop */ return node;
2302 node->in[0+1] = res;
2310 skip_Id (ir_node *node) {
2311 return skip_nop(node);
2315 is_Bad (ir_node *node) {
2317 if ((node) && get_irn_opcode(node) == iro_Bad)
2323 is_no_Block (ir_node *node) {
2325 return (get_irn_opcode(node) != iro_Block);
2329 is_Block (ir_node *node) {
2331 return (get_irn_opcode(node) == iro_Block);
2335 is_Proj (const ir_node *node) {
2337 return node->op == op_Proj
2338 || (!interprocedural_view && node->op == op_Filter);
2341 /* Returns true if the operation manipulates control flow. */
2343 is_cfop(ir_node *node) {
2344 return is_cfopcode(get_irn_op(node));
2347 /* Returns true if the operation manipulates interprocedural control flow:
2348 CallBegin, EndReg, EndExcept */
2349 INLINE int is_ip_cfop(ir_node *node) {
2350 return is_ip_cfopcode(get_irn_op(node));
2353 ir_graph *get_ip_cfop_irg(ir_node *n) {
2354 return get_irn_irg(n);
2357 /* Returns true if the operation can change the control flow because
2360 is_fragile_op(ir_node *node) {
2361 return ( (get_irn_opcode(node) == iro_Call)
2362 || (get_irn_opcode(node) == iro_Quot)
2363 || (get_irn_opcode(node) == iro_DivMod)
2364 || (get_irn_opcode(node) == iro_Div)
2365 || (get_irn_opcode(node) == iro_Mod)
2366 || (get_irn_opcode(node) == iro_Load)
2367 || (get_irn_opcode(node) == iro_Store)
2368 || (get_irn_opcode(node) == iro_Alloc)
2369 || (get_irn_opcode(node) == iro_Bad)
2370 || (get_irn_opcode(node) == iro_Unknown));
2374 /* Returns the memory operand of fragile operations. */
2375 ir_node *get_fragile_op_mem(ir_node *node) {
2376 assert(node && is_fragile_op(node));
2378 switch (get_irn_opcode (node)) {
2387 return get_irn_n(node, 0);
2392 assert(0 && "not reached");