X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Fircons.c;h=f46812628511401c8a2b290ac8da5fb0a2d8d2d0;hb=229c9d24147d83fb3160da88436c3b95fb1b2b1b;hp=a5cc37d9c4e737bace3f2794621e6ed9ce3373ed;hpb=85c5feec141bf6acfc8da034f7e8b749db8c0a0e;p=libfirm diff --git a/ir/ir/ircons.c b/ir/ir/ircons.c index a5cc37d9c..f46812628 100644 --- a/ir/ir/ircons.c +++ b/ir/ir/ircons.c @@ -4,10 +4,10 @@ * Purpose: Various irnode constructors. Automatic construction * of SSA representation. * Author: Martin Trapp, Christian Schaefer - * Modified by: Goetz Lindenmaier, Boris Boesler + * Modified by: Goetz Lindenmaier, Boris Boesler, Michael Beck * Created: * CVS-ID: $Id$ - * Copyright: (c) 1998-2003 Universität Karlsruhe + * Copyright: (c) 1998-2006 Universität Karlsruhe * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. */ @@ -64,7 +64,7 @@ typedef struct Phi_in_stack Phi_in_stack; static uninitialized_local_variable_func_t *default_initialize_local_variable = NULL; /* creates a bd constructor for a binop */ -#define NEW_BD_BINOP(instr, float_support) \ +#define NEW_BD_BINOP(instr) \ static ir_node * \ new_bd_##instr(dbg_info *db, ir_node *block, \ ir_node *op1, ir_node *op2, ir_mode *mode) \ @@ -75,16 +75,13 @@ new_bd_##instr(dbg_info *db, ir_node *block, \ in[0] = op1; \ in[1] = op2; \ res = new_ir_node(db, irg, block, op_##instr, mode, 2, in); \ - if (float_support && mode_is_float(mode) && \ - (get_irg_fp_model(irg) & fp_exceptions)) \ - res->pinned = 1; \ res = optimize_node(res); \ IRN_VRFY_IRG(res, irg); \ return res; \ } /* creates a bd constructor for an unop */ -#define NEW_BD_UNOP(instr, float_support) \ +#define NEW_BD_UNOP(instr) \ static ir_node * \ new_bd_##instr(dbg_info *db, ir_node *block, \ ir_node *op, ir_mode *mode) \ @@ -92,16 +89,13 @@ new_bd_##instr(dbg_info *db, ir_node *block, \ ir_node *res; \ ir_graph *irg = current_ir_graph; \ res = new_ir_node(db, irg, block, op_##instr, mode, 1, &op); \ - if (float_support && mode_is_float(mode) && \ - (get_irg_fp_model(irg) & fp_exceptions)) \ - res->pinned = 1; \ res = optimize_node(res); \ IRN_VRFY_IRG(res, irg); \ return res; \ } /* creates a bd constructor for an divop */ -#define NEW_BD_DIVOP(instr, float_support) \ +#define NEW_BD_DIVOP(instr) \ static ir_node * \ new_bd_##instr(dbg_info *db, ir_node *block, \ ir_node *memop, ir_node *op1, ir_node *op2) \ @@ -109,14 +103,10 @@ new_bd_##instr(dbg_info *db, ir_node *block, \ ir_node *in[3]; \ ir_node *res; \ ir_graph *irg = current_ir_graph; \ - ir_mode *mode = get_irn_mode(op1); \ in[0] = memop; \ in[1] = op1; \ in[2] = op2; \ res = new_ir_node(db, irg, block, op_##instr, mode_T, 3, in); \ - if (float_support && mode_is_float(mode) && \ - (get_irg_fp_model(irg) & fp_exceptions)) \ - res->pinned = 1; \ res = optimize_node(res); \ IRN_VRFY_IRG(res, irg); \ return res; \ @@ -356,8 +346,6 @@ new_bd_Conv(dbg_info *db, ir_node *block, ir_node *op, ir_mode *mode, int strict res = new_ir_node(db, irg, block, op_Conv, mode, 1, &op); res->attr.conv.strict = strict_flag; - if (mode_is_float(mode) && get_irg_fp_model(irg) & fp_exceptions) - res->pinned = 1; res = optimize_node(res); IRN_VRFY_IRG(res, irg); return res; @@ -390,28 +378,25 @@ new_bd_Tuple(dbg_info *db, ir_node *block, int arity, ir_node **in) return res; } /* new_bd_Tuple */ -#define supports_float 1 -#define only_integer 0 - -NEW_BD_BINOP(Add, supports_float) -NEW_BD_BINOP(Sub, supports_float) -NEW_BD_UNOP(Minus, supports_float) -NEW_BD_BINOP(Mul, supports_float) -NEW_BD_DIVOP(Quot, supports_float) -NEW_BD_DIVOP(DivMod, only_integer) -NEW_BD_DIVOP(Div, only_integer) -NEW_BD_DIVOP(Mod, only_integer) -NEW_BD_BINOP(And, only_integer) -NEW_BD_BINOP(Or, only_integer) -NEW_BD_BINOP(Eor, only_integer) -NEW_BD_UNOP(Not, only_integer) -NEW_BD_BINOP(Shl, only_integer) -NEW_BD_BINOP(Shr, only_integer) -NEW_BD_BINOP(Shrs, only_integer) -NEW_BD_BINOP(Rot, only_integer) -NEW_BD_UNOP(Abs, supports_float) -NEW_BD_BINOP(Carry, only_integer) -NEW_BD_BINOP(Borrow, only_integer) +NEW_BD_BINOP(Add) +NEW_BD_BINOP(Sub) +NEW_BD_UNOP(Minus) +NEW_BD_BINOP(Mul) +NEW_BD_DIVOP(Quot) +NEW_BD_DIVOP(DivMod) +NEW_BD_DIVOP(Div) +NEW_BD_DIVOP(Mod) +NEW_BD_BINOP(And) +NEW_BD_BINOP(Or) +NEW_BD_BINOP(Eor) +NEW_BD_UNOP(Not) +NEW_BD_BINOP(Shl) +NEW_BD_BINOP(Shr) +NEW_BD_BINOP(Shrs) +NEW_BD_BINOP(Rot) +NEW_BD_UNOP(Abs) +NEW_BD_BINOP(Carry) +NEW_BD_BINOP(Borrow) static ir_node * new_bd_Cmp(dbg_info *db, ir_node *block, ir_node *op1, ir_node *op2) @@ -419,12 +404,9 @@ new_bd_Cmp(dbg_info *db, ir_node *block, ir_node *op1, ir_node *op2) ir_node *in[2]; ir_node *res; ir_graph *irg = current_ir_graph; - ir_mode *mode = get_irn_mode(op1); in[0] = op1; in[1] = op2; res = new_ir_node(db, irg, block, op_Cmp, mode_T, 2, in); - if (mode_is_float(mode) && get_irg_fp_model(irg) & fp_exceptions) - res->pinned = 1; res = optimize_node(res); IRN_VRFY_IRG(res, irg); return res; @@ -491,14 +473,15 @@ new_bd_Call(dbg_info *db, ir_node *block, ir_node *store, assert((get_unknown_type() == tp) || is_Method_type(tp)); set_Call_type(res, tp); - res->attr.call.callee_arr = NULL; + res->attr.call.exc.pin_state = op_pin_state_pinned; + res->attr.call.callee_arr = NULL; res = optimize_node(res); IRN_VRFY_IRG(res, irg); return res; } /* new_bd_Call */ static ir_node * -new_bd_Return (dbg_info *db, ir_node *block, +new_bd_Return(dbg_info *db, ir_node *block, ir_node *store, int arity, ir_node **in) { ir_node **r_in; @@ -527,8 +510,9 @@ new_bd_Load(dbg_info *db, ir_node *block, in[0] = store; in[1] = adr; res = new_ir_node(db, irg, block, op_Load, mode_T, 2, in); - res->attr.load.load_mode = mode; - res->attr.load.volatility = volatility_non_volatile; + res->attr.load.exc.pin_state = op_pin_state_pinned; + res->attr.load.load_mode = mode; + res->attr.load.volatility = volatility_non_volatile; res = optimize_node(res); IRN_VRFY_IRG(res, irg); return res; @@ -546,7 +530,8 @@ new_bd_Store(dbg_info *db, ir_node *block, in[1] = adr; in[2] = val; res = new_ir_node(db, irg, block, op_Store, mode_T, 3, in); - res->attr.store.volatility = volatility_non_volatile; + res->attr.store.exc.pin_state = op_pin_state_pinned; + res->attr.store.volatility = volatility_non_volatile; res = optimize_node(res); IRN_VRFY_IRG(res, irg); return res; @@ -563,8 +548,9 @@ new_bd_Alloc(dbg_info *db, ir_node *block, ir_node *store, in[0] = store; in[1] = size; res = new_ir_node(db, irg, block, op_Alloc, mode_T, 2, in); - res->attr.alloc.where = where; - res->attr.alloc.type = alloc_type; + res->attr.alloc.exc.pin_state = op_pin_state_pinned; + res->attr.alloc.where = where; + res->attr.alloc.type = alloc_type; res = optimize_node(res); IRN_VRFY_IRG(res, irg); return res; @@ -638,16 +624,6 @@ new_bd_SymConst_type(dbg_info *db, ir_node *block, symconst_symbol value, return res; } /* new_bd_SymConst_type */ -static ir_node * -new_bd_SymConst(dbg_info *db, ir_node *block, symconst_symbol value, - symconst_kind symkind) -{ - ir_graph *irg = current_ir_graph; - - ir_node *res = new_rd_SymConst_type(db, irg, block, value, symkind, firm_unknown_type); - return res; -} /* new_bd_SymConst */ - static ir_node * new_bd_Sync(dbg_info *db, ir_node *block) { @@ -661,7 +637,7 @@ new_bd_Sync(dbg_info *db, ir_node *block) } /* new_bd_Sync */ static ir_node * -new_bd_Confirm(dbg_info *db, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp) +new_bd_Confirm (dbg_info *db, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp) { ir_node *in[2], *res; ir_graph *irg = current_ir_graph; @@ -818,7 +794,9 @@ new_bd_CopyB(dbg_info *db, ir_node *block, in[2] = src; res = new_ir_node(db, irg, block, op_CopyB, mode_T, 3, in); - res->attr.copyb.data_type = data_type; + + res->attr.copyb.exc.pin_state = op_pin_state_pinned; + res->attr.copyb.data_type = data_type; res = optimize_node(res); IRN_VRFY_IRG(res, irg); return res; @@ -869,6 +847,7 @@ new_bd_Bound(dbg_info *db, ir_node *block, in[2] = lower; in[3] = upper; res = new_ir_node(db, irg, block, op_Bound, mode_T, 4, in); + res->attr.bound.exc.pin_state = op_pin_state_pinned; res = optimize_node(res); IRN_VRFY_IRG(res, irg); return res; @@ -1268,27 +1247,39 @@ new_rd_SymConst(dbg_info *db, ir_graph *irg, ir_node *block, symconst_symbol val ir_node *new_rd_SymConst_addr_ent(dbg_info *db, ir_graph *irg, entity *symbol, ir_type *tp) { - symconst_symbol sym = {(ir_type *)symbol}; + symconst_symbol sym; + sym.entity_p = symbol; return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_addr_ent, tp); } /* new_rd_SymConst_addr_ent */ +ir_node *new_rd_SymConst_ofs_ent(dbg_info *db, ir_graph *irg, entity *symbol, ir_type *tp) +{ + symconst_symbol sym; + sym.entity_p = symbol; + return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_ofs_ent, tp); +} /* new_rd_SymConst_ofs_ent */ + ir_node *new_rd_SymConst_addr_name(dbg_info *db, ir_graph *irg, ident *symbol, ir_type *tp) { - symconst_symbol sym = {(ir_type *)symbol}; + symconst_symbol sym; + sym.ident_p = symbol; return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_addr_name, tp); } /* new_rd_SymConst_addr_name */ ir_node *new_rd_SymConst_type_tag(dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) { - symconst_symbol sym = {symbol}; + symconst_symbol sym; + sym.type_p = symbol; return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_type_tag, tp); } /* new_rd_SymConst_type_tag */ ir_node *new_rd_SymConst_size(dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) { - symconst_symbol sym = {symbol}; + symconst_symbol sym; + sym.type_p = symbol; return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_type_size, tp); } /* new_rd_SymConst_size */ ir_node *new_rd_SymConst_align(dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) { - symconst_symbol sym = {symbol}; + symconst_symbol sym; + sym.type_p = symbol; return new_rd_SymConst_type(db, irg, get_irg_start_block(irg), sym, symconst_type_align, tp); } /* new_rd_SymConst_align */ @@ -1826,9 +1817,9 @@ new_d_Block(dbg_info *db, int arity, ir_node **in) \|/ / |/_ \ get_r_value_internal | | | - | | - \|/ \|/ - new_rd_Phi0 new_rd_Phi_in + | | + \|/ \|/ + new_rd_Phi0 new_rd_Phi_in * *************************************************************************** */ @@ -2612,10 +2603,10 @@ mature_immBlock(ir_node *block) /* Traverse a chain of Phi nodes attached to this block and mature these, too. **/ - for (n = block->link; n; n=next) { + for (n = block->link; n; n = next) { inc_irg_visited(current_ir_graph); next = n->link; - exchange (n, phi_merge (block, n->attr.phi0_pos, n->mode, nin, ins)); + exchange(n, phi_merge (block, n->attr.phi0_pos, n->mode, nin, ins)); } block->attr.block.matured = 1; @@ -2669,14 +2660,14 @@ new_d_defaultProj(dbg_info *db, ir_node *arg, long max_proj) { assert(arg->op == op_Cond); arg->attr.cond.kind = fragmentary; arg->attr.cond.default_proj = max_proj; - res = new_Proj (arg, mode_X, max_proj); + res = new_Proj(arg, mode_X, max_proj); return res; } /* new_d_defaultProj */ ir_node * -new_d_Conv (dbg_info *db, ir_node *op, ir_mode *mode) { +new_d_Conv(dbg_info *db, ir_node *op, ir_mode *mode) { return new_bd_Conv(db, current_ir_graph->current_block, op, mode, 0); -} +} /* new_d_Conv */ ir_node * new_d_strictConv(dbg_info *db, ir_node *op, ir_mode *mode) { @@ -2714,7 +2705,8 @@ static void allocate_frag_arr(ir_node *res, ir_op *op, ir_node ***frag_store) { ir_node * new_d_Quot(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2) { ir_node *res; - res = new_bd_Quot (db, current_ir_graph->current_block, memop, op1, op2); + res = new_bd_Quot(db, current_ir_graph->current_block, memop, op1, op2); + res->attr.except.pin_state = op_pin_state_pinned; #if PRECISE_EXC_CONTEXT allocate_frag_arr(res, op_Quot, &res->attr.except.frag_arr); /* Could be optimized away. */ #endif @@ -2725,7 +2717,8 @@ new_d_Quot(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2) { ir_node * new_d_DivMod(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2) { ir_node *res; - res = new_bd_DivMod (db, current_ir_graph->current_block, memop, op1, op2); + res = new_bd_DivMod(db, current_ir_graph->current_block, memop, op1, op2); + res->attr.except.pin_state = op_pin_state_pinned; #if PRECISE_EXC_CONTEXT allocate_frag_arr(res, op_DivMod, &res->attr.except.frag_arr); /* Could be optimized away. */ #endif @@ -2734,10 +2727,11 @@ new_d_DivMod(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2) { } /* new_d_DivMod */ ir_node * -new_d_Div (dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2) +new_d_Div(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2) { ir_node *res; - res = new_bd_Div (db, current_ir_graph->current_block, memop, op1, op2); + res = new_bd_Div(db, current_ir_graph->current_block, memop, op1, op2); + res->attr.except.pin_state = op_pin_state_pinned; #if PRECISE_EXC_CONTEXT allocate_frag_arr(res, op_Div, &res->attr.except.frag_arr); /* Could be optimized away. */ #endif @@ -2748,7 +2742,8 @@ new_d_Div (dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2) ir_node * new_d_Mod(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2) { ir_node *res; - res = new_bd_Mod (db, current_ir_graph->current_block, memop, op1, op2); + res = new_bd_Mod(db, current_ir_graph->current_block, memop, op1, op2); + res->attr.except.pin_state = op_pin_state_pinned; #if PRECISE_EXC_CONTEXT allocate_frag_arr(res, op_Mod, &res->attr.except.frag_arr); /* Could be optimized away. */ #endif @@ -2880,8 +2875,8 @@ new_d_SymConst_type(dbg_info *db, symconst_symbol value, symconst_kind kind, ir_ ir_node * new_d_SymConst(dbg_info *db, symconst_symbol value, symconst_kind kind) { - return new_bd_SymConst(db, get_irg_start_block(current_ir_graph), - value, kind); + return new_bd_SymConst_type(db, get_irg_start_block(current_ir_graph), + value, kind, firm_unknown_type); } /* new_d_SymConst */ ir_node * @@ -3053,10 +3048,11 @@ set_cur_block(ir_node *target) { /* get a value from the parameter array from the current block by its index */ ir_node * get_d_value(dbg_info *db, int pos, ir_mode *mode) { - assert(get_irg_phase_state (current_ir_graph) == phase_building); - inc_irg_visited(current_ir_graph); + ir_graph *irg = current_ir_graph; + assert(get_irg_phase_state(irg) == phase_building); + inc_irg_visited(irg); - return get_r_value_internal (current_ir_graph->current_block, pos + 1, mode); + return get_r_value_internal(irg->current_block, pos + 1, mode); } /* get_d_value */ /* get a value from the parameter array from the current block by its index */ @@ -3068,17 +3064,19 @@ get_value(int pos, ir_mode *mode) { /* set a value at position pos in the parameter array from the current block */ void set_value(int pos, ir_node *value) { - assert(get_irg_phase_state (current_ir_graph) == phase_building); - assert(pos+1 < current_ir_graph->n_loc); - current_ir_graph->current_block->attr.block.graph_arr[pos + 1] = value; + ir_graph *irg = current_ir_graph; + assert(get_irg_phase_state(irg) == phase_building); + assert(pos+1 < irg->n_loc); + irg->current_block->attr.block.graph_arr[pos + 1] = value; } /* set_value */ +/* Find the value number for a node in the current block.*/ int find_value(ir_node *value) { int i; ir_node *bl = current_ir_graph->current_block; - for (i = 1; i < ARR_LEN(bl->attr.block.graph_arr); ++i) + for (i = ARR_LEN(bl->attr.block.graph_arr) - 1; i >= 1; --i) if (bl->attr.block.graph_arr[i] == value) return i - 1; return -1; @@ -3086,12 +3084,13 @@ find_value(ir_node *value) { /* get the current store */ ir_node * -get_store(void) -{ - assert(get_irg_phase_state (current_ir_graph) == phase_building); +get_store(void) { + ir_graph *irg = current_ir_graph; + + assert(get_irg_phase_state(irg) == phase_building); /* GL: one could call get_value instead */ - inc_irg_visited(current_ir_graph); - return get_r_value_internal (current_ir_graph->current_block, 0, mode_M); + inc_irg_visited(irg); + return get_r_value_internal(irg->current_block, 0, mode_M); } /* get_store */ /* set the current store: handles automatic Sync construction for Load nodes */ @@ -3100,7 +3099,8 @@ set_store(ir_node *store) { ir_node *load, *pload, *pred, *in[2]; - assert(get_irg_phase_state (current_ir_graph) == phase_building); + assert(get_irg_phase_state(current_ir_graph) == phase_building); + assert(get_irn_mode(store) == mode_M && "storing non-memory node"); if (get_opt_auto_create_sync()) { /* handle non-volatile Load nodes by automatically creating Sync's */ @@ -3203,6 +3203,9 @@ ir_node *new_Const_type(tarval *con, ir_type *tp) { return new_d_Const_type(NULL, get_type_mode(tp), con, tp); } +ir_node *new_SymConst_type (symconst_symbol value, symconst_kind kind, ir_type *type) { + return new_d_SymConst_type(NULL, value, kind, type); +} ir_node *new_SymConst (symconst_symbol value, symconst_kind kind) { return new_d_SymConst(NULL, value, kind); }