#include <string.h>
#endif
+# include "irprog_t.h"
# include "irgraph_t.h"
# include "irnode_t.h"
# include "irmode_t.h"
#endif
/*
- * language dependant initialization variable
+ * language dependent initialization variable
*/
static uninitialized_local_variable_func_t *default_initialize_local_variable = NULL;
-/* -------------------------------------------- */
-/* privat interfaces, for professional use only */
-/* -------------------------------------------- */
+/* --------------------------------------------- */
+/* private interfaces, for professional use only */
+/* --------------------------------------------- */
/* Constructs a Block with a fixed number of predecessors.
Does not set current_block. Can not be used with automatic
res->attr.block.backedge = new_backedge_arr(irg->obst, arity);
res->attr.block.in_cg = NULL;
res->attr.block.cg_backedge = NULL;
+ res->attr.block.extblk = NULL;
IRN_VRFY_IRG(res, irg);
return res;
ir_node *
new_rd_Const_long (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, long value)
{
- return new_rd_Const(db, irg, block, mode, new_tarval_from_long(value, mode));
+ return new_rd_Const(db, irg, block, mode, new_tarval_from_long(value, mode));
}
ir_node *
ir_node *
new_rd_Minus (dbg_info* db, ir_graph *irg, ir_node *block,
- ir_node *op, ir_mode *mode)
+ ir_node *op, ir_mode *mode)
{
ir_node *res;
return res;
}
+ir_node *
+new_rd_IJmp (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *tgt)
+{
+ ir_node *res;
+
+ res = new_ir_node (db, irg, block, op_IJmp, mode_X, 1, &tgt);
+ res = optimize_node (res);
+ IRN_VRFY_IRG (res, irg);
+
+ if (get_irn_op(res) == op_IJmp) /* still an IJmp */
+ keep_alive(res);
+ return res;
+}
+
ir_node *
new_rd_Cond (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *c)
{
ir_node *
new_rd_SymConst_type (dbg_info* db, ir_graph *irg, ir_node *block, symconst_symbol value,
- symconst_kind symkind, type *tp) {
+ symconst_kind symkind, type *tp) {
ir_node *res;
ir_mode *mode;
ir_node *
new_rd_SymConst (dbg_info* db, ir_graph *irg, ir_node *block, symconst_symbol value,
- symconst_kind symkind)
+ symconst_kind symkind)
{
ir_node *res = new_rd_SymConst_type(db, irg, block, value, symkind, firm_unknown_type);
return res;
ir_node *new_r_Jmp (ir_graph *irg, ir_node *block) {
return new_rd_Jmp(NULL, irg, block);
}
+ir_node *new_r_IJmp (ir_graph *irg, ir_node *block, ir_node *tgt) {
+ return new_rd_IJmp(NULL, irg, block, tgt);
+}
ir_node *new_r_Cond (ir_graph *irg, ir_node *block, ir_node *c) {
return new_rd_Cond(NULL, irg, block, c);
}
return new_rd_Const_long(NULL, irg, block, mode, value);
}
+ir_node *new_r_Const_type(ir_graph *irg, ir_node *block,
+ ir_mode *mode, tarval *con, type *tp) {
+ return new_rd_Const_type(NULL, irg, block, mode, con, tp);
+}
ir_node *new_r_SymConst (ir_graph *irg, ir_node *block,
symconst_symbol value, symconst_kind symkind) {
/* Create and initialize array for Phi-node construction. */
if (get_irg_phase_state(current_ir_graph) == phase_building) {
res->attr.block.graph_arr = NEW_ARR_D(ir_node *, current_ir_graph->obst,
- current_ir_graph->n_loc);
+ current_ir_graph->n_loc);
memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
}
If so, it is a real Phi node and we break the loop. Else the Phi
node merges the same definition on several paths and therefore is
not needed. */
- for (i = 0; i < ins; ++i)
- {
- if (in[i] == res || in[i] == known) continue;
+ for (i = 0; i < ins; ++i) {
+ if (in[i] == res || in[i] == known)
+ continue;
if (known == res)
known = in[i];
#if USE_EXPLICIT_PHI_IN_STACK
free_to_Phi_in_stack(res);
#else
- edges_node_deleted(res, current_ir_graph);
- obstack_free (current_ir_graph->obst, res);
+ edges_node_deleted(res, current_ir_graph);
+ obstack_free(current_ir_graph->obst, res);
#endif
res = known;
} else {
static INLINE ir_node *
new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
- ir_node **in, int ins, ir_node *phi0)
+ ir_node **in, int ins, ir_node *phi0)
{
int i;
ir_node *res, *known;
/* i==ins: there is at most one predecessor, we don't need a phi node. */
if (i == ins) {
if (res != known) {
- edges_node_deleted(res, current_ir_graph);
+ edges_node_deleted(res, current_ir_graph);
obstack_free (current_ir_graph->obst, res);
if (is_Phi(known)) {
- /* If pred is a phi node we want to optmize it: If loops are matured in a bad
- order, an enclosing Phi know may get superfluous. */
- res = optimize_in_place_2(known);
- if (res != known) { exchange(known, res); }
- } else {
- res = known;
+ /* If pred is a phi node we want to optimize it: If loops are matured in a bad
+ order, an enclosing Phi know may get superfluous. */
+ res = optimize_in_place_2(known);
+ if (res != known)
+ exchange(known, res);
+
}
+ else
+ res = known;
} else {
/* A undefined value, e.g., in unreachable code. */
res = new_Bad();
arr[0] = new_Proj(n, mode_M, pn_Call_M_except);
else {
assert((pn_Quot_M == pn_DivMod_M) &&
- (pn_Quot_M == pn_Div_M) &&
- (pn_Quot_M == pn_Mod_M) &&
- (pn_Quot_M == pn_Load_M) &&
- (pn_Quot_M == pn_Store_M) &&
- (pn_Quot_M == pn_Alloc_M) );
+ (pn_Quot_M == pn_Div_M) &&
+ (pn_Quot_M == pn_Mod_M) &&
+ (pn_Quot_M == pn_Load_M) &&
+ (pn_Quot_M == pn_Store_M) &&
+ (pn_Quot_M == pn_Alloc_M) );
arr[0] = new_Proj(n, mode_M, pn_Alloc_M);
}
set_optimize(opt);
else
block->attr.block.graph_arr[pos] = new_Const(mode, tarval_bad);
/* We don't need to care about exception ops in the start block.
- There are none by definition. */
+ There are none by definition. */
return block->attr.block.graph_arr[pos];
} else {
phi0 = new_rd_Phi0(current_ir_graph, block, mode);
block->attr.block.graph_arr[pos] = phi0;
#if PRECISE_EXC_CONTEXT
if (get_opt_precise_exc_context()) {
- /* Set graph_arr for fragile ops. Also here we should break recursion.
- We could choose a cyclic path through an cfop. But the recursion would
- break at some point. */
- set_frag_value(block->attr.block.graph_arr, pos, phi0);
+ /* Set graph_arr for fragile ops. Also here we should break recursion.
+ We could choose a cyclic path through an cfop. But the recursion would
+ break at some point. */
+ set_frag_value(block->attr.block.graph_arr, pos, phi0);
}
#endif
}
if (!is_Bad(prevBlock)) {
#if PRECISE_EXC_CONTEXT
if (get_opt_precise_exc_context() &&
- is_fragile_op(prevCfOp) && (get_irn_op (prevCfOp) != op_Bad)) {
- assert(get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode));
- nin[i-1] = get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode);
+ is_fragile_op(prevCfOp) && (get_irn_op (prevCfOp) != op_Bad)) {
+ assert(get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode));
+ nin[i-1] = get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode);
} else
#endif
nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
if (!phi0) {
phi0_all = block->attr.block.graph_arr[pos];
if (!((get_irn_op(phi0_all) == op_Phi) &&
- (get_irn_arity(phi0_all) == 0) &&
- (get_nodes_block(phi0_all) == block)))
+ (get_irn_arity(phi0_all) == 0) &&
+ (get_nodes_block(phi0_all) == block)))
phi0_all = NULL;
} else {
phi0_all = phi0;
printf("Error: no value set. Use of undefined variable. Initializing to zero.\n");
assert (mode->code >= irm_F && mode->code <= irm_P);
res = new_rd_Const (NULL, current_ir_graph, block, mode,
- get_mode_null(mode));
+ get_mode_null(mode));
}
/* The local valid value is available now. */
return new_rd_Const_long(db, current_ir_graph, current_ir_graph->start_block, mode, value);
}
- ir_node *
+ir_node *
new_d_Const_type (dbg_info* db, ir_mode *mode, tarval *con, type *tp)
{
return new_rd_Const_type(db, current_ir_graph, current_ir_graph->start_block,
static void allocate_frag_arr(ir_node *res, ir_op *op, ir_node ***frag_store) {
if (get_opt_precise_exc_context()) {
if ((current_ir_graph->phase_state == phase_building) &&
- (get_irn_op(res) == op) && /* Could be optimized away. */
- !*frag_store) /* Could be a cse where the arr is already set. */ {
+ (get_irn_op(res) == op) && /* Could be optimized away. */
+ !*frag_store) /* Could be a cse where the arr is already set. */ {
*frag_store = new_frag_arr(res);
}
}
return new_rd_Jmp (db, current_ir_graph, current_ir_graph->current_block);
}
+ir_node *
+new_d_IJmp (dbg_info* db, ir_node *tgt)
+{
+ return new_rd_IJmp (db, current_ir_graph, current_ir_graph->current_block, tgt);
+}
+
ir_node *
new_d_Cond (dbg_info* db, ir_node *c)
{
return new_d_immBlock(NULL);
}
-/* add an adge to a jmp/control flow node */
+/* add an edge to a jmp/control flow node */
void
add_immBlock_pred (ir_node *block, ir_node *jmp)
{
}
void
-keep_alive (ir_node *ka)
-{
+keep_alive (ir_node *ka) {
add_End_keepalive(current_ir_graph->end, ka);
}
/* call for each graph */
void
-finalize_cons (ir_graph *irg) {
+irg_finalize_cons (ir_graph *irg) {
irg->phase_state = phase_high;
}
+void
+irp_finalize_cons (void) {
+ int i, n_irgs = get_irp_n_irgs();
+ for (i = 0; i < n_irgs; i++) {
+ irg_finalize_cons(get_irp_irg(i));
+ }
+ irp->phase_state = phase_high;\
+}
+
+
+
ir_node *new_Block(int arity, ir_node **in) {
return new_d_Block(NULL, arity, in);
ir_node *new_Jmp (void) {
return new_d_Jmp(NULL);
}
+ir_node *new_IJmp (ir_node *tgt) {
+ return new_d_IJmp(NULL, tgt);
+}
ir_node *new_Cond (ir_node *c) {
return new_d_Cond(NULL, c);
}
ir_node *new_Const_long(ir_mode *mode, long value)
{
- return new_d_Const_long(NULL, mode, value);
+ return new_d_Const_long(NULL, mode, value);
}
ir_node *new_Const_type(tarval *con, type *tp) {
projects / libfirm / blobdiff