/* Memory Phis in endless loops must be kept alive.
As we can't distinguish these easily we keep all of them alive. */
if ((res->op == op_Phi) && (mode == mode_M))
- add_End_keepalive(irg->end, res);
+ add_End_keepalive(get_irg_end(irg), res);
return res;
}
ir_node *res;
ir_graph *irg = current_ir_graph;
- res = new_ir_node (db, irg, irg->start_block, op_Const, mode, 0, NULL);
+ res = new_ir_node (db, irg, get_irg_start_block(irg), op_Const, mode, 0, NULL);
res->attr.con.tv = con;
set_Const_type(res, tp); /* Call method because of complex assertion. */
res = optimize_node (res);
}
static ir_node *
-new_bd_Sync (dbg_info *db, ir_node *block, int arity, ir_node **in)
+new_bd_Sync (dbg_info *db, ir_node *block)
{
ir_node *res;
ir_graph *irg = current_ir_graph;
- res = new_ir_node(db, irg, block, op_Sync, mode_M, arity, in);
- res = optimize_node(res);
+ res = new_ir_node(db, irg, block, op_Sync, mode_M, -1, NULL);
+ /* no need to call optimize node here, Sync are always created with no predecessors */
IRN_VRFY_IRG(res, irg);
return res;
}
ir_node *res;
ir_graph *irg = current_ir_graph;
- res = new_ir_node(NULL, irg, irg->start_block, op_Unknown, m, 0, NULL);
+ res = new_ir_node(NULL, irg, get_irg_start_block(irg), op_Unknown, m, 0, NULL);
res = optimize_node(res);
return res;
}
ir_graph *irg = current_ir_graph;
res = new_ir_node(db, irg, block, op_EndReg, mode_T, -1, NULL);
- irg->end_reg = res;
+ set_irg_end_reg(irg, res);
IRN_VRFY_IRG(res, irg);
return res;
}
ir_graph *irg = current_ir_graph;
res = new_ir_node(db, irg, block, op_EndExcept, mode_T, -1, NULL);
- irg->end_except = res;
+ set_irg_end_except(irg, res);
IRN_VRFY_IRG (res, irg);
return res;
}
ir_node *new_rd_SymConst_addr_ent (dbg_info *db, ir_graph *irg, entity *symbol, ir_type *tp)
{
symconst_symbol sym = {(ir_type *)symbol};
- return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_addr_ent, tp);
+ return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_addr_ent, tp);
}
ir_node *new_rd_SymConst_addr_name (dbg_info *db, ir_graph *irg, ident *symbol, ir_type *tp) {
symconst_symbol sym = {(ir_type *)symbol};
- return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_addr_name, tp);
+ return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_addr_name, tp);
}
ir_node *new_rd_SymConst_type_tag (dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {
symconst_symbol sym = {symbol};
- return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_type_tag, tp);
+ return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_type_tag, tp);
}
ir_node *new_rd_SymConst_size (dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {
symconst_symbol sym = {symbol};
- return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_size, tp);
+ return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_type_size, tp);
+}
+
+ir_node *new_rd_SymConst_align (dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {
+ symconst_symbol sym = {symbol};
+ return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_type_align, tp);
}
ir_node *
-new_rd_Sync (dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node **in)
+new_rd_Sync (dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node *in[])
{
ir_node *res;
ir_graph *rem = current_ir_graph;
+ int i;
current_ir_graph = irg;
- res = new_bd_Sync(db, block, arity, in);
+ res = new_bd_Sync(db, block);
current_ir_graph = rem;
+ for (i = 0; i < arity; ++i) add_Sync_pred(res, in[i]);
+
return res;
}
ir_node *
-new_rd_Bad (ir_graph *irg)
-{
- return irg->bad;
+new_rd_Bad (ir_graph *irg) {
+ return get_irg_bad(irg);
}
ir_node *
ir_node *res;
res = new_ir_node(db, irg, block, op_EndReg, mode_T, -1, NULL);
- irg->end_reg = res;
+ set_irg_end_reg(irg, res);
IRN_VRFY_IRG(res, irg);
return res;
}
ir_node *res;
res = new_ir_node(db, irg, block, op_EndExcept, mode_T, -1, NULL);
- irg->end_except = res;
+ set_irg_end_except(irg, res);
IRN_VRFY_IRG (res, irg);
return res;
}
ir_node *
new_rd_NoMem (ir_graph *irg) {
- return irg->no_mem;
+ return get_irg_no_mem(irg);
}
ir_node *
ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where) {
return new_rd_Free(NULL, irg, block, store, ptr, size, free_type, where);
}
-ir_node *new_r_Sync (ir_graph *irg, ir_node *block, int arity, ir_node **in) {
+ir_node *new_r_Sync (ir_graph *irg, ir_node *block, int arity, ir_node *in[]) {
return new_rd_Sync(NULL, irg, block, arity, in);
}
ir_node *new_r_Proj (ir_graph *irg, ir_node *block, ir_node *arg,
/* Now we now the value for "pos" and can enter it in the array with
all known local variables. Attention: this might be a pointer to
- a node, that later will be allocated!!! See new_rd_Phi_in.
- If this is called in mature, after some set_value in the same block,
+ a node, that later will be allocated!!! See new_rd_Phi_in().
+ If this is called in mature, after some set_value() in the same block,
the proper value must not be overwritten:
The call order
get_value (makes Phi0, put's it into graph_arr)
/* Memory Phis in endless loops must be kept alive.
As we can't distinguish these easily we keep all of them alive. */
if ((res->op == op_Phi) && (mode == mode_M))
- add_End_keepalive(irg->end, res);
+ add_End_keepalive(get_irg_end(irg), res);
}
return res;
arr[0] = new_Proj(n, mode_M, pn_Call_M_except);
else if (get_irn_op(n) == op_CopyB)
arr[0] = new_Proj(n, mode_M, pn_CopyB_M_except);
- else if (get_irn_op(n) == op_Bound)
- arr[0] = new_Proj(n, mode_M, pn_Bound_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_Alloc_M) &&
+ (pn_Quot_M == pn_Bound_M));
arr[0] = new_Proj(n, mode_M, pn_Alloc_M);
}
set_optimize(opt);
res = frag_arr[pos];
if (!res) {
if (block->attr.block.graph_arr[pos]) {
- /* There was a set_value after the cfOp and no get_value before that
- set_value. We must build a Phi node now. */
+ /* There was a set_value() after the cfOp and no get_value before that
+ set_value(). We must build a Phi node now. */
if (block->attr.block.matured) {
int ins = get_irn_arity(block);
ir_node **nin;
ir_node *
new_d_Const (dbg_info *db, ir_mode *mode, tarval *con)
{
- return new_bd_Const(db, current_ir_graph->start_block, mode, con);
+ return new_bd_Const(db, get_irg_start_block(current_ir_graph), mode, con);
}
ir_node *
new_d_Const_long(dbg_info *db, ir_mode *mode, long value)
{
- return new_bd_Const_long(db, current_ir_graph->start_block, mode, value);
+ return new_bd_Const_long(db, get_irg_start_block(current_ir_graph), mode, value);
}
ir_node *
new_d_Const_type (dbg_info *db, ir_mode *mode, tarval *con, ir_type *tp)
{
- return new_bd_Const_type(db, current_ir_graph->start_block, mode, con, tp);
+ return new_bd_Const_type(db, get_irg_start_block(current_ir_graph), mode, con, tp);
}
ir_node *
new_d_SymConst_type (dbg_info *db, symconst_symbol value, symconst_kind kind, ir_type *tp)
{
- return new_bd_SymConst_type (db, current_ir_graph->start_block,
+ return new_bd_SymConst_type (db, get_irg_start_block(current_ir_graph),
value, kind, tp);
}
ir_node *
new_d_SymConst (dbg_info *db, symconst_symbol value, symconst_kind kind)
{
- return new_bd_SymConst (db, current_ir_graph->start_block,
+ return new_bd_SymConst (db, get_irg_start_block(current_ir_graph),
value, kind);
}
ir_node *
-new_d_Sync (dbg_info *db, int arity, ir_node** in)
+new_d_Sync (dbg_info *db, int arity, ir_node *in[])
{
- return new_bd_Sync (db, current_ir_graph->current_block, arity, in);
+ return new_rd_Sync (db, current_ir_graph, current_ir_graph->current_block, arity, in);
}
return get_r_value_internal (current_ir_graph->current_block, 0, mode_M);
}
-/* set the current store */
+/* set the current store: handles automatic Sync construction for Load nodes */
void
set_store (ir_node *store)
{
- /* GL: one could call set_value instead */
+ ir_node *load, *pload, *pred, *in[2];
+
assert(get_irg_phase_state (current_ir_graph) == phase_building);
+
+ /* handle non-volatile Load nodes by automatically creating Sync's */
+ load = skip_Proj(store);
+ if (is_Load(load) && get_Load_volatility(load) == volatility_non_volatile) {
+ pred = get_Load_mem(load);
+
+ if (is_Sync(pred)) {
+ /* a Load after a Sync: move it up */
+ set_Load_mem(load, get_Sync_pred(pred, 0));
+ store = pred;
+ }
+ else {
+ pload = skip_Proj(pred);
+ if (is_Load(pload) && get_Load_volatility(pload) == volatility_non_volatile) {
+ /* a Load after a Load: create a new Sync */
+ set_Load_mem(load, get_Load_mem(pload));
+
+ in[0] = pred;
+ in[1] = store;
+ store = new_Sync(2, in);
+ }
+ }
+ }
current_ir_graph->current_block->attr.block.graph_arr[0] = store;
}
void
keep_alive (ir_node *ka) {
- add_End_keepalive(current_ir_graph->end, ka);
+ add_End_keepalive(get_irg_end(current_ir_graph), ka);
}
/* --- Useful access routines --- */
default_initialize_local_variable = func;
}
-/* call for each graph */
-void
-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++) {
+ int i;
+ for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
irg_finalize_cons(get_irp_irg(i));
}
irp->phase_state = phase_high;
ir_type *free_type, where_alloc where) {
return new_d_Free(NULL, store, ptr, size, free_type, where);
}
-ir_node *new_Sync (int arity, ir_node **in) {
+ir_node *new_Sync (int arity, ir_node *in[]) {
return new_d_Sync(NULL, arity, in);
}
ir_node *new_Proj (ir_node *arg, ir_mode *mode, long proj) {