/*
- * Project: libFIRM
- * File name: ir/ir/irnode.c
- * Purpose: Representation of an intermediate operation.
- * Author: Martin Trapp, Christian Schaefer
- * Modified by: Goetz Lindenmaier
- * Created:
- * CVS-ID: $Id$
- * Copyright: (c) 1998-2003 Universität Karlsruhe
- * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
+ * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
+ *
+ * This file is part of libFirm.
+ *
+ * This file may be distributed and/or modified under the terms of the
+ * GNU General Public License version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * Licensees holding valid libFirm Professional Edition licenses may use
+ * this file in accordance with the libFirm Commercial License.
+ * Agreement provided with the Software.
+ *
+ * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE.
*/
+/**
+ * @file
+ * @brief Representation of an intermediate operation.
+ * @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck
+ * @version $Id$
+ */
#ifdef HAVE_CONFIG_H
-# include <config.h>
+# include "config.h"
+#endif
+
+#ifdef HAVE_STRING_H
+# include <string.h>
#endif
-#include <string.h>
#include "ident.h"
#include "irnode_t.h"
#include "irgraph_t.h"
#include "irmode_t.h"
-#include "typegmod.h"
-#include "array.h"
#include "irbackedge_t.h"
#include "irdump.h"
-#include "irflag.h"
#include "irop_t.h"
-
#include "irprog_t.h"
+#include "iredgekinds.h"
+#include "iredges_t.h"
+
+#include "irhooks.h"
+#include "irtools.h"
/* some constants fixing the positions of nodes predecessors
in the in array */
-#define CALL_PARAM_OFFSET 2
-#define SEL_INDEX_OFFSET 2
-#define RETURN_RESULT_OFFSET 1 /* mem is not a result */
-#define END_KEEPALIVE_OFFSET 0
-
-/* Declarations for inlineing */
-INLINE ir_node ** get_irn_in (const ir_node *node);
-INLINE ir_mode *get_irn_mode (const ir_node *node);
-INLINE ir_op *get_irn_op (const ir_node *node);
-INLINE opcode get_irn_opcode (const ir_node *node);
-INLINE ident *get_irn_opident (const ir_node *node);
-INLINE type *get_SymConst_type (ir_node *node);
-INLINE ir_node *skip_nop (ir_node *node);
-INLINE int is_Proj (const ir_node *node);
-
+#define CALL_PARAM_OFFSET 2
+#define FUNCCALL_PARAM_OFFSET 1
+#define SEL_INDEX_OFFSET 2
+#define RETURN_RESULT_OFFSET 1 /* mem is not a result */
+#define END_KEEPALIVE_OFFSET 0
static const char *pnc_name_arr [] = {
- "False", "Eq", "Lt", "Le",
- "Gt", "Ge", "Lg", "Leg", "Uo",
- "Ue", "Ul", "Ule", "Ug", "Uge",
- "Ne", "True"
+ "pn_Cmp_False", "pn_Cmp_Eq", "pn_Cmp_Lt", "pn_Cmp_Le",
+ "pn_Cmp_Gt", "pn_Cmp_Ge", "pn_Cmp_Lg", "pn_Cmp_Leg",
+ "pn_Cmp_Uo", "pn_Cmp_Ue", "pn_Cmp_Ul", "pn_Cmp_Ule",
+ "pn_Cmp_Ug", "pn_Cmp_Uge", "pn_Cmp_Ne", "pn_Cmp_True"
};
-INLINE const char *get_pnc_string(int pnc) {
- return pnc_name_arr[pnc];
-}
-
-
-int
-get_negated_pnc(int pnc) {
- switch (pnc) {
- case False: return True; break;
- case Eq: return Ne; break;
- case Lt: return Uge; break;
- case Le: return Ug; break;
- case Gt: return Ule; break;
- case Ge: return Ul; break;
- case Lg: return Ue; break;
- case Leg: return Uo; break;
- case Uo: return Leg; break;
- case Ue: return Lg; break;
- case Ul: return Ge; break;
- case Ule: return Gt; break;
- case Ug: return Le; break;
- case Uge: return Lt; break;
- case Ne: return Eq; break;
- case True: return False; break;
- }
- return 99; /* to shut up gcc */
-}
-
-const char *pns_name_arr [] = {
- "initial_exec", "global_store",
- "frame_base", "globals", "args"
-};
+/**
+ * returns the pnc name from an pnc constant
+ */
+const char *get_pnc_string(int pnc) {
+ assert(pnc >= 0 && pnc <
+ (int) (sizeof(pnc_name_arr)/sizeof(pnc_name_arr[0])));
+ return pnc_name_arr[pnc];
+}
+
+/*
+ * Calculates the negated (Complement(R)) pnc condition.
+ */
+int get_negated_pnc(int pnc, ir_mode *mode) {
+ pnc ^= pn_Cmp_True;
+
+ /* do NOT add the Uo bit for non-floating point values */
+ if (! mode_is_float(mode))
+ pnc &= ~pn_Cmp_Uo;
+
+ return pnc;
+}
+
+/* Calculates the inversed (R^-1) pnc condition, i.e., "<" --> ">" */
+int
+get_inversed_pnc(int pnc) {
+ int code = pnc & ~(pn_Cmp_Lt|pn_Cmp_Gt);
+ int lesser = pnc & pn_Cmp_Lt;
+ int greater = pnc & pn_Cmp_Gt;
+
+ code |= (lesser ? pn_Cmp_Gt : 0) | (greater ? pn_Cmp_Lt : 0);
+
+ return code;
+}
+
+/**
+ * Indicates, whether additional data can be registered to ir nodes.
+ * If set to 1, this is not possible anymore.
+ */
+static int forbid_new_data = 0;
+
+/**
+ * The amount of additional space for custom data to be allocated upon
+ * creating a new node.
+ */
+unsigned firm_add_node_size = 0;
+
+
+/* register new space for every node */
+unsigned firm_register_additional_node_data(unsigned size) {
+ assert(!forbid_new_data && "Too late to register additional node data");
+
+ if (forbid_new_data)
+ return 0;
+
+ return firm_add_node_size += size;
+}
-const char *symconst_name_arr [] = {
- "type_tag", "size", "linkage_ptr_info"
-};
void
-init_irnode (void)
-{
+init_irnode(void) {
+ /* Forbid the addition of new data to an ir node. */
+ forbid_new_data = 1;
}
-/* irnode constructor */
-/* create a new irnode in irg, with an op, mode, arity and */
-/* some incoming irnodes */
-/* this constructor is used in every specified irnode constructor */
-INLINE ir_node *
-new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
- int arity, ir_node **in)
+/*
+ * irnode constructor.
+ * Create a new irnode in irg, with an op, mode, arity and
+ * some incoming irnodes.
+ * If arity is negative, a node with a dynamic array is created.
+ */
+ir_node *
+new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
+ int arity, ir_node **in)
{
- ir_node *res;
- int node_size = offsetof (ir_node, attr) + op->attr_size;
-
- res = (ir_node *) obstack_alloc (irg->obst, node_size);
-
- res->kind = k_ir_node;
- res->op = op;
- res->mode = mode;
- res->visited = 0;
- res->link = NULL;
- if (arity < 0) {
- res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
- } else {
- res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
- memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
- }
- res->in[0] = block;
- set_irn_dbg_info(res, db);
- res->out = NULL;
+ ir_node *res;
+ size_t node_size = offsetof(ir_node, attr) + op->attr_size + firm_add_node_size;
+ char *p;
+ int i;
+
+ assert(irg && op && mode);
+ p = obstack_alloc(irg->obst, node_size);
+ memset(p, 0, node_size);
+ res = (ir_node *)(p + firm_add_node_size);
+
+ res->kind = k_ir_node;
+ res->op = op;
+ res->mode = mode;
+ res->visited = 0;
+ res->node_idx = irg_register_node_idx(irg, res);
+ res->link = NULL;
+ res->deps = NULL;
+
+ if (arity < 0) {
+ res->in = NEW_ARR_F(ir_node *, 1); /* 1: space for block */
+ } else {
+ res->in = NEW_ARR_D(ir_node *, irg->obst, (arity+1));
+ memcpy(&res->in[1], in, sizeof(ir_node *) * arity);
+ }
+
+ res->in[0] = block;
+ set_irn_dbg_info(res, db);
+ res->out = NULL;
#ifdef DEBUG_libfirm
- res->node_nr = get_irp_new_node_nr();
+ res->node_nr = get_irp_new_node_nr();
#endif
- return res;
-}
+ for (i = 0; i < EDGE_KIND_LAST; ++i)
+ INIT_LIST_HEAD(&res->edge_info[i].outs_head);
-/* Copies all attributes stored in the old node to the new node.
- Assumes both have the same opcode and sufficient size. */
-void
-copy_attrs (ir_node *old, ir_node *new) {
- assert (get_irn_op(old) == get_irn_op(new));
- memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
+ /* don't put this into the for loop, arity is -1 for some nodes! */
+ edges_notify_edge(res, -1, res->in[0], NULL, irg);
+ for (i = 1; i <= arity; ++i)
+ edges_notify_edge(res, i - 1, res->in[i], NULL, irg);
+
+ hook_new_node(irg, res);
+
+ return res;
}
-/** getting some parameters from ir_nodes **/
+/*-- getting some parameters from ir_nodes --*/
int
-is_ir_node (void *thing) {
- assert(thing);
- if (get_kind(thing) == k_ir_node)
- return 1;
- else
- return 0;
+(is_ir_node)(const void *thing) {
+ return _is_ir_node(thing);
}
-/* returns the number of predecessors without the block predecessor. */
-INLINE int
-get_irn_intra_arity (const ir_node *node) {
- assert(node);
- return ARR_LEN(node->in) - 1;
+int
+(get_irn_intra_arity)(const ir_node *node) {
+ return _get_irn_intra_arity(node);
}
-/* returns the number of predecessors without the block predecessor. */
-INLINE int
-get_irn_inter_arity (const ir_node *node) {
- assert(node);
- if (get_irn_opcode(node) == iro_Filter) {
- assert(node->attr.filter.in_cg);
- return ARR_LEN(node->attr.filter.in_cg) - 1;
- } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
- return ARR_LEN(node->attr.block.in_cg) - 1;
- }
- return get_irn_intra_arity(node);
+int
+(get_irn_inter_arity)(const ir_node *node) {
+ return _get_irn_inter_arity(node);
}
-/* returns the number of predecessors without the block predecessor. */
-INLINE int
-get_irn_arity (const ir_node *node) {
- assert(node);
- if (interprocedural_view) return get_irn_inter_arity(node);
- return get_irn_intra_arity(node);
+int (*_get_irn_arity)(const ir_node *node) = _get_irn_intra_arity;
+
+int
+(get_irn_arity)(const ir_node *node) {
+ return _get_irn_arity(node);
}
/* Returns the array with ins. This array is shifted with respect to the
The order of the predecessors in this array is not guaranteed, except that
lists of operands as predecessors of Block or arguments of a Call are
consecutive. */
-INLINE ir_node **
-get_irn_in (const ir_node *node) {
- assert(node);
- if (interprocedural_view) { /* handle Filter and Block specially */
- if (get_irn_opcode(node) == iro_Filter) {
- assert(node->attr.filter.in_cg);
- return node->attr.filter.in_cg;
- } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
- return node->attr.block.in_cg;
- }
- /* else fall through */
- }
- return node->in;
-}
-
-INLINE void
-set_irn_in (ir_node *node, int arity, ir_node **in) {
- ir_node *** arr;
- assert(node);
- if (interprocedural_view) { /* handle Filter and Block specially */
- if (get_irn_opcode(node) == iro_Filter) {
- assert(node->attr.filter.in_cg);
- arr = &node->attr.filter.in_cg;
- } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
- arr = &node->attr.block.in_cg;
- } else {
- arr = &node->in;
- }
- } else {
- arr = &node->in;
- }
- if (arity != ARR_LEN(*arr) - 1) {
- ir_node * block = (*arr)[0];
- *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
- (*arr)[0] = block;
- }
- fix_backedges(current_ir_graph->obst, node);
- memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
-}
-
-INLINE ir_node *
-get_irn_intra_n (ir_node *node, int n) {
- return (node->in[n + 1] = skip_nop(node->in[n + 1]));
-}
-
-INLINE ir_node*
-get_irn_inter_n (ir_node *node, int n) {
- /* handle Filter and Block specially */
- if (get_irn_opcode(node) == iro_Filter) {
- assert(node->attr.filter.in_cg);
- return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
- } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
- return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
- }
-
- return get_irn_intra_n (node, n);
-}
-
-/* to iterate through the predecessors without touching the array */
-/* To iterate over the operands iterate from 0 to i < get_irn_arity(),
- to iterate includind the Block predecessor iterate from i = -1 to
- i < get_irn_arity.
- If it is a block, the entry -1 is NULL. */
-INLINE ir_node *
-get_irn_n (ir_node *node, int n) {
- assert(node); assert(-1 <= n && n < get_irn_arity(node));
- if (interprocedural_view) return get_irn_inter_n (node, n);
- return get_irn_intra_n (node, n);
-}
-
-
-INLINE void
+ir_node **
+get_irn_in(const ir_node *node) {
+ assert(node);
+ if (get_interprocedural_view()) { /* handle Filter and Block specially */
+ if (get_irn_opcode(node) == iro_Filter) {
+ assert(node->attr.filter.in_cg);
+ return node->attr.filter.in_cg;
+ } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
+ return node->attr.block.in_cg;
+ }
+ /* else fall through */
+ }
+ return node->in;
+}
+
+void
+set_irn_in(ir_node *node, int arity, ir_node **in) {
+ int i;
+ ir_node *** arr;
+ ir_graph *irg = current_ir_graph;
+ assert(node);
+ if (get_interprocedural_view()) { /* handle Filter and Block specially */
+ if (get_irn_opcode(node) == iro_Filter) {
+ assert(node->attr.filter.in_cg);
+ arr = &node->attr.filter.in_cg;
+ } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
+ arr = &node->attr.block.in_cg;
+ } else {
+ arr = &node->in;
+ }
+ } else {
+ arr = &node->in;
+ }
+
+ for (i = 0; i < arity; i++) {
+ if (i < ARR_LEN(*arr)-1)
+ edges_notify_edge(node, i, in[i], (*arr)[i+1], irg);
+ else
+ edges_notify_edge(node, i, in[i], NULL, irg);
+ }
+ for(;i < ARR_LEN(*arr)-1; i++) {
+ edges_notify_edge(node, i, NULL, (*arr)[i+1], irg);
+ }
+
+ if (arity != ARR_LEN(*arr) - 1) {
+ ir_node * block = (*arr)[0];
+ *arr = NEW_ARR_D(ir_node *, irg->obst, arity + 1);
+ (*arr)[0] = block;
+ }
+ fix_backedges(irg->obst, node);
+
+ memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
+}
+
+ir_node *
+(get_irn_intra_n)(const ir_node *node, int n) {
+ return _get_irn_intra_n (node, n);
+}
+
+ir_node *
+(get_irn_inter_n)(const ir_node *node, int n) {
+ return _get_irn_inter_n (node, n);
+}
+
+ir_node *(*_get_irn_n)(const ir_node *node, int n) = _get_irn_intra_n;
+
+ir_node *
+(get_irn_n)(const ir_node *node, int n) {
+ return _get_irn_n(node, n);
+}
+
+void
set_irn_n (ir_node *node, int n, ir_node *in) {
- assert(node && -1 <= n && n < get_irn_arity(node));
- if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
- /* Change block pred in both views! */
- node->in[n + 1] = in;
- assert(node->attr.filter.in_cg);
- node->attr.filter.in_cg[n + 1] = in;
- return;
- }
- if (interprocedural_view) { /* handle Filter and Block specially */
- if (get_irn_opcode(node) == iro_Filter) {
- assert(node->attr.filter.in_cg);
- node->attr.filter.in_cg[n + 1] = in;
- return;
- } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
- node->attr.block.in_cg[n + 1] = in;
- return;
- }
- /* else fall through */
- }
- node->in[n + 1] = in;
-}
-
-INLINE ir_mode *
-get_irn_mode (const ir_node *node)
+ assert(node && node->kind == k_ir_node);
+ assert(-1 <= n);
+ assert(n < get_irn_arity(node));
+ assert(in && in->kind == k_ir_node);
+
+ if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
+ /* Change block pred in both views! */
+ node->in[n + 1] = in;
+ assert(node->attr.filter.in_cg);
+ node->attr.filter.in_cg[n + 1] = in;
+ return;
+ }
+ if (get_interprocedural_view()) { /* handle Filter and Block specially */
+ if (get_irn_opcode(node) == iro_Filter) {
+ assert(node->attr.filter.in_cg);
+ node->attr.filter.in_cg[n + 1] = in;
+ return;
+ } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
+ node->attr.block.in_cg[n + 1] = in;
+ return;
+ }
+ /* else fall through */
+ }
+
+ /* Call the hook */
+ hook_set_irn_n(node, n, in, node->in[n + 1]);
+
+ /* Here, we rely on src and tgt being in the current ir graph */
+ edges_notify_edge(node, n, in, node->in[n + 1], current_ir_graph);
+
+ node->in[n + 1] = in;
+}
+
+int add_irn_n(ir_node *node, ir_node *in)
{
- assert (node);
- return node->mode;
+ int pos;
+ ir_graph *irg = get_irn_irg(node);
+
+ assert(node->op->opar == oparity_dynamic);
+ pos = ARR_LEN(node->in) - 1;
+ ARR_APP1(ir_node *, node->in, in);
+ edges_notify_edge(node, pos, node->in[pos + 1], NULL, irg);
+
+ /* Call the hook */
+ hook_set_irn_n(node, pos, node->in[pos + 1], NULL);
+
+ return pos;
}
-INLINE void
-set_irn_mode (ir_node *node, ir_mode *mode)
+int
+(get_irn_deps)(const ir_node *node)
{
- assert (node);
- node->mode=mode;
- return;
+ return _get_irn_deps(node);
}
-INLINE modecode
-get_irn_modecode (const ir_node *node)
+ir_node *
+(get_irn_dep)(const ir_node *node, int pos)
{
- assert (node);
- return node->mode->code;
+ return _get_irn_dep(node, pos);
}
-/** Gets the string representation of the mode .*/
-INLINE const char *
-get_irn_modename (const ir_node *node)
+void
+(set_irn_dep)(ir_node *node, int pos, ir_node *dep)
{
- assert(node);
- return get_mode_name(node->mode);
+ _set_irn_dep(node, pos, dep);
}
-INLINE ident *
-get_irn_modeident (const ir_node *node)
+int add_irn_dep(ir_node *node, ir_node *dep)
{
- assert(node);
- return get_mode_ident(node->mode);
+ int res = 0;
+
+ if (node->deps == NULL) {
+ node->deps = NEW_ARR_F(ir_node *, 1);
+ node->deps[0] = dep;
+ } else {
+ int i, n;
+ int first_zero = -1;
+
+ for(i = 0, n = ARR_LEN(node->deps); i < n; ++i) {
+ if(node->deps[i] == NULL)
+ first_zero = i;
+
+ if(node->deps[i] == dep)
+ return i;
+ }
+
+ if (first_zero >= 0) {
+ node->deps[first_zero] = dep;
+ res = first_zero;
+ } else {
+ ARR_APP1(ir_node *, node->deps, dep);
+ res = n;
+ }
+ }
+
+ edges_notify_edge_kind(node, res, dep, NULL, EDGE_KIND_DEP, get_irn_irg(node));
+
+ return res;
}
-INLINE ir_op *
-get_irn_op (const ir_node *node)
-{
- assert (node);
- return node->op;
+void add_irn_deps(ir_node *tgt, ir_node *src) {
+ int i, n;
+
+ for (i = 0, n = get_irn_deps(src); i < n; ++i)
+ add_irn_dep(tgt, get_irn_dep(src, i));
+}
+
+
+ir_mode *
+(get_irn_mode)(const ir_node *node) {
+ return _get_irn_mode(node);
+}
+
+void
+(set_irn_mode)(ir_node *node, ir_mode *mode) {
+ _set_irn_mode(node, mode);
+}
+
+modecode
+get_irn_modecode(const ir_node *node) {
+ assert(node);
+ return node->mode->code;
+}
+
+/** Gets the string representation of the mode .*/
+const char *
+get_irn_modename(const ir_node *node) {
+ assert(node);
+ return get_mode_name(node->mode);
+}
+
+ident *
+get_irn_modeident(const ir_node *node) {
+ assert(node);
+ return get_mode_ident(node->mode);
+}
+
+ir_op *
+(get_irn_op)(const ir_node *node) {
+ return _get_irn_op(node);
}
/* should be private to the library: */
-INLINE void
-set_irn_op (ir_node *node, ir_op *op)
-{
- assert (node);
- node->op = op;
+void
+(set_irn_op)(ir_node *node, ir_op *op) {
+ _set_irn_op(node, op);
}
-INLINE opcode
-get_irn_opcode (const ir_node *node)
-{
- assert (node);
- assert (k_ir_node == get_kind(node));
- assert (node -> op);
- return node->op->code;
+unsigned
+(get_irn_opcode)(const ir_node *node) {
+ return _get_irn_opcode(node);
}
-INLINE const char *
-get_irn_opname (const ir_node *node)
-{
- assert(node);
- return get_id_str(node->op->name);
+const char *
+get_irn_opname(const ir_node *node) {
+ assert(node);
+ if (is_Phi0(node)) return "Phi0";
+ return get_id_str(node->op->name);
}
-INLINE ident *
-get_irn_opident (const ir_node *node)
-{
- assert(node);
- return node->op->name;
+ident *
+get_irn_opident(const ir_node *node) {
+ assert(node);
+ return node->op->name;
}
-INLINE unsigned long
-get_irn_visited (const ir_node *node)
-{
- assert (node);
- return node->visited;
+unsigned long
+(get_irn_visited)(const ir_node *node) {
+ return _get_irn_visited(node);
}
-INLINE void
-set_irn_visited (ir_node *node, unsigned long visited)
-{
- assert (node);
- node->visited = visited;
+void
+(set_irn_visited)(ir_node *node, unsigned long visited) {
+ _set_irn_visited(node, visited);
}
-INLINE void
-mark_irn_visited (ir_node *node) {
- assert (node);
- node->visited = current_ir_graph->visited;
+void
+(mark_irn_visited)(ir_node *node) {
+ _mark_irn_visited(node);
}
-INLINE int
-irn_not_visited (const ir_node *node) {
- assert (node);
- return (node->visited < current_ir_graph->visited);
+int
+(irn_not_visited)(const ir_node *node) {
+ return _irn_not_visited(node);
}
-INLINE int
-irn_visited (const ir_node *node) {
- assert (node);
- return (node->visited >= current_ir_graph->visited);
+int
+(irn_visited)(const ir_node *node) {
+ return _irn_visited(node);
}
-INLINE void
-set_irn_link (ir_node *node, void *link) {
- assert (node);
- /* Link field is used for Phi construction and various optimizations
- in iropt. */
- assert(get_irg_phase_state(current_ir_graph) != phase_building);
+void
+(set_irn_link)(ir_node *node, void *link) {
+ _set_irn_link(node, link);
+}
- node->link = link;
+void *
+(get_irn_link)(const ir_node *node) {
+ return _get_irn_link(node);
}
-INLINE void *
-get_irn_link (const ir_node *node) {
- assert (node);
- return node->link;
+op_pin_state
+(get_irn_pinned)(const ir_node *node) {
+ return _get_irn_pinned(node);
}
+op_pin_state
+(is_irn_pinned_in_irg) (const ir_node *node) {
+ return _is_irn_pinned_in_irg(node);
+}
+
+void set_irn_pinned(ir_node *node, op_pin_state state) {
+ /* due to optimization an opt may be turned into a Tuple */
+ if (get_irn_op(node) == op_Tuple)
+ return;
+
+ assert(node && get_op_pinned(get_irn_op(node)) >= op_pin_state_exc_pinned);
+ assert(state == op_pin_state_pinned || state == op_pin_state_floats);
+
+ node->attr.except.pin_state = state;
+}
+
+#ifdef DO_HEAPANALYSIS
+/* Access the abstract interpretation information of a node.
+ Returns NULL if no such information is available. */
+struct abstval *get_irn_abst_value(ir_node *n) {
+ return n->av;
+}
+/* Set the abstract interpretation information of a node. */
+void set_irn_abst_value(ir_node *n, struct abstval *os) {
+ n->av = os;
+}
+struct section *firm_get_irn_section(ir_node *n) {
+ return n->sec;
+}
+void firm_set_irn_section(ir_node *n, struct section *s) {
+ n->sec = s;
+}
+#else
+/* Dummies needed for firmjni. */
+struct abstval *get_irn_abst_value(ir_node *n) {
+ (void) n;
+ return NULL;
+}
+void set_irn_abst_value(ir_node *n, struct abstval *os) {
+ (void) n;
+ (void) os;
+}
+struct section *firm_get_irn_section(ir_node *n) {
+ (void) n;
+ return NULL;
+}
+void firm_set_irn_section(ir_node *n, struct section *s) {
+ (void) n;
+ (void) s;
+}
+#endif /* DO_HEAPANALYSIS */
+
+
/* Outputs a unique number for this node */
-INLINE long
-get_irn_node_nr(const ir_node *node) {
- assert(node);
+long get_irn_node_nr(const ir_node *node) {
+ assert(node);
#ifdef DEBUG_libfirm
- return node->node_nr;
+ return node->node_nr;
#else
- return (long)&node;
+ return (long)PTR_TO_INT(node);
#endif
}
-INLINE const_attr
-get_irn_const_attr (ir_node *node)
-{
- assert (node->op == op_Const);
- return node->attr.con;
+const_attr *
+get_irn_const_attr(ir_node *node) {
+ assert(node->op == op_Const);
+ return &node->attr.con;
}
-INLINE long
-get_irn_proj_attr (ir_node *node)
-{
- assert (node->op == op_Proj);
- return node->attr.proj;
+long
+get_irn_proj_attr(ir_node *node) {
+ assert(node->op == op_Proj);
+ return node->attr.proj;
}
-INLINE alloc_attr
-get_irn_alloc_attr (ir_node *node)
-{
- assert (node->op == op_Alloc);
- return node->attr.a;
+alloc_attr *
+get_irn_alloc_attr(ir_node *node) {
+ assert(node->op == op_Alloc);
+ return &node->attr.alloc;
}
-INLINE type *
-get_irn_free_attr (ir_node *node)
-{
- assert (node->op == op_Free);
- return node->attr.f = skip_tid(node->attr.f);
+free_attr *
+get_irn_free_attr(ir_node *node) {
+ assert(node->op == op_Free);
+ return &node->attr.free;
}
-INLINE symconst_attr
-get_irn_symconst_attr (ir_node *node)
-{
- assert (node->op == op_SymConst);
- return node->attr.i;
+symconst_attr *
+get_irn_symconst_attr(ir_node *node) {
+ assert(node->op == op_SymConst);
+ return &node->attr.symc;
}
-INLINE type *
-get_irn_call_attr (ir_node *node)
-{
- assert (node->op == op_Call);
- return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
+ir_type *
+get_irn_call_attr(ir_node *node) {
+ assert(node->op == op_Call);
+ return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
}
-INLINE sel_attr
-get_irn_sel_attr (ir_node *node)
-{
- assert (node->op == op_Sel);
- return node->attr.s;
+sel_attr *
+get_irn_sel_attr(ir_node *node) {
+ assert(node->op == op_Sel);
+ return &node->attr.sel;
}
-INLINE int
-get_irn_phi_attr (ir_node *node)
-{
- assert (node->op == op_Phi);
- return node->attr.phi0_pos;
+int
+get_irn_phi0_attr(ir_node *node) {
+ assert(is_Phi0(node));
+ return node->attr.phi0.pos;
}
-INLINE block_attr
-get_irn_block_attr (ir_node *node)
-{
- assert (node->op == op_Block);
- return node->attr.block;
+block_attr *
+get_irn_block_attr(ir_node *node) {
+ assert(node->op == op_Block);
+ return &node->attr.block;
+}
+
+load_attr *
+get_irn_load_attr(ir_node *node) {
+ assert(node->op == op_Load);
+ return &node->attr.load;
+}
+
+store_attr *
+get_irn_store_attr(ir_node *node) {
+ assert(node->op == op_Store);
+ return &node->attr.store;
+}
+
+except_attr *
+get_irn_except_attr(ir_node *node) {
+ assert(node->op == op_Div || node->op == op_Quot ||
+ node->op == op_DivMod || node->op == op_Mod || node->op == op_Call || node->op == op_Alloc);
+ return &node->attr.except;
+}
+
+void *(get_irn_generic_attr)(ir_node *node) {
+ assert(is_ir_node(node));
+ return _get_irn_generic_attr(node);
+}
+
+const void *(get_irn_generic_attr_const)(const ir_node *node) {
+ assert(is_ir_node(node));
+ return _get_irn_generic_attr_const(node);
+}
+
+unsigned (get_irn_idx)(const ir_node *node) {
+ assert(is_ir_node(node));
+ return _get_irn_idx(node);
+}
+
+int get_irn_pred_pos(ir_node *node, ir_node *arg) {
+ int i;
+ for (i = get_irn_arity(node) - 1; i >= 0; i--) {
+ if (get_irn_n(node, i) == arg)
+ return i;
+ }
+ return -1;
}
/** manipulate fields of individual nodes **/
/* this works for all except Block */
ir_node *
-get_nodes_Block (ir_node *node) {
- assert (!(node->op == op_Block));
- return get_irn_n(node, -1);
+get_nodes_block(const ir_node *node) {
+ assert(node->op != op_Block);
+ assert(is_irn_pinned_in_irg(node) && "block info may be incorrect");
+ return get_irn_n(node, -1);
}
-INLINE void
-set_nodes_Block (ir_node *node, ir_node *block) {
- assert (!(node->op == op_Block));
- set_irn_n(node, -1, block);
+void
+set_nodes_block(ir_node *node, ir_node *block) {
+ assert(node->op != op_Block);
+ set_irn_n(node, -1, block);
}
/* Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
* from Start. If so returns frame type, else Null. */
-type *is_frame_pointer(ir_node *n) {
- if ((get_irn_op(n) == op_Proj) &&
- (get_Proj_proj(n) == pn_Start_P_frame_base)) {
- ir_node *start = get_Proj_pred(n);
- if (get_irn_op(start) == op_Start) {
- return get_irg_frame_type(get_irn_irg(start));
- }
- }
- return NULL;
+ir_type *is_frame_pointer(ir_node *n) {
+ if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_frame_base)) {
+ ir_node *start = get_Proj_pred(n);
+ if (get_irn_op(start) == op_Start) {
+ return get_irg_frame_type(get_irn_irg(start));
+ }
+ }
+ return NULL;
}
/* Test whether arbitrary node is globals pointer, i.e. Proj(pn_Start_P_globals)
* from Start. If so returns global type, else Null. */
-type *is_globals_pointer(ir_node *n) {
- if ((get_irn_op(n) == op_Proj) &&
- (get_Proj_proj(n) == pn_Start_P_globals)) {
- ir_node *start = get_Proj_pred(n);
- if (get_irn_op(start) == op_Start) {
- return get_glob_type();
- }
- }
- return NULL;
+ir_type *is_globals_pointer(ir_node *n) {
+ if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_globals)) {
+ ir_node *start = get_Proj_pred(n);
+ if (get_irn_op(start) == op_Start) {
+ return get_glob_type();
+ }
+ }
+ return NULL;
+}
+
+/* Test whether arbitrary node is tls pointer, i.e. Proj(pn_Start_P_tls)
+ * from Start. If so returns tls type, else Null. */
+ir_type *is_tls_pointer(ir_node *n) {
+ if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_globals)) {
+ ir_node *start = get_Proj_pred(n);
+ if (get_irn_op(start) == op_Start) {
+ return get_tls_type();
+ }
+ }
+ return NULL;
}
/* Test whether arbitrary node is value arg base, i.e. Proj(pn_Start_P_value_arg_base)
* from Start. If so returns 1, else 0. */
int is_value_arg_pointer(ir_node *n) {
- if ((get_irn_op(n) == op_Proj) &&
- (get_Proj_proj(n) == pn_Start_P_value_arg_base) &&
- (get_irn_op(get_Proj_pred(n)) == op_Start))
- return 1;
- return 0;
+ if ((get_irn_op(n) == op_Proj) &&
+ (get_Proj_proj(n) == pn_Start_P_value_arg_base) &&
+ (get_irn_op(get_Proj_pred(n)) == op_Start))
+ return 1;
+ return 0;
}
/* Returns an array with the predecessors of the Block. Depending on
- the implementation of the graph datastructure this can be a copy of
+ the implementation of the graph data structure this can be a copy of
the internal representation of predecessors as well as the internal
array itself. Therefore writing to this array might obstruct the ir. */
-INLINE ir_node **
-get_Block_cfgpred_arr (ir_node *node)
-{
- assert ((node->op == op_Block));
- return (ir_node **)&(get_irn_in(node)[1]);
+ir_node **
+get_Block_cfgpred_arr(ir_node *node) {
+ assert((node->op == op_Block));
+ return (ir_node **)&(get_irn_in(node)[1]);
}
-
-INLINE int
-get_Block_n_cfgpreds (ir_node *node) {
- assert ((node->op == op_Block));
- return (get_irn_arity(node));
+int
+(get_Block_n_cfgpreds)(const ir_node *node) {
+ return _get_Block_n_cfgpreds(node);
}
-INLINE ir_node *
-get_Block_cfgpred (ir_node *node, int pos) {
- assert (node->op == op_Block);
- /* debug @@@
- if (-1 > pos || get_irn_arity(node) <= pos) {
- dump_ir_block_graph(current_ir_graph);
- printf("pos: %d, arity: %d ", pos, get_irn_arity(node));
- DDMN(node);
- } */
- assert(node); assert(-1 <= pos && pos < get_irn_arity(node));
- return get_irn_n(node, pos);
+ir_node *
+(get_Block_cfgpred)(ir_node *node, int pos) {
+ return _get_Block_cfgpred(node, pos);
}
-INLINE void
-set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
- assert (node->op == op_Block);
- set_irn_n(node, pos, pred);
+void
+set_Block_cfgpred(ir_node *node, int pos, ir_node *pred) {
+ assert(node->op == op_Block);
+ set_irn_n(node, pos, pred);
}
-INLINE bool
-get_Block_matured (ir_node *node) {
- assert (node->op == op_Block);
- return node->attr.block.matured;
+ir_node *
+(get_Block_cfgpred_block)(ir_node *node, int pos) {
+ return _get_Block_cfgpred_block(node, pos);
}
-INLINE void
-set_Block_matured (ir_node *node, bool matured) {
- assert (node->op == op_Block);
- node->attr.block.matured = matured;
-}
-INLINE unsigned long
-get_Block_block_visited (ir_node *node) {
- assert (node->op == op_Block);
- return node->attr.block.block_visited;
+int
+get_Block_matured(ir_node *node) {
+ assert(node->op == op_Block);
+ return (int)node->attr.block.is_matured;
}
-INLINE void
-set_Block_block_visited (ir_node *node, unsigned long visit) {
- assert (node->op == op_Block);
- node->attr.block.block_visited = visit;
+void
+set_Block_matured(ir_node *node, int matured) {
+ assert(node->op == op_Block);
+ node->attr.block.is_matured = matured;
}
-/* For this current_ir_graph must be set. */
-INLINE void
-mark_Block_block_visited (ir_node *node) {
- assert (node->op == op_Block);
- node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
+unsigned long
+(get_Block_block_visited)(const ir_node *node) {
+ return _get_Block_block_visited(node);
}
-INLINE int
-Block_not_block_visited(ir_node *node) {
- assert (node->op == op_Block);
- return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
+void
+(set_Block_block_visited)(ir_node *node, unsigned long visit) {
+ _set_Block_block_visited(node, visit);
}
-INLINE ir_node *
-get_Block_graph_arr (ir_node *node, int pos) {
- assert (node->op == op_Block);
- return node->attr.block.graph_arr[pos+1];
+/* For this current_ir_graph must be set. */
+void
+(mark_Block_block_visited)(ir_node *node) {
+ _mark_Block_block_visited(node);
}
-INLINE void
-set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
- assert (node->op == op_Block);
- node->attr.block.graph_arr[pos+1] = value;
+int
+(Block_not_block_visited)(const ir_node *node) {
+ return _Block_not_block_visited(node);
}
-/* handler handling for Blocks * /
-void
-set_Block_handler (ir_node *block, ir_node *handler) {
- assert ((block->op == op_Block));
- assert ((handler->op == op_Block));
- block->attr.block.handler_entry = handler;
+int
+(Block_block_visited)(const ir_node *node) {
+ return _Block_block_visited(node);
}
ir_node *
-get_Block_handler (ir_node *block) {
- assert ((block->op == op_Block));
- return (block->attr.block.handler_entry);
+get_Block_graph_arr (ir_node *node, int pos) {
+ assert(node->op == op_Block);
+ return node->attr.block.graph_arr[pos+1];
}
-/ * handler handling for Nodes * /
void
-set_Node_handler (ir_node *node, ir_node *handler) {
- set_Block_handler (get_nodes_Block (node), handler);
-}
-
-ir_node *
-get_Node_handler (ir_node *node) {
- return (get_Block_handler (get_nodes_Block (node)));
+set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
+ assert(node->op == op_Block);
+ node->attr.block.graph_arr[pos+1] = value;
}
-/ * exc_t handling for Blocks * /
-void set_Block_exc (ir_node *block, exc_t exc) {
- assert ((block->op == op_Block));
- block->attr.block.exc = exc;
+void set_Block_cg_cfgpred_arr(ir_node *node, int arity, ir_node *in[]) {
+ assert(node->op == op_Block);
+ if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
+ node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
+ node->attr.block.in_cg[0] = NULL;
+ node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
+ {
+ /* Fix backedge array. fix_backedges() operates depending on
+ interprocedural_view. */
+ int ipv = get_interprocedural_view();
+ set_interprocedural_view(1);
+ fix_backedges(current_ir_graph->obst, node);
+ set_interprocedural_view(ipv);
+ }
+ }
+ memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
}
-exc_t get_Block_exc (ir_node *block) {
- assert ((block->op == op_Block));
- return (block->attr.block.exc);
+void set_Block_cg_cfgpred(ir_node *node, int pos, ir_node *pred) {
+ assert(node->op == op_Block &&
+ node->attr.block.in_cg &&
+ 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
+ node->attr.block.in_cg[pos + 1] = pred;
}
-/ * exc_t handling for Nodes * /
-void set_Node_exc (ir_node *node, exc_t exc) {
- set_Block_exc (get_nodes_Block (node), exc);
+ir_node **get_Block_cg_cfgpred_arr(ir_node *node) {
+ assert(node->op == op_Block);
+ return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
}
-exc_t get_Node_exc (ir_node *node) {
- return (get_Block_exc (get_nodes_Block (node)));
+int get_Block_cg_n_cfgpreds(ir_node *node) {
+ assert(node->op == op_Block);
+ return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
}
-*/
-void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
- assert(node->op == op_Block);
- if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
- node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
- node->attr.block.in_cg[0] = NULL;
- node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
- {
- /* Fix backedge array. fix_backedges operates depending on
- interprocedural_view. */
- bool ipv = interprocedural_view;
- interprocedural_view = true;
- fix_backedges(current_ir_graph->obst, node);
- interprocedural_view = ipv;
- }
- }
- memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
+ir_node *get_Block_cg_cfgpred(ir_node *node, int pos) {
+ assert(node->op == op_Block && node->attr.block.in_cg);
+ return node->attr.block.in_cg[pos + 1];
}
-void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
- assert(node->op == op_Block &&
- node->attr.block.in_cg &&
- 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
- node->attr.block.in_cg[pos + 1] = pred;
+void remove_Block_cg_cfgpred_arr(ir_node *node) {
+ assert(node->op == op_Block);
+ node->attr.block.in_cg = NULL;
}
-ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
- assert(node->op == op_Block);
- return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
+ir_node *(set_Block_dead)(ir_node *block) {
+ return _set_Block_dead(block);
}
-int get_Block_cg_n_cfgpreds(ir_node * node) {
- assert(node->op == op_Block);
- return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
+int (is_Block_dead)(const ir_node *block) {
+ return _is_Block_dead(block);
}
-ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
- assert(node->op == op_Block && node->attr.block.in_cg);
- return node->attr.block.in_cg[pos + 1];
+ir_extblk *get_Block_extbb(const ir_node *block) {
+ ir_extblk *res;
+ assert(is_Block(block));
+ res = block->attr.block.extblk;
+ assert(res == NULL || is_ir_extbb(res));
+ return res;
}
-void remove_Block_cg_cfgpred_arr(ir_node * node) {
- assert(node->op == op_Block);
- node->attr.block.in_cg = NULL;
+void set_Block_extbb(ir_node *block, ir_extblk *extblk) {
+ assert(is_Block(block));
+ assert(extblk == NULL || is_ir_extbb(extblk));
+ block->attr.block.extblk = extblk;
}
-/* Start references the irg it is in. */
-INLINE ir_graph *
-get_Start_irg(ir_node *node) {
- return get_irn_irg(node);
+/* returns the macro block header of a block. */
+ir_node *get_Block_MacroBlock(const ir_node *block) {
+ assert(is_Block(block));
+ return get_irn_n(block, -1);
}
-INLINE void
-set_Start_irg(ir_node *node, ir_graph *irg) {
- assert(node->op == op_Start);
- assert(is_ir_graph(irg));
- assert(0 && " Why set irg? ");
- //node->attr.start.irg = irg;
+/* returns the graph of a Block. */
+ir_graph *get_Block_irg(const ir_node *block) {
+ assert(is_Block(block));
+ return block->attr.block.irg;
}
-INLINE int
+int
get_End_n_keepalives(ir_node *end) {
- assert (end->op == op_End);
- return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
+ assert(end->op == op_End);
+ return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
}
-INLINE ir_node *
+ir_node *
get_End_keepalive(ir_node *end, int pos) {
- assert (end->op == op_End);
- return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
+ assert(end->op == op_End);
+ return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
}
-INLINE void
-add_End_keepalive (ir_node *end, ir_node *ka) {
- assert (end->op == op_End);
- ARR_APP1 (ir_node *, end->in, ka);
+void
+add_End_keepalive(ir_node *end, ir_node *ka) {
+ assert(end->op == op_End);
+ assert((is_Phi(ka) || is_Proj(ka) || is_Block(ka) || is_irn_keep(ka)) && "Only Phi, Block or Keep nodes can be kept alive!");
+ add_irn_n(end, ka);
}
-INLINE void
+void
set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
- assert (end->op == op_End);
- set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
+ assert(end->op == op_End);
+ set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
+}
+
+/* Set new keep-alives */
+void set_End_keepalives(ir_node *end, int n, ir_node *in[]) {
+ int i;
+ ir_graph *irg = get_irn_irg(end);
+
+ /* notify that edges are deleted */
+ for (i = END_KEEPALIVE_OFFSET; i < ARR_LEN(end->in) - 1; ++i) {
+ edges_notify_edge(end, i, NULL, end->in[i + 1], irg);
+ }
+ ARR_RESIZE(ir_node *, end->in, n + 1 + END_KEEPALIVE_OFFSET);
+
+ for (i = 0; i < n; ++i) {
+ end->in[1 + END_KEEPALIVE_OFFSET + i] = in[i];
+ edges_notify_edge(end, END_KEEPALIVE_OFFSET + i, end->in[1 + END_KEEPALIVE_OFFSET + i], NULL, irg);
+ }
+}
+
+/* Set new keep-alives from old keep-alives, skipping irn */
+void remove_End_keepalive(ir_node *end, ir_node *irn) {
+ int n = get_End_n_keepalives(end);
+ ir_node **in;
+ int i, idx;
+
+ NEW_ARR_A(ir_node *, in, n);
+
+ for (idx = i = 0; i < n; ++i) {
+ ir_node *old_ka = get_End_keepalive(end, i);
+
+ /* skip irn */
+ if (old_ka != irn)
+ in[idx++] = old_ka;
+ }
+
+ /* set new keep-alives */
+ set_End_keepalives(end, idx, in);
}
-INLINE void
+void
free_End (ir_node *end) {
- assert (end->op == op_End);
- end->kind = k_BAD;
- DEL_ARR_F(end->in); /* GL @@@ tut nicht ! */
- end->in = NULL; /* @@@ make sure we get an error if we use the
- in array afterwards ... */
+ assert(end->op == op_End);
+ end->kind = k_BAD;
+ DEL_ARR_F(end->in);
+ end->in = NULL; /* @@@ make sure we get an error if we use the
+ in array afterwards ... */
}
-ir_graph *get_EndReg_irg (ir_node *end) {
- return get_irn_irg(end);
+/* Return the target address of an IJmp */
+ir_node *get_IJmp_target(ir_node *ijmp) {
+ assert(ijmp->op == op_IJmp);
+ return get_irn_n(ijmp, 0);
}
-ir_graph *get_EndExcept_irg (ir_node *end) {
- return get_irn_irg(end);
+/** Sets the target address of an IJmp */
+void set_IJmp_target(ir_node *ijmp, ir_node *tgt) {
+ assert(ijmp->op == op_IJmp);
+ set_irn_n(ijmp, 0, tgt);
}
/*
I know it's complicated.
Basically there are two proglems:
- determining the gaps between the projs
- - determining the biggest case constant to konw the proj number for
+ - determining the biggest case constant to know the proj number for
the default node.
I see several solutions:
1. Introduce a ProjDefault node. Solves both problems.
Solution 2 seems to be the best:
Computing the gaps in the Firm representation is not too hard, i.e.,
-libfirm can implement a routine that transforms betweeen the two
+libFIRM can implement a routine that transforms between the two
flavours. This is also possible for 1) but 2) does not require to
change any existing optimization.
Further it should be far simpler to determine the biggest constant than
dataflow analysis and 3) does not allow to convert the representation to
2a).
*/
-INLINE ir_node *
-get_Cond_selector (ir_node *node) {
- assert (node->op == op_Cond);
- return get_irn_n(node, 0);
+ir_node *
+get_Cond_selector(ir_node *node) {
+ assert(node->op == op_Cond);
+ return get_irn_n(node, 0);
}
-INLINE void
-set_Cond_selector (ir_node *node, ir_node *selector) {
- assert (node->op == op_Cond);
- set_irn_n(node, 0, selector);
+void
+set_Cond_selector(ir_node *node, ir_node *selector) {
+ assert(node->op == op_Cond);
+ set_irn_n(node, 0, selector);
}
-INLINE cond_kind
-get_Cond_kind (ir_node *node) {
- assert (node->op == op_Cond);
- return node->attr.c.kind;
+cond_kind
+get_Cond_kind(ir_node *node) {
+ assert(node->op == op_Cond);
+ return node->attr.cond.kind;
}
-INLINE void
-set_Cond_kind (ir_node *node, cond_kind kind) {
- assert (node->op == op_Cond);
- node->attr.c.kind = kind;
+void
+set_Cond_kind(ir_node *node, cond_kind kind) {
+ assert(node->op == op_Cond);
+ node->attr.cond.kind = kind;
}
-INLINE ir_node *
-get_Return_mem (ir_node *node) {
- assert (node->op == op_Return);
- return get_irn_n(node, 0);
+long
+get_Cond_defaultProj(ir_node *node) {
+ assert(node->op == op_Cond);
+ return node->attr.cond.default_proj;
}
-INLINE void
-set_Return_mem (ir_node *node, ir_node *mem) {
- assert (node->op == op_Return);
- set_irn_n(node, 0, mem);
+ir_node *
+get_Return_mem(ir_node *node) {
+ assert(node->op == op_Return);
+ return get_irn_n(node, 0);
}
-INLINE int
-get_Return_n_ress (ir_node *node) {
- assert (node->op == op_Return);
- return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
+void
+set_Return_mem(ir_node *node, ir_node *mem) {
+ assert(node->op == op_Return);
+ set_irn_n(node, 0, mem);
}
-INLINE ir_node **
-get_Return_res_arr (ir_node *node)
-{
- assert ((node->op == op_Return));
- if (get_Return_n_ress(node) > 0)
- return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
- else
- return NULL;
+int
+get_Return_n_ress(ir_node *node) {
+ assert(node->op == op_Return);
+ return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
+}
+
+ir_node **
+get_Return_res_arr (ir_node *node) {
+ assert((node->op == op_Return));
+ if (get_Return_n_ress(node) > 0)
+ return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
+ else
+ return NULL;
}
/*
-INLINE void
-set_Return_n_res (ir_node *node, int results) {
- assert (node->op == op_Return);
+void
+set_Return_n_res(ir_node *node, int results) {
+ assert(node->op == op_Return);
}
*/
-INLINE ir_node *
-get_Return_res (ir_node *node, int pos) {
- assert (node->op == op_Return);
- assert (get_Return_n_ress(node) > pos);
- return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
+ir_node *
+get_Return_res(ir_node *node, int pos) {
+ assert(node->op == op_Return);
+ assert(get_Return_n_ress(node) > pos);
+ return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
+}
+
+void
+set_Return_res(ir_node *node, int pos, ir_node *res){
+ assert(node->op == op_Return);
+ set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
+}
+
+tarval *(get_Const_tarval)(const ir_node *node) {
+ return _get_Const_tarval(node);
+}
+
+void
+set_Const_tarval(ir_node *node, tarval *con) {
+ assert(node->op == op_Const);
+ node->attr.con.tv = con;
+}
+
+cnst_classify_t (classify_Const)(ir_node *node) {
+ return _classify_Const(node);
+}
+
+
+/* The source language type. Must be an atomic type. Mode of type must
+ be mode of node. For tarvals from entities type must be pointer to
+ entity type. */
+ir_type *
+get_Const_type(ir_node *node) {
+ assert(node->op == op_Const);
+ return node->attr.con.tp;
+}
+
+void
+set_Const_type(ir_node *node, ir_type *tp) {
+ assert(node->op == op_Const);
+ if (tp != firm_unknown_type) {
+ assert(is_atomic_type(tp));
+ assert(get_type_mode(tp) == get_irn_mode(node));
+ }
+ node->attr.con.tp = tp;
+}
+
+
+symconst_kind
+get_SymConst_kind(const ir_node *node) {
+ assert(node->op == op_SymConst);
+ return node->attr.symc.num;
+}
+
+void
+set_SymConst_kind(ir_node *node, symconst_kind num) {
+ assert(node->op == op_SymConst);
+ node->attr.symc.num = num;
+}
+
+ir_type *
+get_SymConst_type(ir_node *node) {
+ assert((node->op == op_SymConst) &&
+ (SYMCONST_HAS_TYPE(get_SymConst_kind(node))));
+ return node->attr.symc.sym.type_p = skip_tid(node->attr.symc.sym.type_p);
+}
+
+void
+set_SymConst_type(ir_node *node, ir_type *tp) {
+ assert((node->op == op_SymConst) &&
+ (SYMCONST_HAS_TYPE(get_SymConst_kind(node))));
+ node->attr.symc.sym.type_p = tp;
+}
+
+ident *
+get_SymConst_name(const ir_node *node) {
+ assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
+ return node->attr.symc.sym.ident_p;
+}
+
+void
+set_SymConst_name(ir_node *node, ident *name) {
+ assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
+ node->attr.symc.sym.ident_p = name;
+}
+
+
+/* Only to access SymConst of kind symconst_addr_ent. Else assertion: */
+ir_entity *get_SymConst_entity(const ir_node *node) {
+ assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
+ return node->attr.symc.sym.entity_p;
+}
+
+void set_SymConst_entity(ir_node *node, ir_entity *ent) {
+ assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
+ node->attr.symc.sym.entity_p = ent;
+}
+
+ir_enum_const *get_SymConst_enum(const ir_node *node) {
+ assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
+ return node->attr.symc.sym.enum_p;
+}
+
+void set_SymConst_enum(ir_node *node, ir_enum_const *ec) {
+ assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
+ node->attr.symc.sym.enum_p = ec;
+}
+
+union symconst_symbol
+get_SymConst_symbol(const ir_node *node) {
+ assert(node->op == op_SymConst);
+ return node->attr.symc.sym;
+}
+
+void
+set_SymConst_symbol(ir_node *node, union symconst_symbol sym) {
+ assert(node->op == op_SymConst);
+ node->attr.symc.sym = sym;
+}
+
+ir_type *
+get_SymConst_value_type(ir_node *node) {
+ assert(node->op == op_SymConst);
+ if (node->attr.symc.tp) node->attr.symc.tp = skip_tid(node->attr.symc.tp);
+ return node->attr.symc.tp;
+}
+
+void
+set_SymConst_value_type(ir_node *node, ir_type *tp) {
+ assert(node->op == op_SymConst);
+ node->attr.symc.tp = tp;
+}
+
+ir_node *
+get_Sel_mem(ir_node *node) {
+ assert(node->op == op_Sel);
+ return get_irn_n(node, 0);
+}
+
+void
+set_Sel_mem(ir_node *node, ir_node *mem) {
+ assert(node->op == op_Sel);
+ set_irn_n(node, 0, mem);
+}
+
+ir_node *
+get_Sel_ptr(ir_node *node) {
+ assert(node->op == op_Sel);
+ return get_irn_n(node, 1);
+}
+
+void
+set_Sel_ptr(ir_node *node, ir_node *ptr) {
+ assert(node->op == op_Sel);
+ set_irn_n(node, 1, ptr);
+}
+
+int
+get_Sel_n_indexs(ir_node *node) {
+ assert(node->op == op_Sel);
+ return (get_irn_arity(node) - SEL_INDEX_OFFSET);
+}
+
+ir_node **
+get_Sel_index_arr(ir_node *node) {
+ assert((node->op == op_Sel));
+ if (get_Sel_n_indexs(node) > 0)
+ return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
+ else
+ return NULL;
+}
+
+ir_node *
+get_Sel_index(ir_node *node, int pos) {
+ assert(node->op == op_Sel);
+ return get_irn_n(node, pos + SEL_INDEX_OFFSET);
+}
+
+void
+set_Sel_index(ir_node *node, int pos, ir_node *index) {
+ assert(node->op == op_Sel);
+ set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
+}
+
+ir_entity *
+get_Sel_entity(ir_node *node) {
+ assert(node->op == op_Sel);
+ return node->attr.sel.ent;
+}
+
+void
+set_Sel_entity(ir_node *node, ir_entity *ent) {
+ assert(node->op == op_Sel);
+ node->attr.sel.ent = ent;
+}
+
+
+/* For unary and binary arithmetic operations the access to the
+ operands can be factored out. Left is the first, right the
+ second arithmetic value as listed in tech report 0999-33.
+ unops are: Minus, Abs, Not, Conv, Cast
+ binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
+ Shr, Shrs, Rotate, Cmp */
+
+
+ir_node *
+get_Call_mem(ir_node *node) {
+ assert(node->op == op_Call);
+ return get_irn_n(node, 0);
+}
+
+void
+set_Call_mem(ir_node *node, ir_node *mem) {
+ assert(node->op == op_Call);
+ set_irn_n(node, 0, mem);
+}
+
+ir_node *
+get_Call_ptr(ir_node *node) {
+ assert(node->op == op_Call);
+ return get_irn_n(node, 1);
+}
+
+void
+set_Call_ptr(ir_node *node, ir_node *ptr) {
+ assert(node->op == op_Call);
+ set_irn_n(node, 1, ptr);
+}
+
+ir_node **
+get_Call_param_arr(ir_node *node) {
+ assert(node->op == op_Call);
+ return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
+}
+
+int
+get_Call_n_params(ir_node *node) {
+ assert(node->op == op_Call);
+ return (get_irn_arity(node) - CALL_PARAM_OFFSET);
+}
+
+int
+get_Call_arity(ir_node *node) {
+ assert(node->op == op_Call);
+ return get_Call_n_params(node);
+}
+
+/* void
+set_Call_arity(ir_node *node, ir_node *arity) {
+ assert(node->op == op_Call);
+}
+*/
+
+ir_node *
+get_Call_param(ir_node *node, int pos) {
+ assert(node->op == op_Call);
+ return get_irn_n(node, pos + CALL_PARAM_OFFSET);
+}
+
+void
+set_Call_param(ir_node *node, int pos, ir_node *param) {
+ assert(node->op == op_Call);
+ set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
+}
+
+ir_type *
+get_Call_type(ir_node *node) {
+ assert(node->op == op_Call);
+ return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
+}
+
+void
+set_Call_type(ir_node *node, ir_type *tp) {
+ assert(node->op == op_Call);
+ assert((get_unknown_type() == tp) || is_Method_type(tp));
+ node->attr.call.cld_tp = tp;
+}
+
+int Call_has_callees(ir_node *node) {
+ assert(node && node->op == op_Call);
+ return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) &&
+ (node->attr.call.callee_arr != NULL));
+}
+
+int get_Call_n_callees(ir_node * node) {
+ assert(node && node->op == op_Call && node->attr.call.callee_arr);
+ return ARR_LEN(node->attr.call.callee_arr);
+}
+
+ir_entity * get_Call_callee(ir_node * node, int pos) {
+ assert(pos >= 0 && pos < get_Call_n_callees(node));
+ return node->attr.call.callee_arr[pos];
+}
+
+void set_Call_callee_arr(ir_node * node, const int n, ir_entity ** arr) {
+ assert(node->op == op_Call);
+ if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
+ node->attr.call.callee_arr = NEW_ARR_D(ir_entity *, current_ir_graph->obst, n);
+ }
+ memcpy(node->attr.call.callee_arr, arr, n * sizeof(ir_entity *));
+}
+
+void remove_Call_callee_arr(ir_node * node) {
+ assert(node->op == op_Call);
+ node->attr.call.callee_arr = NULL;
+}
+
+ir_node * get_CallBegin_ptr(ir_node *node) {
+ assert(node->op == op_CallBegin);
+ return get_irn_n(node, 0);
+}
+
+void set_CallBegin_ptr(ir_node *node, ir_node *ptr) {
+ assert(node->op == op_CallBegin);
+ set_irn_n(node, 0, ptr);
+}
+
+ir_node * get_CallBegin_call(ir_node *node) {
+ assert(node->op == op_CallBegin);
+ return node->attr.callbegin.call;
+}
+
+void set_CallBegin_call(ir_node *node, ir_node *call) {
+ assert(node->op == op_CallBegin);
+ node->attr.callbegin.call = call;
+}
+
+
+#define BINOP(OP) \
+ir_node * get_##OP##_left(const ir_node *node) { \
+ assert(node->op == op_##OP); \
+ return get_irn_n(node, node->op->op_index); \
+} \
+void set_##OP##_left(ir_node *node, ir_node *left) { \
+ assert(node->op == op_##OP); \
+ set_irn_n(node, node->op->op_index, left); \
+} \
+ir_node *get_##OP##_right(const ir_node *node) { \
+ assert(node->op == op_##OP); \
+ return get_irn_n(node, node->op->op_index + 1); \
+} \
+void set_##OP##_right(ir_node *node, ir_node *right) { \
+ assert(node->op == op_##OP); \
+ set_irn_n(node, node->op->op_index + 1, right); \
+}
+
+#define UNOP(OP) \
+ir_node *get_##OP##_op(const ir_node *node) { \
+ assert(node->op == op_##OP); \
+ return get_irn_n(node, node->op->op_index); \
+} \
+void set_##OP##_op (ir_node *node, ir_node *op) { \
+ assert(node->op == op_##OP); \
+ set_irn_n(node, node->op->op_index, op); \
+}
+
+#define BINOP_MEM(OP) \
+BINOP(OP) \
+ \
+ir_node * \
+get_##OP##_mem(ir_node *node) { \
+ assert(node->op == op_##OP); \
+ return get_irn_n(node, 0); \
+} \
+ \
+void \
+set_##OP##_mem(ir_node *node, ir_node *mem) { \
+ assert(node->op == op_##OP); \
+ set_irn_n(node, 0, mem); \
+}
+
+#define DIVOP(OP) \
+BINOP_MEM(OP) \
+ \
+ir_mode *get_##OP##_resmode(const ir_node *node) { \
+ assert(node->op == op_##OP); \
+ return node->attr.divmod.res_mode; \
+} \
+ \
+void set_##OP##_resmode(ir_node *node, ir_mode *mode) { \
+ assert(node->op == op_##OP); \
+ node->attr.divmod.res_mode = mode; \
+}
+
+
+BINOP(Add)
+BINOP(Sub)
+UNOP(Minus)
+BINOP(Mul)
+DIVOP(Quot)
+DIVOP(DivMod)
+DIVOP(Div)
+DIVOP(Mod)
+UNOP(Abs)
+BINOP(And)
+BINOP(Or)
+BINOP(Eor)
+UNOP(Not)
+BINOP(Shl)
+BINOP(Shr)
+BINOP(Shrs)
+BINOP(Rot)
+BINOP(Cmp)
+UNOP(Conv)
+UNOP(Cast)
+
+int get_Conv_strict(ir_node *node) {
+ assert(node->op == op_Conv);
+ return node->attr.conv.strict;
+}
+
+void set_Conv_strict(ir_node *node, int strict_flag) {
+ assert(node->op == op_Conv);
+ node->attr.conv.strict = (char)strict_flag;
+}
+
+ir_type *
+get_Cast_type(ir_node *node) {
+ assert(node->op == op_Cast);
+ return node->attr.cast.totype;
+}
+
+void
+set_Cast_type(ir_node *node, ir_type *to_tp) {
+ assert(node->op == op_Cast);
+ node->attr.cast.totype = to_tp;
+}
+
+
+/* Checks for upcast.
+ *
+ * Returns true if the Cast node casts a class type to a super type.
+ */
+int is_Cast_upcast(ir_node *node) {
+ ir_type *totype = get_Cast_type(node);
+ ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
+ ir_graph *myirg = get_irn_irg(node);
+
+ assert(get_irg_typeinfo_state(myirg) == ir_typeinfo_consistent);
+ assert(fromtype);
+
+ while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
+ totype = get_pointer_points_to_type(totype);
+ fromtype = get_pointer_points_to_type(fromtype);
+ }
+
+ assert(fromtype);
+
+ if (!is_Class_type(totype)) return 0;
+ return is_SubClass_of(fromtype, totype);
+}
+
+/* Checks for downcast.
+ *
+ * Returns true if the Cast node casts a class type to a sub type.
+ */
+int is_Cast_downcast(ir_node *node) {
+ ir_type *totype = get_Cast_type(node);
+ ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
+
+ assert(get_irg_typeinfo_state(get_irn_irg(node)) == ir_typeinfo_consistent);
+ assert(fromtype);
+
+ while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
+ totype = get_pointer_points_to_type(totype);
+ fromtype = get_pointer_points_to_type(fromtype);
+ }
+
+ assert(fromtype);
+
+ if (!is_Class_type(totype)) return 0;
+ return is_SubClass_of(totype, fromtype);
+}
+
+int
+(is_unop)(const ir_node *node) {
+ return _is_unop(node);
+}
+
+ir_node *
+get_unop_op(const ir_node *node) {
+ if (node->op->opar == oparity_unary)
+ return get_irn_n(node, node->op->op_index);
+
+ assert(node->op->opar == oparity_unary);
+ return NULL;
}
-INLINE void
-set_Return_res (ir_node *node, int pos, ir_node *res){
- assert (node->op == op_Return);
- set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
-}
+void
+set_unop_op(ir_node *node, ir_node *op) {
+ if (node->op->opar == oparity_unary)
+ set_irn_n(node, node->op->op_index, op);
-INLINE ir_node *
-get_Raise_mem (ir_node *node) {
- assert (node->op == op_Raise);
- return get_irn_n(node, 0);
+ assert(node->op->opar == oparity_unary);
}
-INLINE void
-set_Raise_mem (ir_node *node, ir_node *mem) {
- assert (node->op == op_Raise);
- set_irn_n(node, 0, mem);
+int
+(is_binop)(const ir_node *node) {
+ return _is_binop(node);
}
-INLINE ir_node *
-get_Raise_exo_ptr (ir_node *node) {
- assert (node->op == op_Raise);
- return get_irn_n(node, 1);
+ir_node *
+get_binop_left(const ir_node *node) {
+ assert(node->op->opar == oparity_binary);
+ return get_irn_n(node, node->op->op_index);
}
-INLINE void
-set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
- assert (node->op == op_Raise);
- set_irn_n(node, 1, exo_ptr);
+void
+set_binop_left(ir_node *node, ir_node *left) {
+ assert(node->op->opar == oparity_binary);
+ set_irn_n(node, node->op->op_index, left);
}
-INLINE tarval *get_Const_tarval (ir_node *node) {
- assert (node->op == op_Const);
- return node->attr.con.tv;
+ir_node *
+get_binop_right(const ir_node *node) {
+ assert(node->op->opar == oparity_binary);
+ return get_irn_n(node, node->op->op_index + 1);
}
-INLINE void
-set_Const_tarval (ir_node *node, tarval *con) {
- assert (node->op == op_Const);
- node->attr.con.tv = con;
+void
+set_binop_right(ir_node *node, ir_node *right) {
+ assert(node->op->opar == oparity_binary);
+ set_irn_n(node, node->op->op_index + 1, right);
}
+int is_Phi(const ir_node *n) {
+ ir_op *op;
-/* The source language type. Must be an atomic type. Mode of type must
- be mode of node. For tarvals from entities type must be pointer to
- entity type. */
-INLINE type *
-get_Const_type (ir_node *node) {
- assert (node->op == op_Const);
- return node->attr.con.tp;
-}
+ assert(n);
+ op = get_irn_op(n);
+
+ if (op == op_Filter) return get_interprocedural_view();
-INLINE void
-set_Const_type (ir_node *node, type *tp) {
- assert (node->op == op_Const);
- if (tp != unknown_type) {
- assert (is_atomic_type(tp));
- assert (get_type_mode(tp) == get_irn_mode(node));
- assert (!tarval_is_entity(get_Const_tarval(node)) ||
- (is_pointer_type(tp) &&
- (get_pointer_points_to_type(tp) ==
- get_entity_type(get_tarval_entity(get_Const_tarval(node))))));
- }
+ if (op == op_Phi)
+ return ((get_irg_phase_state(get_irn_irg(n)) != phase_building) ||
+ (get_irn_arity(n) > 0));
- node->attr.con.tp = tp;
+ return 0;
}
+int is_Phi0(const ir_node *n) {
+ assert(n);
-INLINE symconst_kind
-get_SymConst_kind (const ir_node *node) {
- assert (node->op == op_SymConst);
- return node->attr.i.num;
+ return ((get_irn_op(n) == op_Phi) &&
+ (get_irn_arity(n) == 0) &&
+ (get_irg_phase_state(get_irn_irg(n)) == phase_building));
}
-INLINE void
-set_SymConst_kind (ir_node *node, symconst_kind num) {
- assert (node->op == op_SymConst);
- node->attr.i.num = num;
+ir_node **
+get_Phi_preds_arr(ir_node *node) {
+ assert(node->op == op_Phi);
+ return (ir_node **)&(get_irn_in(node)[1]);
}
-INLINE type *
-get_SymConst_type (ir_node *node) {
- assert ( (node->op == op_SymConst)
- && ( get_SymConst_kind(node) == type_tag
- || get_SymConst_kind(node) == size));
- return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
+int
+get_Phi_n_preds(const ir_node *node) {
+ assert(is_Phi(node) || is_Phi0(node));
+ return (get_irn_arity(node));
}
-INLINE void
-set_SymConst_type (ir_node *node, type *tp) {
- assert ( (node->op == op_SymConst)
- && ( get_SymConst_kind(node) == type_tag
- || get_SymConst_kind(node) == size));
- node->attr.i.tori.typ = tp;
+/*
+void set_Phi_n_preds(ir_node *node, int n_preds) {
+ assert(node->op == op_Phi);
}
+*/
-INLINE ident *
-get_SymConst_ptrinfo (ir_node *node) {
- assert ( (node->op == op_SymConst)
- && (get_SymConst_kind(node) == linkage_ptr_info));
- return node->attr.i.tori.ptrinfo;
+ir_node *
+get_Phi_pred(const ir_node *node, int pos) {
+ assert(is_Phi(node) || is_Phi0(node));
+ return get_irn_n(node, pos);
}
-INLINE void
-set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
- assert ( (node->op == op_SymConst)
- && (get_SymConst_kind(node) == linkage_ptr_info));
- node->attr.i.tori.ptrinfo = ptrinfo;
+void
+set_Phi_pred(ir_node *node, int pos, ir_node *pred) {
+ assert(is_Phi(node) || is_Phi0(node));
+ set_irn_n(node, pos, pred);
}
-INLINE type_or_id_p
-get_SymConst_type_or_id (ir_node *node) {
- assert (node->op == op_SymConst);
- return &(node->attr.i.tori);
-}
-INLINE void
-set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
- assert (node->op == op_SymConst);
- memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
+int is_memop(ir_node *node) {
+ return ((get_irn_op(node) == op_Load) || (get_irn_op(node) == op_Store));
}
-INLINE ir_node *
-get_Sel_mem (ir_node *node) {
- assert (node->op == op_Sel);
- return get_irn_n(node, 0);
+ir_node *get_memop_mem(ir_node *node) {
+ assert(is_memop(node));
+ return get_irn_n(node, 0);
}
-INLINE void
-set_Sel_mem (ir_node *node, ir_node *mem) {
- assert (node->op == op_Sel);
- set_irn_n(node, 0, mem);
+void set_memop_mem(ir_node *node, ir_node *mem) {
+ assert(is_memop(node));
+ set_irn_n(node, 0, mem);
}
-INLINE ir_node *
-get_Sel_ptr (ir_node *node) {
- assert (node->op == op_Sel);
- return get_irn_n(node, 1);
+ir_node *get_memop_ptr(ir_node *node) {
+ assert(is_memop(node));
+ return get_irn_n(node, 1);
}
-INLINE void
-set_Sel_ptr (ir_node *node, ir_node *ptr) {
- assert (node->op == op_Sel);
- set_irn_n(node, 1, ptr);
+void set_memop_ptr(ir_node *node, ir_node *ptr) {
+ assert(is_memop(node));
+ set_irn_n(node, 1, ptr);
}
-INLINE int
-get_Sel_n_indexs (ir_node *node) {
- assert (node->op == op_Sel);
- return (get_irn_arity(node) - SEL_INDEX_OFFSET);
+ir_node *
+get_Load_mem(ir_node *node) {
+ assert(node->op == op_Load);
+ return get_irn_n(node, 0);
}
-INLINE ir_node **
-get_Sel_index_arr (ir_node *node)
-{
- assert ((node->op == op_Sel));
- if (get_Sel_n_indexs(node) > 0)
- return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
- else
- return NULL;
+void
+set_Load_mem(ir_node *node, ir_node *mem) {
+ assert(node->op == op_Load);
+ set_irn_n(node, 0, mem);
}
-INLINE ir_node *
-get_Sel_index (ir_node *node, int pos) {
- assert (node->op == op_Sel);
- return get_irn_n(node, pos + SEL_INDEX_OFFSET);
+ir_node *
+get_Load_ptr(ir_node *node) {
+ assert(node->op == op_Load);
+ return get_irn_n(node, 1);
}
-INLINE void
-set_Sel_index (ir_node *node, int pos, ir_node *index) {
- assert (node->op == op_Sel);
- set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
+void
+set_Load_ptr(ir_node *node, ir_node *ptr) {
+ assert(node->op == op_Load);
+ set_irn_n(node, 1, ptr);
}
-INLINE entity *
-get_Sel_entity (ir_node *node) {
- assert (node->op == op_Sel);
- return node->attr.s.ent;
+ir_mode *
+get_Load_mode(ir_node *node) {
+ assert(node->op == op_Load);
+ return node->attr.load.load_mode;
}
-INLINE void
-set_Sel_entity (ir_node *node, entity *ent) {
- assert (node->op == op_Sel);
- node->attr.s.ent = ent;
+void
+set_Load_mode(ir_node *node, ir_mode *mode) {
+ assert(node->op == op_Load);
+ node->attr.load.load_mode = mode;
}
-type *
-get_InstOf_ent (ir_node *node) {
- assert (node->op = op_InstOf);
- return (node->attr.io.ent);
+ir_volatility
+get_Load_volatility(ir_node *node) {
+ assert(node->op == op_Load);
+ return node->attr.load.volatility;
}
void
-set_InstOf_ent (ir_node *node, type *ent) {
- assert (node->op = op_InstOf);
- node->attr.io.ent = ent;
+set_Load_volatility(ir_node *node, ir_volatility volatility) {
+ assert(node->op == op_Load);
+ node->attr.load.volatility = volatility;
}
+
ir_node *
-get_InstOf_store (ir_node *node) {
- assert (node->op = op_InstOf);
- return (get_irn_n (node, 0));
+get_Store_mem(ir_node *node) {
+ assert(node->op == op_Store);
+ return get_irn_n(node, 0);
}
void
-set_InstOf_store (ir_node *node, ir_node *obj) {
- assert (node->op = op_InstOf);
- set_irn_n (node, 0, obj);
+set_Store_mem(ir_node *node, ir_node *mem) {
+ assert(node->op == op_Store);
+ set_irn_n(node, 0, mem);
}
ir_node *
-get_InstOf_obj (ir_node *node) {
- assert (node->op = op_InstOf);
- return (get_irn_n (node, 1));
+get_Store_ptr(ir_node *node) {
+ assert(node->op == op_Store);
+ return get_irn_n(node, 1);
}
void
-set_InstOf_obj (ir_node *node, ir_node *obj) {
- assert (node->op = op_InstOf);
- set_irn_n (node, 1, obj);
+set_Store_ptr(ir_node *node, ir_node *ptr) {
+ assert(node->op == op_Store);
+ set_irn_n(node, 1, ptr);
}
-
-/* For unary and binary arithmetic operations the access to the
- operands can be factored out. Left is the first, right the
- second arithmetic value as listed in tech report 0999-33.
- unops are: Minus, Abs, Not, Conv, Cast
- binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
- Shr, Shrs, Rotate, Cmp */
-
-
-INLINE ir_node *
-get_Call_mem (ir_node *node) {
- assert (node->op == op_Call);
- return get_irn_n(node, 0);
+ir_node *
+get_Store_value(ir_node *node) {
+ assert(node->op == op_Store);
+ return get_irn_n(node, 2);
}
-INLINE void
-set_Call_mem (ir_node *node, ir_node *mem) {
- assert (node->op == op_Call);
- set_irn_n(node, 0, mem);
+void
+set_Store_value(ir_node *node, ir_node *value) {
+ assert(node->op == op_Store);
+ set_irn_n(node, 2, value);
}
-INLINE ir_node *
-get_Call_ptr (ir_node *node) {
- assert (node->op == op_Call);
- return get_irn_n(node, 1);
+ir_volatility
+get_Store_volatility(ir_node *node) {
+ assert(node->op == op_Store);
+ return node->attr.store.volatility;
}
-INLINE void
-set_Call_ptr (ir_node *node, ir_node *ptr) {
- assert (node->op == op_Call);
- set_irn_n(node, 1, ptr);
+void
+set_Store_volatility(ir_node *node, ir_volatility volatility) {
+ assert(node->op == op_Store);
+ node->attr.store.volatility = volatility;
}
-INLINE ir_node **
-get_Call_param_arr (ir_node *node) {
- assert (node->op == op_Call);
- return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
-}
-INLINE int
-get_Call_n_params (ir_node *node) {
- assert (node->op == op_Call);
- return (get_irn_arity(node) - CALL_PARAM_OFFSET);
+ir_node *
+get_Alloc_mem(ir_node *node) {
+ assert(node->op == op_Alloc);
+ return get_irn_n(node, 0);
}
-INLINE int
-get_Call_arity (ir_node *node) {
- assert (node->op == op_Call);
- return get_Call_n_params(node);
+void
+set_Alloc_mem(ir_node *node, ir_node *mem) {
+ assert(node->op == op_Alloc);
+ set_irn_n(node, 0, mem);
}
-/* INLINE void
-set_Call_arity (ir_node *node, ir_node *arity) {
- assert (node->op == op_Call);
+ir_node *
+get_Alloc_size(ir_node *node) {
+ assert(node->op == op_Alloc);
+ return get_irn_n(node, 1);
}
-*/
-INLINE ir_node *
-get_Call_param (ir_node *node, int pos) {
- assert (node->op == op_Call);
- return get_irn_n(node, pos + CALL_PARAM_OFFSET);
+void
+set_Alloc_size(ir_node *node, ir_node *size) {
+ assert(node->op == op_Alloc);
+ set_irn_n(node, 1, size);
}
-INLINE void
-set_Call_param (ir_node *node, int pos, ir_node *param) {
- assert (node->op == op_Call);
- set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
+ir_type *
+get_Alloc_type(ir_node *node) {
+ assert(node->op == op_Alloc);
+ return node->attr.alloc.type = skip_tid(node->attr.alloc.type);
}
-INLINE type *
-get_Call_type (ir_node *node) {
- assert (node->op == op_Call);
- return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
+void
+set_Alloc_type(ir_node *node, ir_type *tp) {
+ assert(node->op == op_Alloc);
+ node->attr.alloc.type = tp;
}
-INLINE void
-set_Call_type (ir_node *node, type *tp) {
- assert (node->op == op_Call);
- assert (is_method_type(tp));
- node->attr.call.cld_tp = tp;
+where_alloc
+get_Alloc_where(ir_node *node) {
+ assert(node->op == op_Alloc);
+ return node->attr.alloc.where;
}
-int Call_has_callees(ir_node *node) {
- return (node->attr.call.callee_arr != NULL);
+void
+set_Alloc_where(ir_node *node, where_alloc where) {
+ assert(node->op == op_Alloc);
+ node->attr.alloc.where = where;
}
-int get_Call_n_callees(ir_node * node) {
- assert(node->op == op_Call && node->attr.call.callee_arr);
- return ARR_LEN(node->attr.call.callee_arr);
-}
-entity * get_Call_callee(ir_node * node, int pos) {
- assert(node->op == op_Call && node->attr.call.callee_arr);
- return node->attr.call.callee_arr[pos];
+ir_node *
+get_Free_mem(ir_node *node) {
+ assert(node->op == op_Free);
+ return get_irn_n(node, 0);
}
-void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
- assert(node->op == op_Call);
- if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
- node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
- }
- memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
+void
+set_Free_mem(ir_node *node, ir_node *mem) {
+ assert(node->op == op_Free);
+ set_irn_n(node, 0, mem);
}
-void remove_Call_callee_arr(ir_node * node) {
- assert(node->op == op_Call);
- node->attr.call.callee_arr = NULL;
+ir_node *
+get_Free_ptr(ir_node *node) {
+ assert(node->op == op_Free);
+ return get_irn_n(node, 1);
}
-ir_node * get_CallBegin_ptr (ir_node *node) {
- assert(node->op == op_CallBegin);
- return get_irn_n(node, 0);
-}
-void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
- assert(node->op == op_CallBegin);
- set_irn_n(node, 0, ptr);
-}
-ir_graph * get_CallBegin_irg (ir_node *node) {
- return get_irn_irg(node);
-}
-ir_node * get_CallBegin_call (ir_node *node) {
- assert(node->op == op_CallBegin);
- return node->attr.callbegin.call;
-}
-void set_CallBegin_call (ir_node *node, ir_node *call) {
- assert(node->op == op_CallBegin);
- node->attr.callbegin.call = call;
+void
+set_Free_ptr(ir_node *node, ir_node *ptr) {
+ assert(node->op == op_Free);
+ set_irn_n(node, 1, ptr);
}
-INLINE ir_node *
-get_Add_left (ir_node *node) {
- assert (node->op == op_Add);
- return get_irn_n(node, 0);
+ir_node *
+get_Free_size(ir_node *node) {
+ assert(node->op == op_Free);
+ return get_irn_n(node, 2);
}
-INLINE void
-set_Add_left (ir_node *node, ir_node *left) {
- assert (node->op == op_Add);
- set_irn_n(node, 0, left);
+void
+set_Free_size(ir_node *node, ir_node *size) {
+ assert(node->op == op_Free);
+ set_irn_n(node, 2, size);
}
-INLINE ir_node *
-get_Add_right (ir_node *node) {
- assert (node->op == op_Add);
- return get_irn_n(node, 1);
+ir_type *
+get_Free_type(ir_node *node) {
+ assert(node->op == op_Free);
+ return node->attr.free.type = skip_tid(node->attr.free.type);
}
-INLINE void
-set_Add_right (ir_node *node, ir_node *right) {
- assert (node->op == op_Add);
- set_irn_n(node, 1, right);
+void
+set_Free_type(ir_node *node, ir_type *tp) {
+ assert(node->op == op_Free);
+ node->attr.free.type = tp;
}
-INLINE ir_node *
-get_Sub_left (ir_node *node) {
- assert (node->op == op_Sub);
- return get_irn_n(node, 0);
+where_alloc
+get_Free_where(ir_node *node) {
+ assert(node->op == op_Free);
+ return node->attr.free.where;
}
-INLINE void
-set_Sub_left (ir_node *node, ir_node *left) {
- assert (node->op == op_Sub);
- set_irn_n(node, 0, left);
+void
+set_Free_where(ir_node *node, where_alloc where) {
+ assert(node->op == op_Free);
+ node->attr.free.where = where;
}
-INLINE ir_node *
-get_Sub_right (ir_node *node) {
- assert (node->op == op_Sub);
- return get_irn_n(node, 1);
+ir_node **get_Sync_preds_arr(ir_node *node) {
+ assert(node->op == op_Sync);
+ return (ir_node **)&(get_irn_in(node)[1]);
}
-INLINE void
-set_Sub_right (ir_node *node, ir_node *right) {
- assert (node->op == op_Sub);
- set_irn_n(node, 1, right);
+int get_Sync_n_preds(ir_node *node) {
+ assert(node->op == op_Sync);
+ return (get_irn_arity(node));
}
-
-INLINE ir_node *
-get_Minus_op (ir_node *node) {
- assert (node->op == op_Minus);
- return get_irn_n(node, 0);
+/*
+void set_Sync_n_preds(ir_node *node, int n_preds) {
+ assert(node->op == op_Sync);
}
+*/
-INLINE void
-set_Minus_op (ir_node *node, ir_node *op) {
- assert (node->op == op_Minus);
- set_irn_n(node, 0, op);
+ir_node *get_Sync_pred(ir_node *node, int pos) {
+ assert(node->op == op_Sync);
+ return get_irn_n(node, pos);
+}
+
+void set_Sync_pred(ir_node *node, int pos, ir_node *pred) {
+ assert(node->op == op_Sync);
+ set_irn_n(node, pos, pred);
+}
+
+/* Add a new Sync predecessor */
+void add_Sync_pred(ir_node *node, ir_node *pred) {
+ assert(node->op == op_Sync);
+ add_irn_n(node, pred);
+}
+
+/* Returns the source language type of a Proj node. */
+ir_type *get_Proj_type(ir_node *n) {
+ ir_type *tp = firm_unknown_type;
+ ir_node *pred = get_Proj_pred(n);
+
+ switch (get_irn_opcode(pred)) {
+ case iro_Proj: {
+ ir_node *pred_pred;
+ /* Deal with Start / Call here: we need to know the Proj Nr. */
+ assert(get_irn_mode(pred) == mode_T);
+ pred_pred = get_Proj_pred(pred);
+ if (get_irn_op(pred_pred) == op_Start) {
+ ir_type *mtp = get_entity_type(get_irg_entity(get_irn_irg(pred_pred)));
+ tp = get_method_param_type(mtp, get_Proj_proj(n));
+ } else if (get_irn_op(pred_pred) == op_Call) {
+ ir_type *mtp = get_Call_type(pred_pred);
+ tp = get_method_res_type(mtp, get_Proj_proj(n));
+ }
+ } break;
+ case iro_Start: break;
+ case iro_Call: break;
+ case iro_Load: {
+ ir_node *a = get_Load_ptr(pred);
+ if (is_Sel(a))
+ tp = get_entity_type(get_Sel_entity(a));
+ } break;
+ default:
+ break;
+ }
+ return tp;
}
-
-INLINE ir_node *
-get_Mul_left (ir_node *node) {
- assert (node->op == op_Mul);
- return get_irn_n(node, 0);
+ir_node *
+get_Proj_pred(const ir_node *node) {
+ assert(is_Proj(node));
+ return get_irn_n(node, 0);
}
-INLINE void
-set_Mul_left (ir_node *node, ir_node *left) {
- assert (node->op == op_Mul);
- set_irn_n(node, 0, left);
+void
+set_Proj_pred(ir_node *node, ir_node *pred) {
+ assert(is_Proj(node));
+ set_irn_n(node, 0, pred);
}
-INLINE ir_node *
-get_Mul_right (ir_node *node) {
- assert (node->op == op_Mul);
- return get_irn_n(node, 1);
+long
+get_Proj_proj(const ir_node *node) {
+ assert(is_Proj(node));
+ if (get_irn_opcode(node) == iro_Proj) {
+ return node->attr.proj;
+ } else {
+ assert(get_irn_opcode(node) == iro_Filter);
+ return node->attr.filter.proj;
+ }
}
-INLINE void
-set_Mul_right (ir_node *node, ir_node *right) {
- assert (node->op == op_Mul);
- set_irn_n(node, 1, right);
+void
+set_Proj_proj(ir_node *node, long proj) {
+ assert(node->op == op_Proj);
+ node->attr.proj = proj;
}
-INLINE ir_node *
-get_Quot_left (ir_node *node) {
- assert (node->op == op_Quot);
- return get_irn_n(node, 1);
+ir_node **
+get_Tuple_preds_arr(ir_node *node) {
+ assert(node->op == op_Tuple);
+ return (ir_node **)&(get_irn_in(node)[1]);
}
-INLINE void
-set_Quot_left (ir_node *node, ir_node *left) {
- assert (node->op == op_Quot);
- set_irn_n(node, 1, left);
+int
+get_Tuple_n_preds(ir_node *node) {
+ assert(node->op == op_Tuple);
+ return (get_irn_arity(node));
}
-INLINE ir_node *
-get_Quot_right (ir_node *node) {
- assert (node->op == op_Quot);
- return get_irn_n(node, 2);
+/*
+void
+set_Tuple_n_preds(ir_node *node, int n_preds) {
+ assert(node->op == op_Tuple);
}
+*/
-INLINE void
-set_Quot_right (ir_node *node, ir_node *right) {
- assert (node->op == op_Quot);
- set_irn_n(node, 2, right);
+ir_node *
+get_Tuple_pred (ir_node *node, int pos) {
+ assert(node->op == op_Tuple);
+ return get_irn_n(node, pos);
}
-INLINE ir_node *
-get_Quot_mem (ir_node *node) {
- assert (node->op == op_Quot);
- return get_irn_n(node, 0);
+void
+set_Tuple_pred(ir_node *node, int pos, ir_node *pred) {
+ assert(node->op == op_Tuple);
+ set_irn_n(node, pos, pred);
}
-INLINE void
-set_Quot_mem (ir_node *node, ir_node *mem) {
- assert (node->op == op_Quot);
- set_irn_n(node, 0, mem);
+ir_node *
+get_Id_pred(ir_node *node) {
+ assert(node->op == op_Id);
+ return get_irn_n(node, 0);
}
-INLINE ir_node *
-get_DivMod_left (ir_node *node) {
- assert (node->op == op_DivMod);
- return get_irn_n(node, 1);
+void
+set_Id_pred(ir_node *node, ir_node *pred) {
+ assert(node->op == op_Id);
+ set_irn_n(node, 0, pred);
}
-INLINE void
-set_DivMod_left (ir_node *node, ir_node *left) {
- assert (node->op == op_DivMod);
- set_irn_n(node, 1, left);
+ir_node *get_Confirm_value(ir_node *node) {
+ assert(node->op == op_Confirm);
+ return get_irn_n(node, 0);
}
-INLINE ir_node *
-get_DivMod_right (ir_node *node) {
- assert (node->op == op_DivMod);
- return get_irn_n(node, 2);
+void set_Confirm_value(ir_node *node, ir_node *value) {
+ assert(node->op == op_Confirm);
+ set_irn_n(node, 0, value);
}
-INLINE void
-set_DivMod_right (ir_node *node, ir_node *right) {
- assert (node->op == op_DivMod);
- set_irn_n(node, 2, right);
+ir_node *get_Confirm_bound(ir_node *node) {
+ assert(node->op == op_Confirm);
+ return get_irn_n(node, 1);
}
-INLINE ir_node *
-get_DivMod_mem (ir_node *node) {
- assert (node->op == op_DivMod);
- return get_irn_n(node, 0);
+void set_Confirm_bound(ir_node *node, ir_node *bound) {
+ assert(node->op == op_Confirm);
+ set_irn_n(node, 0, bound);
}
-INLINE void
-set_DivMod_mem (ir_node *node, ir_node *mem) {
- assert (node->op == op_DivMod);
- set_irn_n(node, 0, mem);
+pn_Cmp get_Confirm_cmp(const ir_node *node) {
+ assert(node->op == op_Confirm);
+ return node->attr.confirm.cmp;
}
-INLINE ir_node *
-get_Div_left (ir_node *node) {
- assert (node->op == op_Div);
- return get_irn_n(node, 1);
+void set_Confirm_cmp(ir_node *node, pn_Cmp cmp) {
+ assert(node->op == op_Confirm);
+ node->attr.confirm.cmp = cmp;
}
-INLINE void
-set_Div_left (ir_node *node, ir_node *left) {
- assert (node->op == op_Div);
- set_irn_n(node, 1, left);
+ir_node *
+get_Filter_pred(ir_node *node) {
+ assert(node->op == op_Filter);
+ return node->in[1];
}
-INLINE ir_node *
-get_Div_right (ir_node *node) {
- assert (node->op == op_Div);
- return get_irn_n(node, 2);
+void
+set_Filter_pred(ir_node *node, ir_node *pred) {
+ assert(node->op == op_Filter);
+ node->in[1] = pred;
}
-INLINE void
-set_Div_right (ir_node *node, ir_node *right) {
- assert (node->op == op_Div);
- set_irn_n(node, 2, right);
+long
+get_Filter_proj(ir_node *node) {
+ assert(node->op == op_Filter);
+ return node->attr.filter.proj;
}
-INLINE ir_node *
-get_Div_mem (ir_node *node) {
- assert (node->op == op_Div);
- return get_irn_n(node, 0);
+void
+set_Filter_proj(ir_node *node, long proj) {
+ assert(node->op == op_Filter);
+ node->attr.filter.proj = proj;
}
-INLINE void
-set_Div_mem (ir_node *node, ir_node *mem) {
- assert (node->op == op_Div);
- set_irn_n(node, 0, mem);
+/* Don't use get_irn_arity, get_irn_n in implementation as access
+ shall work independent of view!!! */
+void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
+ assert(node->op == op_Filter);
+ if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
+ node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
+ node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
+ memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
+ node->attr.filter.in_cg[0] = node->in[0];
+ }
+ memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
}
-INLINE ir_node *
-get_Mod_left (ir_node *node) {
- assert (node->op == op_Mod);
- return get_irn_n(node, 1);
+void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
+ assert(node->op == op_Filter && node->attr.filter.in_cg &&
+ 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
+ node->attr.filter.in_cg[pos + 1] = pred;
}
-INLINE void
-set_Mod_left (ir_node *node, ir_node *left) {
- assert (node->op == op_Mod);
- set_irn_n(node, 1, left);
+int get_Filter_n_cg_preds(ir_node *node) {
+ assert(node->op == op_Filter && node->attr.filter.in_cg);
+ return (ARR_LEN(node->attr.filter.in_cg) - 1);
}
-INLINE ir_node *
-get_Mod_right (ir_node *node) {
- assert (node->op == op_Mod);
- return get_irn_n(node, 2);
+ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
+ int arity;
+ assert(node->op == op_Filter && node->attr.filter.in_cg &&
+ 0 <= pos);
+ arity = ARR_LEN(node->attr.filter.in_cg);
+ assert(pos < arity - 1);
+ return node->attr.filter.in_cg[pos + 1];
+}
+
+/* Mux support */
+ir_node *get_Mux_sel(ir_node *node) {
+ if (node->op == op_Psi) {
+ assert(get_irn_arity(node) == 3);
+ return get_Psi_cond(node, 0);
+ }
+ assert(node->op == op_Mux);
+ return node->in[1];
}
-INLINE void
-set_Mod_right (ir_node *node, ir_node *right) {
- assert (node->op == op_Mod);
- set_irn_n(node, 2, right);
+void set_Mux_sel(ir_node *node, ir_node *sel) {
+ if (node->op == op_Psi) {
+ assert(get_irn_arity(node) == 3);
+ set_Psi_cond(node, 0, sel);
+ } else {
+ assert(node->op == op_Mux);
+ node->in[1] = sel;
+ }
}
-INLINE ir_node *
-get_Mod_mem (ir_node *node) {
- assert (node->op == op_Mod);
- return get_irn_n(node, 0);
+ir_node *get_Mux_false(ir_node *node) {
+ if (node->op == op_Psi) {
+ assert(get_irn_arity(node) == 3);
+ return get_Psi_default(node);
+ }
+ assert(node->op == op_Mux);
+ return node->in[2];
}
-INLINE void
-set_Mod_mem (ir_node *node, ir_node *mem) {
- assert (node->op == op_Mod);
- set_irn_n(node, 0, mem);
+void set_Mux_false(ir_node *node, ir_node *ir_false) {
+ if (node->op == op_Psi) {
+ assert(get_irn_arity(node) == 3);
+ set_Psi_default(node, ir_false);
+ } else {
+ assert(node->op == op_Mux);
+ node->in[2] = ir_false;
+ }
}
-INLINE ir_node *
-get_Abs_op (ir_node *node) {
- assert (node->op == op_Abs);
- return get_irn_n(node, 0);
+ir_node *get_Mux_true(ir_node *node) {
+ if (node->op == op_Psi) {
+ assert(get_irn_arity(node) == 3);
+ return get_Psi_val(node, 0);
+ }
+ assert(node->op == op_Mux);
+ return node->in[3];
}
-INLINE void
-set_Abs_op (ir_node *node, ir_node *op) {
- assert (node->op == op_Abs);
- set_irn_n(node, 0, op);
+void set_Mux_true(ir_node *node, ir_node *ir_true) {
+ if (node->op == op_Psi) {
+ assert(get_irn_arity(node) == 3);
+ set_Psi_val(node, 0, ir_true);
+ } else {
+ assert(node->op == op_Mux);
+ node->in[3] = ir_true;
+ }
}
-INLINE ir_node *
-get_And_left (ir_node *node) {
- assert (node->op == op_And);
- return get_irn_n(node, 0);
+/* Psi support */
+ir_node *get_Psi_cond(ir_node *node, int pos) {
+ int num_conds = get_Psi_n_conds(node);
+ assert(node->op == op_Psi);
+ assert(pos < num_conds);
+ return get_irn_n(node, 2 * pos);
}
-INLINE void
-set_And_left (ir_node *node, ir_node *left) {
- assert (node->op == op_And);
- set_irn_n(node, 0, left);
+void set_Psi_cond(ir_node *node, int pos, ir_node *cond) {
+ int num_conds = get_Psi_n_conds(node);
+ assert(node->op == op_Psi);
+ assert(pos < num_conds);
+ set_irn_n(node, 2 * pos, cond);
}
-INLINE ir_node *
-get_And_right (ir_node *node) {
- assert (node->op == op_And);
- return get_irn_n(node, 1);
+ir_node *get_Psi_val(ir_node *node, int pos) {
+ int num_vals = get_Psi_n_conds(node);
+ assert(node->op == op_Psi);
+ assert(pos < num_vals);
+ return get_irn_n(node, 2 * pos + 1);
}
-INLINE void
-set_And_right (ir_node *node, ir_node *right) {
- assert (node->op == op_And);
- set_irn_n(node, 1, right);
+void set_Psi_val(ir_node *node, int pos, ir_node *val) {
+ int num_vals = get_Psi_n_conds(node);
+ assert(node->op == op_Psi);
+ assert(pos < num_vals);
+ set_irn_n(node, 2 * pos + 1, val);
}
-INLINE ir_node *
-get_Or_left (ir_node *node) {
- assert (node->op == op_Or);
- return get_irn_n(node, 0);
+ir_node *get_Psi_default(ir_node *node) {
+ int def_pos = get_irn_arity(node) - 1;
+ assert(node->op == op_Psi);
+ return get_irn_n(node, def_pos);
}
-INLINE void
-set_Or_left (ir_node *node, ir_node *left) {
- assert (node->op == op_Or);
- set_irn_n(node, 0, left);
+void set_Psi_default(ir_node *node, ir_node *val) {
+ int def_pos = get_irn_arity(node);
+ assert(node->op == op_Psi);
+ set_irn_n(node, def_pos, val);
}
-INLINE ir_node *
-get_Or_right (ir_node *node) {
- assert (node->op == op_Or);
- return get_irn_n(node, 1);
+int (get_Psi_n_conds)(ir_node *node) {
+ return _get_Psi_n_conds(node);
}
-INLINE void
-set_Or_right (ir_node *node, ir_node *right) {
- assert (node->op == op_Or);
- set_irn_n(node, 1, right);
+/* CopyB support */
+ir_node *get_CopyB_mem(ir_node *node) {
+ assert(node->op == op_CopyB);
+ return get_irn_n(node, 0);
}
-INLINE ir_node *
-get_Eor_left (ir_node *node) {
- assert (node->op == op_Eor);
- return get_irn_n(node, 0);
+void set_CopyB_mem(ir_node *node, ir_node *mem) {
+ assert(node->op == op_CopyB);
+ set_irn_n(node, 0, mem);
}
-INLINE void
-set_Eor_left (ir_node *node, ir_node *left) {
- assert (node->op == op_Eor);
- set_irn_n(node, 0, left);
+ir_node *get_CopyB_dst(ir_node *node) {
+ assert(node->op == op_CopyB);
+ return get_irn_n(node, 1);
}
-INLINE ir_node *
-get_Eor_right (ir_node *node) {
- assert (node->op == op_Eor);
- return get_irn_n(node, 1);
+void set_CopyB_dst(ir_node *node, ir_node *dst) {
+ assert(node->op == op_CopyB);
+ set_irn_n(node, 1, dst);
}
-INLINE void
-set_Eor_right (ir_node *node, ir_node *right) {
- assert (node->op == op_Eor);
- set_irn_n(node, 1, right);
+ir_node *get_CopyB_src (ir_node *node) {
+ assert(node->op == op_CopyB);
+ return get_irn_n(node, 2);
}
+void set_CopyB_src(ir_node *node, ir_node *src) {
+ assert(node->op == op_CopyB);
+ set_irn_n(node, 2, src);
+}
-INLINE ir_node *
-get_Not_op (ir_node *node) {
- assert (node->op == op_Not);
- return get_irn_n(node, 0);
+ir_type *get_CopyB_type(ir_node *node) {
+ assert(node->op == op_CopyB);
+ return node->attr.copyb.data_type;
}
-INLINE void
-set_Not_op (ir_node *node, ir_node *op) {
- assert (node->op == op_Not);
- set_irn_n(node, 0, op);
+void set_CopyB_type(ir_node *node, ir_type *data_type) {
+ assert(node->op == op_CopyB && data_type);
+ node->attr.copyb.data_type = data_type;
}
-INLINE ir_node *
-get_Shl_left (ir_node *node) {
- assert (node->op == op_Shl);
- return get_irn_n(node, 0);
+ir_type *
+get_InstOf_type(ir_node *node) {
+ assert(node->op = op_InstOf);
+ return node->attr.instof.type;
}
-INLINE void
-set_Shl_left (ir_node *node, ir_node *left) {
- assert (node->op == op_Shl);
- set_irn_n(node, 0, left);
+void
+set_InstOf_type(ir_node *node, ir_type *type) {
+ assert(node->op = op_InstOf);
+ node->attr.instof.type = type;
}
-INLINE ir_node *
-get_Shl_right (ir_node *node) {
- assert (node->op == op_Shl);
- return get_irn_n(node, 1);
+ir_node *
+get_InstOf_store(ir_node *node) {
+ assert(node->op = op_InstOf);
+ return get_irn_n(node, 0);
}
-INLINE void
-set_Shl_right (ir_node *node, ir_node *right) {
- assert (node->op == op_Shl);
- set_irn_n(node, 1, right);
+void
+set_InstOf_store(ir_node *node, ir_node *obj) {
+ assert(node->op = op_InstOf);
+ set_irn_n(node, 0, obj);
}
-INLINE ir_node *
-get_Shr_left (ir_node *node) {
- assert (node->op == op_Shr);
- return get_irn_n(node, 0);
+ir_node *
+get_InstOf_obj(ir_node *node) {
+ assert(node->op = op_InstOf);
+ return get_irn_n(node, 1);
}
-INLINE void
-set_Shr_left (ir_node *node, ir_node *left) {
- assert (node->op == op_Shr);
- set_irn_n(node, 0, left);
+void
+set_InstOf_obj(ir_node *node, ir_node *obj) {
+ assert(node->op = op_InstOf);
+ set_irn_n(node, 1, obj);
}
-INLINE ir_node *
-get_Shr_right (ir_node *node) {
- assert (node->op == op_Shr);
- return get_irn_n(node, 1);
+/* Returns the memory input of a Raise operation. */
+ir_node *
+get_Raise_mem(ir_node *node) {
+ assert(node->op == op_Raise);
+ return get_irn_n(node, 0);
}
-INLINE void
-set_Shr_right (ir_node *node, ir_node *right) {
- assert (node->op == op_Shr);
- set_irn_n(node, 1, right);
+void
+set_Raise_mem(ir_node *node, ir_node *mem) {
+ assert(node->op == op_Raise);
+ set_irn_n(node, 0, mem);
}
-INLINE ir_node *
-get_Shrs_left (ir_node *node) {
- assert (node->op == op_Shrs);
- return get_irn_n(node, 0);
+ir_node *
+get_Raise_exo_ptr(ir_node *node) {
+ assert(node->op == op_Raise);
+ return get_irn_n(node, 1);
}
-INLINE void
-set_Shrs_left (ir_node *node, ir_node *left) {
- assert (node->op == op_Shrs);
- set_irn_n(node, 0, left);
+void
+set_Raise_exo_ptr(ir_node *node, ir_node *exo_ptr) {
+ assert(node->op == op_Raise);
+ set_irn_n(node, 1, exo_ptr);
}
-INLINE ir_node *
-get_Shrs_right (ir_node *node) {
- assert (node->op == op_Shrs);
- return get_irn_n(node, 1);
-}
+/* Bound support */
-INLINE void
-set_Shrs_right (ir_node *node, ir_node *right) {
- assert (node->op == op_Shrs);
- set_irn_n(node, 1, right);
+/* Returns the memory input of a Bound operation. */
+ir_node *get_Bound_mem(ir_node *bound) {
+ assert(bound->op == op_Bound);
+ return get_irn_n(bound, 0);
}
-INLINE ir_node *
-get_Rot_left (ir_node *node) {
- assert (node->op == op_Rot);
- return get_irn_n(node, 0);
+void set_Bound_mem(ir_node *bound, ir_node *mem) {
+ assert(bound->op == op_Bound);
+ set_irn_n(bound, 0, mem);
}
-INLINE void
-set_Rot_left (ir_node *node, ir_node *left) {
- assert (node->op == op_Rot);
- set_irn_n(node, 0, left);
+/* Returns the index input of a Bound operation. */
+ir_node *get_Bound_index(ir_node *bound) {
+ assert(bound->op == op_Bound);
+ return get_irn_n(bound, 1);
}
-INLINE ir_node *
-get_Rot_right (ir_node *node) {
- assert (node->op == op_Rot);
- return get_irn_n(node, 1);
+void set_Bound_index(ir_node *bound, ir_node *idx) {
+ assert(bound->op == op_Bound);
+ set_irn_n(bound, 1, idx);
}
-INLINE void
-set_Rot_right (ir_node *node, ir_node *right) {
- assert (node->op == op_Rot);
- set_irn_n(node, 1, right);
+/* Returns the lower bound input of a Bound operation. */
+ir_node *get_Bound_lower(ir_node *bound) {
+ assert(bound->op == op_Bound);
+ return get_irn_n(bound, 2);
}
-INLINE ir_node *
-get_Cmp_left (ir_node *node) {
- assert (node->op == op_Cmp);
- return get_irn_n(node, 0);
+void set_Bound_lower(ir_node *bound, ir_node *lower) {
+ assert(bound->op == op_Bound);
+ set_irn_n(bound, 2, lower);
}
-INLINE void
-set_Cmp_left (ir_node *node, ir_node *left) {
- assert (node->op == op_Cmp);
- set_irn_n(node, 0, left);
+/* Returns the upper bound input of a Bound operation. */
+ir_node *get_Bound_upper(ir_node *bound) {
+ assert(bound->op == op_Bound);
+ return get_irn_n(bound, 3);
}
-INLINE ir_node *
-get_Cmp_right (ir_node *node) {
- assert (node->op == op_Cmp);
- return get_irn_n(node, 1);
+void set_Bound_upper(ir_node *bound, ir_node *upper) {
+ assert(bound->op == op_Bound);
+ set_irn_n(bound, 3, upper);
}
-INLINE void
-set_Cmp_right (ir_node *node, ir_node *right) {
- assert (node->op == op_Cmp);
- set_irn_n(node, 1, right);
+/* Return the operand of a Pin node. */
+ir_node *get_Pin_op(const ir_node *pin) {
+ assert(pin->op == op_Pin);
+ return get_irn_n(pin, 0);
}
-INLINE ir_node *
-get_Conv_op (ir_node *node) {
- assert (node->op == op_Conv);
- return get_irn_n(node, 0);
+void set_Pin_op(ir_node *pin, ir_node *node) {
+ assert(pin->op == op_Pin);
+ set_irn_n(pin, 0, node);
}
-INLINE void
-set_Conv_op (ir_node *node, ir_node *op) {
- assert (node->op == op_Conv);
- set_irn_n(node, 0, op);
+/* Return the assembler text of an ASM pseudo node. */
+ident *get_ASM_text(const ir_node *node) {
+ assert(node->op == op_ASM);
+ return node->attr.assem.asm_text;
}
-INLINE ir_node *
-get_Cast_op (ir_node *node) {
- assert (node->op == op_Cast);
- return get_irn_n(node, 0);
+/* Return the number of input constraints for an ASM node. */
+int get_ASM_n_input_constraints(const ir_node *node) {
+ assert(node->op == op_ASM);
+ return ARR_LEN(node->attr.assem.inputs);
}
-INLINE void
-set_Cast_op (ir_node *node, ir_node *op) {
- assert (node->op == op_Cast);
- set_irn_n(node, 0, op);
+/* Return the input constraints for an ASM node. This is a flexible array. */
+const ir_asm_constraint *get_ASM_input_constraints(const ir_node *node) {
+ assert(node->op == op_ASM);
+ return node->attr.assem.inputs;
}
-INLINE type *
-get_Cast_type (ir_node *node) {
- assert (node->op == op_Cast);
- return node->attr.cast.totype;
+/* Return the number of output constraints for an ASM node. */
+int get_ASM_n_output_constraints(const ir_node *node) {
+ assert(node->op == op_ASM);
+ return ARR_LEN(node->attr.assem.outputs);
}
-INLINE void
-set_Cast_type (ir_node *node, type *to_tp) {
- assert (node->op == op_Cast);
- node->attr.cast.totype = to_tp;
-}
-
-INLINE int
-is_unop (ir_node *node) {
- return (node->op->opar == oparity_unary);
-}
-
-INLINE ir_node *
-get_unop_op (ir_node *node) {
- assert (is_unop(node));
- switch (get_irn_opcode (node)) {
- case iro_Minus: return get_Minus_op(node); break;
- case iro_Abs: return get_Abs_op(node); break;
- case iro_Not: return get_Not_op(node); break;
- case iro_Conv: return get_Conv_op(node); break;
- case iro_Cast: return get_Cast_op(node); break;
- default: return NULL;
- }
-}
-
-INLINE void
-set_unop_op (ir_node *node, ir_node *op) {
- assert (is_unop(node));
- switch (get_irn_opcode (node)) {
- case iro_Minus: set_Minus_op(node, op); break;
- case iro_Abs: set_Abs_op(node, op); break;
- case iro_Not: set_Not_op(node, op); break;
- case iro_Conv: set_Conv_op(node, op); break;
- case iro_Cast: set_Cast_op(node, op); break;
- default: ;
- }
-
-}
-
-int
-is_binop (ir_node *node) {
- return (node->op->opar == oparity_binary);
- /* return (node->op == op_Add ||
- node->op == op_Cmp ||
- node->op == op_Sub ||
- node->op == op_Mul ||
- node->op == op_Quot ||
- node->op == op_DivMod ||
- node->op == op_Div ||
- node->op == op_Mod ||
- node->op == op_And ||
- node->op == op_Or ||
- node->op == op_Eor ||
- node->op == op_Shl ||
- node->op == op_Shr ||
- node->op == op_Shrs ||
- node->op == op_Rot );
- */
-}
-
-INLINE ir_node *
-get_binop_left (ir_node *node) {
- assert (node->op->opar == oparity_binary);
-
- switch (get_irn_opcode (node)) {
- case iro_Add : return get_Add_left(node); break;
- case iro_Sub : return get_Sub_left(node); break;
- case iro_Mul : return get_Mul_left(node); break;
- case iro_Quot : return get_Quot_left(node); break;
- case iro_DivMod: return get_DivMod_left(node); break;
- case iro_Div : return get_Div_left(node); break;
- case iro_Mod : return get_Mod_left(node); break;
- case iro_And : return get_And_left(node); break;
- case iro_Or : return get_Or_left(node); break;
- case iro_Eor : return get_Eor_left(node); break;
- case iro_Shl : return get_Shl_left(node); break;
- case iro_Shr : return get_Shr_left(node); break;
- case iro_Shrs : return get_Shrs_left(node); break;
- case iro_Rot : return get_Rot_left(node); break;
- case iro_Cmp : return get_Cmp_left(node); break;
- default: return NULL;
- };
-}
-
-INLINE void
-set_binop_left (ir_node *node, ir_node *left) {
- assert (node->op->opar == oparity_binary);
-
- switch (get_irn_opcode (node)) {
- case iro_Add : set_Add_left(node, left); break;
- case iro_Sub : set_Sub_left(node, left); break;
- case iro_Mul : set_Mul_left(node, left); break;
- case iro_Quot : set_Quot_left(node, left); break;
- case iro_DivMod: set_DivMod_left(node, left); break;
- case iro_Div : set_Div_left(node, left); break;
- case iro_Mod : set_Mod_left(node, left); break;
- case iro_And : set_And_left(node, left); break;
- case iro_Or : set_Or_left(node, left); break;
- case iro_Eor : set_Eor_left(node, left); break;
- case iro_Shl : set_Shl_left(node, left); break;
- case iro_Shr : set_Shr_left(node, left); break;
- case iro_Shrs : set_Shrs_left(node, left); break;
- case iro_Rot : set_Rot_left(node, left); break;
- case iro_Cmp : set_Cmp_left(node, left); break;
- default: ;
- };
-}
-
-INLINE ir_node *
-get_binop_right (ir_node *node) {
- assert (node->op->opar == oparity_binary);
-
- switch (get_irn_opcode (node)) {
- case iro_Add : return get_Add_right(node); break;
- case iro_Sub : return get_Sub_right(node); break;
- case iro_Mul : return get_Mul_right(node); break;
- case iro_Quot : return get_Quot_right(node); break;
- case iro_DivMod: return get_DivMod_right(node); break;
- case iro_Div : return get_Div_right(node); break;
- case iro_Mod : return get_Mod_right(node); break;
- case iro_And : return get_And_right(node); break;
- case iro_Or : return get_Or_right(node); break;
- case iro_Eor : return get_Eor_right(node); break;
- case iro_Shl : return get_Shl_right(node); break;
- case iro_Shr : return get_Shr_right(node); break;
- case iro_Shrs : return get_Shrs_right(node); break;
- case iro_Rot : return get_Rot_right(node); break;
- case iro_Cmp : return get_Cmp_right(node); break;
- default: return NULL;
- };
-}
-
-INLINE void
-set_binop_right (ir_node *node, ir_node *right) {
- assert (node->op->opar == oparity_binary);
-
- switch (get_irn_opcode (node)) {
- case iro_Add : set_Add_right(node, right); break;
- case iro_Sub : set_Sub_right(node, right); break;
- case iro_Mul : set_Mul_right(node, right); break;
- case iro_Quot : set_Quot_right(node, right); break;
- case iro_DivMod: set_DivMod_right(node, right); break;
- case iro_Div : set_Div_right(node, right); break;
- case iro_Mod : set_Mod_right(node, right); break;
- case iro_And : set_And_right(node, right); break;
- case iro_Or : set_Or_right(node, right); break;
- case iro_Eor : set_Eor_right(node, right); break;
- case iro_Shl : set_Shl_right(node, right); break;
- case iro_Shr : set_Shr_right(node, right); break;
- case iro_Shrs : set_Shrs_right(node, right); break;
- case iro_Rot : set_Rot_right(node, right); break;
- case iro_Cmp : set_Cmp_right(node, right); break;
- default: ;
- };
-}
-
-INLINE int is_Phi (ir_node *n) {
- assert(n);
- return ((get_irn_op(n) == op_Phi) ||
- (get_irn_op(n) == op_Filter && interprocedural_view));
-}
-
-INLINE ir_node **
-get_Phi_preds_arr (ir_node *node) {
- assert (node->op == op_Phi);
- return (ir_node **)&(get_irn_in(node)[1]);
+/* Return the output constraints for an ASM node. */
+const ir_asm_constraint *get_ASM_output_constraints(const ir_node *node) {
+ assert(node->op == op_ASM);
+ return node->attr.assem.outputs;
}
-INLINE int
-get_Phi_n_preds (ir_node *node) {
- assert (is_Phi(node));
- return (get_irn_arity(node));
+/* Return the number of clobbered registers for an ASM node. */
+int get_ASM_n_clobbers(const ir_node *node) {
+ assert(node->op == op_ASM);
+ return ARR_LEN(node->attr.assem.clobber);
}
-/*
-INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
- assert (node->op == op_Phi);
+/* Return the list of clobbered registers for an ASM node. */
+ident **get_ASM_clobbers(const ir_node *node) {
+ assert(node->op == op_ASM);
+ return node->attr.assem.clobber;
}
-*/
-INLINE ir_node *
-get_Phi_pred (ir_node *node, int pos) {
- assert (is_Phi(node));
- return get_irn_n(node, pos);
+/* returns the graph of a node */
+ir_graph *
+get_irn_irg(const ir_node *node) {
+ /*
+ * Do not use get_nodes_Block() here, because this
+ * will check the pinned state.
+ * However even a 'wrong' block is always in the proper
+ * irg.
+ */
+ if (! is_Block(node))
+ node = get_irn_n(node, -1);
+ if (is_Bad(node)) /* sometimes bad is predecessor of nodes instead of block: in case of optimization */
+ node = get_irn_n(node, -1);
+ assert(get_irn_op(node) == op_Block);
+ return node->attr.block.irg;
}
-INLINE void
-set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
- assert (is_Phi(node));
- set_irn_n(node, pos, pred);
-}
-INLINE ir_node *
-get_Load_mem (ir_node *node) {
- assert (node->op == op_Load);
- return get_irn_n(node, 0);
-}
+/*----------------------------------------------------------------*/
+/* Auxiliary routines */
+/*----------------------------------------------------------------*/
-INLINE void
-set_Load_mem (ir_node *node, ir_node *mem) {
- assert (node->op == op_Load);
- set_irn_n(node, 0, mem);
-}
+ir_node *
+skip_Proj(ir_node *node) {
+ /* don't assert node !!! */
+ if (node == NULL)
+ return NULL;
-INLINE ir_node *
-get_Load_ptr (ir_node *node) {
- assert (node->op == op_Load);
- return get_irn_n(node, 1);
+ if (is_Proj(node))
+ node = get_Proj_pred(node);
+
+ return node;
}
-INLINE void
-set_Load_ptr (ir_node *node, ir_node *ptr) {
- assert (node->op == op_Load);
- set_irn_n(node, 1, ptr);
+const ir_node *
+skip_Proj_const(const ir_node *node) {
+ /* don't assert node !!! */
+ if (node == NULL)
+ return NULL;
+
+ if (is_Proj(node))
+ node = get_Proj_pred(node);
+
+ return node;
}
-INLINE
ir_node *
-get_Store_mem (ir_node *node) {
- assert (node->op == op_Store);
- return get_irn_n(node, 0);
-}
+skip_Tuple(ir_node *node) {
+ ir_node *pred;
+ ir_op *op;
-INLINE void
-set_Store_mem (ir_node *node, ir_node *mem) {
- assert (node->op == op_Store);
- set_irn_n(node, 0, mem);
-}
+ if (!get_opt_normalize()) return node;
-INLINE ir_node *
-get_Store_ptr (ir_node *node) {
- assert (node->op == op_Store);
- return get_irn_n(node, 1);
-}
+restart:
+ if (get_irn_op(node) == op_Proj) {
+ pred = get_Proj_pred(node);
+ op = get_irn_op(pred);
-INLINE void
-set_Store_ptr (ir_node *node, ir_node *ptr) {
- assert (node->op == op_Store);
- set_irn_n(node, 1, ptr);
-}
+ /*
+ * Looks strange but calls get_irn_op() only once
+ * in most often cases.
+ */
+ if (op == op_Proj) { /* nested Tuple ? */
+ pred = skip_Tuple(pred);
+ op = get_irn_op(pred);
-INLINE ir_node *
-get_Store_value (ir_node *node) {
- assert (node->op == op_Store);
- return get_irn_n(node, 2);
+ if (op == op_Tuple) {
+ node = get_Tuple_pred(pred, get_Proj_proj(node));
+ goto restart;
+ }
+ } else if (op == op_Tuple) {
+ node = get_Tuple_pred(pred, get_Proj_proj(node));
+ goto restart;
+ }
+ }
+ return node;
}
-INLINE void
-set_Store_value (ir_node *node, ir_node *value) {
- assert (node->op == op_Store);
- set_irn_n(node, 2, value);
+/* returns operand of node if node is a Cast */
+ir_node *skip_Cast(ir_node *node) {
+ if (get_irn_op(node) == op_Cast)
+ return get_Cast_op(node);
+ return node;
}
-INLINE ir_node *
-get_Alloc_mem (ir_node *node) {
- assert (node->op == op_Alloc);
- return get_irn_n(node, 0);
+/* returns operand of node if node is a Confirm */
+ir_node *skip_Confirm(ir_node *node) {
+ if (get_irn_op(node) == op_Confirm)
+ return get_Confirm_value(node);
+ return node;
}
-INLINE void
-set_Alloc_mem (ir_node *node, ir_node *mem) {
- assert (node->op == op_Alloc);
- set_irn_n(node, 0, mem);
+/* skip all high-level ops */
+ir_node *skip_HighLevel(ir_node *node) {
+ if (is_op_highlevel(get_irn_op(node)))
+ return get_irn_n(node, 0);
+ return node;
}
-INLINE ir_node *
-get_Alloc_size (ir_node *node) {
- assert (node->op == op_Alloc);
- return get_irn_n(node, 1);
-}
-INLINE void
-set_Alloc_size (ir_node *node, ir_node *size) {
- assert (node->op == op_Alloc);
- set_irn_n(node, 1, size);
-}
+/* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
+ * than any other approach, as Id chains are resolved and all point to the real node, or
+ * all id's are self loops.
+ *
+ * Note: This function takes 10% of mostly ANY the compiler run, so it's
+ * a little bit "hand optimized".
+ *
+ * Moreover, it CANNOT be switched off using get_opt_normalize() ...
+ */
+ir_node *
+skip_Id(ir_node *node) {
+ ir_node *pred;
+ /* don't assert node !!! */
-INLINE type *
-get_Alloc_type (ir_node *node) {
- assert (node->op == op_Alloc);
- return node->attr.a.type = skip_tid(node->attr.a.type);
-}
+ if (!node || (node->op != op_Id)) return node;
-INLINE void
-set_Alloc_type (ir_node *node, type *tp) {
- assert (node->op == op_Alloc);
- node->attr.a.type = tp;
-}
+ /* Don't use get_Id_pred(): We get into an endless loop for
+ self-referencing Ids. */
+ pred = node->in[0+1];
-INLINE where_alloc
-get_Alloc_where (ir_node *node) {
- assert (node->op == op_Alloc);
- return node->attr.a.where;
-}
+ if (pred->op != op_Id) return pred;
-INLINE void
-set_Alloc_where (ir_node *node, where_alloc where) {
- assert (node->op == op_Alloc);
- node->attr.a.where = where;
-}
+ if (node != pred) { /* not a self referencing Id. Resolve Id chain. */
+ ir_node *rem_pred, *res;
+
+ if (pred->op != op_Id) return pred; /* shortcut */
+ rem_pred = pred;
+ assert(get_irn_arity (node) > 0);
-INLINE ir_node *
-get_Free_mem (ir_node *node) {
- assert (node->op == op_Free);
- return get_irn_n(node, 0);
+ node->in[0+1] = node; /* turn us into a self referencing Id: shorten Id cycles. */
+ res = skip_Id(rem_pred);
+ if (res->op == op_Id) /* self-loop */ return node;
+
+ node->in[0+1] = res; /* Turn Id chain into Ids all referencing the chain end. */
+ return res;
+ } else {
+ return node;
+ }
}
-INLINE void
-set_Free_mem (ir_node *node, ir_node *mem) {
- assert (node->op == op_Free);
- set_irn_n(node, 0, mem);
+void skip_Id_and_store(ir_node **node) {
+ ir_node *n = *node;
+
+ if (!n || (n->op != op_Id)) return;
+
+ /* Don't use get_Id_pred(): We get into an endless loop for
+ self-referencing Ids. */
+ *node = skip_Id(n);
}
-INLINE ir_node *
-get_Free_ptr (ir_node *node) {
- assert (node->op == op_Free);
- return get_irn_n(node, 1);
+int
+(is_Bad)(const ir_node *node) {
+ return _is_Bad(node);
}
-INLINE void
-set_Free_ptr (ir_node *node, ir_node *ptr) {
- assert (node->op == op_Free);
- set_irn_n(node, 1, ptr);
+int
+(is_NoMem)(const ir_node *node) {
+ return _is_NoMem(node);
}
-INLINE ir_node *
-get_Free_size (ir_node *node) {
- assert (node->op == op_Free);
- return get_irn_n(node, 2);
+int
+(is_Minus)(const ir_node *node) {
+ return _is_Minus(node);
}
-INLINE void
-set_Free_size (ir_node *node, ir_node *size) {
- assert (node->op == op_Free);
- set_irn_n(node, 2, size);
+int
+(is_Mod)(const ir_node *node) {
+ return _is_Mod(node);
}
-INLINE type *
-get_Free_type (ir_node *node) {
- assert (node->op == op_Free);
- return node->attr.f = skip_tid(node->attr.f);
+int
+(is_Div)(const ir_node *node) {
+ return _is_Div(node);
}
-INLINE void
-set_Free_type (ir_node *node, type *tp) {
- assert (node->op == op_Free);
- node->attr.f = tp;
+int
+(is_DivMod)(const ir_node *node) {
+ return _is_DivMod(node);
}
-INLINE ir_node **
-get_Sync_preds_arr (ir_node *node) {
- assert (node->op == op_Sync);
- return (ir_node **)&(get_irn_in(node)[1]);
+int
+(is_Quot)(const ir_node *node) {
+ return _is_Quot(node);
}
-INLINE int
-get_Sync_n_preds (ir_node *node) {
- assert (node->op == op_Sync);
- return (get_irn_arity(node));
+int
+(is_Add)(const ir_node *node) {
+ return _is_Add(node);
}
-/*
-INLINE void
-set_Sync_n_preds (ir_node *node, int n_preds) {
- assert (node->op == op_Sync);
+int
+(is_And)(const ir_node *node) {
+ return _is_And(node);
}
-*/
-INLINE ir_node *
-get_Sync_pred (ir_node *node, int pos) {
- assert (node->op == op_Sync);
- return get_irn_n(node, pos);
+int
+(is_Or)(const ir_node *node) {
+ return _is_Or(node);
}
-INLINE void
-set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
- assert (node->op == op_Sync);
- set_irn_n(node, pos, pred);
+int
+(is_Eor)(const ir_node *node) {
+ return _is_Eor(node);
}
-INLINE ir_node *
-get_Proj_pred (ir_node *node) {
- assert (is_Proj(node));
- return get_irn_n(node, 0);
+int
+(is_Sub)(const ir_node *node) {
+ return _is_Sub(node);
}
-INLINE void
-set_Proj_pred (ir_node *node, ir_node *pred) {
- assert (is_Proj(node));
- set_irn_n(node, 0, pred);
+int
+(is_Not)(const ir_node *node) {
+ return _is_Not(node);
}
-INLINE long
-get_Proj_proj (ir_node *node) {
- assert (is_Proj(node));
- if (get_irn_opcode(node) == iro_Proj) {
- return node->attr.proj;
- } else {
- assert(get_irn_opcode(node) == iro_Filter);
- return node->attr.filter.proj;
- }
+int
+(is_Psi)(const ir_node *node) {
+ return _is_Psi(node);
}
-INLINE void
-set_Proj_proj (ir_node *node, long proj) {
- assert (node->op == op_Proj);
- node->attr.proj = proj;
+int
+(is_Tuple)(const ir_node *node) {
+ return _is_Tuple(node);
}
-INLINE ir_node **
-get_Tuple_preds_arr (ir_node *node) {
- assert (node->op == op_Tuple);
- return (ir_node **)&(get_irn_in(node)[1]);
+int
+(is_Start)(const ir_node *node) {
+ return _is_Start(node);
}
-INLINE int
-get_Tuple_n_preds (ir_node *node) {
- assert (node->op == op_Tuple);
- return (get_irn_arity(node));
+int
+(is_End)(const ir_node *node) {
+ return _is_End(node);
}
-/*
-INLINE void
-set_Tuple_n_preds (ir_node *node, int n_preds) {
- assert (node->op == op_Tuple);
+int
+(is_Const)(const ir_node *node) {
+ return _is_Const(node);
}
-*/
-INLINE ir_node *
-get_Tuple_pred (ir_node *node, int pos) {
- assert (node->op == op_Tuple);
- return get_irn_n(node, pos);
+int
+(is_Conv)(const ir_node *node) {
+ return _is_Conv(node);
}
-INLINE void
-set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
- assert (node->op == op_Tuple);
- set_irn_n(node, pos, pred);
+int
+(is_no_Block)(const ir_node *node) {
+ return _is_no_Block(node);
}
-INLINE ir_node *
-get_Id_pred (ir_node *node) {
- assert (node->op == op_Id);
- return get_irn_n(node, 0);
+int
+(is_Block)(const ir_node *node) {
+ return _is_Block(node);
}
-INLINE void
-set_Id_pred (ir_node *node, ir_node *pred) {
- assert (node->op == op_Id);
- set_irn_n(node, 0, pred);
+/* returns true if node is an Unknown node. */
+int
+(is_Unknown)(const ir_node *node) {
+ return _is_Unknown(node);
}
-INLINE ir_node *get_Confirm_value (ir_node *node) {
- assert (node->op == op_Confirm);
- return get_irn_n(node, 0);
+/* returns true if node is a Return node. */
+int
+(is_Return)(const ir_node *node) {
+ return _is_Return(node);
}
-INLINE void set_Confirm_value (ir_node *node, ir_node *value) {
- assert (node->op == op_Confirm);
- set_irn_n(node, 0, value);
+
+/* returns true if node is a Call node. */
+int
+(is_Call)(const ir_node *node) {
+ return _is_Call(node);
}
-INLINE ir_node *get_Confirm_bound (ir_node *node) {
- assert (node->op == op_Confirm);
- return get_irn_n(node, 1);
+
+/* returns true if node is a Sel node. */
+int
+(is_Sel)(const ir_node *node) {
+ return _is_Sel(node);
}
-INLINE void set_Confirm_bound (ir_node *node, ir_node *bound) {
- assert (node->op == op_Confirm);
- set_irn_n(node, 0, bound);
+
+/* returns true if node is a Mux node or a Psi with only one condition. */
+int
+(is_Mux)(const ir_node *node) {
+ return _is_Mux(node);
}
-INLINE pn_Cmp get_Confirm_cmp (ir_node *node) {
- assert (node->op == op_Confirm);
- return node->attr.confirm_cmp;
+
+/* returns true if node is a Load node. */
+int
+(is_Load)(const ir_node *node) {
+ return _is_Load(node);
}
-INLINE void set_Confirm_cmp (ir_node *node, pn_Cmp cmp) {
- assert (node->op == op_Confirm);
- node->attr.confirm_cmp = cmp;
+
+/* returns true if node is a Load node. */
+int
+(is_Store)(const ir_node *node) {
+ return _is_Store(node);
}
+/* returns true if node is a Sync node. */
+int
+(is_Sync)(const ir_node *node) {
+ return _is_Sync(node);
+}
-INLINE ir_node *
-get_Filter_pred (ir_node *node) {
- assert(node->op == op_Filter);
- return node->in[1];
+/* returns true if node is a Confirm node. */
+int
+(is_Confirm)(const ir_node *node) {
+ return _is_Confirm(node);
}
-INLINE void
-set_Filter_pred (ir_node *node, ir_node *pred) {
- assert(node->op == op_Filter);
- node->in[1] = pred;
+
+/* returns true if node is a Pin node. */
+int
+(is_Pin)(const ir_node *node) {
+ return _is_Pin(node);
}
-INLINE long
-get_Filter_proj(ir_node *node) {
- assert(node->op == op_Filter);
- return node->attr.filter.proj;
+
+/* returns true if node is a SymConst node. */
+int
+(is_SymConst)(const ir_node *node) {
+ return _is_SymConst(node);
}
-INLINE void
-set_Filter_proj (ir_node *node, long proj) {
- assert(node->op == op_Filter);
- node->attr.filter.proj = proj;
+
+/* returns true if node is a Cond node. */
+int
+(is_Cond)(const ir_node *node) {
+ return _is_Cond(node);
}
-/* Don't use get_irn_arity, get_irn_n in implementation as access
- shall work independent of view!!! */
-void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
- assert(node->op == op_Filter);
- if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
- node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
- node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
- memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
- node->attr.filter.in_cg[0] = node->in[0];
- }
- memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
+int
+(is_CopyB)(const ir_node *node) {
+ return _is_CopyB(node);
}
-void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
- assert(node->op == op_Filter && node->attr.filter.in_cg &&
- 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
- node->attr.filter.in_cg[pos + 1] = pred;
+/* returns true if node is a Cmp node. */
+int
+(is_Cmp)(const ir_node *node) {
+ return _is_Cmp(node);
}
-int get_Filter_n_cg_preds(ir_node *node) {
- assert(node->op == op_Filter && node->attr.filter.in_cg);
- return (ARR_LEN(node->attr.filter.in_cg) - 1);
+
+/* returns true if node is an Alloc node. */
+int
+(is_Alloc)(const ir_node *node) {
+ return _is_Alloc(node);
}
-ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
- int arity;
- assert(node->op == op_Filter && node->attr.filter.in_cg &&
- 0 <= pos);
- arity = ARR_LEN(node->attr.filter.in_cg);
- assert(pos < arity - 1);
- return node->attr.filter.in_cg[pos + 1];
+
+/* returns true if a node is a Jmp node. */
+int
+(is_Jmp)(const ir_node *node) {
+ return _is_Jmp(node);
}
+/* returns true if a node is a Raise node. */
+int
+(is_Raise)(const ir_node *node) {
+ return _is_Raise(node);
+}
-INLINE ir_graph *
-get_irn_irg(ir_node *node) {
- if (get_irn_op(node) != op_Block)
- node = get_nodes_block(node);
- assert(get_irn_op(node) == op_Block);
- return node->attr.block.irg;
+/* returns true if a node is an ASM node. */
+int
+(is_ASM)(const ir_node *node) {
+ return _is_ASM(node);
}
+int
+is_Proj(const ir_node *node) {
+ assert(node);
+ return node->op == op_Proj ||
+ (!get_interprocedural_view() && node->op == op_Filter);
+}
-/******************************************************************/
-/* Auxiliary routines */
-/******************************************************************/
+/* Returns true if the operation manipulates control flow. */
+int
+is_cfop(const ir_node *node) {
+ return is_cfopcode(get_irn_op(node));
+}
-INLINE ir_node *
-skip_Proj (ir_node *node) {
- /* don't assert node !!! */
- if (node && is_Proj(node)) {
- return get_Proj_pred(node);
- } else {
- return node;
- }
+/* Returns true if the operation manipulates interprocedural control flow:
+ CallBegin, EndReg, EndExcept */
+int is_ip_cfop(const ir_node *node) {
+ return is_ip_cfopcode(get_irn_op(node));
}
-INLINE ir_node *
-skip_Tuple (ir_node *node) {
- ir_node *pred;
+/* Returns true if the operation can change the control flow because
+ of an exception. */
+int
+is_fragile_op(const ir_node *node) {
+ return is_op_fragile(get_irn_op(node));
+}
- if (!get_opt_normalize()) return node;
+/* Returns the memory operand of fragile operations. */
+ir_node *get_fragile_op_mem(ir_node *node) {
+ assert(node && is_fragile_op(node));
- node = skip_nop(node);
- if (get_irn_op(node) == op_Proj) {
- pred = skip_nop(get_Proj_pred(node));
- if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
- pred = skip_nop(skip_Tuple(pred));
- if (get_irn_op(pred) == op_Tuple)
- return get_Tuple_pred(pred, get_Proj_proj(node));
- }
- return node;
+ switch (get_irn_opcode(node)) {
+ case iro_Call :
+ case iro_Quot :
+ case iro_DivMod:
+ case iro_Div :
+ case iro_Mod :
+ case iro_Load :
+ case iro_Store :
+ case iro_Alloc :
+ case iro_Bound :
+ return get_irn_n(node, 0);
+ case iro_Bad :
+ case iro_Unknown:
+ return node;
+ default: ;
+ assert(0 && "should not be reached");
+ return NULL;
+ }
}
-#if 0
-/* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
- than any other approach, as Id chains are resolved and all point to the real node, or
- all id's are self loops. */
-INLINE ir_node *
-skip_nop (ir_node *node) {
- /* don't assert node !!! */
+/* Returns the result mode of a Div operation. */
+ir_mode *get_divop_resmod(const ir_node *node) {
+ switch (get_irn_opcode(node)) {
+ case iro_Quot : return get_Quot_resmode(node);
+ case iro_DivMod: return get_DivMod_resmode(node);
+ case iro_Div : return get_Div_resmode(node);
+ case iro_Mod : return get_Mod_resmode(node);
+ default: ;
+ assert(0 && "should not be reached");
+ return NULL;
+ }
+}
- if (!get_opt_normalize()) return node;
+/* Returns true if the operation is a forking control flow operation. */
+int (is_irn_forking)(const ir_node *node) {
+ return _is_irn_forking(node);
+}
- /* Don't use get_Id_pred: We get into an endless loop for
- self-referencing Ids. */
- if (node && (node->op == op_Id) && (node != node->in[0+1])) {
- ir_node *rem_pred = node->in[0+1];
- ir_node *res;
+/* Return the type associated with the value produced by n
+ * if the node remarks this type as it is the case for
+ * Cast, Const, SymConst and some Proj nodes. */
+ir_type *(get_irn_type)(ir_node *node) {
+ return _get_irn_type(node);
+}
- assert (get_irn_arity (node) > 0);
+/* Return the type attribute of a node n (SymConst, Call, Alloc, Free,
+ Cast) or NULL.*/
+ir_type *(get_irn_type_attr)(ir_node *node) {
+ return _get_irn_type_attr(node);
+}
- node->in[0+1] = node;
- res = skip_nop(rem_pred);
- if (res->op == op_Id) /* self-loop */ return node;
+/* Return the entity attribute of a node n (SymConst, Sel) or NULL. */
+ir_entity *(get_irn_entity_attr)(ir_node *node) {
+ return _get_irn_entity_attr(node);
+}
- node->in[0+1] = res;
- return res;
- } else {
- return node;
- }
+/* Returns non-zero for constant-like nodes. */
+int (is_irn_constlike)(const ir_node *node) {
+ return _is_irn_constlike(node);
}
-#else
-/* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
- than any other approach, as Id chains are resolved and all point to the real node, or
- all id's are self loops. */
-extern int opt_normalize;
-INLINE ir_node *
-skip_nop (ir_node *node) {
- ir_node *pred;
- /* don't assert node !!! */
- if (!opt_normalize) return node;
+/*
+ * Returns non-zero for nodes that are allowed to have keep-alives and
+ * are neither Block nor PhiM.
+ */
+int (is_irn_keep)(const ir_node *node) {
+ return _is_irn_keep(node);
+}
- /* Don't use get_Id_pred: We get into an endless loop for
- self-referencing Ids. */
- if (node && (node->op == op_Id) && (node != (pred = node->in[0+1]))) {
- if (pred->op != op_Id) return pred; /* shortcut */
- ir_node *rem_pred = pred;
- ir_node *res;
+/*
+ * Returns non-zero for nodes that are always placed in the start block.
+ */
+int (is_irn_start_block_placed)(const ir_node *node) {
+ return _is_irn_start_block_placed(node);
+}
- assert (get_irn_arity (node) > 0);
+/* Returns non-zero for nodes that are machine operations. */
+int (is_irn_machine_op)(const ir_node *node) {
+ return _is_irn_machine_op(node);
+}
- node->in[0+1] = node;
- res = skip_nop(rem_pred);
- if (res->op == op_Id) /* self-loop */ return node;
+/* Returns non-zero for nodes that are machine operands. */
+int (is_irn_machine_operand)(const ir_node *node) {
+ return _is_irn_machine_operand(node);
+}
- node->in[0+1] = res;
- return res;
- } else {
- return node;
- }
+/* Returns non-zero for nodes that have the n'th user machine flag set. */
+int (is_irn_machine_user)(const ir_node *node, unsigned n) {
+ return _is_irn_machine_user(node, n);
}
-#endif
+/* Gets the string representation of the jump prediction .*/
+const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred) {
+ switch (pred) {
+ default:
+ case COND_JMP_PRED_NONE: return "no prediction";
+ case COND_JMP_PRED_TRUE: return "true taken";
+ case COND_JMP_PRED_FALSE: return "false taken";
+ }
+}
-INLINE ir_node *
-skip_Id (ir_node *node) {
- return skip_nop(node);
+/* Returns the conditional jump prediction of a Cond node. */
+cond_jmp_predicate (get_Cond_jmp_pred)(const ir_node *cond) {
+ return _get_Cond_jmp_pred(cond);
}
-INLINE int
-is_Bad (ir_node *node) {
- assert(node);
- if ((node) && get_irn_opcode(node) == iro_Bad)
- return 1;
- return 0;
+/* Sets a new conditional jump prediction. */
+void (set_Cond_jmp_pred)(ir_node *cond, cond_jmp_predicate pred) {
+ _set_Cond_jmp_pred(cond, pred);
}
-INLINE int
-is_no_Block (ir_node *node) {
- assert(node);
- return (get_irn_opcode(node) != iro_Block);
+/** the get_type operation must be always implemented and return a firm type */
+static ir_type *get_Default_type(ir_node *n) {
+ (void) n;
+ return get_unknown_type();
}
-INLINE int
-is_Block (ir_node *node) {
- assert(node);
- return (get_irn_opcode(node) == iro_Block);
+/* Sets the get_type operation for an ir_op_ops. */
+ir_op_ops *firm_set_default_get_type(ir_opcode code, ir_op_ops *ops) {
+ switch (code) {
+ case iro_Const: ops->get_type = get_Const_type; break;
+ case iro_SymConst: ops->get_type = get_SymConst_value_type; break;
+ case iro_Cast: ops->get_type = get_Cast_type; break;
+ case iro_Proj: ops->get_type = get_Proj_type; break;
+ default:
+ /* not allowed to be NULL */
+ if (! ops->get_type)
+ ops->get_type = get_Default_type;
+ break;
+ }
+ return ops;
}
-/* returns true if node is a Unknown node. */
-INLINE int
-is_Unknown (ir_node *node) {
- assert(node);
- return (get_irn_opcode(node) == iro_Unknown);
+/** Return the attribute type of a SymConst node if exists */
+static ir_type *get_SymConst_attr_type(ir_node *self) {
+ symconst_kind kind = get_SymConst_kind(self);
+ if (SYMCONST_HAS_TYPE(kind))
+ return get_SymConst_type(self);
+ return NULL;
}
-INLINE int
-is_Proj (const ir_node *node) {
- assert(node);
- return node->op == op_Proj
- || (!interprocedural_view && node->op == op_Filter);
+/** Return the attribute entity of a SymConst node if exists */
+static ir_entity *get_SymConst_attr_entity(ir_node *self) {
+ symconst_kind kind = get_SymConst_kind(self);
+ if (SYMCONST_HAS_ENT(kind))
+ return get_SymConst_entity(self);
+ return NULL;
}
-/* Returns true if the operation manipulates control flow. */
-int
-is_cfop(ir_node *node) {
- return is_cfopcode(get_irn_op(node));
+/** the get_type_attr operation must be always implemented */
+static ir_type *get_Null_type(ir_node *n) {
+ (void) n;
+ return firm_unknown_type;
}
-/* Returns true if the operation manipulates interprocedural control flow:
- CallBegin, EndReg, EndExcept */
-INLINE int is_ip_cfop(ir_node *node) {
- return is_ip_cfopcode(get_irn_op(node));
+/* Sets the get_type operation for an ir_op_ops. */
+ir_op_ops *firm_set_default_get_type_attr(ir_opcode code, ir_op_ops *ops) {
+ switch (code) {
+ case iro_SymConst: ops->get_type_attr = get_SymConst_attr_type; break;
+ case iro_Call: ops->get_type_attr = get_Call_type; break;
+ case iro_Alloc: ops->get_type_attr = get_Alloc_type; break;
+ case iro_Free: ops->get_type_attr = get_Free_type; break;
+ case iro_Cast: ops->get_type_attr = get_Cast_type; break;
+ default:
+ /* not allowed to be NULL */
+ if (! ops->get_type_attr)
+ ops->get_type_attr = get_Null_type;
+ break;
+ }
+ return ops;
}
-ir_graph *get_ip_cfop_irg(ir_node *n) {
- return get_irn_irg(n);
+/** the get_entity_attr operation must be always implemented */
+static ir_entity *get_Null_ent(ir_node *n) {
+ (void) n;
+ return NULL;
}
-/* Returns true if the operation can change the control flow because
- of an exception. */
-int
-is_fragile_op(ir_node *node) {
- return ( (get_irn_opcode(node) == iro_Call)
- || (get_irn_opcode(node) == iro_Quot)
- || (get_irn_opcode(node) == iro_DivMod)
- || (get_irn_opcode(node) == iro_Div)
- || (get_irn_opcode(node) == iro_Mod)
- || (get_irn_opcode(node) == iro_Load)
- || (get_irn_opcode(node) == iro_Store)
- || (get_irn_opcode(node) == iro_Alloc)
- || (get_irn_opcode(node) == iro_Bad)
- || (get_irn_opcode(node) == iro_Unknown));
+/* Sets the get_type operation for an ir_op_ops. */
+ir_op_ops *firm_set_default_get_entity_attr(ir_opcode code, ir_op_ops *ops) {
+ switch (code) {
+ case iro_SymConst: ops->get_entity_attr = get_SymConst_attr_entity; break;
+ case iro_Sel: ops->get_entity_attr = get_Sel_entity; break;
+ default:
+ /* not allowed to be NULL */
+ if (! ops->get_entity_attr)
+ ops->get_entity_attr = get_Null_ent;
+ break;
+ }
+ return ops;
+}
+
+/* Sets the debug information of a node. */
+void (set_irn_dbg_info)(ir_node *n, dbg_info *db) {
+ _set_irn_dbg_info(n, db);
+}
+
+/**
+ * Returns the debug information of an node.
+ *
+ * @param n The node.
+ */
+dbg_info *(get_irn_dbg_info)(const ir_node *n) {
+ return _get_irn_dbg_info(n);
}
-/* Returns the memory operand of fragile operations. */
-ir_node *get_fragile_op_mem(ir_node *node) {
- assert(node && is_fragile_op(node));
-
- switch (get_irn_opcode (node)) {
- case iro_Call :
- case iro_Quot :
- case iro_DivMod:
- case iro_Div :
- case iro_Mod :
- case iro_Load :
- case iro_Store :
- case iro_Alloc :
- return get_irn_n(node, 0);
- case iro_Bad :
- case iro_Unknown:
- return node;
- default: ;
- assert(0 && "not reached");
- return NULL;
- }
-}
+
+#ifdef DEBUG_libfirm
+void dump_irn(ir_node *n) {
+ int i, arity = get_irn_arity(n);
+ printf("%s%s: %ld (%p)\n", get_irn_opname(n), get_mode_name(get_irn_mode(n)), get_irn_node_nr(n), (void *)n);
+ if (!is_Block(n)) {
+ ir_node *pred = get_irn_n(n, -1);
+ printf(" block: %s%s: %ld (%p)\n", get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
+ get_irn_node_nr(pred), (void *)pred);
+ }
+ printf(" preds: \n");
+ for (i = 0; i < arity; ++i) {
+ ir_node *pred = get_irn_n(n, i);
+ printf(" %d: %s%s: %ld (%p)\n", i, get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
+ get_irn_node_nr(pred), (void *)pred);
+ }
+}
+
+#else /* DEBUG_libfirm */
+void dump_irn(ir_node *n) {}
+#endif /* DEBUG_libfirm */
projects / libfirm / blobdiff