return new_d_Conv(dbgi, value, dest_mode);
}
+static ir_node *conv_to_storage_type(dbg_info *const dbgi, ir_node *const val, type_t *const type)
+{
+ ir_mode *const mode = get_ir_mode_storage(type);
+ return create_conv(dbgi, val, mode);
+}
+
/**
* Creates a SymConst node representing a string constant.
*
for (int n = 0; n < n_parameters; ++n) {
expression_t *expression = argument->expression;
ir_node *arg_node = expression_to_firm(expression);
-
- type_t *arg_type = skip_typeref(expression->base.type);
- if (!is_type_compound(arg_type)) {
- ir_mode *const mode = get_ir_mode_storage(arg_type);
- arg_node = create_conv(dbgi, arg_node, mode);
- }
-
- in[n] = arg_node;
+ type_t *arg_type = skip_typeref(expression->base.type);
+ in[n] = conv_to_storage_type(dbgi, arg_node, arg_type);
argument = argument->next;
}
static void assign_value(dbg_info *dbgi, ir_node *addr, type_t *type,
ir_node *value)
{
- if (is_type_scalar(type)) {
- ir_mode *mode = get_ir_mode_storage(type);
- value = create_conv(dbgi, value, mode);
- }
+ value = conv_to_storage_type(dbgi, value, type);
ir_node *memory = get_store();
{
dbg_info *dbgi = get_dbg_info(&expression->base.pos);
type_t *type = skip_typeref(expression->base.type);
-
- if (!is_type_compound(type)) {
- ir_mode *mode = get_ir_mode_storage(type);
- value = create_conv(dbgi, value, mode);
- }
+ value = conv_to_storage_type(dbgi, value, type);
if (expression->kind == EXPR_REFERENCE) {
const reference_expression_t *ref = &expression->reference;
return value;
}
-
-static ir_node *create_incdec(const unary_expression_t *expression)
+static ir_node *create_incdec(unary_expression_t const *const expr, bool const inc, bool const pre)
{
- dbg_info *const dbgi = get_dbg_info(&expression->base.pos);
- const expression_t *value_expr = expression->value;
- ir_node *addr = expression_to_addr(value_expr);
- ir_node *value = get_value_from_lvalue(value_expr, addr);
-
- type_t *type = skip_typeref(expression->base.type);
- ir_mode *mode = get_ir_mode_arithmetic(expression->base.type);
+ type_t *const type = skip_typeref(expr->base.type);
+ ir_mode *const mode = get_ir_mode_arithmetic(type);
ir_node *offset;
if (is_type_pointer(type)) {
- pointer_type_t *pointer_type = &type->pointer;
- offset = get_type_size_node(pointer_type->points_to);
+ offset = get_type_size_node(type->pointer.points_to);
} else {
assert(is_type_arithmetic(type));
offset = new_Const(get_mode_one(mode));
}
- ir_node *result;
- ir_node *store_value;
- switch(expression->base.kind) {
- case EXPR_UNARY_POSTFIX_INCREMENT:
- result = value;
- store_value = new_d_Add(dbgi, value, offset, mode);
- break;
- case EXPR_UNARY_POSTFIX_DECREMENT:
- result = value;
- store_value = new_d_Sub(dbgi, value, offset, mode);
- break;
- case EXPR_UNARY_PREFIX_INCREMENT:
- result = new_d_Add(dbgi, value, offset, mode);
- store_value = result;
- break;
- case EXPR_UNARY_PREFIX_DECREMENT:
- result = new_d_Sub(dbgi, value, offset, mode);
- store_value = result;
- break;
- default:
- panic("no incdec expr");
- }
-
- set_value_for_expression_addr(value_expr, store_value, addr);
+ dbg_info *const dbgi = get_dbg_info(&expr->base.pos);
+ expression_t const *const value_expr = expr->value;
+ ir_node *const addr = expression_to_addr(value_expr);
+ ir_node *const value = get_value_from_lvalue(value_expr, addr);
+ ir_node *const new_value = inc
+ ? new_d_Add(dbgi, value, offset, mode)
+ : new_d_Sub(dbgi, value, offset, mode);
- return result;
+ set_value_for_expression_addr(value_expr, new_value, addr);
+ return pre ? new_value : value;
}
static bool is_local_variable(expression_t *expression)
type_t *points_to = value_type->pointer.points_to;
return deref_address(dbgi, points_to, value_node);
}
- case EXPR_UNARY_POSTFIX_INCREMENT:
- case EXPR_UNARY_POSTFIX_DECREMENT:
- case EXPR_UNARY_PREFIX_INCREMENT:
- case EXPR_UNARY_PREFIX_DECREMENT:
- return create_incdec(expression);
+
+ {
+ bool inc;
+ bool pre;
+ case EXPR_UNARY_POSTFIX_DECREMENT: inc = false; pre = false; goto incdec;
+ case EXPR_UNARY_POSTFIX_INCREMENT: inc = true; pre = false; goto incdec;
+ case EXPR_UNARY_PREFIX_DECREMENT: inc = false; pre = true; goto incdec;
+ case EXPR_UNARY_PREFIX_INCREMENT: inc = true; pre = true; goto incdec;
+incdec:
+ return create_incdec(expression, inc, pre);
+ }
+
case EXPR_UNARY_CAST: {
ir_node *value_node = expression_to_firm(value);
type_t *from_type = value->base.type;
}
ir_node *value = expression_to_firm(expr);
- if (!is_type_compound(type)) {
- ir_mode *mode = get_ir_mode_storage(type);
- value = create_conv(NULL, value, mode);
- }
+ value = conv_to_storage_type(NULL, value, type);
return create_initializer_const(value);
}
ir_node * node = expression_to_firm(value);
dbg_info *const dbgi = get_dbg_info(&entity->base.pos);
- ir_mode *const mode = get_ir_mode_storage(init_type);
- node = create_conv(dbgi, node, mode);
+ node = conv_to_storage_type(dbgi, node, init_type);
if (declaration_kind == DECLARATION_KIND_LOCAL_VARIABLE) {
set_value(entity->variable.v.value_number, node);
int in_len;
if (!is_type_void(type)) {
- ir_mode *const mode = get_ir_mode_storage(type);
if (res) {
- res = create_conv(dbgi, res, mode);
+ res = conv_to_storage_type(dbgi, res, type);
} else {
- res = new_Unknown(mode);
+ res = new_Unknown(get_ir_mode_storage(type));
}
in_len = 1;
} else {
ir_mode *param_mode = get_type_mode(param_irtype);
long pn = n;
ir_node *value = new_rd_Proj(dbgi, args, param_mode, pn);
-
- ir_mode *mode = get_ir_mode_storage(type);
- value = create_conv(NULL, value, mode);
+ value = conv_to_storage_type(dbgi, value, type);
parameter->declaration.kind = DECLARATION_KIND_PARAMETER;
parameter->variable.v.value_number = next_value_number_function;
projects / cparser / blobdiff