*/
#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_t.h"
#include "irop_t.h"
-
#include "irprog_t.h"
+#include "iredges_t.h"
+
+#include "irhooks.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",
/**
* returns the pnc name from an pnc constant
*/
-INLINE const char *get_pnc_string(int pnc) {
+const char *get_pnc_string(int pnc) {
return pnc_name_arr[pnc];
}
-/**
- * Calculates the negated pnc condition.
+/*
+ * 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_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 */
+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;
}
const char *pns_name_arr [] = {
};
const char *symconst_name_arr [] = {
- "type_tag", "size", "linkage_ptr_info"
+ "type_tag", "size", "addr_name", "addr_ent"
};
+/**
+ * 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 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;
+}
+
+
void
-init_irnode (void)
-{
+init_irnode(void) {
+ /* Forbid the addition of new data to an ir node. */
+ forbid_new_data = 1;
}
/*
* some incoming irnodes.
* If arity is negative, a node with a dynamic array is created.
*/
-INLINE ir_node *
+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)
+ int arity, ir_node **in)
{
ir_node *res;
- int node_size = offsetof (ir_node, attr) + op->attr_size;
+ size_t node_size = offsetof(ir_node, attr) + op->attr_size + firm_add_node_size;
+ char *p;
assert(irg && op && mode);
- res = (ir_node *) obstack_alloc (irg->obst, node_size);
+ 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->kind = k_ir_node;
+ res->op = op;
+ res->mode = mode;
res->visited = 0;
- res->link = NULL;
+ 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;
res->node_nr = get_irp_new_node_nr();
#endif
- return res;
-}
+#if FIRM_EDGES_INPLACE
+ {
+ int i, n;
+ int not_a_block = is_no_Block(res);
-/* Copies all attributes stored in the old node to the new node.
- Assumes both have the same opcode and sufficient size. */
-void
-copy_attrs (const ir_node *old_node, ir_node *new_node) {
- assert(get_irn_op(old_node) == get_irn_op(new_node));
- memcpy(&new_node->attr, &old_node->attr, get_op_attr_size(get_irn_op(old_node)));
+ INIT_LIST_HEAD(&res->edge_info.outs_head);
+ if(!not_a_block)
+ INIT_LIST_HEAD(&res->attr.block.succ_head);
+
+
+ for (i = 0, n = arity + not_a_block; i < n; ++i)
+ edges_notify_edge(res, i - not_a_block, res->in[i], NULL, irg);
+ }
+#endif
+
+ hook_new_node(irg, res);
+
+ return res;
}
-/** getting some parameters from ir_nodes **/
+/*-- getting some parameters from ir_nodes --*/
int
-is_ir_node (const void *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 **
+ir_node **
get_irn_in (const ir_node *node) {
assert(node);
- if (interprocedural_view) { /* handle Filter and Block specially */
+ 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;
return node->in;
}
-INLINE void
+void
set_irn_in (ir_node *node, int arity, ir_node **in) {
+ int i;
ir_node *** arr;
assert(node);
- if (interprocedural_view) { /* handle Filter and Block specially */
+ 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 {
arr = &node->in;
}
- if (arity != ARR_LEN(*arr) - 1) {
+
+ for (i = 0; i < arity; i++) {
+ if (i < ARR_LEN(*arr)-1)
+ edges_notify_edge(node, i, in[i], (*arr)[i+1], current_ir_graph);
+ else
+ edges_notify_edge(node, i, in[i], NULL, current_ir_graph);
+ }
+ for(;i < ARR_LEN(*arr)-1; i++) {
+ edges_notify_edge(node, i, NULL, (*arr)[i+1], current_ir_graph);
+ }
+
+ 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]));
+ir_node *
+(get_irn_intra_n)(const ir_node *node, int n) {
+ return _get_irn_intra_n (node, n);
}
-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);
+ir_node *
+(get_irn_inter_n)(const ir_node *node, int n) {
+ return _get_irn_inter_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 including 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);
-}
+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);
+}
-INLINE void
+void
set_irn_n (ir_node *node, int n, ir_node *in) {
- assert(node && -1 <= n && n < get_irn_arity(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;
node->attr.filter.in_cg[n + 1] = in;
return;
}
- if (interprocedural_view) { /* handle Filter and Block specially */
+ 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;
}
/* 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;
}
-INLINE ir_mode *
-get_irn_mode (const ir_node *node)
-{
- assert (node);
- return node->mode;
+ir_mode *
+(get_irn_mode)(const ir_node *node) {
+ return _get_irn_mode(node);
}
-INLINE void
-set_irn_mode (ir_node *node, ir_mode *mode)
+void
+(set_irn_mode)(ir_node *node, ir_mode *mode)
{
- assert (node);
- node->mode=mode;
- return;
+ _set_irn_mode(node, mode);
}
-INLINE modecode
+modecode
get_irn_modecode (const ir_node *node)
{
assert (node);
}
/** Gets the string representation of the mode .*/
-INLINE const char *
+const char *
get_irn_modename (const ir_node *node)
{
assert(node);
return get_mode_name(node->mode);
}
-INLINE ident *
+ident *
get_irn_modeident (const ir_node *node)
{
assert(node);
return get_mode_ident(node->mode);
}
-INLINE ir_op *
-get_irn_op (const ir_node *node)
+ir_op *
+(get_irn_op)(const ir_node *node)
{
- assert (node);
- return node->op;
+ return _get_irn_op(node);
}
/* should be private to the library: */
-INLINE void
+void
set_irn_op (ir_node *node, ir_op *op)
{
assert (node);
node->op = op;
}
-INLINE opcode
-get_irn_opcode (const ir_node *node)
+opcode
+(get_irn_opcode)(const ir_node *node)
{
- assert (k_ir_node == get_kind(node));
- assert (node -> op);
- return node->op->code;
+ return _get_irn_opcode(node);
}
-INLINE const char *
+const char *
get_irn_opname (const ir_node *node)
{
assert(node);
+ if ((get_irn_op((ir_node *)node) == op_Phi) &&
+ (get_irg_phase_state(get_irn_irg((ir_node *)node)) == phase_building) &&
+ (get_irn_arity((ir_node *)node) == 0)) return "Phi0";
return get_id_str(node->op->name);
}
-INLINE ident *
+ident *
get_irn_opident (const ir_node *node)
{
assert(node);
return node->op->name;
}
-INLINE unsigned long
-get_irn_visited (const ir_node *node)
+unsigned long
+(get_irn_visited)(const ir_node *node)
{
- assert (node);
- return node->visited;
+ return _get_irn_visited(node);
}
-INLINE void
-set_irn_visited (ir_node *node, unsigned long visited)
+void
+(set_irn_visited)(ir_node *node, unsigned long visited)
{
- assert (node);
- node->visited = 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) { return NULL; }
+void set_irn_abst_value(ir_node *n, struct abstval *os) {}
+struct section *firm_get_irn_section(ir_node *n) { return NULL; }
+void firm_set_irn_section(ir_node *n, struct section *s) {}
+#endif /* DO_HEAPANALYSIS */
+
+
/* Outputs a unique number for this node */
-INLINE long
+long
get_irn_node_nr(const ir_node *node) {
assert(node);
#ifdef DEBUG_libfirm
return node->node_nr;
#else
- return (long)&node;
+ return (long)node;
#endif
}
-INLINE const_attr
+const_attr
get_irn_const_attr (ir_node *node)
{
assert (node->op == op_Const);
return node->attr.con;
}
-INLINE long
+long
get_irn_proj_attr (ir_node *node)
{
assert (node->op == op_Proj);
return node->attr.proj;
}
-INLINE alloc_attr
+alloc_attr
get_irn_alloc_attr (ir_node *node)
{
assert (node->op == op_Alloc);
return node->attr.a;
}
-INLINE type *
+free_attr
get_irn_free_attr (ir_node *node)
{
assert (node->op == op_Free);
- return node->attr.f = skip_tid(node->attr.f);
+ return node->attr.f;
}
-INLINE symconst_attr
+symconst_attr
get_irn_symconst_attr (ir_node *node)
{
assert (node->op == op_SymConst);
return node->attr.i;
}
-INLINE type *
+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
+sel_attr
get_irn_sel_attr (ir_node *node)
{
assert (node->op == op_Sel);
return node->attr.s;
}
-INLINE int
+int
get_irn_phi_attr (ir_node *node)
{
assert (node->op == op_Phi);
return node->attr.phi0_pos;
}
-INLINE block_attr
+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) {
+ return &node->attr;
+}
+
/** manipulate fields of individual nodes **/
/* this works for all except Block */
ir_node *
-get_nodes_Block (ir_node *node) {
+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) {
+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) {
+ir_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);
/* 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) {
+ir_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);
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 **
+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)(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
+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
+ir_node *
+(get_Block_cfgpred_block)(ir_node *node, int pos) {
+ return _get_Block_cfgpred_block(node, pos);
+}
+
+int
get_Block_matured (ir_node *node) {
assert (node->op == op_Block);
- return node->attr.block.matured;
+ return (int)node->attr.block.matured;
}
-INLINE void
-set_Block_matured (ir_node *node, bool matured) {
+void
+set_Block_matured (ir_node *node, int 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;
+
+unsigned long
+(get_Block_block_visited)(ir_node *node) {
+ return _get_Block_block_visited(node);
}
-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_block_visited)(ir_node *node, unsigned long visit) {
+ _set_Block_block_visited(node, visit);
}
/* 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);
+void
+(mark_Block_block_visited)(ir_node *node) {
+ _mark_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));
+int
+(Block_not_block_visited)(ir_node *node) {
+ return _Block_not_block_visited(node);
}
-INLINE ir_node *
+ir_node *
get_Block_graph_arr (ir_node *node, int pos) {
assert (node->op == op_Block);
return node->attr.block.graph_arr[pos+1];
}
-INLINE void
+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;
}
-/* 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;
-}
-
-ir_node *
-get_Block_handler (ir_node *block) {
- assert ((block->op == op_Block));
- return (block->attr.block.handler_entry);
-}
-
-/ * 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)));
-}
-
-/ * 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;
-}
-
-exc_t get_Block_exc (ir_node *block) {
- assert ((block->op == op_Block));
- return (block->attr.block.exc);
-}
-
-/ * exc_t handling for Nodes * /
-void set_Node_exc (ir_node *node, exc_t exc) {
- set_Block_exc (get_nodes_Block (node), exc);
-}
-
-exc_t get_Node_exc (ir_node *node) {
- return (get_Block_exc (get_nodes_Block (node)));
-}
-*/
-
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[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 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);
- interprocedural_view = ipv;
+ set_interprocedural_view(ipv);
}
}
memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
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 &&
+ 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
node->attr.block.in_cg[pos + 1] = pred;
}
node->attr.block.in_cg = NULL;
}
-/* Start references the irg it is in. */
-INLINE ir_graph *
-get_Start_irg(ir_node *node) {
- return get_irn_irg(node);
+ir_node *(set_Block_dead)(ir_node *block) {
+ return _set_Block_dead(block);
+}
+
+int (is_Block_dead)(const ir_node *block) {
+ return _is_Block_dead(block);
+}
+
+ir_extblk *get_Block_extbb(const ir_node *block) {
+ assert(is_Block(block));
+ return block->attr.block.extblk;
+}
+
+void set_Block_extbb(ir_node *block, ir_extblk *extblk) {
+ assert(is_Block(block));
+ block->attr.block.extblk = extblk;
}
-INLINE void
+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;
+ assert(0 && " Why set irg? -- use set_irn_irg");
}
-INLINE int
+int
get_End_n_keepalives(ir_node *end) {
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);
}
-INLINE void
+void
add_End_keepalive (ir_node *end, ir_node *ka) {
assert (end->op == op_End);
ARR_APP1 (ir_node *, end->in, 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);
}
-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 ... */
+ 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);
}
/*
dataflow analysis and 3) does not allow to convert the representation to
2a).
*/
-INLINE ir_node *
+ir_node *
get_Cond_selector (ir_node *node) {
assert (node->op == op_Cond);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Cond_selector (ir_node *node, ir_node *selector) {
assert (node->op == op_Cond);
set_irn_n(node, 0, selector);
}
-INLINE cond_kind
+cond_kind
get_Cond_kind (ir_node *node) {
assert (node->op == op_Cond);
return node->attr.c.kind;
}
-INLINE void
+void
set_Cond_kind (ir_node *node, cond_kind kind) {
assert (node->op == op_Cond);
node->attr.c.kind = kind;
}
-INLINE ir_node *
+long
+get_Cond_defaultProj (ir_node *node) {
+ assert (node->op == op_Cond);
+ return node->attr.c.default_proj;
+}
+
+ir_node *
get_Return_mem (ir_node *node) {
assert (node->op == op_Return);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Return_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Return);
set_irn_n(node, 0, mem);
}
-INLINE int
+int
get_Return_n_ress (ir_node *node) {
assert (node->op == op_Return);
return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
}
-INLINE ir_node **
+ir_node **
get_Return_res_arr (ir_node *node)
{
assert ((node->op == op_Return));
}
/*
-INLINE void
+void
set_Return_n_res (ir_node *node, int results) {
assert (node->op == op_Return);
}
*/
-INLINE ir_node *
+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);
}
-INLINE void
+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);
}
-INLINE ir_node *
+ir_node *
get_Raise_mem (ir_node *node) {
assert (node->op == op_Raise);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Raise_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Raise);
set_irn_n(node, 0, mem);
}
-INLINE ir_node *
+ir_node *
get_Raise_exo_ptr (ir_node *node) {
assert (node->op == op_Raise);
return get_irn_n(node, 1);
}
-INLINE void
+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 tarval *get_Const_tarval (ir_node *node) {
- assert (node->op == op_Const);
- return node->attr.con.tv;
+tarval *(get_Const_tarval)(ir_node *node) {
+ return _get_Const_tarval(node);
}
-INLINE void
+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. */
-INLINE type *
+ir_type *
get_Const_type (ir_node *node) {
assert (node->op == op_Const);
return node->attr.con.tp;
}
-INLINE void
-set_Const_type (ir_node *node, type *tp) {
+void
+set_Const_type (ir_node *node, ir_type *tp) {
assert (node->op == op_Const);
- if (tp != unknown_type) {
+ if (tp != firm_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))))));
}
-
node->attr.con.tp = tp;
}
-INLINE symconst_kind
+symconst_kind
get_SymConst_kind (const ir_node *node) {
assert (node->op == op_SymConst);
return node->attr.i.num;
}
-INLINE void
+void
set_SymConst_kind (ir_node *node, symconst_kind num) {
assert (node->op == op_SymConst);
node->attr.i.num = num;
}
-INLINE type *
+ir_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);
+ && ( get_SymConst_kind(node) == symconst_type_tag
+ || get_SymConst_kind(node) == symconst_size));
+ return node->attr.i.sym.type_p = skip_tid(node->attr.i.sym.type_p);
+}
+
+void
+set_SymConst_type (ir_node *node, ir_type *tp) {
+ assert ( (node->op == op_SymConst)
+ && ( get_SymConst_kind(node) == symconst_type_tag
+ || get_SymConst_kind(node) == symconst_size));
+ node->attr.i.sym.type_p = tp;
+}
+
+ident *
+get_SymConst_name (ir_node *node) {
+ assert ( (node->op == op_SymConst)
+ && (get_SymConst_kind(node) == symconst_addr_name));
+ return node->attr.i.sym.ident_p;
}
-INLINE void
-set_SymConst_type (ir_node *node, type *tp) {
+void
+set_SymConst_name (ir_node *node, ident *name) {
assert ( (node->op == op_SymConst)
- && ( get_SymConst_kind(node) == type_tag
- || get_SymConst_kind(node) == size));
- node->attr.i.tori.typ = tp;
+ && (get_SymConst_kind(node) == symconst_addr_name));
+ node->attr.i.sym.ident_p = name;
}
-INLINE ident *
-get_SymConst_ptrinfo (ir_node *node) {
+
+/* Only to access SymConst of kind symconst_addr_ent. Else assertion: */
+entity *get_SymConst_entity (ir_node *node) {
assert ( (node->op == op_SymConst)
- && (get_SymConst_kind(node) == linkage_ptr_info));
- return node->attr.i.tori.ptrinfo;
+ && (get_SymConst_kind (node) == symconst_addr_ent));
+ return node->attr.i.sym.entity_p;
}
-INLINE void
-set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
+void set_SymConst_entity (ir_node *node, entity *ent) {
assert ( (node->op == op_SymConst)
- && (get_SymConst_kind(node) == linkage_ptr_info));
- node->attr.i.tori.ptrinfo = ptrinfo;
+ && (get_SymConst_kind(node) == symconst_addr_ent));
+ node->attr.i.sym.entity_p = ent;
+}
+
+union symconst_symbol
+get_SymConst_symbol (ir_node *node) {
+ assert (node->op == op_SymConst);
+ return node->attr.i.sym;
+}
+
+void
+set_SymConst_symbol (ir_node *node, union symconst_symbol sym) {
+ assert (node->op == op_SymConst);
+ //memcpy (&(node->attr.i.sym), sym, sizeof(type_or_id));
+ node->attr.i.sym = sym;
}
-INLINE type_or_id_p
-get_SymConst_type_or_id (ir_node *node) {
+ir_type *
+get_SymConst_value_type (ir_node *node) {
assert (node->op == op_SymConst);
- return &(node->attr.i.tori);
+ if (node->attr.i.tp) node->attr.i.tp = skip_tid(node->attr.i.tp);
+ return node->attr.i.tp;
}
-INLINE void
-set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
+void
+set_SymConst_value_type (ir_node *node, ir_type *tp) {
assert (node->op == op_SymConst);
- memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
+ node->attr.i.tp = tp;
}
-INLINE ir_node *
+ir_node *
get_Sel_mem (ir_node *node) {
assert (node->op == op_Sel);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Sel_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Sel);
set_irn_n(node, 0, mem);
}
-INLINE ir_node *
+ir_node *
get_Sel_ptr (ir_node *node) {
assert (node->op == op_Sel);
return get_irn_n(node, 1);
}
-INLINE void
+void
set_Sel_ptr (ir_node *node, ir_node *ptr) {
assert (node->op == op_Sel);
set_irn_n(node, 1, ptr);
}
-INLINE int
+int
get_Sel_n_indexs (ir_node *node) {
assert (node->op == op_Sel);
return (get_irn_arity(node) - SEL_INDEX_OFFSET);
}
-INLINE ir_node **
+ir_node **
get_Sel_index_arr (ir_node *node)
{
assert ((node->op == op_Sel));
return NULL;
}
-INLINE ir_node *
+ir_node *
get_Sel_index (ir_node *node, int pos) {
assert (node->op == op_Sel);
return get_irn_n(node, pos + SEL_INDEX_OFFSET);
}
-INLINE void
+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);
}
-INLINE entity *
+entity *
get_Sel_entity (ir_node *node) {
assert (node->op == op_Sel);
return node->attr.s.ent;
}
-INLINE void
+void
set_Sel_entity (ir_node *node, entity *ent) {
assert (node->op == op_Sel);
node->attr.s.ent = ent;
}
-type *
-get_InstOf_ent (ir_node *node) {
+ir_type *
+get_InstOf_type (ir_node *node) {
assert (node->op = op_InstOf);
- return (node->attr.io.ent);
+ return (node->attr.io.type);
}
void
-set_InstOf_ent (ir_node *node, type *ent) {
+set_InstOf_type (ir_node *node, ir_type *type) {
assert (node->op = op_InstOf);
- node->attr.io.ent = ent;
+ node->attr.io.type = type;
}
ir_node *
Shr, Shrs, Rotate, Cmp */
-INLINE ir_node *
+ir_node *
get_Call_mem (ir_node *node) {
assert (node->op == op_Call);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Call_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Call);
set_irn_n(node, 0, mem);
}
-INLINE ir_node *
+ir_node *
get_Call_ptr (ir_node *node) {
assert (node->op == op_Call);
return get_irn_n(node, 1);
}
-INLINE void
+void
set_Call_ptr (ir_node *node, ir_node *ptr) {
assert (node->op == op_Call);
set_irn_n(node, 1, ptr);
}
-INLINE ir_node **
+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
+int
get_Call_n_params (ir_node *node) {
assert (node->op == op_Call);
return (get_irn_arity(node) - CALL_PARAM_OFFSET);
}
-INLINE int
+int
get_Call_arity (ir_node *node) {
assert (node->op == op_Call);
return get_Call_n_params(node);
}
-/* INLINE void
+/* void
set_Call_arity (ir_node *node, ir_node *arity) {
assert (node->op == op_Call);
}
*/
-INLINE ir_node *
+ir_node *
get_Call_param (ir_node *node, int pos) {
assert (node->op == op_Call);
return get_irn_n(node, pos + CALL_PARAM_OFFSET);
}
-INLINE void
+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);
}
-INLINE type *
+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);
}
-INLINE void
-set_Call_type (ir_node *node, type *tp) {
+void
+set_Call_type (ir_node *node, ir_type *tp) {
assert (node->op == op_Call);
- assert (is_method_type(tp));
+ assert ((get_unknown_type() == tp) || is_Method_type(tp));
node->attr.call.cld_tp = tp;
}
int Call_has_callees(ir_node *node) {
- return (node->attr.call.callee_arr != NULL);
+ 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->op == op_Call && node->attr.call.callee_arr);
+ assert(node && 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);
+ assert(pos >= 0 && pos < get_Call_n_callees(node));
return node->attr.call.callee_arr[pos];
}
-void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
+void set_Call_callee_arr(ir_node * node, const 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);
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;
node->attr.callbegin.call = call;
}
-#define BINOP(OP) \
-ir_node * get_##OP##_left(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(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(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(OP) \
+ir_node * get_##OP##_left(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(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(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); \
}
BINOP(Add)
BINOP(Mul)
BINOP(Quot)
-INLINE ir_node *
+ir_node *
get_Quot_mem (ir_node *node) {
assert (node->op == op_Quot);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Quot_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Quot);
set_irn_n(node, 0, mem);
BINOP(DivMod)
-INLINE ir_node *
+ir_node *
get_DivMod_mem (ir_node *node) {
assert (node->op == op_DivMod);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_DivMod_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_DivMod);
set_irn_n(node, 0, mem);
BINOP(Div)
-INLINE ir_node *
+ir_node *
get_Div_mem (ir_node *node) {
assert (node->op == op_Div);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Div_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Div);
set_irn_n(node, 0, mem);
BINOP(Mod)
-INLINE ir_node *
+ir_node *
get_Mod_mem (ir_node *node) {
assert (node->op == op_Mod);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Mod_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Mod);
set_irn_n(node, 0, mem);
UNOP(Conv)
UNOP(Cast)
-INLINE type *
+ir_type *
get_Cast_type (ir_node *node) {
assert (node->op == op_Cast);
return node->attr.cast.totype;
}
-INLINE void
-set_Cast_type (ir_node *node, type *to_tp) {
+void
+set_Cast_type (ir_node *node, ir_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);
+
+/* 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);
}
-INLINE ir_node *
+ir_node *
get_unop_op (ir_node *node) {
if (node->op->opar == oparity_unary)
return get_irn_n(node, node->op->op_index);
return NULL;
}
-INLINE void
+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);
}
int
-is_binop (ir_node *node) {
- return (node->op->opar == oparity_binary);
+(is_binop)(const ir_node *node) {
+ return _is_binop(node);
}
-INLINE ir_node *
+ir_node *
get_binop_left (ir_node *node) {
if (node->op->opar == oparity_binary)
return get_irn_n(node, node->op->op_index);
return NULL;
}
-INLINE void
+void
set_binop_left (ir_node *node, ir_node *left) {
if (node->op->opar == oparity_binary)
set_irn_n(node, node->op->op_index, left);
assert (node->op->opar == oparity_binary);
}
-INLINE ir_node *
+ir_node *
get_binop_right (ir_node *node) {
if (node->op->opar == oparity_binary)
return get_irn_n(node, node->op->op_index + 1);
return NULL;
}
-INLINE void
+void
set_binop_right (ir_node *node, ir_node *right) {
if (node->op->opar == oparity_binary)
set_irn_n(node, node->op->op_index + 1, right);
assert (node->op->opar == oparity_binary);
}
-INLINE int is_Phi (ir_node *n) {
+int is_Phi (const ir_node *n) {
ir_op *op;
assert(n);
op = get_irn_op(n);
- return (op == op_Phi) || (op == op_Filter && interprocedural_view);
+
+ if (op == op_Filter) return get_interprocedural_view();
+
+ if (op == op_Phi)
+ return ((get_irg_phase_state(get_irn_irg(n)) != phase_building) ||
+ (get_irn_arity(n) > 0));
+
+ return 0;
}
-INLINE ir_node **
+int is_Phi0 (const ir_node *n) {
+ assert(n);
+
+ return ((get_irn_op(n) == op_Phi) &&
+ (get_irn_arity(n) == 0) &&
+ (get_irg_phase_state(get_irn_irg(n)) == phase_building));
+}
+
+ir_node **
get_Phi_preds_arr (ir_node *node) {
assert (node->op == op_Phi);
return (ir_node **)&(get_irn_in(node)[1]);
}
-INLINE int
+int
get_Phi_n_preds (ir_node *node) {
- assert (is_Phi(node));
+ assert (is_Phi(node) || is_Phi0(node));
return (get_irn_arity(node));
}
/*
-INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
+void set_Phi_n_preds (ir_node *node, int n_preds) {
assert (node->op == op_Phi);
}
*/
-INLINE ir_node *
+ir_node *
get_Phi_pred (ir_node *node, int pos) {
- assert (is_Phi(node));
+ assert (is_Phi(node) || is_Phi0(node));
return get_irn_n(node, pos);
}
-INLINE void
+void
set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
- assert (is_Phi(node));
+ assert (is_Phi(node) || is_Phi0(node));
set_irn_n(node, pos, pred);
}
-INLINE ir_node *
+
+int is_memop(ir_node *node) {
+ return ((get_irn_op(node) == op_Load) || (get_irn_op(node) == op_Store));
+}
+
+ir_node *get_memop_mem (ir_node *node) {
+ assert(is_memop(node));
+ return get_irn_n(node, 0);
+}
+
+void set_memop_mem (ir_node *node, ir_node *mem) {
+ assert(is_memop(node));
+ set_irn_n(node, 0, mem);
+}
+
+ir_node *get_memop_ptr (ir_node *node) {
+ assert(is_memop(node));
+ return get_irn_n(node, 1);
+}
+
+void set_memop_ptr (ir_node *node, ir_node *ptr) {
+ assert(is_memop(node));
+ set_irn_n(node, 1, ptr);
+}
+
+ir_node *
get_Load_mem (ir_node *node) {
assert (node->op == op_Load);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Load_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Load);
set_irn_n(node, 0, mem);
}
-INLINE ir_node *
+ir_node *
get_Load_ptr (ir_node *node) {
assert (node->op == op_Load);
return get_irn_n(node, 1);
}
-INLINE void
+void
set_Load_ptr (ir_node *node, ir_node *ptr) {
assert (node->op == op_Load);
set_irn_n(node, 1, ptr);
}
-INLINE
+ir_mode *
+get_Load_mode (ir_node *node) {
+ assert (node->op == op_Load);
+ return node->attr.load.load_mode;
+}
+
+void
+set_Load_mode (ir_node *node, ir_mode *mode) {
+ assert (node->op == op_Load);
+ node->attr.load.load_mode = mode;
+}
+
+ent_volatility
+get_Load_volatility (ir_node *node) {
+ assert (node->op == op_Load);
+ return node->attr.load.volatility;
+}
+
+void
+set_Load_volatility (ir_node *node, ent_volatility volatility) {
+ assert (node->op == op_Load);
+ node->attr.load.volatility = volatility;
+}
+
+
ir_node *
get_Store_mem (ir_node *node) {
assert (node->op == op_Store);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Store_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Store);
set_irn_n(node, 0, mem);
}
-INLINE ir_node *
+ir_node *
get_Store_ptr (ir_node *node) {
assert (node->op == op_Store);
return get_irn_n(node, 1);
}
-INLINE void
+void
set_Store_ptr (ir_node *node, ir_node *ptr) {
assert (node->op == op_Store);
set_irn_n(node, 1, ptr);
}
-INLINE ir_node *
+ir_node *
get_Store_value (ir_node *node) {
assert (node->op == op_Store);
return get_irn_n(node, 2);
}
-INLINE void
+void
set_Store_value (ir_node *node, ir_node *value) {
assert (node->op == op_Store);
set_irn_n(node, 2, value);
}
-INLINE ir_node *
+ent_volatility
+get_Store_volatility (ir_node *node) {
+ assert (node->op == op_Store);
+ return node->attr.store.volatility;
+}
+
+void
+set_Store_volatility (ir_node *node, ent_volatility volatility) {
+ assert (node->op == op_Store);
+ node->attr.store.volatility = volatility;
+}
+
+
+ir_node *
get_Alloc_mem (ir_node *node) {
assert (node->op == op_Alloc);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Alloc_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Alloc);
set_irn_n(node, 0, mem);
}
-INLINE ir_node *
+ir_node *
get_Alloc_size (ir_node *node) {
assert (node->op == op_Alloc);
return get_irn_n(node, 1);
}
-INLINE void
+void
set_Alloc_size (ir_node *node, ir_node *size) {
assert (node->op == op_Alloc);
set_irn_n(node, 1, size);
}
-INLINE type *
+ir_type *
get_Alloc_type (ir_node *node) {
assert (node->op == op_Alloc);
return node->attr.a.type = skip_tid(node->attr.a.type);
}
-INLINE void
-set_Alloc_type (ir_node *node, type *tp) {
+void
+set_Alloc_type (ir_node *node, ir_type *tp) {
assert (node->op == op_Alloc);
node->attr.a.type = tp;
}
-INLINE where_alloc
+where_alloc
get_Alloc_where (ir_node *node) {
assert (node->op == op_Alloc);
return node->attr.a.where;
}
-INLINE void
+void
set_Alloc_where (ir_node *node, where_alloc where) {
assert (node->op == op_Alloc);
node->attr.a.where = where;
}
-INLINE ir_node *
+ir_node *
get_Free_mem (ir_node *node) {
assert (node->op == op_Free);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Free_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Free);
set_irn_n(node, 0, mem);
}
-INLINE ir_node *
+ir_node *
get_Free_ptr (ir_node *node) {
assert (node->op == op_Free);
return get_irn_n(node, 1);
}
-INLINE void
+void
set_Free_ptr (ir_node *node, ir_node *ptr) {
assert (node->op == op_Free);
set_irn_n(node, 1, ptr);
}
-INLINE ir_node *
+ir_node *
get_Free_size (ir_node *node) {
assert (node->op == op_Free);
return get_irn_n(node, 2);
}
-INLINE void
+void
set_Free_size (ir_node *node, ir_node *size) {
assert (node->op == op_Free);
set_irn_n(node, 2, size);
}
-INLINE type *
+ir_type *
get_Free_type (ir_node *node) {
assert (node->op == op_Free);
- return node->attr.f = skip_tid(node->attr.f);
+ return node->attr.f.type = skip_tid(node->attr.f.type);
+}
+
+void
+set_Free_type (ir_node *node, ir_type *tp) {
+ assert (node->op == op_Free);
+ node->attr.f.type = tp;
+}
+
+where_alloc
+get_Free_where (ir_node *node) {
+ assert (node->op == op_Free);
+ return node->attr.f.where;
}
-INLINE void
-set_Free_type (ir_node *node, type *tp) {
+void
+set_Free_where (ir_node *node, where_alloc where) {
assert (node->op == op_Free);
- node->attr.f = tp;
+ node->attr.f.where = where;
}
-INLINE ir_node **
+ir_node **
get_Sync_preds_arr (ir_node *node) {
assert (node->op == op_Sync);
return (ir_node **)&(get_irn_in(node)[1]);
}
-INLINE int
+int
get_Sync_n_preds (ir_node *node) {
assert (node->op == op_Sync);
return (get_irn_arity(node));
}
/*
-INLINE void
+void
set_Sync_n_preds (ir_node *node, int n_preds) {
assert (node->op == op_Sync);
}
*/
-INLINE ir_node *
+ir_node *
get_Sync_pred (ir_node *node, int pos) {
assert (node->op == op_Sync);
return get_irn_n(node, pos);
}
-INLINE void
+void
set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
assert (node->op == op_Sync);
set_irn_n(node, pos, pred);
}
-INLINE ir_node *
-get_Proj_pred (ir_node *node) {
+ir_type *get_Proj_type(ir_node *n)
+{
+ ir_type *tp = NULL;
+ 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 (get_irn_op(a) == op_Sel)
+ tp = get_entity_type(get_Sel_entity(a));
+ } break;
+ default:
+ break;
+ }
+ return tp;
+}
+
+ir_node *
+get_Proj_pred (const ir_node *node) {
assert (is_Proj(node));
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Proj_pred (ir_node *node, ir_node *pred) {
assert (is_Proj(node));
set_irn_n(node, 0, pred);
}
-INLINE long
-get_Proj_proj (ir_node *node) {
+long
+get_Proj_proj (const ir_node *node) {
assert (is_Proj(node));
if (get_irn_opcode(node) == iro_Proj) {
return node->attr.proj;
}
}
-INLINE void
+void
set_Proj_proj (ir_node *node, long proj) {
assert (node->op == op_Proj);
node->attr.proj = proj;
}
-INLINE ir_node **
+ir_node **
get_Tuple_preds_arr (ir_node *node) {
assert (node->op == op_Tuple);
return (ir_node **)&(get_irn_in(node)[1]);
}
-INLINE int
+int
get_Tuple_n_preds (ir_node *node) {
assert (node->op == op_Tuple);
return (get_irn_arity(node));
}
/*
-INLINE void
+void
set_Tuple_n_preds (ir_node *node, int n_preds) {
assert (node->op == op_Tuple);
}
*/
-INLINE ir_node *
+ir_node *
get_Tuple_pred (ir_node *node, int pos) {
assert (node->op == op_Tuple);
return get_irn_n(node, pos);
}
-INLINE void
+void
set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
assert (node->op == op_Tuple);
set_irn_n(node, pos, pred);
}
-INLINE ir_node *
+ir_node *
get_Id_pred (ir_node *node) {
assert (node->op == op_Id);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Id_pred (ir_node *node, ir_node *pred) {
assert (node->op == op_Id);
set_irn_n(node, 0, pred);
}
-INLINE ir_node *get_Confirm_value (ir_node *node) {
+ir_node *get_Confirm_value (ir_node *node) {
assert (node->op == op_Confirm);
return get_irn_n(node, 0);
}
-INLINE void set_Confirm_value (ir_node *node, ir_node *value) {
+void set_Confirm_value (ir_node *node, ir_node *value) {
assert (node->op == op_Confirm);
set_irn_n(node, 0, value);
}
-INLINE ir_node *get_Confirm_bound (ir_node *node) {
+ir_node *get_Confirm_bound (ir_node *node) {
assert (node->op == op_Confirm);
return get_irn_n(node, 1);
}
-INLINE void set_Confirm_bound (ir_node *node, ir_node *bound) {
+void set_Confirm_bound (ir_node *node, ir_node *bound) {
assert (node->op == op_Confirm);
set_irn_n(node, 0, bound);
}
-INLINE pn_Cmp get_Confirm_cmp (ir_node *node) {
+pn_Cmp get_Confirm_cmp (ir_node *node) {
assert (node->op == op_Confirm);
return node->attr.confirm_cmp;
}
-INLINE void set_Confirm_cmp (ir_node *node, pn_Cmp cmp) {
+void set_Confirm_cmp (ir_node *node, pn_Cmp cmp) {
assert (node->op == op_Confirm);
node->attr.confirm_cmp = cmp;
}
-INLINE ir_node *
+ir_node *
get_Filter_pred (ir_node *node) {
assert(node->op == op_Filter);
return node->in[1];
}
-INLINE void
+void
set_Filter_pred (ir_node *node, ir_node *pred) {
assert(node->op == op_Filter);
node->in[1] = pred;
}
-INLINE long
+long
get_Filter_proj(ir_node *node) {
assert(node->op == op_Filter);
return node->attr.filter.proj;
}
-INLINE void
+void
set_Filter_proj (ir_node *node, long proj) {
assert(node->op == op_Filter);
node->attr.filter.proj = proj;
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);
+ 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
node->attr.filter.in_cg[pos + 1] = pred;
}
int get_Filter_n_cg_preds(ir_node *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);
+ 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) {
+ assert(node->op == op_Mux);
+ return node->in[1];
+}
+void set_Mux_sel (ir_node *node, ir_node *sel) {
+ assert(node->op == op_Mux);
+ node->in[1] = sel;
+}
+
+ir_node *get_Mux_false (ir_node *node) {
+ assert(node->op == op_Mux);
+ return node->in[2];
+}
+void set_Mux_false (ir_node *node, ir_node *ir_false) {
+ assert(node->op == op_Mux);
+ node->in[2] = ir_false;
+}
+
+ir_node *get_Mux_true (ir_node *node) {
+ assert(node->op == op_Mux);
+ return node->in[3];
+}
+void set_Mux_true (ir_node *node, ir_node *ir_true) {
+ assert(node->op == op_Mux);
+ node->in[3] = ir_true;
+}
+
+/* CopyB support */
+ir_node *get_CopyB_mem (ir_node *node) {
+ assert (node->op == op_CopyB);
+ 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);
+}
+
+ir_node *get_CopyB_dst (ir_node *node) {
+ assert (node->op == op_CopyB);
+ 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);
+}
+
+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);
+}
+
+ir_type *get_CopyB_type(ir_node *node) {
+ assert (node->op == op_CopyB);
+ return node->attr.copyb.data_type;
+}
+
+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;
+}
+
+/* Bound support */
+
+/* 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);
+}
+
+void set_Bound_mem (ir_node *bound, ir_node *mem) {
+ assert (bound->op == op_Bound);
+ set_irn_n(bound, 0, mem);
+}
+
+/* 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);
+}
+
+void set_Bound_index(ir_node *bound, ir_node *idx) {
+ assert (bound->op == op_Bound);
+ set_irn_n(bound, 1, idx);
+}
+
+/* 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);
+}
+
+void set_Bound_lower(ir_node *bound, ir_node *lower) {
+ assert (bound->op == op_Bound);
+ set_irn_n(bound, 2, lower);
+}
+
+/* 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);
+}
+
+void set_Bound_upper(ir_node *bound, ir_node *upper) {
+ assert (bound->op == op_Bound);
+ set_irn_n(bound, 3, upper);
+}
-INLINE ir_graph *
-get_irn_irg(ir_node *node) {
- if (get_irn_op(node) != op_Block)
- node = get_nodes_block(node);
+/* 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;
}
/* Auxiliary routines */
/*----------------------------------------------------------------*/
-INLINE ir_node *
+ir_node *
skip_Proj (ir_node *node) {
/* don't assert node !!! */
if (node && is_Proj(node)) {
}
}
-INLINE ir_node *
+ir_node *
skip_Tuple (ir_node *node) {
ir_node *pred;
+ ir_op *op;
if (!get_opt_normalize()) return node;
- node = skip_nop(node);
+restart:
+ node = skip_Id(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));
+ pred = skip_Id(get_Proj_pred(node));
+ op = get_irn_op(pred);
+
+ /*
+ * Looks strange but calls get_irn_op() only once
+ * in most often cases.
+ */
+ if (op == op_Proj) { /* nested Tuple ? */
+ pred = skip_Id(skip_Tuple(pred));
+ op = get_irn_op(pred);
+
+ 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;
}
+/* returns operand of node if node is a Cast */
+ir_node *skip_Cast (ir_node *node) {
+ if (node && get_irn_op(node) == op_Cast)
+ return get_Cast_op(node);
+ return node;
+}
+
+/* returns operand of node if node is a Confirm */
+ir_node *skip_Confirm (ir_node *node) {
+ if (node && get_irn_op(node) == op_Confirm)
+ return get_Confirm_value(node);
+ return node;
+}
+
+/* skip all high-level ops */
+ir_node *skip_HighLevel(ir_node *node) {
+ if (node && is_op_highlevel(get_irn_op(node)))
+ return get_irn_n(node, 0);
+ return node;
+}
+
#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) {
+ * than any other approach, as Id chains are resolved and all point to the real node, or
+ * all id's are self loops.
+ *
+ * Moreover, it CANNOT be switched off using get_opt_normalize() ...
+ */
+ir_node *
+skip_Id (ir_node *node) {
/* don't assert node !!! */
- if (!get_opt_normalize()) return 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])) {
assert (get_irn_arity (node) > 0);
node->in[0+1] = node;
- res = skip_nop(rem_pred);
+ res = skip_Id(rem_pred);
if (res->op == op_Id) /* self-loop */ return node;
node->in[0+1] = res;
}
#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) {
+ * 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 !!! */
- if (!get_opt_normalize()) return node;
+ if (!node || (node->op != op_Id)) return node;
- /* Don't use get_Id_pred: We get into an endless loop for
+ /* 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]))) {
+ pred = node->in[0+1];
+
+ if (pred->op != op_Id) return pred;
+
+ if (node != pred) { /* not a self referencing Id. Resolve Id chain. */
ir_node *rem_pred, *res;
if (pred->op != op_Id) return pred; /* shortcut */
assert (get_irn_arity (node) > 0);
- node->in[0+1] = node;
- res = skip_nop(rem_pred);
+ 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;
+ node->in[0+1] = res; /* Turn Id chain into Ids all referencing the chain end. */
return res;
} else {
return node;
}
#endif
+void skip_Id_and_store(ir_node **node) {
+ ir_node *n = *node;
+ if (!n || (n->op != op_Id)) return;
-INLINE ir_node *
-skip_Id (ir_node *node) {
- return skip_nop(node);
+ /* Don't use get_Id_pred(): We get into an endless loop for
+ self-referencing Ids. */
+ *node = skip_Id(n);
}
-INLINE int
-is_Bad (ir_node *node) {
- assert(node);
- if ((node) && get_irn_opcode(node) == iro_Bad)
- return 1;
- return 0;
+int
+(is_Bad)(const ir_node *node) {
+ return _is_Bad(node);
}
-INLINE int
-is_no_Block (ir_node *node) {
- assert(node);
- return (get_irn_opcode(node) != iro_Block);
+int
+(is_Const)(const ir_node *node) {
+ return _is_Const(node);
}
-INLINE int
-is_Block (ir_node *node) {
- assert(node);
- return (get_irn_opcode(node) == iro_Block);
+int
+(is_no_Block)(const ir_node *node) {
+ return _is_no_Block(node);
+}
+
+int
+(is_Block)(const ir_node *node) {
+ return _is_Block(node);
}
/* returns true if node is a Unknown node. */
-INLINE int
-is_Unknown (ir_node *node) {
- assert(node);
- return (get_irn_opcode(node) == iro_Unknown);
+int
+(is_Unknown)(const ir_node *node) {
+ return _is_Unknown(node);
}
-INLINE int
+int
is_Proj (const ir_node *node) {
assert(node);
return node->op == op_Proj
- || (!interprocedural_view && node->op == op_Filter);
+ || (!get_interprocedural_view() && node->op == op_Filter);
}
/* Returns true if the operation manipulates control flow. */
int
-is_cfop(ir_node *node) {
+is_cfop(const ir_node *node) {
return is_cfopcode(get_irn_op(node));
}
/* Returns true if the operation manipulates interprocedural control flow:
CallBegin, EndReg, EndExcept */
-INLINE int is_ip_cfop(ir_node *node) {
+int is_ip_cfop(const ir_node *node) {
return is_ip_cfopcode(get_irn_op(node));
}
-ir_graph *get_ip_cfop_irg(ir_node *n) {
- return get_irn_irg(n);
-}
-
/* Returns true if the operation can change the control flow because
of an exception. */
int
-is_fragile_op(ir_node *node) {
+is_fragile_op(const ir_node *node) {
return is_op_fragile(get_irn_op(node));
}
return NULL;
}
}
+
+/* Returns true if the operation is a forking control flow operation. */
+int (is_irn_forking)(const ir_node *node) {
+ return _is_irn_forking(node);
+}
+
+/* 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);
+}
+
+/* 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);
+}
+
+/* Return the entity attribute of a node n (SymConst, Sel) or NULL. */
+entity *(get_irn_entity_attr)(ir_node *node) {
+ return _get_irn_entity_attr(node);
+}
+
+/* Returns non-zero for constant-like nodes. */
+int (is_irn_constlike)(const ir_node *node) {
+ return _is_irn_constlike(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);
+}
+
+/* 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";
+ }
+}
+
+/* Returns the conditional jump prediction of a Cond node. */
+cond_jmp_predicate (get_Cond_jmp_pred)(ir_node *cond) {
+ return _get_Cond_jmp_pred(cond);
+}
+
+/* Sets a new conditional jump prediction. */
+void (set_Cond_jmp_pred)(ir_node *cond, cond_jmp_predicate pred) {
+ _set_Cond_jmp_pred(cond, pred);
+}
+
+/** the get_type operation must be always implemented and return a firm type */
+static ir_type *get_Default_type(ir_node *n) {
+ return get_unknown_type();
+}
+
+/* Sets the get_type operation for an ir_op_ops. */
+ir_op_ops *firm_set_default_get_type(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;
+}
+
+/** 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 (kind == symconst_type_tag || kind == symconst_size)
+ return get_SymConst_type(self);
+ return NULL;
+}
+
+/** Return the attribute entity of a SymConst node if exists */
+static entity *get_SymConst_attr_entity(ir_node *self) {
+ symconst_kind kind = get_SymConst_kind(self);
+ if (kind == symconst_addr_ent)
+ return get_SymConst_entity(self);
+ return NULL;
+}
+
+/** the get_type_attr operation must be always implemented */
+static ir_type *get_Null_type(ir_node *n) {
+ return firm_unknown_type;
+}
+
+/* Sets the get_type operation for an ir_op_ops. */
+ir_op_ops *firm_set_default_get_type_attr(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;
+}
+
+/** the get_entity_attr operation must be always implemented */
+static entity *get_Null_ent(ir_node *n) {
+ return NULL;
+}
+
+/* Sets the get_type operation for an ir_op_ops. */
+ir_op_ops *firm_set_default_get_entity_attr(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;
+}
+
+#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