2 * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
4 * This file is part of libFirm.
6 * This file may be distributed and/or modified under the terms of the
7 * GNU General Public License version 2 as published by the Free Software
8 * Foundation and appearing in the file LICENSE.GPL included in the
9 * packaging of this file.
11 * Licensees holding valid libFirm Professional Edition licenses may use
12 * this file in accordance with the libFirm Commercial License.
13 * Agreement provided with the Software.
15 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
16 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * @brief Representation of an intermediate operation.
23 * @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck
36 #include "irgraph_t.h"
38 #include "irbackedge_t.h"
42 #include "iredgekinds.h"
43 #include "iredges_t.h"
49 /* some constants fixing the positions of nodes predecessors
51 #define CALL_PARAM_OFFSET 2
52 #define FUNCCALL_PARAM_OFFSET 1
53 #define SEL_INDEX_OFFSET 2
54 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
55 #define END_KEEPALIVE_OFFSET 0
57 static const char *pnc_name_arr [] = {
58 "pn_Cmp_False", "pn_Cmp_Eq", "pn_Cmp_Lt", "pn_Cmp_Le",
59 "pn_Cmp_Gt", "pn_Cmp_Ge", "pn_Cmp_Lg", "pn_Cmp_Leg",
60 "pn_Cmp_Uo", "pn_Cmp_Ue", "pn_Cmp_Ul", "pn_Cmp_Ule",
61 "pn_Cmp_Ug", "pn_Cmp_Uge", "pn_Cmp_Ne", "pn_Cmp_True"
65 * returns the pnc name from an pnc constant
67 const char *get_pnc_string(int pnc) {
68 assert(pnc >= 0 && pnc <
69 (int) (sizeof(pnc_name_arr)/sizeof(pnc_name_arr[0])));
70 return pnc_name_arr[pnc];
74 * Calculates the negated (Complement(R)) pnc condition.
76 pn_Cmp get_negated_pnc(long pnc, ir_mode *mode) {
79 /* do NOT add the Uo bit for non-floating point values */
80 if (! mode_is_float(mode))
86 /* Calculates the inversed (R^-1) pnc condition, i.e., "<" --> ">" */
87 pn_Cmp get_inversed_pnc(long pnc) {
88 long code = pnc & ~(pn_Cmp_Lt|pn_Cmp_Gt);
89 long lesser = pnc & pn_Cmp_Lt;
90 long greater = pnc & pn_Cmp_Gt;
92 code |= (lesser ? pn_Cmp_Gt : 0) | (greater ? pn_Cmp_Lt : 0);
98 * Indicates, whether additional data can be registered to ir nodes.
99 * If set to 1, this is not possible anymore.
101 static int forbid_new_data = 0;
104 * The amount of additional space for custom data to be allocated upon
105 * creating a new node.
107 unsigned firm_add_node_size = 0;
110 /* register new space for every node */
111 unsigned firm_register_additional_node_data(unsigned size) {
112 assert(!forbid_new_data && "Too late to register additional node data");
117 return firm_add_node_size += size;
123 /* Forbid the addition of new data to an ir node. */
128 * irnode constructor.
129 * Create a new irnode in irg, with an op, mode, arity and
130 * some incoming irnodes.
131 * If arity is negative, a node with a dynamic array is created.
134 new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
135 int arity, ir_node **in)
138 size_t node_size = offsetof(ir_node, attr) + op->attr_size + firm_add_node_size;
142 assert(irg && op && mode);
143 p = obstack_alloc(irg->obst, node_size);
144 memset(p, 0, node_size);
145 res = (ir_node *)(p + firm_add_node_size);
147 res->kind = k_ir_node;
151 res->node_idx = irg_register_node_idx(irg, res);
156 res->in = NEW_ARR_F(ir_node *, 1); /* 1: space for block */
158 res->in = NEW_ARR_D(ir_node *, irg->obst, (arity+1));
159 memcpy(&res->in[1], in, sizeof(ir_node *) * arity);
163 set_irn_dbg_info(res, db);
167 res->node_nr = get_irp_new_node_nr();
170 for (i = 0; i < EDGE_KIND_LAST; ++i)
171 INIT_LIST_HEAD(&res->edge_info[i].outs_head);
173 /* don't put this into the for loop, arity is -1 for some nodes! */
174 edges_notify_edge(res, -1, res->in[0], NULL, irg);
175 for (i = 1; i <= arity; ++i)
176 edges_notify_edge(res, i - 1, res->in[i], NULL, irg);
178 hook_new_node(irg, res);
183 /*-- getting some parameters from ir_nodes --*/
186 (is_ir_node)(const void *thing) {
187 return _is_ir_node(thing);
191 (get_irn_intra_arity)(const ir_node *node) {
192 return _get_irn_intra_arity(node);
196 (get_irn_inter_arity)(const ir_node *node) {
197 return _get_irn_inter_arity(node);
200 int (*_get_irn_arity)(const ir_node *node) = _get_irn_intra_arity;
203 (get_irn_arity)(const ir_node *node) {
204 return _get_irn_arity(node);
207 /* Returns the array with ins. This array is shifted with respect to the
208 array accessed by get_irn_n: The block operand is at position 0 not -1.
209 (@@@ This should be changed.)
210 The order of the predecessors in this array is not guaranteed, except that
211 lists of operands as predecessors of Block or arguments of a Call are
214 get_irn_in(const ir_node *node) {
216 if (get_interprocedural_view()) { /* handle Filter and Block specially */
217 if (get_irn_opcode(node) == iro_Filter) {
218 assert(node->attr.filter.in_cg);
219 return node->attr.filter.in_cg;
220 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
221 return node->attr.block.in_cg;
223 /* else fall through */
229 set_irn_in(ir_node *node, int arity, ir_node **in) {
232 ir_graph *irg = current_ir_graph;
234 if (get_interprocedural_view()) { /* handle Filter and Block specially */
235 ir_opcode code = get_irn_opcode(node);
236 if (code == iro_Filter) {
237 assert(node->attr.filter.in_cg);
238 pOld_in = &node->attr.filter.in_cg;
239 } else if (code == iro_Block && node->attr.block.in_cg) {
240 pOld_in = &node->attr.block.in_cg;
248 for (i = 0; i < arity; i++) {
249 if (i < ARR_LEN(*pOld_in)-1)
250 edges_notify_edge(node, i, in[i], (*pOld_in)[i+1], irg);
252 edges_notify_edge(node, i, in[i], NULL, irg);
254 for (;i < ARR_LEN(*pOld_in)-1; i++) {
255 edges_notify_edge(node, i, NULL, (*pOld_in)[i+1], irg);
258 if (arity != ARR_LEN(*pOld_in) - 1) {
259 ir_node * block = (*pOld_in)[0];
260 *pOld_in = NEW_ARR_D(ir_node *, irg->obst, arity + 1);
261 (*pOld_in)[0] = block;
263 fix_backedges(irg->obst, node);
265 memcpy((*pOld_in) + 1, in, sizeof(ir_node *) * arity);
269 (get_irn_intra_n)(const ir_node *node, int n) {
270 return _get_irn_intra_n (node, n);
274 (get_irn_inter_n)(const ir_node *node, int n) {
275 return _get_irn_inter_n (node, n);
278 ir_node *(*_get_irn_n)(const ir_node *node, int n) = _get_irn_intra_n;
281 (get_irn_n)(const ir_node *node, int n) {
282 return _get_irn_n(node, n);
286 set_irn_n (ir_node *node, int n, ir_node *in) {
287 assert(node && node->kind == k_ir_node);
289 assert(n < get_irn_arity(node));
290 assert(in && in->kind == k_ir_node);
292 if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
293 /* Change block pred in both views! */
294 node->in[n + 1] = in;
295 assert(node->attr.filter.in_cg);
296 node->attr.filter.in_cg[n + 1] = in;
299 if (get_interprocedural_view()) { /* handle Filter and Block specially */
300 if (get_irn_opcode(node) == iro_Filter) {
301 assert(node->attr.filter.in_cg);
302 node->attr.filter.in_cg[n + 1] = in;
304 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
305 node->attr.block.in_cg[n + 1] = in;
308 /* else fall through */
312 hook_set_irn_n(node, n, in, node->in[n + 1]);
314 /* Here, we rely on src and tgt being in the current ir graph */
315 edges_notify_edge(node, n, in, node->in[n + 1], current_ir_graph);
317 node->in[n + 1] = in;
320 int add_irn_n(ir_node *node, ir_node *in)
323 ir_graph *irg = get_irn_irg(node);
325 assert(node->op->opar == oparity_dynamic);
326 pos = ARR_LEN(node->in) - 1;
327 ARR_APP1(ir_node *, node->in, in);
328 edges_notify_edge(node, pos, node->in[pos + 1], NULL, irg);
331 hook_set_irn_n(node, pos, node->in[pos + 1], NULL);
337 (get_irn_deps)(const ir_node *node)
339 return _get_irn_deps(node);
343 (get_irn_dep)(const ir_node *node, int pos)
345 return _get_irn_dep(node, pos);
349 (set_irn_dep)(ir_node *node, int pos, ir_node *dep)
351 _set_irn_dep(node, pos, dep);
354 int add_irn_dep(ir_node *node, ir_node *dep)
358 if (node->deps == NULL) {
359 node->deps = NEW_ARR_F(ir_node *, 1);
365 for(i = 0, n = ARR_LEN(node->deps); i < n; ++i) {
366 if(node->deps[i] == NULL)
369 if(node->deps[i] == dep)
373 if (first_zero >= 0) {
374 node->deps[first_zero] = dep;
377 ARR_APP1(ir_node *, node->deps, dep);
382 edges_notify_edge_kind(node, res, dep, NULL, EDGE_KIND_DEP, get_irn_irg(node));
387 void add_irn_deps(ir_node *tgt, ir_node *src) {
390 for (i = 0, n = get_irn_deps(src); i < n; ++i)
391 add_irn_dep(tgt, get_irn_dep(src, i));
396 (get_irn_mode)(const ir_node *node) {
397 return _get_irn_mode(node);
401 (set_irn_mode)(ir_node *node, ir_mode *mode) {
402 _set_irn_mode(node, mode);
406 get_irn_modecode(const ir_node *node) {
408 return node->mode->code;
411 /** Gets the string representation of the mode .*/
413 get_irn_modename(const ir_node *node) {
415 return get_mode_name(node->mode);
419 get_irn_modeident(const ir_node *node) {
421 return get_mode_ident(node->mode);
425 (get_irn_op)(const ir_node *node) {
426 return _get_irn_op(node);
429 /* should be private to the library: */
431 (set_irn_op)(ir_node *node, ir_op *op) {
432 _set_irn_op(node, op);
436 (get_irn_opcode)(const ir_node *node) {
437 return _get_irn_opcode(node);
441 get_irn_opname(const ir_node *node) {
443 if (is_Phi0(node)) return "Phi0";
444 return get_id_str(node->op->name);
448 get_irn_opident(const ir_node *node) {
450 return node->op->name;
454 (get_irn_visited)(const ir_node *node) {
455 return _get_irn_visited(node);
459 (set_irn_visited)(ir_node *node, unsigned long visited) {
460 _set_irn_visited(node, visited);
464 (mark_irn_visited)(ir_node *node) {
465 _mark_irn_visited(node);
469 (irn_not_visited)(const ir_node *node) {
470 return _irn_not_visited(node);
474 (irn_visited)(const ir_node *node) {
475 return _irn_visited(node);
479 (set_irn_link)(ir_node *node, void *link) {
480 _set_irn_link(node, link);
484 (get_irn_link)(const ir_node *node) {
485 return _get_irn_link(node);
489 (get_irn_pinned)(const ir_node *node) {
490 return _get_irn_pinned(node);
494 (is_irn_pinned_in_irg) (const ir_node *node) {
495 return _is_irn_pinned_in_irg(node);
498 void set_irn_pinned(ir_node *node, op_pin_state state) {
499 /* due to optimization an opt may be turned into a Tuple */
500 if (get_irn_op(node) == op_Tuple)
503 assert(node && get_op_pinned(get_irn_op(node)) >= op_pin_state_exc_pinned);
504 assert(state == op_pin_state_pinned || state == op_pin_state_floats);
506 node->attr.except.pin_state = state;
509 #ifdef DO_HEAPANALYSIS
510 /* Access the abstract interpretation information of a node.
511 Returns NULL if no such information is available. */
512 struct abstval *get_irn_abst_value(ir_node *n) {
515 /* Set the abstract interpretation information of a node. */
516 void set_irn_abst_value(ir_node *n, struct abstval *os) {
519 struct section *firm_get_irn_section(ir_node *n) {
522 void firm_set_irn_section(ir_node *n, struct section *s) {
526 /* Dummies needed for firmjni. */
527 struct abstval *get_irn_abst_value(ir_node *n) {
531 void set_irn_abst_value(ir_node *n, struct abstval *os) {
535 struct section *firm_get_irn_section(ir_node *n) {
539 void firm_set_irn_section(ir_node *n, struct section *s) {
543 #endif /* DO_HEAPANALYSIS */
546 /* Outputs a unique number for this node */
547 long get_irn_node_nr(const ir_node *node) {
550 return node->node_nr;
552 return (long)PTR_TO_INT(node);
557 get_irn_const_attr(ir_node *node) {
558 assert(node->op == op_Const);
559 return &node->attr.con;
563 get_irn_proj_attr(ir_node *node) {
564 assert(node->op == op_Proj);
565 return node->attr.proj;
569 get_irn_alloc_attr(ir_node *node) {
570 assert(node->op == op_Alloc);
571 return &node->attr.alloc;
575 get_irn_free_attr(ir_node *node) {
576 assert(node->op == op_Free);
577 return &node->attr.free;
581 get_irn_symconst_attr(ir_node *node) {
582 assert(node->op == op_SymConst);
583 return &node->attr.symc;
587 get_irn_call_attr(ir_node *node) {
588 assert(node->op == op_Call);
589 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
593 get_irn_sel_attr(ir_node *node) {
594 assert(node->op == op_Sel);
595 return &node->attr.sel;
599 get_irn_phi_attr(ir_node *node) {
600 return &node->attr.phi;
604 get_irn_block_attr(ir_node *node) {
605 assert(node->op == op_Block);
606 return &node->attr.block;
610 get_irn_load_attr(ir_node *node) {
611 assert(node->op == op_Load);
612 return &node->attr.load;
616 get_irn_store_attr(ir_node *node) {
617 assert(node->op == op_Store);
618 return &node->attr.store;
622 get_irn_except_attr(ir_node *node) {
623 assert(node->op == op_Div || node->op == op_Quot ||
624 node->op == op_DivMod || node->op == op_Mod || node->op == op_Call || node->op == op_Alloc);
625 return &node->attr.except;
628 void *(get_irn_generic_attr)(ir_node *node) {
629 assert(is_ir_node(node));
630 return _get_irn_generic_attr(node);
633 const void *(get_irn_generic_attr_const)(const ir_node *node) {
634 assert(is_ir_node(node));
635 return _get_irn_generic_attr_const(node);
638 unsigned (get_irn_idx)(const ir_node *node) {
639 assert(is_ir_node(node));
640 return _get_irn_idx(node);
643 int get_irn_pred_pos(ir_node *node, ir_node *arg) {
645 for (i = get_irn_arity(node) - 1; i >= 0; i--) {
646 if (get_irn_n(node, i) == arg)
652 /** manipulate fields of individual nodes **/
654 /* this works for all except Block */
656 get_nodes_block(const ir_node *node) {
657 assert(node->op != op_Block);
658 return get_irn_n(node, -1);
662 set_nodes_block(ir_node *node, ir_node *block) {
663 assert(node->op != op_Block);
664 set_irn_n(node, -1, block);
667 /* this works for all except Block */
669 get_nodes_MacroBlock(const ir_node *node) {
670 assert(node->op != op_Block);
671 return get_Block_MacroBlock(get_irn_n(node, -1));
674 /* Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
675 * from Start. If so returns frame type, else Null. */
676 ir_type *is_frame_pointer(const ir_node *n) {
677 if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_frame_base)) {
678 ir_node *start = get_Proj_pred(n);
679 if (is_Start(start)) {
680 return get_irg_frame_type(get_irn_irg(start));
686 /* Test whether arbitrary node is globals pointer, i.e. Proj(pn_Start_P_globals)
687 * from Start. If so returns global type, else Null. */
688 ir_type *is_globals_pointer(const ir_node *n) {
689 if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_globals)) {
690 ir_node *start = get_Proj_pred(n);
691 if (is_Start(start)) {
692 return get_glob_type();
698 /* Test whether arbitrary node is tls pointer, i.e. Proj(pn_Start_P_tls)
699 * from Start. If so returns tls type, else Null. */
700 ir_type *is_tls_pointer(const ir_node *n) {
701 if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_globals)) {
702 ir_node *start = get_Proj_pred(n);
703 if (is_Start(start)) {
704 return get_tls_type();
710 /* Test whether arbitrary node is value arg base, i.e. Proj(pn_Start_P_value_arg_base)
711 * from Start. If so returns 1, else 0. */
712 int is_value_arg_pointer(const ir_node *n) {
714 (get_Proj_proj(n) == pn_Start_P_value_arg_base) &&
715 is_Start(get_Proj_pred(n)))
720 /* Returns an array with the predecessors of the Block. Depending on
721 the implementation of the graph data structure this can be a copy of
722 the internal representation of predecessors as well as the internal
723 array itself. Therefore writing to this array might obstruct the ir. */
725 get_Block_cfgpred_arr(ir_node *node) {
726 assert((node->op == op_Block));
727 return (ir_node **)&(get_irn_in(node)[1]);
731 (get_Block_n_cfgpreds)(const ir_node *node) {
732 return _get_Block_n_cfgpreds(node);
736 (get_Block_cfgpred)(const ir_node *node, int pos) {
737 return _get_Block_cfgpred(node, pos);
741 set_Block_cfgpred(ir_node *node, int pos, ir_node *pred) {
742 assert(node->op == op_Block);
743 set_irn_n(node, pos, pred);
747 (get_Block_cfgpred_block)(const ir_node *node, int pos) {
748 return _get_Block_cfgpred_block(node, pos);
752 get_Block_matured(const ir_node *node) {
753 assert(node->op == op_Block);
754 return (int)node->attr.block.is_matured;
758 set_Block_matured(ir_node *node, int matured) {
759 assert(node->op == op_Block);
760 node->attr.block.is_matured = matured;
764 (get_Block_block_visited)(const ir_node *node) {
765 return _get_Block_block_visited(node);
769 (set_Block_block_visited)(ir_node *node, unsigned long visit) {
770 _set_Block_block_visited(node, visit);
773 /* For this current_ir_graph must be set. */
775 (mark_Block_block_visited)(ir_node *node) {
776 _mark_Block_block_visited(node);
780 (Block_not_block_visited)(const ir_node *node) {
781 return _Block_not_block_visited(node);
785 (Block_block_visited)(const ir_node *node) {
786 return _Block_block_visited(node);
790 get_Block_graph_arr(ir_node *node, int pos) {
791 assert(node->op == op_Block);
792 return node->attr.block.graph_arr[pos+1];
796 set_Block_graph_arr(ir_node *node, int pos, ir_node *value) {
797 assert(node->op == op_Block);
798 node->attr.block.graph_arr[pos+1] = value;
801 #ifdef INTERPROCEDURAL_VIEW
802 void set_Block_cg_cfgpred_arr(ir_node *node, int arity, ir_node *in[]) {
803 assert(node->op == op_Block);
804 if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
805 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
806 node->attr.block.in_cg[0] = NULL;
807 node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
809 /* Fix backedge array. fix_backedges() operates depending on
810 interprocedural_view. */
811 int ipv = get_interprocedural_view();
812 set_interprocedural_view(1);
813 fix_backedges(current_ir_graph->obst, node);
814 set_interprocedural_view(ipv);
817 memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
820 void set_Block_cg_cfgpred(ir_node *node, int pos, ir_node *pred) {
821 assert(node->op == op_Block &&
822 node->attr.block.in_cg &&
823 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
824 node->attr.block.in_cg[pos + 1] = pred;
827 ir_node **get_Block_cg_cfgpred_arr(ir_node *node) {
828 assert(node->op == op_Block);
829 return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
832 int get_Block_cg_n_cfgpreds(const ir_node *node) {
833 assert(node->op == op_Block);
834 return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
837 ir_node *get_Block_cg_cfgpred(const ir_node *node, int pos) {
838 assert(node->op == op_Block && node->attr.block.in_cg);
839 return node->attr.block.in_cg[pos + 1];
842 void remove_Block_cg_cfgpred_arr(ir_node *node) {
843 assert(node->op == op_Block);
844 node->attr.block.in_cg = NULL;
848 ir_node *(set_Block_dead)(ir_node *block) {
849 return _set_Block_dead(block);
852 int (is_Block_dead)(const ir_node *block) {
853 return _is_Block_dead(block);
856 ir_extblk *get_Block_extbb(const ir_node *block) {
858 assert(is_Block(block));
859 res = block->attr.block.extblk;
860 assert(res == NULL || is_ir_extbb(res));
864 void set_Block_extbb(ir_node *block, ir_extblk *extblk) {
865 assert(is_Block(block));
866 assert(extblk == NULL || is_ir_extbb(extblk));
867 block->attr.block.extblk = extblk;
870 /* returns the macro block header of a block. */
871 ir_node *get_Block_MacroBlock(const ir_node *block) {
873 assert(is_Block(block));
874 mbh = get_irn_n(block, -1);
875 /* once macro block header is respected by all optimizations,
876 this assert can be removed */
881 /* returns the macro block header of a node. */
882 ir_node *get_irn_MacroBlock(const ir_node *n) {
884 n = get_nodes_block(n);
885 /* if the Block is Bad, do NOT try to get it's MB, it will fail. */
889 return get_Block_MacroBlock(n);
892 /* returns the graph of a Block. */
893 ir_graph *get_Block_irg(const ir_node *block) {
894 assert(is_Block(block));
895 return block->attr.block.irg;
898 int has_Block_label(const ir_node *block) {
899 assert(is_Block(block));
900 return block->attr.block.has_label;
903 ir_label_t get_Block_label(const ir_node *block) {
904 assert(is_Block(block));
905 return block->attr.block.label;
908 void set_Block_label(ir_node *block, ir_label_t label) {
909 assert(is_Block(block));
910 block->attr.block.has_label = 1;
911 block->attr.block.label = label;
915 get_End_n_keepalives(const ir_node *end) {
916 assert(end->op == op_End);
917 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
921 get_End_keepalive(const ir_node *end, int pos) {
922 assert(end->op == op_End);
923 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
927 add_End_keepalive(ir_node *end, ir_node *ka) {
928 assert(end->op == op_End);
929 assert((is_Phi(ka) || is_Proj(ka) || is_Block(ka) || is_irn_keep(ka)) && "Only Phi, Block or Keep nodes can be kept alive!");
934 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
935 assert(end->op == op_End);
936 set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
939 /* Set new keep-alives */
940 void set_End_keepalives(ir_node *end, int n, ir_node *in[]) {
942 ir_graph *irg = get_irn_irg(end);
944 /* notify that edges are deleted */
945 for (i = END_KEEPALIVE_OFFSET; i < ARR_LEN(end->in) - 1; ++i) {
946 edges_notify_edge(end, i, NULL, end->in[i + 1], irg);
948 ARR_RESIZE(ir_node *, end->in, n + 1 + END_KEEPALIVE_OFFSET);
950 for (i = 0; i < n; ++i) {
951 end->in[1 + END_KEEPALIVE_OFFSET + i] = in[i];
952 edges_notify_edge(end, END_KEEPALIVE_OFFSET + i, end->in[1 + END_KEEPALIVE_OFFSET + i], NULL, irg);
956 /* Set new keep-alives from old keep-alives, skipping irn */
957 void remove_End_keepalive(ir_node *end, ir_node *irn) {
958 int n = get_End_n_keepalives(end);
962 NEW_ARR_A(ir_node *, in, n);
964 for (idx = i = 0; i < n; ++i) {
965 ir_node *old_ka = get_End_keepalive(end, i);
972 /* set new keep-alives */
973 set_End_keepalives(end, idx, in);
977 free_End(ir_node *end) {
978 assert(end->op == op_End);
981 end->in = NULL; /* @@@ make sure we get an error if we use the
982 in array afterwards ... */
985 /* Return the target address of an IJmp */
986 ir_node *get_IJmp_target(const ir_node *ijmp) {
987 assert(ijmp->op == op_IJmp);
988 return get_irn_n(ijmp, 0);
991 /** Sets the target address of an IJmp */
992 void set_IJmp_target(ir_node *ijmp, ir_node *tgt) {
993 assert(ijmp->op == op_IJmp);
994 set_irn_n(ijmp, 0, tgt);
998 > Implementing the case construct (which is where the constant Proj node is
999 > important) involves far more than simply determining the constant values.
1000 > We could argue that this is more properly a function of the translator from
1001 > Firm to the target machine. That could be done if there was some way of
1002 > projecting "default" out of the Cond node.
1003 I know it's complicated.
1004 Basically there are two problems:
1005 - determining the gaps between the Projs
1006 - determining the biggest case constant to know the proj number for
1008 I see several solutions:
1009 1. Introduce a ProjDefault node. Solves both problems.
1010 This means to extend all optimizations executed during construction.
1011 2. Give the Cond node for switch two flavors:
1012 a) there are no gaps in the Projs (existing flavor)
1013 b) gaps may exist, default proj is still the Proj with the largest
1014 projection number. This covers also the gaps.
1015 3. Fix the semantic of the Cond to that of 2b)
1017 Solution 2 seems to be the best:
1018 Computing the gaps in the Firm representation is not too hard, i.e.,
1019 libFIRM can implement a routine that transforms between the two
1020 flavours. This is also possible for 1) but 2) does not require to
1021 change any existing optimization.
1022 Further it should be far simpler to determine the biggest constant than
1023 to compute all gaps.
1024 I don't want to choose 3) as 2a) seems to have advantages for
1025 dataflow analysis and 3) does not allow to convert the representation to
1029 get_Cond_selector(const ir_node *node) {
1030 assert(node->op == op_Cond);
1031 return get_irn_n(node, 0);
1035 set_Cond_selector(ir_node *node, ir_node *selector) {
1036 assert(node->op == op_Cond);
1037 set_irn_n(node, 0, selector);
1041 get_Cond_kind(const ir_node *node) {
1042 assert(node->op == op_Cond);
1043 return node->attr.cond.kind;
1047 set_Cond_kind(ir_node *node, cond_kind kind) {
1048 assert(node->op == op_Cond);
1049 node->attr.cond.kind = kind;
1053 get_Cond_defaultProj(const ir_node *node) {
1054 assert(node->op == op_Cond);
1055 return node->attr.cond.default_proj;
1059 get_Return_mem(const ir_node *node) {
1060 assert(node->op == op_Return);
1061 return get_irn_n(node, 0);
1065 set_Return_mem(ir_node *node, ir_node *mem) {
1066 assert(node->op == op_Return);
1067 set_irn_n(node, 0, mem);
1071 get_Return_n_ress(const ir_node *node) {
1072 assert(node->op == op_Return);
1073 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
1077 get_Return_res_arr(ir_node *node) {
1078 assert((node->op == op_Return));
1079 if (get_Return_n_ress(node) > 0)
1080 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
1087 set_Return_n_res(ir_node *node, int results) {
1088 assert(node->op == op_Return);
1093 get_Return_res(const ir_node *node, int pos) {
1094 assert(node->op == op_Return);
1095 assert(get_Return_n_ress(node) > pos);
1096 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
1100 set_Return_res(ir_node *node, int pos, ir_node *res){
1101 assert(node->op == op_Return);
1102 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
1105 tarval *(get_Const_tarval)(const ir_node *node) {
1106 return _get_Const_tarval(node);
1110 set_Const_tarval(ir_node *node, tarval *con) {
1111 assert(node->op == op_Const);
1112 node->attr.con.tv = con;
1115 int (is_Const_null)(const ir_node *node) {
1116 return _is_Const_null(node);
1119 int (is_Const_one)(const ir_node *node) {
1120 return _is_Const_one(node);
1123 int (is_Const_all_one)(const ir_node *node) {
1124 return _is_Const_all_one(node);
1128 /* The source language type. Must be an atomic type. Mode of type must
1129 be mode of node. For tarvals from entities type must be pointer to
1132 get_Const_type(ir_node *node) {
1133 assert(node->op == op_Const);
1134 node->attr.con.tp = skip_tid(node->attr.con.tp);
1135 return node->attr.con.tp;
1139 set_Const_type(ir_node *node, ir_type *tp) {
1140 assert(node->op == op_Const);
1141 if (tp != firm_unknown_type) {
1142 assert(is_atomic_type(tp));
1143 assert(get_type_mode(tp) == get_irn_mode(node));
1145 node->attr.con.tp = tp;
1150 get_SymConst_kind(const ir_node *node) {
1151 assert(node->op == op_SymConst);
1152 return node->attr.symc.num;
1156 set_SymConst_kind(ir_node *node, symconst_kind num) {
1157 assert(node->op == op_SymConst);
1158 node->attr.symc.num = num;
1162 get_SymConst_type(ir_node *node) {
1163 assert((node->op == op_SymConst) &&
1164 (SYMCONST_HAS_TYPE(get_SymConst_kind(node))));
1165 return node->attr.symc.sym.type_p = skip_tid(node->attr.symc.sym.type_p);
1169 set_SymConst_type(ir_node *node, ir_type *tp) {
1170 assert((node->op == op_SymConst) &&
1171 (SYMCONST_HAS_TYPE(get_SymConst_kind(node))));
1172 node->attr.symc.sym.type_p = tp;
1176 get_SymConst_name(const ir_node *node) {
1177 assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
1178 return node->attr.symc.sym.ident_p;
1182 set_SymConst_name(ir_node *node, ident *name) {
1183 assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
1184 node->attr.symc.sym.ident_p = name;
1188 /* Only to access SymConst of kind symconst_addr_ent. Else assertion: */
1189 ir_entity *get_SymConst_entity(const ir_node *node) {
1190 assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
1191 return node->attr.symc.sym.entity_p;
1194 void set_SymConst_entity(ir_node *node, ir_entity *ent) {
1195 assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
1196 node->attr.symc.sym.entity_p = ent;
1199 ir_enum_const *get_SymConst_enum(const ir_node *node) {
1200 assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
1201 return node->attr.symc.sym.enum_p;
1204 void set_SymConst_enum(ir_node *node, ir_enum_const *ec) {
1205 assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
1206 node->attr.symc.sym.enum_p = ec;
1209 union symconst_symbol
1210 get_SymConst_symbol(const ir_node *node) {
1211 assert(node->op == op_SymConst);
1212 return node->attr.symc.sym;
1216 set_SymConst_symbol(ir_node *node, union symconst_symbol sym) {
1217 assert(node->op == op_SymConst);
1218 node->attr.symc.sym = sym;
1221 ir_label_t get_SymConst_label(const ir_node *node) {
1222 assert(node->op == op_SymConst && SYMCONST_HAS_LABEL(get_SymConst_kind(node)));
1223 return node->attr.symc.sym.label;
1226 void set_SymConst_label(ir_node *node, ir_label_t label) {
1227 assert(node->op == op_SymConst && SYMCONST_HAS_LABEL(get_SymConst_kind(node)));
1228 node->attr.symc.sym.label = label;
1232 get_SymConst_value_type(ir_node *node) {
1233 assert(node->op == op_SymConst);
1234 if (node->attr.symc.tp) node->attr.symc.tp = skip_tid(node->attr.symc.tp);
1235 return node->attr.symc.tp;
1239 set_SymConst_value_type(ir_node *node, ir_type *tp) {
1240 assert(node->op == op_SymConst);
1241 node->attr.symc.tp = tp;
1245 get_Sel_mem(const ir_node *node) {
1246 assert(node->op == op_Sel);
1247 return get_irn_n(node, 0);
1251 set_Sel_mem(ir_node *node, ir_node *mem) {
1252 assert(node->op == op_Sel);
1253 set_irn_n(node, 0, mem);
1257 get_Sel_ptr(const ir_node *node) {
1258 assert(node->op == op_Sel);
1259 return get_irn_n(node, 1);
1263 set_Sel_ptr(ir_node *node, ir_node *ptr) {
1264 assert(node->op == op_Sel);
1265 set_irn_n(node, 1, ptr);
1269 get_Sel_n_indexs(const ir_node *node) {
1270 assert(node->op == op_Sel);
1271 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
1275 get_Sel_index_arr(ir_node *node) {
1276 assert((node->op == op_Sel));
1277 if (get_Sel_n_indexs(node) > 0)
1278 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
1284 get_Sel_index(const ir_node *node, int pos) {
1285 assert(node->op == op_Sel);
1286 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
1290 set_Sel_index(ir_node *node, int pos, ir_node *index) {
1291 assert(node->op == op_Sel);
1292 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
1296 get_Sel_entity(const ir_node *node) {
1297 assert(node->op == op_Sel);
1298 return node->attr.sel.ent;
1301 ir_entity *_get_Sel_entity(ir_node *node) {
1302 return get_Sel_entity(node);
1306 set_Sel_entity(ir_node *node, ir_entity *ent) {
1307 assert(node->op == op_Sel);
1308 node->attr.sel.ent = ent;
1312 /* For unary and binary arithmetic operations the access to the
1313 operands can be factored out. Left is the first, right the
1314 second arithmetic value as listed in tech report 0999-33.
1315 unops are: Minus, Abs, Not, Conv, Cast
1316 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1317 Shr, Shrs, Rotate, Cmp */
1321 get_Call_mem(const ir_node *node) {
1322 assert(node->op == op_Call);
1323 return get_irn_n(node, 0);
1327 set_Call_mem(ir_node *node, ir_node *mem) {
1328 assert(node->op == op_Call);
1329 set_irn_n(node, 0, mem);
1333 get_Call_ptr(const ir_node *node) {
1334 assert(node->op == op_Call);
1335 return get_irn_n(node, 1);
1339 set_Call_ptr(ir_node *node, ir_node *ptr) {
1340 assert(node->op == op_Call);
1341 set_irn_n(node, 1, ptr);
1345 get_Call_param_arr(ir_node *node) {
1346 assert(node->op == op_Call);
1347 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1351 get_Call_n_params(const ir_node *node) {
1352 assert(node->op == op_Call);
1353 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1357 get_Call_arity(const ir_node *node) {
1358 assert(node->op == op_Call);
1359 return get_Call_n_params(node);
1363 set_Call_arity(ir_node *node, ir_node *arity) {
1364 assert(node->op == op_Call);
1369 get_Call_param(const ir_node *node, int pos) {
1370 assert(node->op == op_Call);
1371 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1375 set_Call_param(ir_node *node, int pos, ir_node *param) {
1376 assert(node->op == op_Call);
1377 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1381 get_Call_type(ir_node *node) {
1382 assert(node->op == op_Call);
1383 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1387 set_Call_type(ir_node *node, ir_type *tp) {
1388 assert(node->op == op_Call);
1389 assert((get_unknown_type() == tp) || is_Method_type(tp));
1390 node->attr.call.cld_tp = tp;
1393 int Call_has_callees(const ir_node *node) {
1394 assert(node && node->op == op_Call);
1395 return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) &&
1396 (node->attr.call.callee_arr != NULL));
1399 int get_Call_n_callees(const ir_node *node) {
1400 assert(node && node->op == op_Call && node->attr.call.callee_arr);
1401 return ARR_LEN(node->attr.call.callee_arr);
1404 ir_entity *get_Call_callee(const ir_node *node, int pos) {
1405 assert(pos >= 0 && pos < get_Call_n_callees(node));
1406 return node->attr.call.callee_arr[pos];
1409 void set_Call_callee_arr(ir_node *node, const int n, ir_entity ** arr) {
1410 assert(node->op == op_Call);
1411 if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1412 node->attr.call.callee_arr = NEW_ARR_D(ir_entity *, current_ir_graph->obst, n);
1414 memcpy(node->attr.call.callee_arr, arr, n * sizeof(ir_entity *));
1417 void remove_Call_callee_arr(ir_node *node) {
1418 assert(node->op == op_Call);
1419 node->attr.call.callee_arr = NULL;
1422 ir_node *get_CallBegin_ptr(const ir_node *node) {
1423 assert(node->op == op_CallBegin);
1424 return get_irn_n(node, 0);
1427 void set_CallBegin_ptr(ir_node *node, ir_node *ptr) {
1428 assert(node->op == op_CallBegin);
1429 set_irn_n(node, 0, ptr);
1432 ir_node *get_CallBegin_call(const ir_node *node) {
1433 assert(node->op == op_CallBegin);
1434 return node->attr.callbegin.call;
1437 void set_CallBegin_call(ir_node *node, ir_node *call) {
1438 assert(node->op == op_CallBegin);
1439 node->attr.callbegin.call = call;
1444 ir_node * get_##OP##_left(const ir_node *node) { \
1445 assert(node->op == op_##OP); \
1446 return get_irn_n(node, node->op->op_index); \
1448 void set_##OP##_left(ir_node *node, ir_node *left) { \
1449 assert(node->op == op_##OP); \
1450 set_irn_n(node, node->op->op_index, left); \
1452 ir_node *get_##OP##_right(const ir_node *node) { \
1453 assert(node->op == op_##OP); \
1454 return get_irn_n(node, node->op->op_index + 1); \
1456 void set_##OP##_right(ir_node *node, ir_node *right) { \
1457 assert(node->op == op_##OP); \
1458 set_irn_n(node, node->op->op_index + 1, right); \
1462 ir_node *get_##OP##_op(const ir_node *node) { \
1463 assert(node->op == op_##OP); \
1464 return get_irn_n(node, node->op->op_index); \
1466 void set_##OP##_op(ir_node *node, ir_node *op) { \
1467 assert(node->op == op_##OP); \
1468 set_irn_n(node, node->op->op_index, op); \
1471 #define BINOP_MEM(OP) \
1475 get_##OP##_mem(const ir_node *node) { \
1476 assert(node->op == op_##OP); \
1477 return get_irn_n(node, 0); \
1481 set_##OP##_mem(ir_node *node, ir_node *mem) { \
1482 assert(node->op == op_##OP); \
1483 set_irn_n(node, 0, mem); \
1489 ir_mode *get_##OP##_resmode(const ir_node *node) { \
1490 assert(node->op == op_##OP); \
1491 return node->attr.divmod.res_mode; \
1494 void set_##OP##_resmode(ir_node *node, ir_mode *mode) { \
1495 assert(node->op == op_##OP); \
1496 node->attr.divmod.res_mode = mode; \
1522 int get_Conv_strict(const ir_node *node) {
1523 assert(node->op == op_Conv);
1524 return node->attr.conv.strict;
1527 void set_Conv_strict(ir_node *node, int strict_flag) {
1528 assert(node->op == op_Conv);
1529 node->attr.conv.strict = (char)strict_flag;
1533 get_Cast_type(ir_node *node) {
1534 assert(node->op == op_Cast);
1535 node->attr.cast.totype = skip_tid(node->attr.cast.totype);
1536 return node->attr.cast.totype;
1540 set_Cast_type(ir_node *node, ir_type *to_tp) {
1541 assert(node->op == op_Cast);
1542 node->attr.cast.totype = to_tp;
1546 /* Checks for upcast.
1548 * Returns true if the Cast node casts a class type to a super type.
1550 int is_Cast_upcast(ir_node *node) {
1551 ir_type *totype = get_Cast_type(node);
1552 ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
1554 assert(get_irg_typeinfo_state(get_irn_irg(node)) == ir_typeinfo_consistent);
1557 while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
1558 totype = get_pointer_points_to_type(totype);
1559 fromtype = get_pointer_points_to_type(fromtype);
1564 if (!is_Class_type(totype)) return 0;
1565 return is_SubClass_of(fromtype, totype);
1568 /* Checks for downcast.
1570 * Returns true if the Cast node casts a class type to a sub type.
1572 int is_Cast_downcast(ir_node *node) {
1573 ir_type *totype = get_Cast_type(node);
1574 ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
1576 assert(get_irg_typeinfo_state(get_irn_irg(node)) == ir_typeinfo_consistent);
1579 while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
1580 totype = get_pointer_points_to_type(totype);
1581 fromtype = get_pointer_points_to_type(fromtype);
1586 if (!is_Class_type(totype)) return 0;
1587 return is_SubClass_of(totype, fromtype);
1591 (is_unop)(const ir_node *node) {
1592 return _is_unop(node);
1596 get_unop_op(const ir_node *node) {
1597 if (node->op->opar == oparity_unary)
1598 return get_irn_n(node, node->op->op_index);
1600 assert(node->op->opar == oparity_unary);
1605 set_unop_op(ir_node *node, ir_node *op) {
1606 if (node->op->opar == oparity_unary)
1607 set_irn_n(node, node->op->op_index, op);
1609 assert(node->op->opar == oparity_unary);
1613 (is_binop)(const ir_node *node) {
1614 return _is_binop(node);
1618 get_binop_left(const ir_node *node) {
1619 assert(node->op->opar == oparity_binary);
1620 return get_irn_n(node, node->op->op_index);
1624 set_binop_left(ir_node *node, ir_node *left) {
1625 assert(node->op->opar == oparity_binary);
1626 set_irn_n(node, node->op->op_index, left);
1630 get_binop_right(const ir_node *node) {
1631 assert(node->op->opar == oparity_binary);
1632 return get_irn_n(node, node->op->op_index + 1);
1636 set_binop_right(ir_node *node, ir_node *right) {
1637 assert(node->op->opar == oparity_binary);
1638 set_irn_n(node, node->op->op_index + 1, right);
1642 (is_Phi)(const ir_node *n) {
1646 int is_Phi0(const ir_node *n) {
1649 return ((get_irn_op(n) == op_Phi) &&
1650 (get_irn_arity(n) == 0) &&
1651 (get_irg_phase_state(get_irn_irg(n)) == phase_building));
1655 get_Phi_preds_arr(ir_node *node) {
1656 assert(node->op == op_Phi);
1657 return (ir_node **)&(get_irn_in(node)[1]);
1661 get_Phi_n_preds(const ir_node *node) {
1662 assert(is_Phi(node) || is_Phi0(node));
1663 return (get_irn_arity(node));
1667 void set_Phi_n_preds(ir_node *node, int n_preds) {
1668 assert(node->op == op_Phi);
1673 get_Phi_pred(const ir_node *node, int pos) {
1674 assert(is_Phi(node) || is_Phi0(node));
1675 return get_irn_n(node, pos);
1679 set_Phi_pred(ir_node *node, int pos, ir_node *pred) {
1680 assert(is_Phi(node) || is_Phi0(node));
1681 set_irn_n(node, pos, pred);
1685 int is_memop(const ir_node *node) {
1686 ir_opcode code = get_irn_opcode(node);
1687 return (code == iro_Load || code == iro_Store);
1690 ir_node *get_memop_mem(const ir_node *node) {
1691 assert(is_memop(node));
1692 return get_irn_n(node, 0);
1695 void set_memop_mem(ir_node *node, ir_node *mem) {
1696 assert(is_memop(node));
1697 set_irn_n(node, 0, mem);
1700 ir_node *get_memop_ptr(const ir_node *node) {
1701 assert(is_memop(node));
1702 return get_irn_n(node, 1);
1705 void set_memop_ptr(ir_node *node, ir_node *ptr) {
1706 assert(is_memop(node));
1707 set_irn_n(node, 1, ptr);
1711 get_Load_mem(const ir_node *node) {
1712 assert(node->op == op_Load);
1713 return get_irn_n(node, 0);
1717 set_Load_mem(ir_node *node, ir_node *mem) {
1718 assert(node->op == op_Load);
1719 set_irn_n(node, 0, mem);
1723 get_Load_ptr(const ir_node *node) {
1724 assert(node->op == op_Load);
1725 return get_irn_n(node, 1);
1729 set_Load_ptr(ir_node *node, ir_node *ptr) {
1730 assert(node->op == op_Load);
1731 set_irn_n(node, 1, ptr);
1735 get_Load_mode(const ir_node *node) {
1736 assert(node->op == op_Load);
1737 return node->attr.load.load_mode;
1741 set_Load_mode(ir_node *node, ir_mode *mode) {
1742 assert(node->op == op_Load);
1743 node->attr.load.load_mode = mode;
1747 get_Load_volatility(const ir_node *node) {
1748 assert(node->op == op_Load);
1749 return node->attr.load.volatility;
1753 set_Load_volatility(ir_node *node, ir_volatility volatility) {
1754 assert(node->op == op_Load);
1755 node->attr.load.volatility = volatility;
1759 get_Load_align(const ir_node *node) {
1760 assert(node->op == op_Load);
1761 return node->attr.load.aligned;
1765 set_Load_align(ir_node *node, ir_align align) {
1766 assert(node->op == op_Load);
1767 node->attr.load.aligned = align;
1772 get_Store_mem(const ir_node *node) {
1773 assert(node->op == op_Store);
1774 return get_irn_n(node, 0);
1778 set_Store_mem(ir_node *node, ir_node *mem) {
1779 assert(node->op == op_Store);
1780 set_irn_n(node, 0, mem);
1784 get_Store_ptr(const ir_node *node) {
1785 assert(node->op == op_Store);
1786 return get_irn_n(node, 1);
1790 set_Store_ptr(ir_node *node, ir_node *ptr) {
1791 assert(node->op == op_Store);
1792 set_irn_n(node, 1, ptr);
1796 get_Store_value(const ir_node *node) {
1797 assert(node->op == op_Store);
1798 return get_irn_n(node, 2);
1802 set_Store_value(ir_node *node, ir_node *value) {
1803 assert(node->op == op_Store);
1804 set_irn_n(node, 2, value);
1808 get_Store_volatility(const ir_node *node) {
1809 assert(node->op == op_Store);
1810 return node->attr.store.volatility;
1814 set_Store_volatility(ir_node *node, ir_volatility volatility) {
1815 assert(node->op == op_Store);
1816 node->attr.store.volatility = volatility;
1820 get_Store_align(const ir_node *node) {
1821 assert(node->op == op_Store);
1822 return node->attr.store.aligned;
1826 set_Store_align(ir_node *node, ir_align align) {
1827 assert(node->op == op_Store);
1828 node->attr.store.aligned = align;
1833 get_Alloc_mem(const ir_node *node) {
1834 assert(node->op == op_Alloc);
1835 return get_irn_n(node, 0);
1839 set_Alloc_mem(ir_node *node, ir_node *mem) {
1840 assert(node->op == op_Alloc);
1841 set_irn_n(node, 0, mem);
1845 get_Alloc_size(const ir_node *node) {
1846 assert(node->op == op_Alloc);
1847 return get_irn_n(node, 1);
1851 set_Alloc_size(ir_node *node, ir_node *size) {
1852 assert(node->op == op_Alloc);
1853 set_irn_n(node, 1, size);
1857 get_Alloc_type(ir_node *node) {
1858 assert(node->op == op_Alloc);
1859 return node->attr.alloc.type = skip_tid(node->attr.alloc.type);
1863 set_Alloc_type(ir_node *node, ir_type *tp) {
1864 assert(node->op == op_Alloc);
1865 node->attr.alloc.type = tp;
1869 get_Alloc_where(const ir_node *node) {
1870 assert(node->op == op_Alloc);
1871 return node->attr.alloc.where;
1875 set_Alloc_where(ir_node *node, ir_where_alloc where) {
1876 assert(node->op == op_Alloc);
1877 node->attr.alloc.where = where;
1882 get_Free_mem(const ir_node *node) {
1883 assert(node->op == op_Free);
1884 return get_irn_n(node, 0);
1888 set_Free_mem(ir_node *node, ir_node *mem) {
1889 assert(node->op == op_Free);
1890 set_irn_n(node, 0, mem);
1894 get_Free_ptr(const ir_node *node) {
1895 assert(node->op == op_Free);
1896 return get_irn_n(node, 1);
1900 set_Free_ptr(ir_node *node, ir_node *ptr) {
1901 assert(node->op == op_Free);
1902 set_irn_n(node, 1, ptr);
1906 get_Free_size(const ir_node *node) {
1907 assert(node->op == op_Free);
1908 return get_irn_n(node, 2);
1912 set_Free_size(ir_node *node, ir_node *size) {
1913 assert(node->op == op_Free);
1914 set_irn_n(node, 2, size);
1918 get_Free_type(ir_node *node) {
1919 assert(node->op == op_Free);
1920 return node->attr.free.type = skip_tid(node->attr.free.type);
1924 set_Free_type(ir_node *node, ir_type *tp) {
1925 assert(node->op == op_Free);
1926 node->attr.free.type = tp;
1930 get_Free_where(const ir_node *node) {
1931 assert(node->op == op_Free);
1932 return node->attr.free.where;
1936 set_Free_where(ir_node *node, ir_where_alloc where) {
1937 assert(node->op == op_Free);
1938 node->attr.free.where = where;
1941 ir_node **get_Sync_preds_arr(ir_node *node) {
1942 assert(node->op == op_Sync);
1943 return (ir_node **)&(get_irn_in(node)[1]);
1946 int get_Sync_n_preds(const ir_node *node) {
1947 assert(node->op == op_Sync);
1948 return (get_irn_arity(node));
1952 void set_Sync_n_preds(ir_node *node, int n_preds) {
1953 assert(node->op == op_Sync);
1957 ir_node *get_Sync_pred(const ir_node *node, int pos) {
1958 assert(node->op == op_Sync);
1959 return get_irn_n(node, pos);
1962 void set_Sync_pred(ir_node *node, int pos, ir_node *pred) {
1963 assert(node->op == op_Sync);
1964 set_irn_n(node, pos, pred);
1967 /* Add a new Sync predecessor */
1968 void add_Sync_pred(ir_node *node, ir_node *pred) {
1969 assert(node->op == op_Sync);
1970 add_irn_n(node, pred);
1973 /* Returns the source language type of a Proj node. */
1974 ir_type *get_Proj_type(ir_node *n) {
1975 ir_type *tp = firm_unknown_type;
1976 ir_node *pred = get_Proj_pred(n);
1978 switch (get_irn_opcode(pred)) {
1981 /* Deal with Start / Call here: we need to know the Proj Nr. */
1982 assert(get_irn_mode(pred) == mode_T);
1983 pred_pred = get_Proj_pred(pred);
1984 if (get_irn_op(pred_pred) == op_Start) {
1985 ir_type *mtp = get_entity_type(get_irg_entity(get_irn_irg(pred_pred)));
1986 tp = get_method_param_type(mtp, get_Proj_proj(n));
1987 } else if (get_irn_op(pred_pred) == op_Call) {
1988 ir_type *mtp = get_Call_type(pred_pred);
1989 tp = get_method_res_type(mtp, get_Proj_proj(n));
1992 case iro_Start: break;
1993 case iro_Call: break;
1995 ir_node *a = get_Load_ptr(pred);
1997 tp = get_entity_type(get_Sel_entity(a));
2006 get_Proj_pred(const ir_node *node) {
2007 assert(is_Proj(node));
2008 return get_irn_n(node, 0);
2012 set_Proj_pred(ir_node *node, ir_node *pred) {
2013 assert(is_Proj(node));
2014 set_irn_n(node, 0, pred);
2018 get_Proj_proj(const ir_node *node) {
2019 assert(is_Proj(node));
2020 if (get_irn_opcode(node) == iro_Proj) {
2021 return node->attr.proj;
2023 assert(get_irn_opcode(node) == iro_Filter);
2024 return node->attr.filter.proj;
2029 set_Proj_proj(ir_node *node, long proj) {
2030 assert(node->op == op_Proj);
2031 node->attr.proj = proj;
2035 get_Tuple_preds_arr(ir_node *node) {
2036 assert(node->op == op_Tuple);
2037 return (ir_node **)&(get_irn_in(node)[1]);
2041 get_Tuple_n_preds(const ir_node *node) {
2042 assert(node->op == op_Tuple);
2043 return (get_irn_arity(node));
2048 set_Tuple_n_preds(ir_node *node, int n_preds) {
2049 assert(node->op == op_Tuple);
2054 get_Tuple_pred(const ir_node *node, int pos) {
2055 assert(node->op == op_Tuple);
2056 return get_irn_n(node, pos);
2060 set_Tuple_pred(ir_node *node, int pos, ir_node *pred) {
2061 assert(node->op == op_Tuple);
2062 set_irn_n(node, pos, pred);
2066 get_Id_pred(const ir_node *node) {
2067 assert(node->op == op_Id);
2068 return get_irn_n(node, 0);
2072 set_Id_pred(ir_node *node, ir_node *pred) {
2073 assert(node->op == op_Id);
2074 set_irn_n(node, 0, pred);
2077 ir_node *get_Confirm_value(const ir_node *node) {
2078 assert(node->op == op_Confirm);
2079 return get_irn_n(node, 0);
2082 void set_Confirm_value(ir_node *node, ir_node *value) {
2083 assert(node->op == op_Confirm);
2084 set_irn_n(node, 0, value);
2087 ir_node *get_Confirm_bound(const ir_node *node) {
2088 assert(node->op == op_Confirm);
2089 return get_irn_n(node, 1);
2092 void set_Confirm_bound(ir_node *node, ir_node *bound) {
2093 assert(node->op == op_Confirm);
2094 set_irn_n(node, 0, bound);
2097 pn_Cmp get_Confirm_cmp(const ir_node *node) {
2098 assert(node->op == op_Confirm);
2099 return node->attr.confirm.cmp;
2102 void set_Confirm_cmp(ir_node *node, pn_Cmp cmp) {
2103 assert(node->op == op_Confirm);
2104 node->attr.confirm.cmp = cmp;
2108 get_Filter_pred(ir_node *node) {
2109 assert(node->op == op_Filter);
2114 set_Filter_pred(ir_node *node, ir_node *pred) {
2115 assert(node->op == op_Filter);
2120 get_Filter_proj(ir_node *node) {
2121 assert(node->op == op_Filter);
2122 return node->attr.filter.proj;
2126 set_Filter_proj(ir_node *node, long proj) {
2127 assert(node->op == op_Filter);
2128 node->attr.filter.proj = proj;
2131 /* Don't use get_irn_arity, get_irn_n in implementation as access
2132 shall work independent of view!!! */
2133 void set_Filter_cg_pred_arr(ir_node *node, int arity, ir_node ** in) {
2134 assert(node->op == op_Filter);
2135 if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2136 ir_graph *irg = get_irn_irg(node);
2137 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2138 node->attr.filter.backedge = new_backedge_arr(irg->obst, arity);
2139 node->attr.filter.in_cg[0] = node->in[0];
2141 memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2144 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2145 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2146 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2147 node->attr.filter.in_cg[pos + 1] = pred;
2150 int get_Filter_n_cg_preds(ir_node *node) {
2151 assert(node->op == op_Filter && node->attr.filter.in_cg);
2152 return (ARR_LEN(node->attr.filter.in_cg) - 1);
2155 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2157 assert(node->op == op_Filter && node->attr.filter.in_cg &&
2159 arity = ARR_LEN(node->attr.filter.in_cg);
2160 assert(pos < arity - 1);
2161 return node->attr.filter.in_cg[pos + 1];
2165 ir_node *get_Mux_sel(const ir_node *node) {
2166 if (node->op == op_Psi) {
2167 assert(get_irn_arity(node) == 3);
2168 return get_Psi_cond(node, 0);
2170 assert(node->op == op_Mux);
2174 void set_Mux_sel(ir_node *node, ir_node *sel) {
2175 if (node->op == op_Psi) {
2176 assert(get_irn_arity(node) == 3);
2177 set_Psi_cond(node, 0, sel);
2179 assert(node->op == op_Mux);
2184 ir_node *get_Mux_false(const ir_node *node) {
2185 if (node->op == op_Psi) {
2186 assert(get_irn_arity(node) == 3);
2187 return get_Psi_default(node);
2189 assert(node->op == op_Mux);
2193 void set_Mux_false(ir_node *node, ir_node *ir_false) {
2194 if (node->op == op_Psi) {
2195 assert(get_irn_arity(node) == 3);
2196 set_Psi_default(node, ir_false);
2198 assert(node->op == op_Mux);
2199 node->in[2] = ir_false;
2203 ir_node *get_Mux_true(const ir_node *node) {
2204 if (node->op == op_Psi) {
2205 assert(get_irn_arity(node) == 3);
2206 return get_Psi_val(node, 0);
2208 assert(node->op == op_Mux);
2212 void set_Mux_true(ir_node *node, ir_node *ir_true) {
2213 if (node->op == op_Psi) {
2214 assert(get_irn_arity(node) == 3);
2215 set_Psi_val(node, 0, ir_true);
2217 assert(node->op == op_Mux);
2218 node->in[3] = ir_true;
2223 ir_node *get_Psi_cond(const ir_node *node, int pos) {
2224 assert(node->op == op_Psi);
2225 assert(pos < get_Psi_n_conds(node));
2226 return get_irn_n(node, 2 * pos);
2229 void set_Psi_cond(ir_node *node, int pos, ir_node *cond) {
2230 assert(node->op == op_Psi);
2231 assert(pos < get_Psi_n_conds(node));
2232 set_irn_n(node, 2 * pos, cond);
2235 ir_node *get_Psi_val(const ir_node *node, int pos) {
2236 assert(node->op == op_Psi);
2237 assert(pos < get_Psi_n_conds(node));
2238 return get_irn_n(node, 2 * pos + 1);
2241 void set_Psi_val(ir_node *node, int pos, ir_node *val) {
2242 assert(node->op == op_Psi);
2243 assert(pos < get_Psi_n_conds(node));
2244 set_irn_n(node, 2 * pos + 1, val);
2247 ir_node *get_Psi_default(const ir_node *node) {
2248 int def_pos = get_irn_arity(node) - 1;
2249 assert(node->op == op_Psi);
2250 return get_irn_n(node, def_pos);
2253 void set_Psi_default(ir_node *node, ir_node *val) {
2254 int def_pos = get_irn_arity(node);
2255 assert(node->op == op_Psi);
2256 set_irn_n(node, def_pos, val);
2259 int (get_Psi_n_conds)(const ir_node *node) {
2260 return _get_Psi_n_conds(node);
2264 ir_node *get_CopyB_mem(const ir_node *node) {
2265 assert(node->op == op_CopyB);
2266 return get_irn_n(node, 0);
2269 void set_CopyB_mem(ir_node *node, ir_node *mem) {
2270 assert(node->op == op_CopyB);
2271 set_irn_n(node, 0, mem);
2274 ir_node *get_CopyB_dst(const ir_node *node) {
2275 assert(node->op == op_CopyB);
2276 return get_irn_n(node, 1);
2279 void set_CopyB_dst(ir_node *node, ir_node *dst) {
2280 assert(node->op == op_CopyB);
2281 set_irn_n(node, 1, dst);
2284 ir_node *get_CopyB_src(const ir_node *node) {
2285 assert(node->op == op_CopyB);
2286 return get_irn_n(node, 2);
2289 void set_CopyB_src(ir_node *node, ir_node *src) {
2290 assert(node->op == op_CopyB);
2291 set_irn_n(node, 2, src);
2294 ir_type *get_CopyB_type(ir_node *node) {
2295 assert(node->op == op_CopyB);
2296 return node->attr.copyb.data_type = skip_tid(node->attr.copyb.data_type);
2299 void set_CopyB_type(ir_node *node, ir_type *data_type) {
2300 assert(node->op == op_CopyB && data_type);
2301 node->attr.copyb.data_type = data_type;
2306 get_InstOf_type(ir_node *node) {
2307 assert(node->op == op_InstOf);
2308 return node->attr.instof.type = skip_tid(node->attr.instof.type);
2312 set_InstOf_type(ir_node *node, ir_type *type) {
2313 assert(node->op == op_InstOf);
2314 node->attr.instof.type = type;
2318 get_InstOf_store(const ir_node *node) {
2319 assert(node->op == op_InstOf);
2320 return get_irn_n(node, 0);
2324 set_InstOf_store(ir_node *node, ir_node *obj) {
2325 assert(node->op == op_InstOf);
2326 set_irn_n(node, 0, obj);
2330 get_InstOf_obj(const ir_node *node) {
2331 assert(node->op == op_InstOf);
2332 return get_irn_n(node, 1);
2336 set_InstOf_obj(ir_node *node, ir_node *obj) {
2337 assert(node->op == op_InstOf);
2338 set_irn_n(node, 1, obj);
2341 /* Returns the memory input of a Raise operation. */
2343 get_Raise_mem(const ir_node *node) {
2344 assert(node->op == op_Raise);
2345 return get_irn_n(node, 0);
2349 set_Raise_mem(ir_node *node, ir_node *mem) {
2350 assert(node->op == op_Raise);
2351 set_irn_n(node, 0, mem);
2355 get_Raise_exo_ptr(const ir_node *node) {
2356 assert(node->op == op_Raise);
2357 return get_irn_n(node, 1);
2361 set_Raise_exo_ptr(ir_node *node, ir_node *exo_ptr) {
2362 assert(node->op == op_Raise);
2363 set_irn_n(node, 1, exo_ptr);
2368 /* Returns the memory input of a Bound operation. */
2369 ir_node *get_Bound_mem(const ir_node *bound) {
2370 assert(bound->op == op_Bound);
2371 return get_irn_n(bound, 0);
2374 void set_Bound_mem(ir_node *bound, ir_node *mem) {
2375 assert(bound->op == op_Bound);
2376 set_irn_n(bound, 0, mem);
2379 /* Returns the index input of a Bound operation. */
2380 ir_node *get_Bound_index(const ir_node *bound) {
2381 assert(bound->op == op_Bound);
2382 return get_irn_n(bound, 1);
2385 void set_Bound_index(ir_node *bound, ir_node *idx) {
2386 assert(bound->op == op_Bound);
2387 set_irn_n(bound, 1, idx);
2390 /* Returns the lower bound input of a Bound operation. */
2391 ir_node *get_Bound_lower(const ir_node *bound) {
2392 assert(bound->op == op_Bound);
2393 return get_irn_n(bound, 2);
2396 void set_Bound_lower(ir_node *bound, ir_node *lower) {
2397 assert(bound->op == op_Bound);
2398 set_irn_n(bound, 2, lower);
2401 /* Returns the upper bound input of a Bound operation. */
2402 ir_node *get_Bound_upper(const ir_node *bound) {
2403 assert(bound->op == op_Bound);
2404 return get_irn_n(bound, 3);
2407 void set_Bound_upper(ir_node *bound, ir_node *upper) {
2408 assert(bound->op == op_Bound);
2409 set_irn_n(bound, 3, upper);
2412 /* Return the operand of a Pin node. */
2413 ir_node *get_Pin_op(const ir_node *pin) {
2414 assert(pin->op == op_Pin);
2415 return get_irn_n(pin, 0);
2418 void set_Pin_op(ir_node *pin, ir_node *node) {
2419 assert(pin->op == op_Pin);
2420 set_irn_n(pin, 0, node);
2423 /* Return the assembler text of an ASM pseudo node. */
2424 ident *get_ASM_text(const ir_node *node) {
2425 assert(node->op == op_ASM);
2426 return node->attr.assem.asm_text;
2429 /* Return the number of input constraints for an ASM node. */
2430 int get_ASM_n_input_constraints(const ir_node *node) {
2431 assert(node->op == op_ASM);
2432 return ARR_LEN(node->attr.assem.inputs);
2435 /* Return the input constraints for an ASM node. This is a flexible array. */
2436 const ir_asm_constraint *get_ASM_input_constraints(const ir_node *node) {
2437 assert(node->op == op_ASM);
2438 return node->attr.assem.inputs;
2441 /* Return the number of output constraints for an ASM node. */
2442 int get_ASM_n_output_constraints(const ir_node *node) {
2443 assert(node->op == op_ASM);
2444 return ARR_LEN(node->attr.assem.outputs);
2447 /* Return the output constraints for an ASM node. */
2448 const ir_asm_constraint *get_ASM_output_constraints(const ir_node *node) {
2449 assert(node->op == op_ASM);
2450 return node->attr.assem.outputs;
2453 /* Return the number of clobbered registers for an ASM node. */
2454 int get_ASM_n_clobbers(const ir_node *node) {
2455 assert(node->op == op_ASM);
2456 return ARR_LEN(node->attr.assem.clobber);
2459 /* Return the list of clobbered registers for an ASM node. */
2460 ident **get_ASM_clobbers(const ir_node *node) {
2461 assert(node->op == op_ASM);
2462 return node->attr.assem.clobber;
2465 /* returns the graph of a node */
2467 get_irn_irg(const ir_node *node) {
2469 * Do not use get_nodes_Block() here, because this
2470 * will check the pinned state.
2471 * However even a 'wrong' block is always in the proper
2474 if (! is_Block(node))
2475 node = get_irn_n(node, -1);
2476 if (is_Bad(node)) /* sometimes bad is predecessor of nodes instead of block: in case of optimization */
2477 node = get_irn_n(node, -1);
2478 assert(get_irn_op(node) == op_Block);
2479 return node->attr.block.irg;
2483 /*----------------------------------------------------------------*/
2484 /* Auxiliary routines */
2485 /*----------------------------------------------------------------*/
2488 skip_Proj(ir_node *node) {
2489 /* don't assert node !!! */
2494 node = get_Proj_pred(node);
2500 skip_Proj_const(const ir_node *node) {
2501 /* don't assert node !!! */
2506 node = get_Proj_pred(node);
2512 skip_Tuple(ir_node *node) {
2516 if (!get_opt_normalize()) return node;
2519 if (get_irn_op(node) == op_Proj) {
2520 pred = get_Proj_pred(node);
2521 op = get_irn_op(pred);
2524 * Looks strange but calls get_irn_op() only once
2525 * in most often cases.
2527 if (op == op_Proj) { /* nested Tuple ? */
2528 pred = skip_Tuple(pred);
2529 op = get_irn_op(pred);
2531 if (op == op_Tuple) {
2532 node = get_Tuple_pred(pred, get_Proj_proj(node));
2535 } else if (op == op_Tuple) {
2536 node = get_Tuple_pred(pred, get_Proj_proj(node));
2543 /* returns operand of node if node is a Cast */
2544 ir_node *skip_Cast(ir_node *node) {
2545 if (get_irn_op(node) == op_Cast)
2546 return get_Cast_op(node);
2550 /* returns operand of node if node is a Confirm */
2551 ir_node *skip_Confirm(ir_node *node) {
2552 if (get_irn_op(node) == op_Confirm)
2553 return get_Confirm_value(node);
2557 /* skip all high-level ops */
2558 ir_node *skip_HighLevel_ops(ir_node *node) {
2559 while (is_op_highlevel(get_irn_op(node))) {
2560 node = get_irn_n(node, 0);
2566 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2567 * than any other approach, as Id chains are resolved and all point to the real node, or
2568 * all id's are self loops.
2570 * Note: This function takes 10% of mostly ANY the compiler run, so it's
2571 * a little bit "hand optimized".
2573 * Moreover, it CANNOT be switched off using get_opt_normalize() ...
2576 skip_Id(ir_node *node) {
2578 /* don't assert node !!! */
2580 if (!node || (node->op != op_Id)) return node;
2582 /* Don't use get_Id_pred(): We get into an endless loop for
2583 self-referencing Ids. */
2584 pred = node->in[0+1];
2586 if (pred->op != op_Id) return pred;
2588 if (node != pred) { /* not a self referencing Id. Resolve Id chain. */
2589 ir_node *rem_pred, *res;
2591 if (pred->op != op_Id) return pred; /* shortcut */
2594 assert(get_irn_arity (node) > 0);
2596 node->in[0+1] = node; /* turn us into a self referencing Id: shorten Id cycles. */
2597 res = skip_Id(rem_pred);
2598 if (res->op == op_Id) /* self-loop */ return node;
2600 node->in[0+1] = res; /* Turn Id chain into Ids all referencing the chain end. */
2607 void skip_Id_and_store(ir_node **node) {
2610 if (!n || (n->op != op_Id)) return;
2612 /* Don't use get_Id_pred(): We get into an endless loop for
2613 self-referencing Ids. */
2618 (is_Bad)(const ir_node *node) {
2619 return _is_Bad(node);
2623 (is_NoMem)(const ir_node *node) {
2624 return _is_NoMem(node);
2628 (is_Minus)(const ir_node *node) {
2629 return _is_Minus(node);
2633 (is_Mod)(const ir_node *node) {
2634 return _is_Mod(node);
2638 (is_Div)(const ir_node *node) {
2639 return _is_Div(node);
2643 (is_DivMod)(const ir_node *node) {
2644 return _is_DivMod(node);
2648 (is_Quot)(const ir_node *node) {
2649 return _is_Quot(node);
2653 (is_Add)(const ir_node *node) {
2654 return _is_Add(node);
2658 (is_And)(const ir_node *node) {
2659 return _is_And(node);
2663 (is_Or)(const ir_node *node) {
2664 return _is_Or(node);
2668 (is_Eor)(const ir_node *node) {
2669 return _is_Eor(node);
2673 (is_Sub)(const ir_node *node) {
2674 return _is_Sub(node);
2678 (is_Shl)(const ir_node *node) {
2679 return _is_Shl(node);
2683 (is_Shr)(const ir_node *node) {
2684 return _is_Shr(node);
2688 (is_Shrs)(const ir_node *node) {
2689 return _is_Shrs(node);
2693 (is_Rot)(const ir_node *node) {
2694 return _is_Rot(node);
2698 (is_Not)(const ir_node *node) {
2699 return _is_Not(node);
2703 (is_Psi)(const ir_node *node) {
2704 return _is_Psi(node);
2708 (is_Tuple)(const ir_node *node) {
2709 return _is_Tuple(node);
2713 (is_Bound)(const ir_node *node) {
2714 return _is_Bound(node);
2718 (is_Start)(const ir_node *node) {
2719 return _is_Start(node);
2723 (is_End)(const ir_node *node) {
2724 return _is_End(node);
2728 (is_Const)(const ir_node *node) {
2729 return _is_Const(node);
2733 (is_Conv)(const ir_node *node) {
2734 return _is_Conv(node);
2738 (is_strictConv)(const ir_node *node) {
2739 return _is_strictConv(node);
2743 (is_Cast)(const ir_node *node) {
2744 return _is_Cast(node);
2748 (is_no_Block)(const ir_node *node) {
2749 return _is_no_Block(node);
2753 (is_Block)(const ir_node *node) {
2754 return _is_Block(node);
2757 /* returns true if node is an Unknown node. */
2759 (is_Unknown)(const ir_node *node) {
2760 return _is_Unknown(node);
2763 /* returns true if node is a Return node. */
2765 (is_Return)(const ir_node *node) {
2766 return _is_Return(node);
2769 /* returns true if node is a Call node. */
2771 (is_Call)(const ir_node *node) {
2772 return _is_Call(node);
2775 /* returns true if node is a Sel node. */
2777 (is_Sel)(const ir_node *node) {
2778 return _is_Sel(node);
2781 /* returns true if node is a Mux node or a Psi with only one condition. */
2783 (is_Mux)(const ir_node *node) {
2784 return _is_Mux(node);
2787 /* returns true if node is a Load node. */
2789 (is_Load)(const ir_node *node) {
2790 return _is_Load(node);
2793 /* returns true if node is a Load node. */
2795 (is_Store)(const ir_node *node) {
2796 return _is_Store(node);
2799 /* returns true if node is a Sync node. */
2801 (is_Sync)(const ir_node *node) {
2802 return _is_Sync(node);
2805 /* Returns true if node is a Confirm node. */
2807 (is_Confirm)(const ir_node *node) {
2808 return _is_Confirm(node);
2811 /* Returns true if node is a Pin node. */
2813 (is_Pin)(const ir_node *node) {
2814 return _is_Pin(node);
2817 /* Returns true if node is a SymConst node. */
2819 (is_SymConst)(const ir_node *node) {
2820 return _is_SymConst(node);
2823 /* Returns true if node is a SymConst node with kind symconst_addr_ent. */
2825 (is_SymConst_addr_ent)(const ir_node *node) {
2826 return _is_SymConst_addr_ent(node);
2829 /* Returns true if node is a Cond node. */
2831 (is_Cond)(const ir_node *node) {
2832 return _is_Cond(node);
2836 (is_CopyB)(const ir_node *node) {
2837 return _is_CopyB(node);
2840 /* returns true if node is a Cmp node. */
2842 (is_Cmp)(const ir_node *node) {
2843 return _is_Cmp(node);
2846 /* returns true if node is an Alloc node. */
2848 (is_Alloc)(const ir_node *node) {
2849 return _is_Alloc(node);
2852 /* returns true if a node is a Jmp node. */
2854 (is_Jmp)(const ir_node *node) {
2855 return _is_Jmp(node);
2858 /* returns true if a node is a Raise node. */
2860 (is_Raise)(const ir_node *node) {
2861 return _is_Raise(node);
2864 /* returns true if a node is an ASM node. */
2866 (is_ASM)(const ir_node *node) {
2867 return _is_ASM(node);
2871 (is_Proj)(const ir_node *node) {
2873 return node->op == op_Proj ||
2874 (!get_interprocedural_view() && node->op == op_Filter);
2877 /* Returns true if the operation manipulates control flow. */
2878 int is_cfop(const ir_node *node) {
2879 return is_op_cfopcode(get_irn_op(node));
2882 /* Returns true if the operation manipulates interprocedural control flow:
2883 CallBegin, EndReg, EndExcept */
2884 int is_ip_cfop(const ir_node *node) {
2885 return is_ip_cfopcode(get_irn_op(node));
2888 /* Returns true if the operation can change the control flow because
2891 is_fragile_op(const ir_node *node) {
2892 return is_op_fragile(get_irn_op(node));
2895 /* Returns the memory operand of fragile operations. */
2896 ir_node *get_fragile_op_mem(ir_node *node) {
2897 assert(node && is_fragile_op(node));
2899 switch (get_irn_opcode(node)) {
2910 return get_irn_n(node, pn_Generic_M_regular);
2915 assert(0 && "should not be reached");
2920 /* Returns the result mode of a Div operation. */
2921 ir_mode *get_divop_resmod(const ir_node *node) {
2922 switch (get_irn_opcode(node)) {
2923 case iro_Quot : return get_Quot_resmode(node);
2924 case iro_DivMod: return get_DivMod_resmode(node);
2925 case iro_Div : return get_Div_resmode(node);
2926 case iro_Mod : return get_Mod_resmode(node);
2928 assert(0 && "should not be reached");
2933 /* Returns true if the operation is a forking control flow operation. */
2934 int (is_irn_forking)(const ir_node *node) {
2935 return _is_irn_forking(node);
2938 /* Return the type associated with the value produced by n
2939 * if the node remarks this type as it is the case for
2940 * Cast, Const, SymConst and some Proj nodes. */
2941 ir_type *(get_irn_type)(ir_node *node) {
2942 return _get_irn_type(node);
2945 /* Return the type attribute of a node n (SymConst, Call, Alloc, Free,
2947 ir_type *(get_irn_type_attr)(ir_node *node) {
2948 return _get_irn_type_attr(node);
2951 /* Return the entity attribute of a node n (SymConst, Sel) or NULL. */
2952 ir_entity *(get_irn_entity_attr)(ir_node *node) {
2953 return _get_irn_entity_attr(node);
2956 /* Returns non-zero for constant-like nodes. */
2957 int (is_irn_constlike)(const ir_node *node) {
2958 return _is_irn_constlike(node);
2962 * Returns non-zero for nodes that are allowed to have keep-alives and
2963 * are neither Block nor PhiM.
2965 int (is_irn_keep)(const ir_node *node) {
2966 return _is_irn_keep(node);
2970 * Returns non-zero for nodes that are always placed in the start block.
2972 int (is_irn_start_block_placed)(const ir_node *node) {
2973 return _is_irn_start_block_placed(node);
2976 /* Returns non-zero for nodes that are machine operations. */
2977 int (is_irn_machine_op)(const ir_node *node) {
2978 return _is_irn_machine_op(node);
2981 /* Returns non-zero for nodes that are machine operands. */
2982 int (is_irn_machine_operand)(const ir_node *node) {
2983 return _is_irn_machine_operand(node);
2986 /* Returns non-zero for nodes that have the n'th user machine flag set. */
2987 int (is_irn_machine_user)(const ir_node *node, unsigned n) {
2988 return _is_irn_machine_user(node, n);
2992 /* Gets the string representation of the jump prediction .*/
2993 const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred) {
2996 case COND_JMP_PRED_NONE: return "no prediction";
2997 case COND_JMP_PRED_TRUE: return "true taken";
2998 case COND_JMP_PRED_FALSE: return "false taken";
3002 /* Returns the conditional jump prediction of a Cond node. */
3003 cond_jmp_predicate (get_Cond_jmp_pred)(const ir_node *cond) {
3004 return _get_Cond_jmp_pred(cond);
3007 /* Sets a new conditional jump prediction. */
3008 void (set_Cond_jmp_pred)(ir_node *cond, cond_jmp_predicate pred) {
3009 _set_Cond_jmp_pred(cond, pred);
3012 /** the get_type operation must be always implemented and return a firm type */
3013 static ir_type *get_Default_type(ir_node *n) {
3015 return get_unknown_type();
3018 /* Sets the get_type operation for an ir_op_ops. */
3019 ir_op_ops *firm_set_default_get_type(ir_opcode code, ir_op_ops *ops) {
3021 case iro_Const: ops->get_type = get_Const_type; break;
3022 case iro_SymConst: ops->get_type = get_SymConst_value_type; break;
3023 case iro_Cast: ops->get_type = get_Cast_type; break;
3024 case iro_Proj: ops->get_type = get_Proj_type; break;
3026 /* not allowed to be NULL */
3027 if (! ops->get_type)
3028 ops->get_type = get_Default_type;
3034 /** Return the attribute type of a SymConst node if exists */
3035 static ir_type *get_SymConst_attr_type(ir_node *self) {
3036 symconst_kind kind = get_SymConst_kind(self);
3037 if (SYMCONST_HAS_TYPE(kind))
3038 return get_SymConst_type(self);
3042 /** Return the attribute entity of a SymConst node if exists */
3043 static ir_entity *get_SymConst_attr_entity(ir_node *self) {
3044 symconst_kind kind = get_SymConst_kind(self);
3045 if (SYMCONST_HAS_ENT(kind))
3046 return get_SymConst_entity(self);
3050 /** the get_type_attr operation must be always implemented */
3051 static ir_type *get_Null_type(ir_node *n) {
3053 return firm_unknown_type;
3056 /* Sets the get_type operation for an ir_op_ops. */
3057 ir_op_ops *firm_set_default_get_type_attr(ir_opcode code, ir_op_ops *ops) {
3059 case iro_SymConst: ops->get_type_attr = get_SymConst_attr_type; break;
3060 case iro_Call: ops->get_type_attr = get_Call_type; break;
3061 case iro_Alloc: ops->get_type_attr = get_Alloc_type; break;
3062 case iro_Free: ops->get_type_attr = get_Free_type; break;
3063 case iro_Cast: ops->get_type_attr = get_Cast_type; break;
3065 /* not allowed to be NULL */
3066 if (! ops->get_type_attr)
3067 ops->get_type_attr = get_Null_type;
3073 /** the get_entity_attr operation must be always implemented */
3074 static ir_entity *get_Null_ent(ir_node *n) {
3079 /* Sets the get_type operation for an ir_op_ops. */
3080 ir_op_ops *firm_set_default_get_entity_attr(ir_opcode code, ir_op_ops *ops) {
3082 case iro_SymConst: ops->get_entity_attr = get_SymConst_attr_entity; break;
3083 case iro_Sel: ops->get_entity_attr = _get_Sel_entity; break;
3085 /* not allowed to be NULL */
3086 if (! ops->get_entity_attr)
3087 ops->get_entity_attr = get_Null_ent;
3093 /* Sets the debug information of a node. */
3094 void (set_irn_dbg_info)(ir_node *n, dbg_info *db) {
3095 _set_irn_dbg_info(n, db);
3099 * Returns the debug information of an node.
3101 * @param n The node.
3103 dbg_info *(get_irn_dbg_info)(const ir_node *n) {
3104 return _get_irn_dbg_info(n);
3109 #ifdef DEBUG_libfirm
3110 void dump_irn(const ir_node *n) {
3111 int i, arity = get_irn_arity(n);
3112 printf("%s%s: %ld (%p)\n", get_irn_opname(n), get_mode_name(get_irn_mode(n)), get_irn_node_nr(n), (void *)n);
3114 ir_node *pred = get_irn_n(n, -1);
3115 printf(" block: %s%s: %ld (%p)\n", get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
3116 get_irn_node_nr(pred), (void *)pred);
3118 printf(" preds: \n");
3119 for (i = 0; i < arity; ++i) {
3120 ir_node *pred = get_irn_n(n, i);
3121 printf(" %d: %s%s: %ld (%p)\n", i, get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
3122 get_irn_node_nr(pred), (void *)pred);
3126 #else /* DEBUG_libfirm */
3127 void dump_irn(const ir_node *n) { (void) n; }
3128 #endif /* DEBUG_libfirm */