X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Flower%2Flower_hl.c;h=292921ca6ef85b7b2c8933304e54be68752a8ae8;hb=4a91add53071efebc35ec6ec328a1264b2ff3084;hp=2cf19a33b435622cb9a24d93a57d443e10c13eda;hpb=9d3c8631459f431c313160dab5778e8a7b88dd92;p=libfirm diff --git a/ir/lower/lower_hl.c b/ir/lower/lower_hl.c index 2cf19a33b..292921ca6 100644 --- a/ir/lower/lower_hl.c +++ b/ir/lower/lower_hl.c @@ -21,7 +21,6 @@ * @file * @brief Lower some High-level constructs, moved from the firmlower. * @author Boris Boesler, Goetz Lindenmaier, Michael Beck - * @version $Id$ */ #include "config.h" @@ -43,201 +42,161 @@ */ static void lower_sel(ir_node *sel) { - ir_graph *irg = current_ir_graph; - ir_entity *ent; - ir_node *newn, *cnst, *index, *ptr, *bl; - ir_tarval *tv; - ir_mode *basemode, *mode, *mode_Int; - ir_type *basetyp, *owner; - dbg_info *dbg; - - assert(is_Sel(sel)); - - /* Do not lower frame type/global offset table access: must be lowered by the backend. */ - ptr = get_Sel_ptr(sel); - if (ptr == get_irg_frame(current_ir_graph)) + ir_graph *irg = get_irn_irg(sel); + ir_entity *ent = get_Sel_entity(sel); + ir_type *owner = get_entity_owner(ent); + dbg_info *dbg = get_irn_dbg_info(sel); + ir_mode *mode = get_irn_mode(sel); + ir_node *bl = get_nodes_block(sel); + ir_node *newn; + + /* we can only replace Sels when the layout of the owner type is decided. */ + if (get_type_state(owner) != layout_fixed) return; - ent = get_Sel_entity(sel); - owner = get_entity_owner(ent); - - /* - * Cannot handle value param entities or frame type entities here. - * Must be lowered by the backend. - */ - if (is_value_param_type(owner) || is_frame_type(owner)) - return; - - dbg = get_irn_dbg_info(sel); - mode = get_irn_mode(sel); - - mode_Int = get_reference_mode_signed_eq(mode); - - /* TLS access, must be handled by the linker */ - if (get_tls_type() == owner) { - symconst_symbol sym; + if (0 < get_Sel_n_indexs(sel)) { + /* an Array access */ + ir_type *basetyp = get_entity_type(ent); + ir_mode *basemode; + ir_node *index; + if (is_Primitive_type(basetyp)) + basemode = get_type_mode(basetyp); + else + basemode = mode_P_data; + + assert(basemode && "no mode for lowering Sel"); + assert((get_mode_size_bits(basemode) % 8 == 0) && "can not deal with unorthodox modes"); + index = get_Sel_index(sel, 0); + + if (is_Array_type(owner)) { + ir_type *arr_ty = owner; + size_t dims = get_array_n_dimensions(arr_ty); + size_t *map = ALLOCAN(size_t, dims); + ir_mode *mode_Int = get_reference_mode_signed_eq(mode); + ir_tarval *tv; + ir_node *last_size; + size_t i; + + assert(dims == (size_t)get_Sel_n_indexs(sel) + && "array dimension must match number of indices of Sel node"); + + for (i = 0; i < dims; i++) { + size_t order = get_array_order(arr_ty, i); + + assert(order < dims && + "order of a dimension must be smaller than the arrays dim"); + map[order] = i; + } + newn = get_Sel_ptr(sel); + + /* Size of the array element */ + tv = new_tarval_from_long(get_type_size_bytes(basetyp), mode_Int); + last_size = new_rd_Const(dbg, irg, tv); + + /* + * We compute the offset part of dimension d_i recursively + * with the the offset part of dimension d_{i-1} + * + * off_0 = sizeof(array_element_type); + * off_i = (u_i - l_i) * off_{i-1} ; i >= 1 + * + * whereas u_i is the upper bound of the current dimension + * and l_i the lower bound of the current dimension. + */ + for (i = dims; i > 0;) { + size_t dim = map[--i]; + ir_node *lb, *ub, *elms, *n, *ind; + + elms = NULL; + lb = get_array_lower_bound(arr_ty, dim); + ub = get_array_upper_bound(arr_ty, dim); + + assert(irg == current_ir_graph); + if (! is_Unknown(lb)) + lb = new_rd_Conv(dbg, bl, copy_const_value(get_irn_dbg_info(sel), lb, bl), mode_Int); + else + lb = NULL; + + if (! is_Unknown(ub)) + ub = new_rd_Conv(dbg, bl, copy_const_value(get_irn_dbg_info(sel), ub, bl), mode_Int); + else + ub = NULL; - sym.entity_p = ent; - bl = get_nodes_block(sel); + /* + * If the array has more than one dimension, lower and upper + * bounds have to be set in the non-last dimension. + */ + if (i > 0) { + assert(lb != NULL && "lower bound has to be set in multi-dim array"); + assert(ub != NULL && "upper bound has to be set in multi-dim array"); - cnst = new_rd_SymConst(dbg, irg, mode, sym, symconst_addr_ent); - newn = new_rd_Add(dbg, bl, ptr, cnst, mode); - } else { - /* not TLS */ + /* Elements in one Dimension */ + elms = new_rd_Sub(dbg, bl, ub, lb, mode_Int); + } - assert(get_type_state(get_entity_owner(ent)) == layout_fixed); - assert(get_type_state(get_entity_type(ent)) == layout_fixed); + ind = new_rd_Conv(dbg, bl, get_Sel_index(sel, dim), mode_Int); - bl = get_nodes_block(sel); - if (0 < get_Sel_n_indexs(sel)) { - /* an Array access */ - basetyp = get_entity_type(ent); - if (is_Primitive_type(basetyp)) - basemode = get_type_mode(basetyp); - else - basemode = mode_P_data; - - assert(basemode && "no mode for lowering Sel"); - assert((get_mode_size_bits(basemode) % 8 == 0) && "can not deal with unorthodox modes"); - index = get_Sel_index(sel, 0); - - if (is_Array_type(owner)) { - ir_type *arr_ty = owner; - int dims = get_array_n_dimensions(arr_ty); - int *map = ALLOCAN(int, dims); - ir_node *last_size; - int i; - - assert(dims == get_Sel_n_indexs(sel) - && "array dimension must match number of indices of Sel node"); - - for (i = 0; i < dims; i++) { - int order = get_array_order(arr_ty, i); - - assert(order < dims && - "order of a dimension must be smaller than the arrays dim"); - map[order] = i; - } - newn = get_Sel_ptr(sel); + /* + * Normalize index, id lower bound is set, also assume + * lower bound == 0 + */ + if (lb != NULL) + ind = new_rd_Sub(dbg, bl, ind, lb, mode_Int); - /* Size of the array element */ - tv = new_tarval_from_long(get_type_size_bytes(basetyp), mode_Int); - last_size = new_rd_Const(dbg, irg, tv); + n = new_rd_Mul(dbg, bl, ind, last_size, mode_Int); /* - * We compute the offset part of dimension d_i recursively - * with the the offset part of dimension d_{i-1} - * - * off_0 = sizeof(array_element_type); - * off_i = (u_i - l_i) * off_{i-1} ; i >= 1 - * - * whereas u_i is the upper bound of the current dimension - * and l_i the lower bound of the current dimension. + * see comment above. */ - for (i = dims - 1; i >= 0; i--) { - int dim = map[i]; - ir_node *lb, *ub, *elms, *n, *ind; - - elms = NULL; - lb = get_array_lower_bound(arr_ty, dim); - ub = get_array_upper_bound(arr_ty, dim); - - assert(irg == current_ir_graph); - if (! is_Unknown(lb)) - lb = new_rd_Conv(dbg, bl, copy_const_value(get_irn_dbg_info(sel), lb, bl), mode_Int); - else - lb = NULL; - - if (! is_Unknown(ub)) - ub = new_rd_Conv(dbg, bl, copy_const_value(get_irn_dbg_info(sel), ub, bl), mode_Int); - else - ub = NULL; - - /* - * If the array has more than one dimension, lower and upper - * bounds have to be set in the non-last dimension. - */ - if (i > 0) { - assert(lb != NULL && "lower bound has to be set in multi-dim array"); - assert(ub != NULL && "upper bound has to be set in multi-dim array"); - - /* Elements in one Dimension */ - elms = new_rd_Sub(dbg, bl, ub, lb, mode_Int); - } - - ind = new_rd_Conv(dbg, bl, get_Sel_index(sel, dim), mode_Int); - - /* - * Normalize index, id lower bound is set, also assume - * lower bound == 0 - */ - if (lb != NULL) - ind = new_rd_Sub(dbg, bl, ind, lb, mode_Int); - - n = new_rd_Mul(dbg, bl, ind, last_size, mode_Int); - - /* - * see comment above. - */ - if (i > 0) - last_size = new_rd_Mul(dbg, bl, last_size, elms, mode_Int); - - newn = new_rd_Add(dbg, bl, newn, n, mode); - } - } else { - /* no array type */ - ir_mode *idx_mode = get_irn_mode(index); - ir_tarval *tv = new_tarval_from_long(get_mode_size_bytes(basemode), idx_mode); - - newn = new_rd_Add(dbg, bl, get_Sel_ptr(sel), - new_rd_Mul(dbg, bl, index, - new_r_Const(irg, tv), - idx_mode), - mode); - } - } else if (is_Method_type(get_entity_type(ent)) && - is_Class_type(owner) && - (owner != get_glob_type()) && - (!is_frame_type(owner))) { - ir_node *add; - ir_mode *ent_mode = get_type_mode(get_entity_type(ent)); - - /* We need an additional load when accessing methods from a dispatch table. */ - tv = new_tarval_from_long(get_entity_offset(ent), mode_Int); - cnst = new_rd_Const(dbg, irg, tv); - add = new_rd_Add(dbg, bl, get_Sel_ptr(sel), cnst, mode); -#ifdef DO_CACHEOPT /* cacheopt version */ - newn = new_rd_Load(dbg, bl, get_Sel_mem(sel), sel, ent_mode, 0); - cacheopt_map_addrs_register_node(newn); - set_Load_ptr(newn, add); -#else /* normal code */ - newn = new_rd_Load(dbg, bl, get_Sel_mem(sel), add, ent_mode, 0); -#endif - newn = new_r_Proj(newn, ent_mode, pn_Load_res); - - } else if (get_entity_owner(ent) != get_glob_type()) { - int offset; - - /* replace Sel by add(obj, const(ent.offset)) */ - newn = get_Sel_ptr(sel); - offset = get_entity_offset(ent); - if (offset != 0) { - ir_mode *mode_UInt = get_reference_mode_unsigned_eq(mode); - - tv = new_tarval_from_long(offset, mode_UInt); - cnst = new_r_Const(irg, tv); - newn = new_rd_Add(dbg, bl, newn, cnst, mode); + if (i > 0) + last_size = new_rd_Mul(dbg, bl, last_size, elms, mode_Int); + + newn = new_rd_Add(dbg, bl, newn, n, mode); } } else { - /* global_type */ - newn = new_rd_SymConst_addr_ent(NULL, irg, mode, ent); + /* no array type */ + ir_mode *idx_mode = get_irn_mode(index); + ir_tarval *tv = new_tarval_from_long(get_mode_size_bytes(basemode), idx_mode); + + newn = new_rd_Add(dbg, bl, get_Sel_ptr(sel), + new_rd_Mul(dbg, bl, index, + new_r_Const(irg, tv), + idx_mode), + mode); + } + } else if (is_Method_type(get_entity_type(ent)) && is_Class_type(owner)) { + /* We need an additional load when accessing methods from a dispatch + * table. + * Matze TODO: Is this really still used? At least liboo does its own + * lowering of Method-Sels... + */ + ir_mode *ent_mode = get_type_mode(get_entity_type(ent)); + int offset = get_entity_offset(ent); + ir_mode *mode_Int = get_reference_mode_signed_eq(mode); + ir_tarval *tv = new_tarval_from_long(offset, mode_Int); + ir_node *cnst = new_rd_Const(dbg, irg, tv); + ir_node *add = new_rd_Add(dbg, bl, get_Sel_ptr(sel), cnst, mode); + ir_node *mem = get_Sel_mem(sel); + newn = new_rd_Load(dbg, bl, mem, add, ent_mode, cons_none); + newn = new_r_Proj(newn, ent_mode, pn_Load_res); + } else { + int offset = get_entity_offset(ent); + + /* replace Sel by add(obj, const(ent.offset)) */ + newn = get_Sel_ptr(sel); + if (offset != 0) { + ir_mode *mode_UInt = get_reference_mode_unsigned_eq(mode); + ir_tarval *tv = new_tarval_from_long(offset, mode_UInt); + ir_node *cnst = new_r_Const(irg, tv); + newn = new_rd_Add(dbg, bl, newn, cnst, mode); } } + /* run the hooks */ hook_lower(sel); exchange(sel, newn); -} /* lower_sel */ +} /** * Lower a all possible SymConst nodes. @@ -253,9 +212,6 @@ static void lower_symconst(ir_node *symc) ir_graph *irg; switch (get_SymConst_kind(symc)) { - case symconst_type_tag: - assert(!"SymConst kind symconst_type_tag not implemented"); - break; case symconst_type_size: /* rewrite the SymConst node by a Const node */ irg = get_irn_irg(symc); @@ -337,7 +293,7 @@ static int is_integral_size(int size) static void lower_bitfields_loads(ir_node *proj, ir_node *load) { ir_node *sel = get_Load_ptr(load); - ir_node *block, *n_proj, *res, *ptr; + ir_node *block, *res, *ptr; ir_graph *irg; ir_entity *ent; ir_type *bf_type; @@ -390,7 +346,7 @@ static void lower_bitfields_loads(ir_node *proj, ir_node *load) /* create new proj, switch off CSE or we may get the old one back */ old_cse = get_opt_cse(); set_opt_cse(0); - res = n_proj = new_r_Proj(load, mode, pn_Load_res); + res = new_r_Proj(load, mode, pn_Load_res); set_opt_cse(old_cse); if (mode_is_signed(mode)) { /* signed */ @@ -482,7 +438,7 @@ static void lower_bitfields_stores(ir_node *store) if (neg_mask) { /* there are some bits, normal case */ - irn = new_r_Load(block, mem, ptr, mode, 0); + irn = new_r_Load(block, mem, ptr, mode, cons_none); mem = new_r_Proj(irn, mode_M, pn_Load_M); irn = new_r_Proj(irn, mode, pn_Load_res); @@ -502,24 +458,6 @@ static void lower_bitfields_stores(ir_node *store) set_Store_ptr(store, ptr); } /* lower_bitfields_stores */ -/** - * Lowers unaligned Loads. - */ -static void lower_unaligned_Load(ir_node *load) -{ - (void) load; - /* NYI */ -} - -/** - * Lowers unaligned Stores - */ -static void lower_unaligned_Store(ir_node *store) -{ - (void) store; - /* NYI */ -} - /** * lowers IR-nodes, called from walker */ @@ -533,14 +471,6 @@ static void lower_irnode(ir_node *irn, void *env) case iro_SymConst: lower_symconst(irn); break; - case iro_Load: - if (env != NULL && get_Load_align(irn) == align_non_aligned) - lower_unaligned_Load(irn); - break; - case iro_Store: - if (env != NULL && get_Store_align(irn) == align_non_aligned) - lower_unaligned_Store(irn); - break; case iro_Cast: exchange(irn, get_Cast_op(irn)); break; @@ -579,9 +509,9 @@ static void lower_bf_access(ir_node *irn, void *env) * Replace Sel nodes by address computation. Also resolves array access. * Handle Bitfields by added And/Or calculations. */ -void lower_highlevel_graph(ir_graph *irg, int lower_bitfields) +void lower_highlevel_graph(ir_graph *irg) { - if (lower_bitfields) { + if (is_irg_state(irg, IR_GRAPH_STATE_IMPLICIT_BITFIELD_MASKING)) { /* First step: lower bitfield access: must be run as long as Sels still * exists. */ irg_walk_graph(irg, NULL, lower_bf_access, NULL); @@ -589,31 +519,27 @@ void lower_highlevel_graph(ir_graph *irg, int lower_bitfields) /* Finally: lower SymConst-Size and Sel nodes, Casts, unaligned Load/Stores. */ irg_walk_graph(irg, NULL, lower_irnode, NULL); - - set_irg_outs_inconsistent(irg); } -struct pass_t { +typedef struct pass_t { ir_graph_pass_t pass; - int lower_bitfields; -}; +} pass_t; /** * Wrapper for running lower_highlevel_graph() as an ir_graph pass. */ static int lower_highlevel_graph_wrapper(ir_graph *irg, void *context) { - struct pass_t *pass = context; + (void)context; - lower_highlevel_graph(irg, pass->lower_bitfields); + lower_highlevel_graph(irg); return 0; } /* lower_highlevel_graph_wrapper */ -ir_graph_pass_t *lower_highlevel_graph_pass(const char *name, int lower_bitfields) +ir_graph_pass_t *lower_highlevel_graph_pass(const char *name) { - struct pass_t *pass = XMALLOCZ(struct pass_t); + pass_t *pass = XMALLOCZ(pass_t); - pass->lower_bitfields = lower_bitfields; return def_graph_pass_constructor( &pass->pass, name ? name : "lower_hl", lower_highlevel_graph_wrapper); } /* lower_highlevel_graph_pass */ @@ -636,14 +562,14 @@ ir_prog_pass_t *lower_const_code_pass(const char *name) * Replace Sel nodes by address computation. Also resolves array access. * Handle Bitfields by added And/Or calculations. */ -void lower_highlevel(int lower_bitfields) +void lower_highlevel() { - int i, n; + size_t i, n; n = get_irp_n_irgs(); for (i = 0; i < n; ++i) { ir_graph *irg = get_irp_irg(i); - lower_highlevel_graph(irg, lower_bitfields); + lower_highlevel_graph(irg); } lower_const_code(); } /* lower_highlevel */