type = skip_typeref(type);
switch(type->kind) {
+ case TYPE_ERROR:
+ panic("error type occured");
case TYPE_ATOMIC:
return get_atomic_type_size(&type->atomic);
case TYPE_ENUM:
unsigned size = fold_constant(type->size);
- assert(!is_type_floating(base));
+ assert(!is_type_float(base));
if(is_type_signed(base)) {
return get_signed_int_type_for_bit_size(irbase, size);
} else {
size_t align_all = 1;
size_t offset = 0;
size_t bit_offset = 0;
- declaration_t *entry = type->declaration->context.declarations;
+ declaration_t *entry = type->declaration->scope.declarations;
for( ; entry != NULL; entry = entry->next) {
if(entry->namespc != NAMESPACE_NORMAL)
continue;
int align_all = 1;
int size = 0;
- declaration_t *entry = declaration->context.declarations;
+ declaration_t *entry = declaration->scope.declarations;
for( ; entry != NULL; entry = entry->next) {
if(entry->namespc != NAMESPACE_NORMAL)
continue;
ir_type *firm_type = NULL;
switch(type->kind) {
+ case TYPE_ERROR:
+ panic("error type occured");
case TYPE_ATOMIC:
firm_type = create_atomic_type(&type->atomic);
break;
static ir_node *const_to_firm(const const_expression_t *cnst)
{
- dbg_info *dbgi = get_dbg_info(&cnst->expression.source_position);
- ir_mode *mode = get_ir_mode(cnst->expression.datatype);
+ dbg_info *dbgi = get_dbg_info(&cnst->base.source_position);
+ ir_mode *mode = get_ir_mode(cnst->base.type);
char buf[128];
tarval *tv;
static ir_node *string_literal_to_firm(
const string_literal_expression_t* literal)
{
- return string_to_firm(&literal->expression.source_position, "Lstr",
+ return string_to_firm(&literal->base.source_position, "Lstr",
&literal->value);
}
elem_type);
ident *const id = unique_ident("Lstr");
- dbg_info *const dbgi = get_dbg_info(&literal->expression.source_position);
+ dbg_info *const dbgi = get_dbg_info(&literal->base.source_position);
ir_entity *const entity = new_d_entity(global_type, id, type, dbgi);
set_entity_ld_ident(entity, id);
set_entity_variability(entity, variability_constant);
static ir_node *deref_address(ir_type *const irtype, ir_node *const addr,
dbg_info *const dbgi)
{
- if(is_compound_type(irtype) || is_Array_type(irtype)) {
+ if (is_compound_type(irtype) ||
+ is_Method_type(irtype) ||
+ is_Array_type(irtype)) {
return addr;
}
static ir_node *reference_expression_to_firm(const reference_expression_t *ref)
{
- dbg_info *dbgi = get_dbg_info(&ref->expression.source_position);
+ dbg_info *dbgi = get_dbg_info(&ref->base.source_position);
declaration_t *declaration = ref->declaration;
type_t *type = skip_typeref(declaration->type);
static ir_node *reference_addr(const reference_expression_t *ref)
{
- dbg_info *dbgi = get_dbg_info(&ref->expression.source_position);
+ dbg_info *dbgi = get_dbg_info(&ref->base.source_position);
declaration_t *declaration = ref->declaration;
switch((declaration_kind_t) declaration->declaration_kind) {
case DECLARATION_KIND_LOCAL_VARIABLE:
panic("local variable without entity has no address");
case DECLARATION_KIND_FUNCTION: {
- type_t *const type = skip_typeref(ref->expression.datatype);
+ type_t *const type = skip_typeref(ref->base.type);
ir_mode *const mode = get_ir_mode(type);
return create_symconst(dbgi, mode, declaration->v.entity);
}
static ir_node *process_builtin_call(const call_expression_t *call)
{
- dbg_info *dbgi = get_dbg_info(&call->expression.source_position);
+ dbg_info *dbgi = get_dbg_info(&call->base.source_position);
assert(call->function->kind == EXPR_BUILTIN_SYMBOL);
builtin_symbol_expression_t *builtin = &call->function->builtin_symbol;
- type_t *type = skip_typeref(builtin->expression.datatype);
+ type_t *type = skip_typeref(builtin->base.type);
assert(is_type_pointer(type));
type_t *function_type = skip_typeref(type->pointer.points_to);
}
ir_node *callee = expression_to_firm(function);
- type_t *type = skip_typeref(function->base.datatype);
+ type_t *type = skip_typeref(function->base.type);
assert(is_type_pointer(type));
pointer_type_t *pointer_type = &type->pointer;
type_t *points_to = skip_typeref(pointer_type->points_to);
++n_parameters;
}
- dbg_info *dbgi = get_dbg_info(&call->expression.source_position);
+ dbg_info *dbgi = get_dbg_info(&call->base.source_position);
ir_type *ir_method_type = get_ir_type((type_t*) function_type);
ir_type *new_method_type = NULL;
in[n] = arg_node;
if(new_method_type != NULL) {
- ir_type *irtype = get_ir_type(expression->base.datatype);
+ ir_type *irtype = get_ir_type(expression->base.type);
set_method_param_type(new_method_type, n, irtype);
}
{
expression_t *select = expression->value;
assert(select->kind == EXPR_SELECT);
- type_t *type = select->base.datatype;
+ type_t *type = select->base.type;
assert(type->kind == TYPE_BITFIELD);
ir_mode *mode = get_ir_mode(type->bitfield.base);
ir_node *addr = expression_to_addr(select);
assert(get_irn_mode(value) == mode);
- dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
/* kill upper bits of value and shift to right position */
ir_entity *entity = select->select.compound_entry->v.entity;
}
ir_node *addr = expression_to_addr(expression);
- type_t *type = skip_typeref(expression->base.datatype);
+ type_t *type = skip_typeref(expression->base.type);
assign_value(dbgi, addr, type, value);
}
static ir_node *create_incdec(const unary_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
- type_t *type = skip_typeref(expression->expression.datatype);
+ dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ type_t *type = skip_typeref(expression->base.type);
ir_mode *mode = get_ir_mode(type);
expression_t *value = expression->value;
offset = new_Const(mode, get_mode_one(mode));
}
- switch(expression->expression.kind) {
+ switch(expression->base.kind) {
case EXPR_UNARY_POSTFIX_INCREMENT: {
ir_node *new_value = new_d_Add(dbgi, value_node, offset, mode);
set_value_for_expression(value, new_value);
ir_node *res = NULL;
pn_Cmp cmp_val;
- cmp_val = get_pnc(expression->expression.kind);
+ cmp_val = get_pnc(expression->base.kind);
if (is_local_variable(op1) && is_local_variable(op2)) {
var = op1->reference.declaration;
expression_t *select = expression->value;
assert(select->kind == EXPR_SELECT);
- type_t *type = select->base.datatype;
+ type_t *type = select->base.type;
assert(type->kind == TYPE_BITFIELD);
ir_mode *mode = get_ir_mode(type->bitfield.base);
- dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
ir_node *addr = expression_to_addr(select);
ir_node *mem = get_store();
ir_node *load = new_d_Load(dbgi, mem, addr, mode);
static ir_node *unary_expression_to_firm(const unary_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
- type_t *type = skip_typeref(expression->expression.datatype);
+ dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ type_t *type = skip_typeref(expression->base.type);
- if(expression->expression.kind == EXPR_UNARY_TAKE_ADDRESS)
+ if(expression->base.kind == EXPR_UNARY_TAKE_ADDRESS)
return expression_to_addr(expression->value);
const expression_t *value = expression->value;
- switch(expression->expression.kind) {
+ switch(expression->base.kind) {
case EXPR_UNARY_NEGATE: {
ir_node *value_node = expression_to_firm(value);
ir_mode *mode = get_ir_mode(type);
}
case EXPR_UNARY_DEREFERENCE: {
ir_node *value_node = expression_to_firm(value);
- type_t *value_type = skip_typeref(value->base.datatype);
+ type_t *value_type = skip_typeref(value->base.type);
ir_type *irtype = get_ir_type(value_type);
assert(is_Pointer_type(irtype));
ir_type *points_to = get_pointer_points_to_type(irtype);
return create_incdec(expression);
case EXPR_UNARY_CAST: {
ir_node *value_node = expression_to_firm(value);
- ir_mode *mode = get_ir_mode(type);
- ir_node *node = create_conv(dbgi, value_node, mode);
- node = do_strict_conv(dbgi, node);
- return node;
+ if(is_type_scalar(type)) {
+ ir_mode *mode = get_ir_mode(type);
+ ir_node *node = create_conv(dbgi, value_node, mode);
+ node = do_strict_conv(dbgi, node);
+ return node;
+ } else {
+ return value_node;
+ }
}
case EXPR_UNARY_CAST_IMPLICIT: {
ir_node *value_node = expression_to_firm(value);
- ir_mode *mode = get_ir_mode(type);
- return create_conv(dbgi, value_node, mode);
+ if(is_type_scalar(type)) {
+ ir_mode *mode = get_ir_mode(type);
+ return create_conv(dbgi, value_node, mode);
+ } else {
+ return value_node;
+ }
}
case EXPR_UNARY_ASSUME:
if(firm_opt.confirm)
static ir_node *create_lazy_op(const binary_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
- type_t *type = expression->expression.datatype;
+ dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ type_t *type = expression->base.type;
ir_mode *mode = get_ir_mode(type);
if(is_constant_expression(expression->left)) {
long val = fold_constant(expression->left);
- expression_kind_t ekind = expression->expression.kind;
+ expression_kind_t ekind = expression->base.kind;
if((ekind == EXPR_BINARY_LOGICAL_AND && val != 0)
|| (ekind == EXPR_BINARY_LOGICAL_OR && val == 0)) {
return expression_to_firm(expression->right);
static ir_node *create_arithmetic_binop(const binary_expression_t *expression,
create_arithmetic_func func)
{
- dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
ir_node *left = expression_to_firm(expression->left);
ir_node *right = expression_to_firm(expression->right);
- type_t *type = expression->right->base.datatype;
+ type_t *type = expression->right->base.type;
/* be careful with the modes, because in arithmetic assign nodes only
* the right operand has the mode of the arithmetic already */
ir_mode *mode = get_ir_mode(type);
static ir_node *create_arithmetic_assign_binop(
const binary_expression_t *expression, create_arithmetic_func func)
{
- dbg_info *const dbgi = get_dbg_info(&expression->expression.source_position);
- type_t *const type = skip_typeref(expression->expression.datatype);
+ dbg_info *const dbgi = get_dbg_info(&expression->base.source_position);
+ type_t *const type = skip_typeref(expression->base.type);
ir_node *value;
if (is_type_pointer(type)) {
static ir_node *create_add(const binary_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
ir_node *left = expression_to_firm(expression->left);
ir_node *right = expression_to_firm(expression->right);
- type_t *type = expression->expression.datatype;
+ type_t *type = expression->base.type;
expression_t *expr_left = expression->left;
expression_t *expr_right = expression->right;
- type_t *type_left = skip_typeref(expr_left->base.datatype);
- type_t *type_right = skip_typeref(expr_right->base.datatype);
+ type_t *type_left = skip_typeref(expr_left->base.type);
+ type_t *type_right = skip_typeref(expr_right->base.type);
if(is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
ir_mode *const mode = get_ir_mode(type);
static ir_node *create_sub(const binary_expression_t *expression)
{
- dbg_info *const dbgi = get_dbg_info(&expression->expression.source_position);
+ dbg_info *const dbgi = get_dbg_info(&expression->base.source_position);
expression_t *const expr_left = expression->left;
expression_t *const expr_right = expression->right;
ir_node *const left = expression_to_firm(expr_left);
ir_node *const right = expression_to_firm(expr_right);
- type_t *const type = expression->expression.datatype;
- type_t *const type_left = skip_typeref(expr_left->base.datatype);
- type_t *const type_right = skip_typeref(expr_right->base.datatype);
+ type_t *const type = expression->base.type;
+ type_t *const type_left = skip_typeref(expr_left->base.type);
+ type_t *const type_right = skip_typeref(expr_right->base.type);
if (is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
ir_mode *const mode = get_ir_mode(type);
static ir_node *create_shift(const binary_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
ir_node *left = expression_to_firm(expression->left);
ir_node *right = expression_to_firm(expression->right);
- type_t *type = expression->expression.datatype;
+ type_t *type = expression->base.type;
ir_mode *mode = get_ir_mode(type);
/* firm always wants the shift count to be unsigned */
ir_node *res;
- switch(expression->expression.kind) {
+ switch(expression->base.kind) {
case EXPR_BINARY_SHIFTLEFT_ASSIGN:
case EXPR_BINARY_SHIFTLEFT:
res = new_d_Shl(dbgi, left, right, mode);
case EXPR_BINARY_SHIFTRIGHT_ASSIGN:
case EXPR_BINARY_SHIFTRIGHT: {
expression_t *expr_left = expression->left;
- type_t *type_left = skip_typeref(expr_left->base.datatype);
+ type_t *type_left = skip_typeref(expr_left->base.type);
if(is_type_signed(type_left)) {
res = new_d_Shrs(dbgi, left, right, mode);
static ir_node *create_divmod(const binary_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
ir_node *left = expression_to_firm(expression->left);
ir_node *right = expression_to_firm(expression->right);
ir_node *pin = new_Pin(new_NoMem());
/* be careful with the modes, because in arithmetic assign nodes only
* the right operand has the mode of the arithmetic already */
- type_t *type = expression->right->base.datatype;
+ type_t *type = expression->right->base.type;
ir_mode *mode = get_ir_mode(type);
left = create_conv(dbgi, left, mode);
ir_node *op;
ir_node *res;
- switch (expression->expression.kind) {
+ switch (expression->base.kind) {
case EXPR_BINARY_DIV:
case EXPR_BINARY_DIV_ASSIGN:
if(mode_is_float(mode)) {
const binary_expression_t *expression)
{
ir_node * value = create_divmod(expression);
- dbg_info *const dbgi = get_dbg_info(&expression->expression.source_position);
- type_t *const type = expression->expression.datatype;
+ dbg_info *const dbgi = get_dbg_info(&expression->base.source_position);
+ type_t *const type = expression->base.type;
ir_mode *const mode = get_ir_mode(type);
assert(type->kind != TYPE_POINTER);
const binary_expression_t *expression)
{
ir_node * value = create_shift(expression);
- dbg_info *const dbgi = get_dbg_info(&expression->expression.source_position);
- type_t *const type = expression->expression.datatype;
+ dbg_info *const dbgi = get_dbg_info(&expression->base.source_position);
+ type_t *const type = expression->base.type;
ir_mode *const mode = get_ir_mode(type);
value = create_conv(dbgi, value, mode);
static ir_node *binary_expression_to_firm(const binary_expression_t *expression)
{
- expression_kind_t kind = expression->expression.kind;
+ expression_kind_t kind = expression->base.kind;
switch(kind) {
case EXPR_BINARY_EQUAL:
case EXPR_BINARY_ISLESSEQUAL:
case EXPR_BINARY_ISLESSGREATER:
case EXPR_BINARY_ISUNORDERED: {
- dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
ir_node *left = expression_to_firm(expression->left);
ir_node *right = expression_to_firm(expression->right);
ir_node *cmp = new_d_Cmp(dbgi, left, right);
static ir_node *array_access_addr(const array_access_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
ir_node *base_addr = expression_to_firm(expression->array_ref);
ir_node *offset = expression_to_firm(expression->index);
offset = create_conv(dbgi, offset, mode_uint);
- type_t *ref_type = skip_typeref(expression->array_ref->base.datatype);
+ type_t *ref_type = skip_typeref(expression->array_ref->base.type);
assert(is_type_pointer(ref_type));
pointer_type_t *pointer_type = &ref_type->pointer;
static ir_node *array_access_to_firm(
const array_access_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
ir_node *addr = array_access_addr(expression);
type_t *type = revert_automatic_type_conversion(
(const expression_t*) expression);
return deref_address(irtype, addr, dbgi);
}
-static ir_node *sizeof_to_firm(const sizeof_expression_t *expression)
+/**
+ * Transform a sizeof expression into Firm code.
+ */
+static ir_node *sizeof_to_firm(const typeprop_expression_t *expression)
{
type_t *type = expression->type;
if(type == NULL) {
- type = expression->size_expression->base.datatype;
+ type = expression->tp_expression->base.type;
assert(type != NULL);
}
- ir_mode *const mode = get_ir_mode(expression->expression.datatype);
+ ir_mode *const mode = get_ir_mode(expression->base.type);
symconst_symbol sym;
sym.type_p = get_ir_type(type);
return new_SymConst(mode, sym, symconst_type_size);
}
-static ir_node *alignof_to_firm(const alignof_expression_t *expression)
+/**
+ * Transform an alignof expression into Firm code.
+ */
+static ir_node *alignof_to_firm(const typeprop_expression_t *expression)
{
- type_t *const type = expression->type;
- ir_mode *const mode = get_ir_mode(expression->expression.datatype);
+ type_t *type = expression->type;
+ if(type == NULL) {
+ /* beware: if expression is a variable reference, return the
+ alignment of the variable. */
+ const expression_t *tp_expression = expression->tp_expression;
+ const declaration_t *declaration = expr_is_variable(tp_expression);
+ if (declaration != NULL) {
+ /* TODO: get the alignment of this variable. */
+ }
+ type = tp_expression->base.type;
+ assert(type != NULL);
+ }
+
+ ir_mode *const mode = get_ir_mode(expression->base.type);
symconst_symbol sym;
sym.type_p = get_ir_type(type);
return new_SymConst(mode, sym, symconst_type_align);
static ir_node *conditional_to_firm(const conditional_expression_t *expression)
{
- dbg_info *const dbgi = get_dbg_info(&expression->expression.source_position);
+ dbg_info *const dbgi = get_dbg_info(&expression->base.source_position);
/* first try to fold a constant condition */
if(is_constant_expression(expression->condition)) {
static ir_node *select_addr(const select_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
ir_node *compound_addr = expression_to_firm(expression->compound);
static ir_node *select_to_firm(const select_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
ir_node *addr = select_addr(expression);
type_t *type = revert_automatic_type_conversion(
(const expression_t*) expression);
static ir_node *classify_type_to_firm(const classify_type_expression_t *const expr)
{
- const type_t *const type = expr->type_expression->base.datatype;
+ const type_t *const type = expr->type_expression->base.type;
gcc_type_class tc;
switch (type->kind)
panic("Unimplemented case in classify_type_to_firm().");
}
- dbg_info *const dbgi = get_dbg_info(&expr->expression.source_position);
+ dbg_info *const dbgi = get_dbg_info(&expr->base.source_position);
ir_mode *const mode = mode_int;
tarval *const tv = new_tarval_from_long(tc, mode);
return new_d_Const(dbgi, mode, tv);
const string_literal_expression_t *const expr)
{
if (current_function_name == NULL) {
- const source_position_t *const src_pos =
- &expr->expression.source_position;
+ const source_position_t *const src_pos = &expr->base.source_position;
const char *const name = current_function_decl->symbol->string;
const string_t string = { name, strlen(name) + 1 };
current_function_name = string_to_firm(src_pos, "__func__", &string);
int const n = get_method_n_params(method_type) - 1;
ir_entity *const parm_ent = get_method_value_param_ent(method_type, n);
ir_node *const arg_base = get_irg_value_param_base(current_ir_graph);
- dbg_info *const dbgi =
- get_dbg_info(&expr->expression.source_position);
+ dbg_info *const dbgi = get_dbg_info(&expr->base.source_position);
ir_node *const no_mem = new_NoMem();
ir_node *const arg_sel =
new_d_simpleSel(dbgi, no_mem, arg_base, parm_ent);
static ir_node *va_arg_expression_to_firm(const va_arg_expression_t *const expr)
{
- ir_type *const irtype = get_ir_type(expr->expression.datatype);
+ ir_type *const irtype = get_ir_type(expr->base.type);
ir_node *const ap = expression_to_firm(expr->ap);
- dbg_info *const dbgi = get_dbg_info(&expr->expression.source_position);
+ dbg_info *const dbgi = get_dbg_info(&expr->base.source_position);
ir_node *const res = deref_address(irtype, ap, dbgi);
- size_t const parm_size = get_type_size(expr->expression.datatype);
+ size_t const parm_size = get_type_size(expr->base.type);
ir_node *const cnst = new_Const_long(mode_uint, parm_size);
ir_node *const add = new_d_Add(dbgi, ap, cnst, mode_P_data);
set_value_for_expression(expr->ap, add);
static ir_node *dereference_addr(const unary_expression_t *const expression)
{
- assert(expression->expression.kind == EXPR_UNARY_DEREFERENCE);
+ assert(expression->base.kind == EXPR_UNARY_DEREFERENCE);
return expression_to_firm(expression->value);
}
static ir_node *builtin_constant_to_firm(
const builtin_constant_expression_t *expression)
{
- ir_mode *mode = get_ir_mode(expression->expression.datatype);
+ ir_mode *mode = get_ir_mode(expression->base.type);
long v;
if (is_constant_expression(expression->value)) {
case EXPR_ARRAY_ACCESS:
return array_access_to_firm(&expression->array_access);
case EXPR_SIZEOF:
- return sizeof_to_firm(&expression->sizeofe);
+ return sizeof_to_firm(&expression->typeprop);
case EXPR_ALIGNOF:
- return alignof_to_firm(&expression->alignofe);
+ return alignof_to_firm(&expression->typeprop);
case EXPR_CONDITIONAL:
return conditional_to_firm(&expression->conditional);
case EXPR_SELECT:
ir_node *res = _expression_to_firm(expression);
if(res != NULL && get_irn_mode(res) == mode_b) {
- ir_mode *mode = get_ir_mode(expression->base.datatype);
+ ir_mode *mode = get_ir_mode(expression->base.type);
res = create_conv(NULL, res, mode);
}
{
declaration_t *compound_declaration = type->declaration;
- declaration_t *compound_entry = compound_declaration->context.declarations;
+ declaration_t *compound_entry = compound_declaration->scope.declarations;
compound_graph_path_entry_t entry;
entry.type = COMPOUND_GRAPH_ENTRY_COMPOUND;
if(get_cur_block() == NULL)
return;
- ir_type *func_irtype = get_ir_type(current_function_decl->type);
+ dbg_info *dbgi = get_dbg_info(&statement->base.source_position);
+ ir_type *func_irtype = get_ir_type(current_function_decl->type);
- dbg_info *dbgi = get_dbg_info(&statement->statement.source_position);
ir_node *in[1];
int in_len;
if(get_method_n_ress(func_irtype) > 0) {
ir_type *res_type = get_method_res_type(func_irtype, 0);
- if(statement->return_value != NULL) {
- ir_node *node = expression_to_firm(statement->return_value);
+ if(statement->value != NULL) {
+ ir_node *node = expression_to_firm(statement->value);
node = do_strict_conv(dbgi, node);
in[0] = node;
} else {
in_len = 1;
} else {
/* build return_value for its side effects */
- if(statement->return_value != NULL) {
- expression_to_firm(statement->return_value);
+ if(statement->value != NULL) {
+ expression_to_firm(statement->value);
}
in_len = 0;
}
ir_node *result = NULL;
statement_t *statement = compound->statements;
for( ; statement != NULL; statement = statement->base.next) {
- //context2firm(&statement->context);
+ //context2firm(&statement->scope);
if(statement->base.next == NULL
&& statement->kind == STATEMENT_EXPRESSION) {
static void create_local_declaration(declaration_t *declaration)
{
+ if(declaration->symbol == NULL)
+ return;
+
type_t *type = skip_typeref(declaration->type);
switch ((storage_class_tag_t) declaration->storage_class) {
for( ; declaration != end; declaration = declaration->next) {
if(declaration->namespc != NAMESPACE_NORMAL)
continue;
- create_local_variable(declaration);
+ create_local_declaration(declaration);
}
}
}
/* create declarations */
- declaration_t *declaration = statement->context.declarations;
+ declaration_t *declaration = statement->scope.declarations;
for( ; declaration != NULL; declaration = declaration->next) {
create_local_declaration(declaration);
}
static void switch_statement_to_firm(const switch_statement_t *statement)
{
- dbg_info *dbgi = get_dbg_info(&statement->statement.source_position);
+ dbg_info *dbgi = get_dbg_info(&statement->base.source_position);
ir_node *expression = expression_to_firm(statement->expression);
ir_node *cond = new_d_Cond(dbgi, expression);
current_switch_cond = cond;
break_label = break_block;
- statement_to_firm(statement->body);
+ if (statement->body != NULL) {
+ statement_to_firm(statement->body);
+ }
if(get_cur_block() != NULL) {
ir_node *jmp = new_Jmp();
static void case_label_to_firm(const case_label_statement_t *statement)
{
- dbg_info *dbgi = get_dbg_info(&statement->statement.source_position);
+ dbg_info *dbgi = get_dbg_info(&statement->base.source_position);
ir_node *const fallthrough = (get_cur_block() == NULL ? NULL : new_Jmp());
add_immBlock_pred(block, proj);
mature_immBlock(block);
- if(statement->label_statement != NULL) {
- statement_to_firm(statement->label_statement);
+ if(statement->statement != NULL) {
+ statement_to_firm(statement->statement);
}
}
set_cur_block(block);
keep_alive(block);
- if(statement->label_statement != NULL) {
- statement_to_firm(statement->label_statement);
+ if(statement->statement != NULL) {
+ statement_to_firm(statement->statement);
}
}
case STATEMENT_LABEL: {
const label_statement_t *const label_stmt = &stmt->label;
- count += count_decls_in_stmts(label_stmt->label_statement);
+ if(label_stmt->statement != NULL) {
+ count += count_decls_in_stmts(label_stmt->statement);
+ }
break;
}
case STATEMENT_FOR: {
const for_statement_t *const for_stmt = &stmt->fors;
- count += count_local_declarations(for_stmt->context.declarations, NULL);
+ count += count_local_declarations(for_stmt->scope.declarations, NULL);
count += count_decls_in_expression(for_stmt->initialisation);
count += count_decls_in_expression(for_stmt->condition);
count += count_decls_in_expression(for_stmt->step);
case STATEMENT_CASE_LABEL: {
const case_label_statement_t *label = &stmt->case_label;
count += count_decls_in_expression(label->expression);
- count += count_decls_in_stmts(label->label_statement);
+ if(label->statement != NULL) {
+ count += count_decls_in_stmts(label->statement);
+ }
break;
}
case STATEMENT_RETURN: {
const return_statement_t *ret_stmt = &stmt->returns;
- count += count_decls_in_expression(ret_stmt->return_value);
+ count += count_decls_in_expression(ret_stmt->value);
break;
}
}
int count = 0;
/* count parameters */
- count += count_local_declarations(declaration->context.declarations, NULL);
+ count += count_local_declarations(declaration->scope.declarations, NULL);
/* count local variables declared in body */
count += count_decls_in_stmts(declaration->init.statement);
ir_type *function_irtype = get_ir_type(declaration->type);
int n = 0;
- declaration_t *parameter = declaration->context.declarations;
+ declaration_t *parameter = declaration->scope.declarations;
for( ; parameter != NULL; parameter = parameter->next, ++n) {
assert(parameter->declaration_kind == DECLARATION_KIND_UNKNOWN);
type_t *type = skip_typeref(parameter->type);
panic("Invalid storage class for global variable");
}
-static void context_to_firm(context_t *context)
+static void scope_to_firm(scope_t *scope)
{
/* first pass: create declarations */
- declaration_t *declaration = context->declarations;
+ declaration_t *declaration = scope->declarations;
for( ; declaration != NULL; declaration = declaration->next) {
if(declaration->namespc != NAMESPACE_NORMAL)
continue;
}
/* second pass: create code */
- declaration = context->declarations;
+ declaration = scope->declarations;
for( ; declaration != NULL; declaration = declaration->next) {
if(declaration->namespc != NAMESPACE_NORMAL)
continue;
break_label = NULL;
current_switch_cond = NULL;
- context_to_firm(&unit->context);
+ scope_to_firm(&unit->scope);
}
projects / cparser / blobdiff