/*
- * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
#include "irprog_t.h"
#include "iredgekinds.h"
#include "iredges_t.h"
+#include "ircons.h"
#include "irhooks.h"
#include "irtools.h"
void
set_irn_in(ir_node *node, int arity, ir_node **in) {
int i;
- ir_node *** arr;
+ ir_node *** pOld_in;
ir_graph *irg = current_ir_graph;
assert(node);
if (get_interprocedural_view()) { /* handle Filter and Block specially */
- if (get_irn_opcode(node) == iro_Filter) {
+ ir_opcode code = get_irn_opcode(node);
+ if (code == 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;
+ pOld_in = &node->attr.filter.in_cg;
+ } else if (code == iro_Block && node->attr.block.in_cg) {
+ pOld_in = &node->attr.block.in_cg;
} else {
- arr = &node->in;
+ pOld_in = &node->in;
}
} else {
- arr = &node->in;
+ pOld_in = &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);
+ if (i < ARR_LEN(*pOld_in)-1)
+ edges_notify_edge(node, i, in[i], (*pOld_in)[i+1], irg);
else
- edges_notify_edge(node, i, in[i], NULL, irg);
+ 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);
+ for (;i < ARR_LEN(*pOld_in)-1; i++) {
+ edges_notify_edge(node, i, NULL, (*pOld_in)[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;
+ if (arity != ARR_LEN(*pOld_in) - 1) {
+ ir_node * block = (*pOld_in)[0];
+ *pOld_in = NEW_ARR_D(ir_node *, irg->obst, arity + 1);
+ (*pOld_in)[0] = block;
}
fix_backedges(irg->obst, node);
- memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
+ memcpy((*pOld_in) + 1, in, sizeof(ir_node *) * arity);
}
ir_node *
/* Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
* from Start. If so returns frame type, else Null. */
-ir_type *is_frame_pointer(ir_node *n) {
+ir_type *is_frame_pointer(const 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) {
+ if (is_Start(start)) {
return get_irg_frame_type(get_irn_irg(start));
}
}
/* Test whether arbitrary node is globals pointer, i.e. Proj(pn_Start_P_globals)
* from Start. If so returns global type, else Null. */
-ir_type *is_globals_pointer(ir_node *n) {
+ir_type *is_globals_pointer(const 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) {
+ if (is_Start(start)) {
return get_glob_type();
}
}
/* 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) {
+ir_type *is_tls_pointer(const 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) {
+ if (is_Start(start)) {
return get_tls_type();
}
}
/* 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) &&
+int is_value_arg_pointer(const ir_node *n) {
+ if (is_Proj(n) &&
(get_Proj_proj(n) == pn_Start_P_value_arg_base) &&
- (get_irn_op(get_Proj_pred(n)) == op_Start))
+ is_Start(get_Proj_pred(n)))
return 1;
return 0;
}
}
ir_node *
-get_Block_graph_arr (ir_node *node, int pos) {
+get_Block_graph_arr(ir_node *node, int pos) {
assert(node->op == op_Block);
return node->attr.block.graph_arr[pos+1];
}
void
-set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
+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;
}
return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
}
-int get_Block_cg_n_cfgpreds(ir_node *node) {
+int get_Block_cg_n_cfgpreds(const ir_node *node) {
assert(node->op == op_Block);
return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
}
-ir_node *get_Block_cg_cfgpred(ir_node *node, int pos) {
+ir_node *get_Block_cg_cfgpred(const ir_node *node, int pos) {
assert(node->op == op_Block && node->attr.block.in_cg);
return node->attr.block.in_cg[pos + 1];
}
return mbh;
}
+/* returns the macro block header of a node. */
+ir_node *get_irn_MacroBlock(const ir_node *n) {
+ if (! is_Block(n)) {
+ n = get_nodes_block(n);
+ /* if the Block is Bad, do NOT try to get it's MB, it will fail. */
+ if (is_Bad(n))
+ return (ir_node *)n;
+ }
+ return get_Block_MacroBlock(n);
+}
+
/* returns the graph of a Block. */
ir_graph *get_Block_irg(const ir_node *block) {
assert(is_Block(block));
}
int
-get_End_n_keepalives(ir_node *end) {
+get_End_n_keepalives(const ir_node *end) {
assert(end->op == op_End);
return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
}
ir_node *
-get_End_keepalive(ir_node *end, int pos) {
+get_End_keepalive(const ir_node *end, int pos) {
assert(end->op == op_End);
return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
}
}
void
-free_End (ir_node *end) {
+free_End(ir_node *end) {
assert(end->op == op_End);
end->kind = k_BAD;
DEL_ARR_F(end->in);
}
/* Return the target address of an IJmp */
-ir_node *get_IJmp_target(ir_node *ijmp) {
+ir_node *get_IJmp_target(const ir_node *ijmp) {
assert(ijmp->op == op_IJmp);
return get_irn_n(ijmp, 0);
}
> Firm to the target machine. That could be done if there was some way of
> projecting "default" out of the Cond node.
I know it's complicated.
-Basically there are two proglems:
- - determining the gaps between the projs
+Basically there are two problems:
+ - determining the gaps between the Projs
- 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.
This means to extend all optimizations executed during construction.
2. Give the Cond node for switch two flavors:
- a) there are no gaps in the projs (existing flavor)
+ a) there are no gaps in the Projs (existing flavor)
b) gaps may exist, default proj is still the Proj with the largest
projection number. This covers also the gaps.
3. Fix the semantic of the Cond to that of 2b)
}
ir_node **
-get_Return_res_arr (ir_node *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]);
return node->attr.sel.ent;
}
+ir_entity *_get_Sel_entity(ir_node *node) {
+ return get_Sel_entity(node);
+}
+
void
set_Sel_entity(ir_node *node, ir_entity *ent) {
assert(node->op == op_Sel);
return ARR_LEN(node->attr.call.callee_arr);
}
-ir_entity * get_Call_callee(const ir_node *node, int pos) {
+ir_entity *get_Call_callee(const ir_node *node, int pos) {
assert(pos >= 0 && pos < get_Call_n_callees(node));
return node->attr.call.callee_arr[pos];
}
node->attr.call.callee_arr = NULL;
}
-ir_node * get_CallBegin_ptr(ir_node *node) {
+ir_node *get_CallBegin_ptr(const ir_node *node) {
assert(node->op == op_CallBegin);
return get_irn_n(node, 0);
}
set_irn_n(node, 0, ptr);
}
-ir_node * get_CallBegin_call(ir_node *node) {
+ir_node *get_CallBegin_call(const ir_node *node) {
assert(node->op == op_CallBegin);
return node->attr.callbegin.call;
}
-void set_CallBegin_call(ir_node *node, ir_node *call) {
+void set_CallBegin_call(ir_node *node, ir_node *call) {
assert(node->op == op_CallBegin);
node->attr.callbegin.call = call;
}
assert(node->op == op_##OP); \
return get_irn_n(node, node->op->op_index); \
} \
-void set_##OP##_op (ir_node *node, ir_node *op) { \
+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(OP) \
\
ir_node * \
-get_##OP##_mem(ir_node *node) { \
+get_##OP##_mem(const ir_node *node) { \
assert(node->op == op_##OP); \
return get_irn_n(node, 0); \
} \
}
-int is_memop(ir_node *node) {
- return ((get_irn_op(node) == op_Load) || (get_irn_op(node) == op_Store));
+int is_memop(const ir_node *node) {
+ ir_opcode code = get_irn_opcode(node);
+ return (code == iro_Load || code == iro_Store);
}
-ir_node *get_memop_mem(ir_node *node) {
+ir_node *get_memop_mem(const ir_node *node) {
assert(is_memop(node));
return get_irn_n(node, 0);
}
set_irn_n(node, 0, mem);
}
-ir_node *get_memop_ptr(ir_node *node) {
+ir_node *get_memop_ptr(const ir_node *node) {
assert(is_memop(node));
return get_irn_n(node, 1);
}
}
ir_node *
-get_Load_mem(ir_node *node) {
+get_Load_mem(const ir_node *node) {
assert(node->op == op_Load);
return get_irn_n(node, 0);
}
}
ir_node *
-get_Load_ptr(ir_node *node) {
+get_Load_ptr(const ir_node *node) {
assert(node->op == op_Load);
return get_irn_n(node, 1);
}
}
ir_mode *
-get_Load_mode(ir_node *node) {
+get_Load_mode(const ir_node *node) {
assert(node->op == op_Load);
return node->attr.load.load_mode;
}
}
ir_volatility
-get_Load_volatility(ir_node *node) {
+get_Load_volatility(const ir_node *node) {
assert(node->op == op_Load);
return node->attr.load.volatility;
}
}
ir_align
-get_Load_align(ir_node *node) {
+get_Load_align(const ir_node *node) {
assert(node->op == op_Load);
return node->attr.load.aligned;
}
ir_node *
-get_Store_mem(ir_node *node) {
+get_Store_mem(const ir_node *node) {
assert(node->op == op_Store);
return get_irn_n(node, 0);
}
}
ir_node *
-get_Store_ptr(ir_node *node) {
+get_Store_ptr(const ir_node *node) {
assert(node->op == op_Store);
return get_irn_n(node, 1);
}
}
ir_node *
-get_Store_value(ir_node *node) {
+get_Store_value(const ir_node *node) {
assert(node->op == op_Store);
return get_irn_n(node, 2);
}
}
ir_volatility
-get_Store_volatility(ir_node *node) {
+get_Store_volatility(const ir_node *node) {
assert(node->op == op_Store);
return node->attr.store.volatility;
}
}
ir_align
-get_Store_align(ir_node *node) {
+get_Store_align(const ir_node *node) {
assert(node->op == op_Store);
return node->attr.store.aligned;
}
}
/* returns operand of node if node is a Cast */
-ir_node *skip_Cast(const ir_node *node) {
+ir_node *skip_Cast(ir_node *node) {
if (get_irn_op(node) == op_Cast)
return get_Cast_op(node);
return node;
}
/* 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);
+ir_node *skip_HighLevel_ops(ir_node *node) {
+ while (is_op_highlevel(get_irn_op(node))) {
+ node = get_irn_n(node, 0);
+ }
return node;
}
return _is_Tuple(node);
}
+int
+(is_Bound)(const ir_node *node) {
+ return _is_Bound(node);
+}
+
int
(is_Start)(const ir_node *node) {
return _is_Start(node);
return _is_Sync(node);
}
-/* returns true if node is a Confirm node. */
+/* Returns true if node is a Confirm node. */
int
(is_Confirm)(const ir_node *node) {
return _is_Confirm(node);
}
-/* returns true if node is a Pin node. */
+/* Returns true if node is a Pin node. */
int
(is_Pin)(const ir_node *node) {
return _is_Pin(node);
}
-/* returns true if node is a SymConst node. */
+/* Returns true if node is a SymConst node. */
int
(is_SymConst)(const ir_node *node) {
return _is_SymConst(node);
}
-/* returns true if node is a Cond node. */
+/* Returns true if node is a SymConst node with kind symconst_addr_ent. */
+int
+(is_SymConst_addr_ent)(const ir_node *node) {
+ return _is_SymConst_addr_ent(node);
+}
+
+/* Returns true if node is a Cond node. */
int
(is_Cond)(const ir_node *node) {
return _is_Cond(node);
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;
+ case iro_Sel: ops->get_entity_attr = _get_Sel_entity; break;
default:
/* not allowed to be NULL */
if (! ops->get_entity_attr)
projects / libfirm / blobdiff