*/
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))
- 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))
+ 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;
- 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;
+ int dims = get_array_n_dimensions(arr_ty);
+ int *map = ALLOCAN(int, dims);
+ ir_mode *mode_Int = get_reference_mode_signed_eq(mode);
+ ir_tarval *tv;
+ 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);
+
+ /* 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 - 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;
- 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, cons_none);
- 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, cons_none);
-#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.
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
*/
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;
*/
void lower_highlevel(int lower_bitfields)
{
- int i, n;
+ size_t i, n;
n = get_irp_n_irgs();
for (i = 0; i < n; ++i) {