* @file
* @brief Lower some High-level constructs, moved from the firmlower.
* @author Boris Boesler, Goetz Lindenmaier, Michael Beck
- * @version $Id$
*/
#include "config.h"
*/
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;
+ 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);
- newn = new_rd_Load(dbg, bl, get_Sel_mem(sel), add, ent_mode, cons_none);
- 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.
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);
assert(!"unknown SymConst kind");
break;
}
-} /* lower_symconst */
+}
/**
* Checks, whether a size is an integral size
return 0;
/* must be at least byte size */
return size >= 8;
-} /* is_integral_size */
+}
/**
* lower bitfield load access.
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;
/* 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 */
}
exchange(proj, res);
-} /* lower_bitfields_loads */
+}
/**
* lower bitfield store access.
set_Store_mem(store, mem);
set_Store_value(store, value);
set_Store_ptr(store, ptr);
-} /* lower_bitfields_stores */
+}
/**
* lowers IR-nodes, called from walker
* 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);
/* Finally: lower SymConst-Size and Sel nodes, Casts, unaligned Load/Stores. */
irg_walk_graph(irg, NULL, lower_irnode, NULL);
-
- set_irg_outs_inconsistent(irg);
}
typedef struct pass_t {
ir_graph_pass_t pass;
- int lower_bitfields;
} pass_t;
/**
*/
static int lower_highlevel_graph_wrapper(ir_graph *irg, void *context)
{
- pass_t *pass = (pass_t*)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)
{
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 */
+}
/*
* does the same as lower_highlevel() for all nodes on the const code irg
void lower_const_code(void)
{
walk_const_code(NULL, lower_irnode, NULL);
-} /* lower_const_code */
+}
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()
{
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 */
+}