X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Fircons.c;h=59f389d15e342834d729f0bbfb996f8d0eba7326;hb=fc7e44183102c47e31152fc136a35034c1820873;hp=adf17398bdf4923c64361bdbd4ef4e05062dd8d9;hpb=30b120caf1fbc6fcb13c6b3bef8f7132ebff72aa;p=libfirm diff --git a/ir/ir/ircons.c b/ir/ir/ircons.c index adf17398b..59f389d15 100644 --- a/ir/ir/ircons.c +++ b/ir/ir/ircons.c @@ -155,9 +155,6 @@ new_rd_Const (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval { type *tp = unknown_type; /* removing this somehow causes errors in jack. */ - if (tarval_is_entity(con)) - tp = find_pointer_type_to_type(get_entity_type(get_tarval_entity(con))); - return new_rd_Const_type (db, irg, block, mode, con, tp); } @@ -183,7 +180,7 @@ new_rd_Proj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode assert(res); assert(get_Proj_pred(res)); - assert(get_nodes_Block(get_Proj_pred(res))); + assert(get_nodes_block(get_Proj_pred(res))); res = optimize_node(res); @@ -220,6 +217,8 @@ new_rd_Cast (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, type *to_ { ir_node *res; + assert(is_atomic_type(to_tp)); + res = new_ir_node(db, irg, block, op_Cast, get_irn_mode(op), 1, &op); res->attr.cast.totype = to_tp; res = optimize_node(res); @@ -543,9 +542,10 @@ new_rd_Call (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, res = new_ir_node(db, irg, block, op_Call, mode_T, r_arity, r_in); - assert(is_method_type(tp)); + 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; @@ -585,7 +585,7 @@ new_rd_Raise (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, ir_no INLINE ir_node * new_rd_Load (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *store, ir_node *adr) + ir_node *store, ir_node *adr, ir_mode *mode) { ir_node *in[2]; ir_node *res; @@ -593,6 +593,9 @@ new_rd_Load (dbg_info* db, ir_graph *irg, 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.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; @@ -609,6 +612,8 @@ new_rd_Store (dbg_info* db, ir_graph *irg, 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.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; @@ -624,8 +629,9 @@ new_rd_Alloc (dbg_info* db, ir_graph *irg, 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.a.where = where; - res->attr.a.type = alloc_type; + res->attr.a.exc.pin_state = op_pin_state_pinned; + res->attr.a.where = where; + res->attr.a.type = alloc_type; res = optimize_node(res); IRN_VRFY_IRG(res, irg); return res; @@ -693,8 +699,7 @@ new_rd_InstOf (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, INLINE 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; @@ -702,6 +707,7 @@ new_rd_SymConst_type (dbg_info* db, ir_graph *irg, ir_node *block, symconst_symb mode = mode_P_mach; else mode = mode_Iu; + res = new_ir_node(db, irg, block, op_SymConst, mode, 0, NULL); res->attr.i.num = symkind; @@ -839,7 +845,7 @@ new_rd_Filter (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mod assert(res); assert(get_Proj_pred(res)); - assert(get_nodes_Block(get_Proj_pred(res))); + assert(get_nodes_block(get_Proj_pred(res))); res = optimize_node(res); IRN_VRFY_IRG(res, irg); @@ -847,27 +853,10 @@ new_rd_Filter (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mod } -ir_node * -new_rd_FuncCall (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *callee, int arity, ir_node **in, type *tp) +INLINE ir_node * +new_rd_NoMem (ir_graph *irg) { - ir_node **r_in; - ir_node *res; - int r_arity; - - r_arity = arity+1; - NEW_ARR_A(ir_node *, r_in, r_arity); - r_in[0] = callee; - memcpy(&r_in[1], in, sizeof (ir_node *) * arity); - - res = new_ir_node(db, irg, block, op_FuncCall, mode_T, r_arity, r_in); - - assert(is_method_type(tp)); - set_FuncCall_type(res, tp); - res->attr.call.callee_arr = NULL; - res = optimize_node(res); - IRN_VRFY_IRG(res, irg); - return res; + return irg->no_mem; } @@ -1000,8 +989,8 @@ INLINE ir_node *new_r_Phi (ir_graph *irg, ir_node *block, int arity, return new_rd_Phi(NULL, irg, block, arity, in, mode); } INLINE ir_node *new_r_Load (ir_graph *irg, ir_node *block, - ir_node *store, ir_node *adr) { - return new_rd_Load(NULL, irg, block, store, adr); + ir_node *store, ir_node *adr, ir_mode *mode) { + return new_rd_Load(NULL, irg, block, store, adr, mode); } INLINE ir_node *new_r_Store (ir_graph *irg, ir_node *block, ir_node *store, ir_node *adr, ir_node *val) { @@ -1059,10 +1048,8 @@ INLINE ir_node *new_r_Filter (ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode, long proj) { return new_rd_Filter(NULL, irg, block, arg, mode, proj); } -INLINE ir_node *new_r_FuncCall (ir_graph *irg, ir_node *block, - ir_node *callee, int arity, ir_node **in, - type *tp) { - return new_rd_FuncCall(NULL, irg, block, callee, arity, in, tp); +INLINE ir_node *new_r_NoMem (ir_graph *irg) { + return new_rd_NoMem(irg); } @@ -1147,7 +1134,7 @@ new_d_Block (dbg_info* db, int arity, ir_node **in) Call Graph: ( A ---> B == A "calls" B) - get_value mature_block + get_value mature_immBlock | | | | | | @@ -1369,7 +1356,7 @@ phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins) The call order get_value (makes Phi0, put's it into graph_arr) set_value (overwrites Phi0 in graph_arr) - mature_block (upgrades Phi0, puts it again into graph_arr, overwriting + mature_immBlock (upgrades Phi0, puts it again into graph_arr, overwriting the proper value.) fails. */ if (!block->attr.block.graph_arr[pos]) { @@ -1460,7 +1447,7 @@ get_r_value_internal (ir_node *block, int pos, ir_mode *mode) /* The block is not mature, we don't know how many in's are needed. A Phi with zero predecessors is created. Such a Phi node is called Phi0 node. (There is also an obsolete Phi0 opcode.) The Phi0 is then added - to the list of Phi0 nodes in this block to be matured by mature_block + to the list of Phi0 nodes in this block to be matured by mature_immBlock later. The Phi0 has to remember the pos of it's internal value. If the real Phi is computed, pos is used to update the array with the local @@ -1606,14 +1593,22 @@ static INLINE ir_node ** new_frag_arr (ir_node *n) return arr; } +/** + * returns the frag_arr from a node + */ static INLINE ir_node ** get_frag_arr (ir_node *n) { - if (get_irn_op(n) == op_Call) { - return n->attr.call.frag_arr; - } else if (get_irn_op(n) == op_Alloc) { - return n->attr.a.frag_arr; - } else { - return n->attr.frag_arr; + switch (get_irn_opcode(n)) { + case iro_Call: + return n->attr.call.exc.frag_arr; + case iro_Alloc: + return n->attr.a.exc.frag_arr; + case iro_Load: + return n->attr.load.exc.frag_arr; + case iro_Store: + return n->attr.store.exc.frag_arr; + default: + return n->attr.except.frag_arr; } } @@ -1764,7 +1759,7 @@ phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins) optimization possibilities. The Phi0 node either is allocated in this function, or it comes from a former call to get_r_value_internal. In this case we may not yet - exchange phi0, as this is done in mature_block. */ + exchange phi0, as this is done in mature_immBlock. */ if (!phi0) { phi0_all = block->attr.block.graph_arr[pos]; if (!((get_irn_op(phi0_all) == op_Phi) && @@ -1861,7 +1856,7 @@ get_r_value_internal (ir_node *block, int pos, ir_mode *mode) /* The block is not mature, we don't know how many in's are needed. A Phi with zero predecessors is created. Such a Phi node is called Phi0 node. The Phi0 is then added to the list of Phi0 nodes in this block - to be matured by mature_block later. + to be matured by mature_immBlock later. The Phi0 has to remember the pos of it's internal value. If the real Phi is computed, pos is used to update the array with the local values. */ @@ -1893,7 +1888,7 @@ get_r_value_internal (ir_node *block, int pos, ir_mode *mode) /** Finalize a Block node, when all control flows are known. */ /** Acceptable parameters are only Block nodes. */ void -mature_block (ir_node *block) +mature_immBlock (ir_node *block) { int ins; @@ -2050,8 +2045,9 @@ new_d_Quot (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2) ir_node *res; res = new_rd_Quot (db, current_ir_graph, 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.frag_arr); /* Could be optimized away. */ + allocate_frag_arr(res, op_Quot, &res->attr.except.frag_arr); /* Could be optimized away. */ #endif return res; @@ -2063,8 +2059,9 @@ new_d_DivMod (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2) ir_node *res; res = new_rd_DivMod (db, current_ir_graph, 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.frag_arr); /* Could be optimized away. */ + allocate_frag_arr(res, op_DivMod, &res->attr.except.frag_arr); /* Could be optimized away. */ #endif return res; @@ -2076,8 +2073,9 @@ new_d_Div (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2) ir_node *res; res = new_rd_Div (db, current_ir_graph, 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.frag_arr); /* Could be optimized away. */ + allocate_frag_arr(res, op_Div, &res->attr.except.frag_arr); /* Could be optimized away. */ #endif return res; @@ -2089,8 +2087,9 @@ new_d_Mod (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2) ir_node *res; res = new_rd_Mod (db, current_ir_graph, 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.frag_arr); /* Could be optimized away. */ + allocate_frag_arr(res, op_Mod, &res->attr.except.frag_arr); /* Could be optimized away. */ #endif return res; @@ -2186,7 +2185,7 @@ new_d_Call (dbg_info* db, ir_node *store, ir_node *callee, int arity, ir_node ** res = new_rd_Call (db, current_ir_graph, current_ir_graph->current_block, store, callee, arity, in, tp); #if PRECISE_EXC_CONTEXT - allocate_frag_arr(res, op_Call, &res->attr.call.frag_arr); /* Could be optimized away. */ + allocate_frag_arr(res, op_Call, &res->attr.call.exc.frag_arr); /* Could be optimized away. */ #endif return res; @@ -2207,13 +2206,13 @@ new_d_Raise (dbg_info* db, ir_node *store, ir_node *obj) } ir_node * -new_d_Load (dbg_info* db, ir_node *store, ir_node *addr) +new_d_Load (dbg_info* db, ir_node *store, ir_node *addr, ir_mode *mode) { ir_node *res; res = new_rd_Load (db, current_ir_graph, current_ir_graph->current_block, - store, addr); + store, addr, mode); #if PRECISE_EXC_CONTEXT - allocate_frag_arr(res, op_Load, &res->attr.frag_arr); /* Could be optimized away. */ + allocate_frag_arr(res, op_Load, &res->attr.load.exc.frag_arr); /* Could be optimized away. */ #endif return res; @@ -2226,7 +2225,7 @@ new_d_Store (dbg_info* db, ir_node *store, ir_node *addr, ir_node *val) res = new_rd_Store (db, current_ir_graph, current_ir_graph->current_block, store, addr, val); #if PRECISE_EXC_CONTEXT - allocate_frag_arr(res, op_Store, &res->attr.frag_arr); /* Could be optimized away. */ + allocate_frag_arr(res, op_Store, &res->attr.store.exc.frag_arr); /* Could be optimized away. */ #endif return res; @@ -2240,7 +2239,7 @@ new_d_Alloc (dbg_info* db, ir_node *store, ir_node *size, type *alloc_type, res = new_rd_Alloc (db, current_ir_graph, current_ir_graph->current_block, store, size, alloc_type, where); #if PRECISE_EXC_CONTEXT - allocate_frag_arr(res, op_Alloc, &res->attr.a.frag_arr); /* Could be optimized away. */ + allocate_frag_arr(res, op_Alloc, &res->attr.a.exc.frag_arr); /* Could be optimized away. */ #endif return res; @@ -2355,14 +2354,9 @@ new_d_Filter (dbg_info *db, ir_node *arg, ir_mode *mode, long proj) } ir_node * -new_d_FuncCall (dbg_info* db, ir_node *callee, int arity, ir_node **in, - type *tp) +(new_d_NoMem)(void) { - ir_node *res; - res = new_rd_FuncCall (db, current_ir_graph, current_ir_graph->current_block, - callee, arity, in, tp); - - return res; + return __new_d_NoMem(); } /* ********************************************************************* */ @@ -2406,7 +2400,7 @@ new_immBlock (void) { /* add an adge to a jmp/control flow node */ void -add_in_edge (ir_node *block, ir_node *jmp) +add_immBlock_pred (ir_node *block, ir_node *jmp) { if (block->attr.block.matured) { assert(0 && "Error: Block already matured!\n"); @@ -2419,7 +2413,7 @@ add_in_edge (ir_node *block, ir_node *jmp) /* changing the current block */ void -switch_block (ir_node *target) +set_cur_block (ir_node *target) { current_ir_graph->current_block = target; } @@ -2479,7 +2473,7 @@ keep_alive (ir_node *ka) /** Useful access routines **/ /* Returns the current block of the current graph. To set the current - block use switch_block(). */ + block use set_cur_block. */ ir_node *get_cur_block() { return get_irg_current_block(current_ir_graph); } @@ -2531,6 +2525,11 @@ ir_node *new_Raise (ir_node *store, ir_node *obj) { ir_node *new_Const (ir_mode *mode, tarval *con) { return new_d_Const(NULL, mode, con); } + +ir_node *new_Const_type(tarval *con, type *tp) { + return new_d_Const_type(NULL, get_type_mode(tp), con, tp); +} + ir_node *new_SymConst (symconst_symbol value, symconst_kind kind) { return new_d_SymConst(NULL, value, kind); } @@ -2612,8 +2611,8 @@ ir_node *new_Cast (ir_node *op, type *to_tp) { ir_node *new_Phi (int arity, ir_node **in, ir_mode *mode) { return new_d_Phi(NULL, arity, in, mode); } -ir_node *new_Load (ir_node *store, ir_node *addr) { - return new_d_Load(NULL, store, addr); +ir_node *new_Load (ir_node *store, ir_node *addr, ir_mode *mode) { + return new_d_Load(NULL, store, addr, mode); } ir_node *new_Store (ir_node *store, ir_node *addr, ir_node *val) { return new_d_Store(NULL, store, addr, val); @@ -2665,6 +2664,6 @@ ir_node *new_Break (void) { ir_node *new_Filter (ir_node *arg, ir_mode *mode, long proj) { return new_d_Filter(NULL, arg, mode, proj); } -ir_node *new_FuncCall (ir_node *callee, int arity, ir_node **in, type *tp) { - return new_d_FuncCall(NULL, callee, arity, in, tp); +ir_node *new_NoMem (void) { + return new_d_NoMem(); }