From 49f5ee9b35b2d79c142302212fa5d68af1383e49 Mon Sep 17 00:00:00 2001 From: Matthias Braun Date: Wed, 12 Dec 2012 18:43:06 +0100 Subject: [PATCH] cleanup: improve coding style - add some more consts - remove some unnecessary asserts (which made the code noisy) - replace an if with ?: --- ast2firm.c | 108 +++++++++++++++++++++++++---------------------------- 1 file changed, 50 insertions(+), 58 deletions(-) diff --git a/ast2firm.c b/ast2firm.c index be4c170..26bddff 100644 --- a/ast2firm.c +++ b/ast2firm.c @@ -3435,37 +3435,37 @@ static void store_complex(dbg_info *dbgi, ir_node *addr, type_t *type, complex_value value) { value = complex_conv_to_storage(dbgi, value, type); - ir_graph *irg = current_ir_graph; - ir_type *irtype = get_ir_type(type); - ir_node *mem = get_store(); - ir_node *nomem = get_irg_no_mem(irg); - ir_mode *mode = get_complex_mode_storage(type); - ir_node *real = create_conv(dbgi, value.real, mode); - ir_node *imag = create_conv(dbgi, value.imag, mode); - ir_node *storer = new_d_Store(dbgi, mem, addr, real, cons_floats); - ir_node *memr = new_Proj(storer, mode_M, pn_Store_M); - ir_mode *mode_uint = atomic_modes[ATOMIC_TYPE_UINT]; - ir_node *one = new_Const(get_mode_one(mode_uint)); - ir_node *in[1] = { one }; - ir_entity *arrent = get_array_element_entity(irtype); - ir_node *addri = new_d_Sel(dbgi, nomem, addr, 1, in, arrent); - ir_node *storei = new_d_Store(dbgi, memr, addri, imag, cons_floats); - ir_node *memi = new_Proj(storei, mode_M, pn_Store_M); + ir_graph *const irg = current_ir_graph; + ir_type *const irtype = get_ir_type(type); + ir_node *const mem = get_store(); + ir_node *const nomem = get_irg_no_mem(irg); + ir_mode *const mode = get_complex_mode_storage(type); + ir_node *const real = create_conv(dbgi, value.real, mode); + ir_node *const imag = create_conv(dbgi, value.imag, mode); + ir_node *const storer = new_d_Store(dbgi, mem, addr, real, cons_floats); + ir_node *const memr = new_Proj(storer, mode_M, pn_Store_M); + ir_mode *const muint = atomic_modes[ATOMIC_TYPE_UINT]; + ir_node *const one = new_Const(get_mode_one(muint)); + ir_node *const in[1] = { one }; + ir_entity *const arrent = get_array_element_entity(irtype); + ir_node *const addri = new_d_Sel(dbgi, nomem, addr, 1, in, arrent); + ir_node *const storei = new_d_Store(dbgi, memr, addri, imag, cons_floats); + ir_node *const memi = new_Proj(storei, mode_M, pn_Store_M); set_store(memi); } static ir_node *complex_to_memory(dbg_info *dbgi, type_t *type, complex_value value) { - ir_graph *irg = current_ir_graph; - ir_type *frame_type = get_irg_frame_type(irg); - ident *id = id_unique("cmplex_tmp.%u"); - ir_type *irtype = get_ir_type(type); - ir_entity *tmp_storage = new_entity(frame_type, id, irtype); + ir_graph *const irg = current_ir_graph; + ir_type *const frame_type = get_irg_frame_type(irg); + ident *const id = id_unique("cmplex_tmp.%u"); + ir_type *const irtype = get_ir_type(type); + ir_entity *const tmp_storage = new_entity(frame_type, id, irtype); + ir_node *const frame = get_irg_frame(irg); + ir_node *const nomem = get_irg_no_mem(irg); + ir_node *const addr = new_simpleSel(nomem, frame, tmp_storage); set_entity_compiler_generated(tmp_storage, 1); - ir_node *frame = get_irg_frame(irg); - ir_node *nomem = get_irg_no_mem(irg); - ir_node *addr = new_simpleSel(nomem, frame, tmp_storage); store_complex(dbgi, addr, type, value); return addr; } @@ -3494,11 +3494,11 @@ static complex_value complex_deref_address(dbg_info *const dbgi, if (type->base.qualifiers & TYPE_QUALIFIER_VOLATILE) flags |= cons_volatile; - ir_mode *const mode = get_complex_mode_storage(type); - ir_node *const memory = get_store(); - ir_node *const load = new_d_Load(dbgi, memory, addr, mode, flags); - ir_node *const load_mem = new_Proj(load, mode_M, pn_Load_M); - ir_node *const load_res = new_Proj(load, mode, pn_Load_res); + ir_mode *const mode = get_complex_mode_storage(type); + ir_node *const memory = get_store(); + ir_node *const load = new_d_Load(dbgi, memory, addr, mode, flags); + ir_node *const load_mem = new_Proj(load, mode_M, pn_Load_M); + ir_node *const load_res = new_Proj(load, mode, pn_Load_res); ir_type *const irtype = get_ir_type(type); ir_mode *const mode_uint = atomic_modes[ATOMIC_TYPE_UINT]; @@ -3533,10 +3533,9 @@ static complex_value complex_reference_to_firm(const reference_expression_t *ref static complex_value complex_select_to_firm(const select_expression_t *select) { - dbg_info *dbgi = get_dbg_info(&select->base.pos); - ir_node *addr = select_addr(select); - type_t *type = skip_typeref(select->base.type); - assert(is_type_complex(type)); + dbg_info *const dbgi = get_dbg_info(&select->base.pos); + ir_node *const addr = select_addr(select); + type_t *const type = skip_typeref(select->base.type); return complex_deref_address(dbgi, type, addr, cons_none); } @@ -3574,21 +3573,19 @@ static complex_value get_complex_from_lvalue(const expression_t *expression, static complex_value complex_cast_to_firm(const unary_expression_t *expression) { - const expression_t *value = expression->value; - dbg_info *dbgi = get_dbg_info(&expression->base.pos); - type_t *from_type = skip_typeref(value->base.type); - type_t *to_type = skip_typeref(expression->base.type); - ir_mode *mode = get_complex_mode_storage(to_type); - - assert(is_type_complex(to_type)); + const expression_t *const value = expression->value; + dbg_info *const dbgi = get_dbg_info(&expression->base.pos); + type_t *const from_type = skip_typeref(value->base.type); + type_t *const to_type = skip_typeref(expression->base.type); + ir_mode *const mode = get_complex_mode_storage(to_type); if (is_type_complex(from_type)) { complex_value cvalue = expression_to_complex(value); return complex_conv(dbgi, cvalue, mode); } else { - ir_node *value_node = expression_to_value(value); - ir_node *zero = new_Const(get_mode_null(mode)); - ir_node *casted = create_conv(dbgi, value_node, mode); + ir_node *const value_node = expression_to_value(value); + ir_node *const zero = new_Const(get_mode_null(mode)); + ir_node *const casted = create_conv(dbgi, value_node, mode); return (complex_value) { casted, zero }; } } @@ -3683,12 +3680,10 @@ static void set_complex_value_for_expression(dbg_info *dbgi, complex_value value, ir_node *addr) { - type_t *type = skip_typeref(expression->base.type); - assert(is_type_complex(type)); - - ir_mode *mode = get_complex_mode_storage(type); - ir_node *real = create_conv(dbgi, value.real, mode); - ir_node *imag = create_conv(dbgi, value.imag, mode); + type_t *const type = skip_typeref(expression->base.type); + ir_mode *const mode = get_complex_mode_storage(type); + ir_node *const real = create_conv(dbgi, value.real, mode); + ir_node *const imag = create_conv(dbgi, value.imag, mode); if (expression->kind == EXPR_REFERENCE) { const reference_expression_t *ref = &expression->reference; @@ -3943,7 +3938,7 @@ static complex_value complex_conditional_to_firm( static void create_local_declarations(entity_t*); static complex_value compound_statement_to_firm_complex( - compound_statement_t *compound) + const compound_statement_t *compound) { create_local_declarations(compound->scope.entities); @@ -3972,7 +3967,7 @@ static complex_value compound_statement_to_firm_complex( static complex_value complex_statement_expression_to_firm( const statement_expression_t *const expr) { - statement_t *statement = expr->statement; + const statement_t *const statement = expr->statement; assert(statement->kind == STATEMENT_COMPOUND); return compound_statement_to_firm_complex(&statement->compound); @@ -4042,11 +4037,9 @@ static complex_value expression_to_complex(const expression_t *expression) return complex_conditional_to_firm(&expression->conditional); case EXPR_STATEMENT: return complex_statement_expression_to_firm(&expression->statement); - default: - break; + panic("unexpected complex expression"); } - panic("complex expression not implemented yet"); } @@ -4955,7 +4948,7 @@ static ir_node *expression_statement_to_firm(expression_statement_t *statement) type_t *type = skip_typeref(expression->base.type); if (is_type_complex(type)) { expression_to_complex(expression); - return NULL; /* TODO */ + return NULL; } else { return expression_to_value(statement->expression); } @@ -5677,9 +5670,8 @@ static int count_local_variables(const entity_t *entity, for (; entity != end; entity = entity->base.next) { if ((entity->kind == ENTITY_VARIABLE || entity->kind == ENTITY_PARAMETER) && !var_needs_entity(&entity->variable)) { - ++count; - if (is_type_complex(skip_typeref(entity->declaration.type))) - ++count; + type_t *type = skip_typeref(entity->declaration.type); + count += is_type_complex(type) ? 2 : 1; } } return count; -- 2.20.1