#include "token_t.h"
#include "type_t.h"
#include "ast_t.h"
+#include "parser.h"
#define MAGIC_DEFAULT_PN_NUMBER (long) -314159265
static ir_type *ir_type_const_char;
+static ir_type *ir_type_wchar_t;
static ir_type *ir_type_void;
static ir_type *ir_type_int;
-static ir_type *ir_type_void_ptr;
static type_t *type_const_char;
static type_t *type_void;
static type_t *type_int;
-static symbol_t *symbol_alloca;
-
static int next_value_number_function;
static ir_node *continue_label;
static ir_node *break_label;
DECLARATION_TYPE_LOCAL_VARIABLE_ENTITY,
DECLARATION_TYPE_COMPOUND_MEMBER,
DECLARATION_TYPE_LABEL_BLOCK,
+ DECLARATION_TYPE_ENUM_ENTRY
} declaration_type_t;
static ir_type *get_ir_type(type_t *type);
void init_ast2firm(void)
{
- type_const_char = make_atomic_type(ATOMIC_TYPE_CHAR, TYPE_QUALIFIER_CONST);
- type_void = make_atomic_type(ATOMIC_TYPE_VOID, TYPE_QUALIFIER_NONE);
- type_int = make_atomic_type(ATOMIC_TYPE_INT, TYPE_QUALIFIER_NONE);
-
- ir_type_int = get_ir_type(type_int);
- ir_type_const_char = get_ir_type(type_const_char);
- ir_type_void = get_ir_type(type_int); /* we don't have a real void
- type in firm */
- ir_type_void_ptr = new_type_pointer(new_id_from_str("void_ptr"),
- ir_type_void, mode_P_data);
-
- type_void->firm_type = ir_type_void;
-
- symbol_alloca = symbol_table_insert("__builtin_alloca");
}
void exit_ast2firm(void)
return new_id_from_str(buf);
}
-static ir_mode *get_atomic_mode(const type_t* atomic_type)
+static ir_mode *get_atomic_mode(const atomic_type_t* atomic_type)
{
- switch(atomic_type->v.atomic_type.atype) {
+ switch(atomic_type->atype) {
case ATOMIC_TYPE_SCHAR:
case ATOMIC_TYPE_CHAR:
return mode_Bs;
static unsigned get_type_size(type_t *type);
-static unsigned get_atomic_type_size(const type_t *type)
+static unsigned get_atomic_type_size(const atomic_type_t *type)
{
- switch(type->v.atomic_type.atype) {
+ switch(type->atype) {
case ATOMIC_TYPE_CHAR:
case ATOMIC_TYPE_SCHAR:
case ATOMIC_TYPE_UCHAR:
panic("Trying to determine size of invalid atomic type");
}
-static unsigned get_compound_type_size(type_t *type)
+static unsigned get_compound_type_size(compound_type_t *type)
{
- ir_type *irtype = get_ir_type(type);
+ ir_type *irtype = get_ir_type((type_t*) type);
return get_type_size_bytes(irtype);
}
-static unsigned get_array_type_size(type_t *type)
+static unsigned get_array_type_size(array_type_t *type)
{
- ir_type *irtype = get_ir_type(type);
+ ir_type *irtype = get_ir_type((type_t*) type);
return get_type_size_bytes(irtype);
}
switch(type->type) {
case TYPE_ATOMIC:
- return get_atomic_type_size(type);
+ return get_atomic_type_size(&type->atomic);
case TYPE_ENUM:
return get_mode_size_bytes(mode_Is);
case TYPE_COMPOUND_UNION:
case TYPE_COMPOUND_STRUCT:
- return get_compound_type_size(type);
+ return get_compound_type_size(&type->compound);
case TYPE_FUNCTION:
/* just a pointer to the function */
return get_mode_size_bytes(mode_P_code);
case TYPE_POINTER:
return get_mode_size_bytes(mode_P_data);
case TYPE_ARRAY:
- return get_array_type_size(type);
+ return get_array_type_size(&type->array);
case TYPE_BUILTIN:
case TYPE_TYPEDEF:
case TYPE_TYPEOF:
panic("Trying to determine size of invalid type");
}
-static unsigned count_parameters(const type_t *type)
+static unsigned count_parameters(const function_type_t *function_type)
{
unsigned count = 0;
- function_parameter_t *parameter = type->v.function_type.parameters;
+ function_parameter_t *parameter = function_type->parameters;
for ( ; parameter != NULL; parameter = parameter->next) {
++count;
}
static long fold_constant(const expression_t *expression);
-static ir_type *create_atomic_type(const type_t *type)
+static ir_type *create_atomic_type(const atomic_type_t *type)
{
ir_mode *mode = get_atomic_mode(type);
ident *id = get_mode_ident(mode);
return irtype;
}
-static ir_type *create_method_type(const type_t *type)
+static ir_type *create_method_type(const function_type_t *function_type)
{
- type_t *result_type = type->v.function_type.result_type;
+ type_t *return_type = function_type->return_type;
ident *id = unique_ident("functiontype");
- int n_parameters = count_parameters(type);
- int n_results = result_type == type_void ? 0 : 1;
+ int n_parameters = count_parameters(function_type);
+ int n_results = return_type == type_void ? 0 : 1;
ir_type *irtype = new_type_method(id, n_parameters, n_results);
- if(result_type != type_void) {
- ir_type *restype = get_ir_type(result_type);
+ if(return_type != type_void) {
+ ir_type *restype = get_ir_type(return_type);
set_method_res_type(irtype, 0, restype);
}
- function_parameter_t *parameter = type->v.function_type.parameters;
+ function_parameter_t *parameter = function_type->parameters;
int n = 0;
for( ; parameter != NULL; parameter = parameter->next) {
ir_type *p_irtype = get_ir_type(parameter->type);
++n;
}
- if(type->v.function_type.variadic || type->v.function_type.unspecified_parameters) {
+ if(function_type->variadic || function_type->unspecified_parameters) {
set_method_variadicity(irtype, variadicity_variadic);
}
return irtype;
}
-static ir_type *create_pointer_type(type_t *type)
+static ir_type *create_pointer_type(pointer_type_t *type)
{
- type_t *points_to = type->v.pointer_type.points_to;
+ type_t *points_to = type->points_to;
ir_type *ir_points_to;
/* Avoid endless recursion if the points_to type contains this poiner type
* again (might be a struct). We therefore first create a void* pointer
*/
ir_type *ir_type = new_type_pointer(unique_ident("pointer"),
ir_type_void, mode_P_data);
- type->firm_type = ir_type;
+ type->type.firm_type = ir_type;
ir_points_to = get_ir_type(points_to);
set_pointer_points_to_type(ir_type, ir_points_to);
return ir_type;
}
-static ir_type *create_array_type(type_t *type)
+static ir_type *create_array_type(array_type_t *type)
{
- type_t *element_type = type->v.array_type.element_type;
+ type_t *element_type = type->element_type;
ir_type *ir_element_type = get_ir_type(element_type);
ident *id = unique_ident("array");
ir_type *ir_type = new_type_array(id, 1, ir_element_type);
- if(type->v.array_type.size != NULL) {
- int n_elements = fold_constant(type->v.array_type.size);
+ if(type->size != NULL) {
+ int n_elements = fold_constant(type->size);
set_array_bounds_int(ir_type, 0, 0, n_elements);
#define INVALID_TYPE ((ir_type_ptr)-1)
-static ir_type *create_struct_type(type_t *type)
+static ir_type *create_struct_type(compound_type_t *type)
{
- symbol_t *symbol = type->v.compound_type.declaration->symbol;
+ symbol_t *symbol = type->declaration->symbol;
ident *id;
if(symbol != NULL) {
id = unique_ident(symbol->string);
}
ir_type *ir_type = new_type_struct(id);
- type->firm_type = ir_type;
+ type->type.firm_type = ir_type;
int align_all = 1;
int offset = 0;
- declaration_t *entry = type->v.compound_type.declaration->context.declarations;
+ declaration_t *entry = type->declaration->context.declarations;
for( ; entry != NULL; entry = entry->next) {
if(entry->namespc != NAMESPACE_NORMAL)
continue;
return ir_type;
}
-static ir_type *create_union_type(type_t *type)
+static ir_type *create_union_type(compound_type_t *type)
{
- declaration_t *declaration = type->v.compound_type.declaration;
+ declaration_t *declaration = type->declaration;
symbol_t *symbol = declaration->symbol;
ident *id;
if(symbol != NULL) {
}
ir_type *ir_type = new_type_union(id);
- type->firm_type = ir_type;
+ type->type.firm_type = ir_type;
int align_all = 1;
int size = 0;
return ir_type;
}
+static ir_node *expression_to_firm(const expression_t *expression);
+static inline ir_mode *get_ir_mode(type_t *type);
+
+static ir_type *create_enum_type(enum_type_t *const type)
+{
+ type->type.firm_type = ir_type_int;
+
+ ir_mode *const mode = get_ir_mode((type_t*) type);
+ tarval *const one = get_mode_one(mode);
+ tarval * tv_next = get_tarval_null(mode);
+
+ declaration_t *declaration = type->declaration->next;
+ for (; declaration != NULL; declaration = declaration->next) {
+ if (declaration->storage_class != STORAGE_CLASS_ENUM_ENTRY)
+ break;
+
+ declaration->declaration_type = DECLARATION_TYPE_ENUM_ENTRY;
+
+ expression_t *const init = declaration->init.enum_value;
+ if (init != NULL) {
+ ir_node *const cnst = expression_to_firm(init);
+ if (!is_Const(cnst)) {
+ panic("couldn't fold constant");
+ }
+ tv_next = get_Const_tarval(cnst);
+ }
+ declaration->v.enum_val = tv_next;
+ tv_next = tarval_add(tv_next, one);
+ }
+
+ return ir_type_int;
+}
+
static ir_type *get_ir_type(type_t *type)
{
assert(type != NULL);
type = skip_typeref(type);
- if(type->firm_type != NULL) {
- assert(type->firm_type != INVALID_TYPE);
- return type->firm_type;
+ if(type->base.firm_type != NULL) {
+ assert(type->base.firm_type != INVALID_TYPE);
+ return type->base.firm_type;
}
ir_type *firm_type = NULL;
switch(type->type) {
case TYPE_ATOMIC:
- firm_type = create_atomic_type(type);
+ firm_type = create_atomic_type(&type->atomic);
break;
case TYPE_FUNCTION:
- firm_type = create_method_type(type);
+ firm_type = create_method_type(&type->function);
break;
case TYPE_POINTER:
- firm_type = create_pointer_type(type);
+ firm_type = create_pointer_type(&type->pointer);
break;
case TYPE_ARRAY:
- firm_type = create_array_type(type);
+ firm_type = create_array_type(&type->array);
break;
case TYPE_COMPOUND_STRUCT:
- firm_type = create_struct_type(type);
+ firm_type = create_struct_type(&type->compound);
break;
case TYPE_COMPOUND_UNION:
- firm_type = create_union_type(type);
+ firm_type = create_union_type(&type->compound);
break;
case TYPE_ENUM:
- firm_type = ir_type_int;
+ firm_type = create_enum_type(&type->enumt);
break;
case TYPE_BUILTIN:
case TYPE_TYPEOF:
if(firm_type == NULL)
panic("unknown type found");
- type->firm_type = firm_type;
+ type->base.firm_type = firm_type;
return firm_type;
}
return entity;
}
-
-
-static ir_node *expression_to_firm(const expression_t *expression);
-
static dbg_info *get_dbg_info(const source_position_t *pos)
{
return (dbg_info*) pos;
}
-static ir_node *const_to_firm(const const_t *cnst)
+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);
if(mode_is_signed(mode)) {
len = snprintf(buf, sizeof(buf), "%lld", cnst->v.int_value);
} else {
- len = snprintf(buf, sizeof(buf), "%llu", cnst->v.int_value);
+ len = snprintf(buf, sizeof(buf), "%llu",
+ (unsigned long long) cnst->v.int_value);
}
tv = new_tarval_from_str(buf, len, mode);
}
return create_symconst(dbgi, entity);
}
-static ir_node *string_literal_to_firm(const string_literal_t* literal)
+static ir_node *string_literal_to_firm(
+ const string_literal_expression_t* literal)
{
return string_to_firm(&literal->expression.source_position, "Lstr",
literal->value);
}
-static ir_node *deref_address(type_t *const type, ir_node *const addr,
+static ir_node *wide_string_literal_to_firm(
+ const wide_string_literal_expression_t* const literal)
+{
+ ir_type *const global_type = get_glob_type();
+ ir_type *const elem_type = ir_type_wchar_t;
+ ir_type *const type = new_type_array(unique_ident("strtype"), 1,
+ elem_type);
+
+ ident *const id = unique_ident("Lstr");
+ ir_entity *const entity = new_entity(global_type, id, type);
+ set_entity_ld_ident(entity, id);
+ set_entity_variability(entity, variability_constant);
+
+ ir_mode *const mode = get_type_mode(elem_type);
+
+ const wchar_rep_t *const string = literal->value.begin;
+ const size_t slen = literal->value.size;
+
+ set_array_lower_bound_int(type, 0, 0);
+ set_array_upper_bound_int(type, 0, slen);
+ set_type_size_bytes(type, slen);
+ set_type_state(type, layout_fixed);
+
+ tarval **const tvs = xmalloc(slen * sizeof(tvs[0]));
+ for(size_t i = 0; i < slen; ++i) {
+ tvs[i] = new_tarval_from_long(string[i], mode);
+ }
+
+ set_array_entity_values(entity, tvs, slen);
+ free(tvs);
+
+ dbg_info *const dbgi = get_dbg_info(&literal->expression.source_position);
+
+ return create_symconst(dbgi, entity);
+}
+
+static ir_node *deref_address(ir_type *const irtype, ir_node *const addr,
dbg_info *const dbgi)
{
- switch (type->type) {
- case TYPE_ARRAY:
- case TYPE_COMPOUND_STRUCT:
- case TYPE_COMPOUND_UNION:
- return addr;
-
- default: {
- ir_mode *const mode = get_ir_mode(type);
- ir_node *const memory = get_store();
- ir_node *const load = new_d_Load(dbgi, memory, addr, mode);
- ir_node *const load_mem = new_d_Proj(dbgi, load, mode_M, pn_Load_M);
- ir_node *const load_res = new_d_Proj(dbgi, load, mode, pn_Load_res);
- set_store(load_mem);
- return load_res;
+ if(is_compound_type(irtype) || is_Array_type(irtype)) {
+ return addr;
+ }
+
+ ir_mode *const mode = get_type_mode(irtype);
+ ir_node *const memory = get_store();
+ ir_node *const load = new_d_Load(dbgi, memory, addr, mode);
+ ir_node *const load_mem = new_d_Proj(dbgi, load, mode_M, pn_Load_M);
+ ir_node *const load_res = new_d_Proj(dbgi, load, mode, pn_Load_res);
+ set_store(load_mem);
+ return load_res;
+}
+
+static ir_node *do_strict_conv(dbg_info *dbgi, ir_node *node)
+{
+ ir_mode *mode = get_irn_mode(node);
+
+ if(!(get_irg_fp_model(current_ir_graph) & fp_explicit_rounding))
+ return node;
+ if(!mode_is_float(mode))
+ return node;
+
+ /* check if there is already a Conv */
+ if (get_irn_op(node) == op_Conv) {
+ /* convert it into a strict Conv */
+ set_Conv_strict(node, 1);
+ return node;
+ }
+
+ /* otherwise create a new one */
+ return new_d_strictConv(dbgi, node, mode);
+}
+
+static ir_node *get_global_var_address(dbg_info *const dbgi,
+ const declaration_t *const decl)
+{
+ assert(decl->declaration_type == DECLARATION_TYPE_GLOBAL_VARIABLE);
+
+ ir_entity *const entity = decl->v.entity;
+ switch ((storage_class_tag_t)decl->storage_class) {
+ case STORAGE_CLASS_THREAD:
+ case STORAGE_CLASS_THREAD_EXTERN:
+ case STORAGE_CLASS_THREAD_STATIC: {
+ ir_node *const no_mem = new_NoMem();
+ ir_node *const tls = get_irg_tls(current_ir_graph);
+ return new_d_simpleSel(dbgi, no_mem, tls, entity);
}
+
+ default:
+ return create_symconst(dbgi, entity);
}
}
switch((declaration_type_t) declaration->declaration_type) {
case DECLARATION_TYPE_UNKNOWN:
- break;
+ if (declaration->storage_class != STORAGE_CLASS_ENUM_ENTRY) {
+ break;
+ }
+ get_ir_type(type);
+ /* FALLTHROUGH */
+
+ case DECLARATION_TYPE_ENUM_ENTRY: {
+ ir_mode *const mode = get_ir_mode(type);
+ return new_Const(mode, declaration->v.enum_val);
+ }
+
case DECLARATION_TYPE_LOCAL_VARIABLE: {
ir_mode *mode = get_ir_mode(type);
return get_value(declaration->v.value_number, mode);
return create_symconst(dbgi, declaration->v.entity);
}
case DECLARATION_TYPE_GLOBAL_VARIABLE: {
- ir_entity *entity = declaration->v.entity;
- ir_node *symconst = create_symconst(dbgi, entity);
- return deref_address(type, symconst, dbgi);
+ ir_node *const addr = get_global_var_address(dbgi, declaration);
+ ir_type *const irtype = get_entity_type(declaration->v.entity);
+ return deref_address(irtype, addr, dbgi);
}
+
case DECLARATION_TYPE_LOCAL_VARIABLE_ENTITY: {
ir_entity *entity = declaration->v.entity;
ir_node *frame = get_irg_frame(current_ir_graph);
ir_node *sel = new_d_simpleSel(dbgi, new_NoMem(), frame, entity);
- return deref_address(type, sel, dbgi);
+ ir_type *irtype = get_entity_type(entity);
+ return deref_address(irtype, sel, dbgi);
}
case DECLARATION_TYPE_COMPOUND_MEMBER:
return create_symconst(dbgi, declaration->v.entity);
}
case DECLARATION_TYPE_GLOBAL_VARIABLE: {
- ir_entity *entity = declaration->v.entity;
- ir_node *symconst = create_symconst(dbgi, entity);
- return symconst;
+ ir_node *const addr = get_global_var_address(dbgi, declaration);
+ return addr;
}
case DECLARATION_TYPE_LOCAL_VARIABLE_ENTITY: {
ir_entity *entity = declaration->v.entity;
return sel;
}
+
+ case DECLARATION_TYPE_ENUM_ENTRY:
+ panic("trying to reference enum entry");
+
case DECLARATION_TYPE_COMPOUND_MEMBER:
case DECLARATION_TYPE_LABEL_BLOCK:
panic("not implemented reference type");
dbg_info *dbgi = get_dbg_info(&call->expression.source_position);
assert(call->function->type == EXPR_BUILTIN_SYMBOL);
- builtin_symbol_expression_t *builtin
- = (builtin_symbol_expression_t*) call->function;
- symbol_t *symbol = builtin->symbol;
+ builtin_symbol_expression_t *builtin = &call->function->builtin_symbol;
- if(symbol == symbol_alloca) {
+ type_t *type = skip_typeref(builtin->expression.datatype);
+ assert(is_type_pointer(type));
+
+ type_t *function_type = skip_typeref(type->pointer.points_to);
+ symbol_t *symbol = builtin->symbol;
+
+ switch(symbol->ID) {
+ case T___builtin_alloca: {
if(call->arguments == NULL || call->arguments->next != NULL) {
panic("invalid number of parameters on __builtin_alloca");
}
ir_node *res = new_Proj(alloca, mode_P_data, pn_Alloc_res);
return res;
- } else {
+ }
+ case T___builtin_nan:
+ case T___builtin_nanf:
+ case T___builtin_nand: {
+ /* Ignore string for now... */
+ assert(is_type_function(function_type));
+ ir_mode *mode = get_ir_mode(function_type->function.return_type);
+ tarval *tv = get_mode_NAN(mode);
+ ir_node *res = new_d_Const(dbgi, mode, tv);
+ return res;
+ }
+ default:
panic("Unsupported builtin found\n");
}
}
{
assert(get_cur_block() != NULL);
- expression_t *function = call->function;
+ expression_t *function = call->function;
if(function->type == EXPR_BUILTIN_SYMBOL) {
return process_builtin_call(call);
}
- ir_node *callee = expression_to_firm(function);
+ ir_node *callee = expression_to_firm(function);
- type_t *type;
- if (function->datatype->type == TYPE_POINTER) {
- type_t *const ptr_type = function->datatype;
- assert(ptr_type->v.pointer_type.points_to->type == TYPE_FUNCTION);
- type = ptr_type->v.pointer_type.points_to;
- } else {
- assert(function->datatype->type == TYPE_FUNCTION);
- type = function->datatype;
- }
+ type_t *type = skip_typeref(function->base.datatype);
+ assert(is_type_pointer(type));
+ pointer_type_t *pointer_type = &type->pointer;
+ type_t *points_to = skip_typeref(pointer_type->points_to);
+ assert(is_type_function(points_to));
+ function_type_t *function_type = &points_to->function;
int n_parameters = 0;
call_argument_t *argument = call->arguments;
++n_parameters;
}
- ir_type *ir_method_type = get_ir_type((type_t*) type);
+ dbg_info *dbgi = get_dbg_info(&call->expression.source_position);
+
+ ir_type *ir_method_type = get_ir_type((type_t*) function_type);
ir_type *new_method_type = NULL;
- if(type->v.function_type.variadic || type->v.function_type.unspecified_parameters) {
+ if(function_type->variadic || function_type->unspecified_parameters) {
/* we need to construct a new method type matching the call
* arguments... */
int n_res = get_method_n_ress(ir_method_type);
expression_t *expression = argument->expression;
ir_node *arg_node = expression_to_firm(expression);
+ arg_node = do_strict_conv(dbgi, arg_node);
+
in[n] = arg_node;
if(new_method_type != NULL) {
- ir_type *irtype = get_ir_type(expression->datatype);
+ ir_type *irtype = get_ir_type(expression->base.datatype);
set_method_param_type(new_method_type, n, irtype);
}
if(new_method_type != NULL)
ir_method_type = new_method_type;
- dbg_info *dbgi = get_dbg_info(&call->expression.source_position);
ir_node *store = get_store();
ir_node *node = new_d_Call(dbgi, store, callee, n_parameters, in,
ir_method_type);
ir_node *mem = new_d_Proj(dbgi, node, mode_M, pn_Call_M_regular);
set_store(mem);
- type_t *result_type = type->v.function_type.result_type;
+ type_t *return_type = skip_typeref(function_type->return_type);
ir_node *result = NULL;
- if(result_type != type_void) {
- ir_mode *mode = get_ir_mode(result_type);
+
+ if(!is_type_atomic(return_type, ATOMIC_TYPE_VOID)) {
+ ir_mode *mode;
+ if(is_type_scalar(return_type)) {
+ mode = get_ir_mode(return_type);
+ } else {
+ mode = mode_P_data;
+ }
ir_node *resproj = new_d_Proj(dbgi, node, mode_T, pn_Call_T_result);
result = new_d_Proj(dbgi, resproj, mode, 0);
}
}
static void statement_to_firm(statement_t *statement);
-static ir_node *compound_statement_to_firm(statement_t *compound);
+static ir_node *compound_statement_to_firm(compound_statement_t *compound);
static ir_node *expression_to_addr(const expression_t *expression);
static void create_condition_evaluation(const expression_t *expression,
ir_node *true_block,
ir_node *false_block);
+static void assign_value(dbg_info *dbgi, ir_node *addr, type_t *type,
+ ir_node *value)
+{
+ value = do_strict_conv(dbgi, value);
+
+ ir_node *memory = get_store();
+
+ if(is_type_scalar(type)) {
+ ir_node *store = new_d_Store(dbgi, memory, addr, value);
+ ir_node *store_mem = new_d_Proj(dbgi, store, mode_M, pn_Store_M);
+ set_store(store_mem);
+ } else {
+ ir_type *irtype = get_ir_type(type);
+ ir_node *copyb = new_d_CopyB(dbgi, memory, addr, value, irtype);
+ ir_node *copyb_mem = new_Proj(copyb, mode_M, pn_CopyB_M_regular);
+ set_store(copyb_mem);
+ }
+}
+
static void set_value_for_expression(const expression_t *expression,
ir_node *value)
{
+ dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ value = do_strict_conv(dbgi, value);
+
if(expression->type == EXPR_REFERENCE) {
reference_expression_t *ref = (reference_expression_t*) expression;
}
}
- dbg_info *dbgi = get_dbg_info(&expression->source_position);
- ir_node *addr = expression_to_addr(expression);
- assert(get_irn_mode(value) == get_ir_mode(expression->datatype));
- ir_node *memory = get_store();
- ir_node *store = new_d_Store(dbgi, memory, addr, value);
- ir_node *store_mem = new_d_Proj(dbgi, store, mode_M, pn_Store_M);
- set_store(store_mem);
+ ir_node *addr = expression_to_addr(expression);
+ type_t *type = skip_typeref(expression->base.datatype);
+ assign_value(dbgi, addr, type, value);
}
static ir_node *create_conv(dbg_info *dbgi, ir_node *value, ir_mode *dest_mode)
static ir_node *create_incdec(const unary_expression_t *expression)
{
dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
- type_t *type = expression->expression.datatype;
+ type_t *type = skip_typeref(expression->expression.datatype);
ir_mode *mode = get_ir_mode(type);
expression_t *value = expression->value;
ir_node *value_node = expression_to_firm(value);
ir_node *offset;
- if(type->type == TYPE_POINTER) {
- unsigned elem_size = get_type_size(type->v.pointer_type.points_to);
+ if(is_type_pointer(type)) {
+ pointer_type_t *pointer_type = &type->pointer;
+ unsigned elem_size = get_type_size(pointer_type->points_to);
offset = new_Const_long(mode_Is, elem_size);
} else {
assert(is_type_arithmetic(type));
{
dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
type_t *type = skip_typeref(expression->expression.datatype);
+ ir_mode *mode = get_ir_mode(type);
if(expression->type == UNEXPR_TAKE_ADDRESS)
return expression_to_addr(expression->value);
switch(expression->type) {
case UNEXPR_NEGATE:
- return new_d_Minus(dbgi, value_node, get_ir_mode(type));
+ return new_d_Minus(dbgi, value_node, mode);
case UNEXPR_PLUS:
return value_node;
case UNEXPR_BITWISE_NEGATE:
- return new_d_Not(dbgi, value_node, get_ir_mode(type));
+ return new_d_Not(dbgi, value_node, mode);
case UNEXPR_NOT: {
if(get_irn_mode(value_node) != mode_b) {
value_node = create_conv(dbgi, value_node, mode_b);
}
value_node = new_d_Not(dbgi, value_node, mode_b);
- ir_mode *const mode = get_ir_mode(type);
if(mode != mode_b) {
value_node = create_conv(dbgi, value_node, mode);
}
return value_node;
}
- case UNEXPR_DEREFERENCE:
- return deref_address(type, value_node, dbgi);
+ case UNEXPR_DEREFERENCE: {
+ type_t *value_type = skip_typeref(value->base.datatype);
+ ir_type *irtype = get_ir_type(value_type);
+ assert(is_Pointer_type(irtype));
+ ir_type *points_to = get_pointer_points_to_type(irtype);
+ return deref_address(points_to, value_node, dbgi);
+ }
case UNEXPR_POSTFIX_INCREMENT:
case UNEXPR_POSTFIX_DECREMENT:
case UNEXPR_PREFIX_INCREMENT:
case UNEXPR_PREFIX_DECREMENT:
return create_incdec(expression);
- case UNEXPR_CAST:
+ case UNEXPR_CAST: {
+ ir_node *node = create_conv(dbgi, value_node, get_ir_mode(type));
+ node = do_strict_conv(dbgi, node);
+ return node;
+ }
+ case UNEXPR_CAST_IMPLICIT:
return create_conv(dbgi, value_node, get_ir_mode(type));
case UNEXPR_TAKE_ADDRESS:
dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
ir_node *left = expression_to_firm(expression->left);
ir_node *right = expression_to_firm(expression->right);
- type_t *type = expression->right->datatype;
+ type_t *type = expression->right->base.datatype;
/* 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);
dbg_info *const dbgi,
const create_arithmetic_func func)
{
- type_t *const points_to = type->v.pointer_type.points_to;
- const unsigned elem_size = get_type_size(points_to);
+ pointer_type_t *const pointer_type = (pointer_type_t*)type;
+ type_t *const points_to = pointer_type->points_to;
+ const unsigned elem_size = get_type_size(points_to);
assert(elem_size >= 1);
if (elem_size > 1) {
const binary_expression_t *expression, create_arithmetic_func func)
{
dbg_info *const dbgi = get_dbg_info(&expression->expression.source_position);
- type_t *const type = expression->expression.datatype;
+ type_t *const type = skip_typeref(expression->expression.datatype);
ir_node *value;
- if (type->type == TYPE_POINTER) {
+ if (is_type_pointer(type)) {
ir_node *const pointer = expression_to_firm(expression->left);
ir_node * integer = expression_to_firm(expression->right);
value = pointer_arithmetic(pointer, integer, type, dbgi, func);
expression_t *expr_left = expression->left;
expression_t *expr_right = expression->right;
- type_t *type_left = skip_typeref(expr_left->datatype);
- type_t *type_right = skip_typeref(expr_right->datatype);
+ type_t *type_left = skip_typeref(expr_left->base.datatype);
+ type_t *type_right = skip_typeref(expr_right->base.datatype);
if(is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
ir_mode *const mode = get_ir_mode(type);
return new_d_Add(dbgi, left, right, mode);
}
- if (type_left->type == TYPE_POINTER || type_left->type == TYPE_ARRAY) {
+ if (is_type_pointer(type_left)) {
return pointer_arithmetic(left, right, type, dbgi, new_d_Add);
} else {
- assert(type_right->type == TYPE_POINTER || type_right->type == TYPE_ARRAY);
+ assert(is_type_pointer(type_right));
return pointer_arithmetic(right, left, type, dbgi, new_d_Add);
}
}
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->datatype);
- type_t *const type_right = skip_typeref(expr_right->datatype);
+ type_t *const type_left = skip_typeref(expr_left->base.datatype);
+ type_t *const type_right = skip_typeref(expr_right->base.datatype);
if (is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
ir_mode *const mode = get_ir_mode(type);
return new_d_Sub(dbgi, left, right, mode);
- } else if (type_left->type == TYPE_POINTER && type_right->type == TYPE_POINTER) {
- const type_t *const ptr_type = type_left;
- const unsigned elem_size = get_type_size(ptr_type->v.pointer_type.points_to);
+ } else if (is_type_pointer(type_left) && is_type_pointer(type_right)) {
+ const pointer_type_t *const ptr_type = &type_left->pointer;
+ const unsigned elem_size = get_type_size(ptr_type->points_to);
ir_mode *const mode = get_ir_mode(type);
ir_node *const sub = new_d_Sub(dbgi, left, right, mode);
ir_node *const cnst = new_Const_long(mode_Is, (long)elem_size);
return new_d_Proj(dbgi, div, mode, pn_Div_res);
}
- assert(type_left->type == TYPE_POINTER);
+ assert(is_type_pointer(type_left));
return pointer_arithmetic(left, right, type_left, dbgi, new_d_Sub);
}
case BINEXPR_SHIFTRIGHT_ASSIGN:
case BINEXPR_SHIFTRIGHT: {
expression_t *expr_left = expression->left;
- type_t *type_left = skip_typeref(expr_left->datatype);
+ type_t *type_left = skip_typeref(expr_left->base.datatype);
if(is_type_signed(type_left)) {
res = new_d_Shrs(dbgi, left, right, mode);
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->datatype;
+ type_t *type = expression->right->base.datatype;
ir_mode *mode = get_ir_mode(type);
left = create_conv(dbgi, left, mode);
ir_node *op;
case BINEXPR_ASSIGN: {
ir_node *right = expression_to_firm(expression->right);
set_value_for_expression(expression->left, right);
+
return right;
}
case BINEXPR_ADD:
static ir_node *array_access_addr(const array_access_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
- ir_node *base_addr;
- ir_node *offset;
+ dbg_info *dbgi = get_dbg_info(&expression->expression.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_Iu);
- type_t *type_left = skip_typeref(expression->array_ref->datatype);
- type_t *type_right = skip_typeref(expression->index->datatype);
+ type_t *ref_type = skip_typeref(expression->array_ref->base.datatype);
+ assert(is_type_pointer(ref_type));
+ pointer_type_t *pointer_type = (pointer_type_t*) ref_type;
- if(type_left->type == TYPE_POINTER || type_left->type == TYPE_ARRAY) {
- base_addr = expression_to_firm(expression->array_ref);
- offset = expression_to_firm(expression->index);
- } else {
- assert(type_right->type == TYPE_POINTER
- || type_right->type == TYPE_ARRAY);
- base_addr = expression_to_firm(expression->index);
- offset = expression_to_firm(expression->array_ref);
- }
- offset = create_conv(dbgi, offset, mode_Iu);
-
- unsigned elem_size = get_type_size(expression->expression.datatype);
+ unsigned elem_size = get_type_size(pointer_type->points_to);
ir_node *elem_size_const = new_Const_long(mode_Iu, elem_size);
ir_node *real_offset = new_d_Mul(dbgi, offset, elem_size_const,
mode_Iu);
static ir_node *array_access_to_firm(
const array_access_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
- ir_node *addr = array_access_addr(expression);
- type_t *type = skip_typeref(expression->expression.datatype);
- return deref_address(type, addr, dbgi);
+ dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
+ ir_node *addr = array_access_addr(expression);
+ type_t *type = revert_automatic_type_conversion(
+ (const expression_t*) expression);
+ type = skip_typeref(type);
+ ir_type *irtype = get_ir_type(type);
+
+ return deref_address(irtype, addr, dbgi);
}
static ir_node *sizeof_to_firm(const sizeof_expression_t *expression)
{
type_t *type = expression->type;
if(type == NULL) {
- type = expression->size_expression->datatype;
+ type = expression->size_expression->base.datatype;
assert(type != NULL);
}
mature_immBlock(common_block);
/* TODO improve static semantics, so either both or no values are NULL */
- if (true_val == NULL || false_val == NULL) return NULL;
+ if (true_val == NULL || false_val == NULL)
+ return NULL;
ir_node *in[2] = { true_val, false_val };
ir_mode *mode = get_irn_mode(true_val);
static ir_node *select_to_firm(const select_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
- ir_node *addr = select_addr(expression);
- type_t *type = skip_typeref(expression->expression.datatype);
- return deref_address(type, addr, dbgi);
+ dbg_info *dbgi = get_dbg_info(&expression->expression.source_position);
+ ir_node *addr = select_addr(expression);
+ type_t *type = revert_automatic_type_conversion(
+ (const expression_t*) expression);
+ type = skip_typeref(type);
+ ir_type *irtype = get_ir_type(type);
+
+ return deref_address(irtype, addr, dbgi);
}
/* Values returned by __builtin_classify_type. */
static ir_node *classify_type_to_firm(const classify_type_expression_t *const expr)
{
- const type_t *const type = expr->type_expression->datatype;
+ const type_t *const type = expr->type_expression->base.datatype;
gcc_type_class tc;
switch (type->type)
{
- case TYPE_ATOMIC:
- switch (type->v.atomic_type.atype) {
+ case TYPE_ATOMIC: {
+ const atomic_type_t *const atomic_type = &type->atomic;
+ switch (atomic_type->atype) {
// should not be reached
case ATOMIC_TYPE_INVALID:
tc = no_type_class;
panic("Unimplemented case in classify_type_to_firm().");
}
break;
+ }
case TYPE_ARRAY: // gcc handles this as pointer
case TYPE_FUNCTION: // gcc handles this as pointer
return new_d_Const(dbgi, mode, tv);
}
-static ir_node *function_name_to_firm(const string_literal_t *const expr)
+static ir_node *function_name_to_firm(
+ const string_literal_expression_t *const expr)
{
if (current_function_name == NULL) {
const source_position_t *const src_pos =
statement_t *statement = expr->statement;
assert(statement->type == STATEMENT_COMPOUND);
- return compound_statement_to_firm(statement);
+ return compound_statement_to_firm((compound_statement_t*) statement);
}
static ir_node *dereference_addr(const unary_expression_t *const expression)
{
switch(expression->type) {
case EXPR_REFERENCE:
- return reference_addr((const reference_expression_t*) expression);
+ return reference_addr(&expression->reference);
case EXPR_ARRAY_ACCESS:
- return array_access_addr((const array_access_expression_t*) expression);
+ return array_access_addr(&expression->array_access);
case EXPR_SELECT:
- return select_addr((const select_expression_t*) expression);
+ return select_addr(&expression->select);
+ case EXPR_CALL:
+ return call_expression_to_firm(&expression->call);
case EXPR_UNARY: {
- const unary_expression_t *const unary_expr =
- (const unary_expression_t*)expression;
+ const unary_expression_t *const unary_expr = &expression->unary;
if (unary_expr->type == UNEXPR_DEREFERENCE) {
return dereference_addr(unary_expr);
}
{
switch(expression->type) {
case EXPR_CONST:
- return const_to_firm((const const_t*) expression);
+ return const_to_firm(&expression->conste);
case EXPR_STRING_LITERAL:
- return string_literal_to_firm((const string_literal_t*) expression);
+ return string_literal_to_firm(&expression->string);
+ case EXPR_WIDE_STRING_LITERAL:
+ return wide_string_literal_to_firm(&expression->wide_string);
case EXPR_REFERENCE:
- return reference_expression_to_firm(
- (const reference_expression_t*) expression);
+ return reference_expression_to_firm(&expression->reference);
case EXPR_CALL:
- return call_expression_to_firm((const call_expression_t*) expression);
+ return call_expression_to_firm(&expression->call);
case EXPR_UNARY:
- return unary_expression_to_firm((const unary_expression_t*) expression);
+ return unary_expression_to_firm(&expression->unary);
case EXPR_BINARY:
- return binary_expression_to_firm(
- (const binary_expression_t*) expression);
+ return binary_expression_to_firm(&expression->binary);
case EXPR_ARRAY_ACCESS:
- return array_access_to_firm(
- (const array_access_expression_t*) expression);
+ return array_access_to_firm(&expression->array_access);
case EXPR_SIZEOF:
- return sizeof_to_firm((const sizeof_expression_t*) expression);
+ return sizeof_to_firm(&expression->sizeofe);
case EXPR_CONDITIONAL:
- return conditional_to_firm((const conditional_expression_t*)expression);
+ return conditional_to_firm(&expression->conditional);
case EXPR_SELECT:
- return select_to_firm((const select_expression_t*) expression);
+ return select_to_firm(&expression->select);
case EXPR_CLASSIFY_TYPE:
- return classify_type_to_firm((const classify_type_expression_t*)expression);
+ return classify_type_to_firm(&expression->classify_type);
case EXPR_FUNCTION:
case EXPR_PRETTY_FUNCTION:
- return function_name_to_firm((const string_literal_t*)expression);
+ return function_name_to_firm(&expression->string);
case EXPR_STATEMENT:
- return statement_expression_to_firm(
- (const statement_expression_t*) expression);
+ return statement_expression_to_firm(&expression->statement);
case EXPR_OFFSETOF:
case EXPR_VA_ARG:
case EXPR_BUILTIN_SYMBOL:
ir_node *res = _expression_to_firm(expression);
if(res != NULL && get_irn_mode(res) == mode_b) {
- ir_mode *mode = get_ir_mode(expression->datatype);
+ ir_mode *mode = get_ir_mode(expression->base.datatype);
res = create_conv(NULL, res, mode);
}
break;
}
- dbg_info *dbgi = get_dbg_info(&expression->source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
ir_node *condition = expression_to_modeb(expression);
ir_node *cond = new_d_Cond(dbgi, condition);
ir_node *true_proj = new_d_Proj(dbgi, cond, mode_X, pn_Cond_true);
set_cur_block(NULL);
}
-
-static void return_statement_to_firm(statement_t *statement)
+static void return_statement_to_firm(return_statement_t *statement)
{
if(get_cur_block() == NULL)
return;
- dbg_info *dbgi = get_dbg_info(&statement->source_position);
- ir_node *ret;
+ ir_type *func_irtype = get_ir_type(current_function_decl->type);
- if(statement->v.return_value != NULL) {
- ir_node *retval = expression_to_firm(statement->v.return_value);
- ir_node *in[1];
+ dbg_info *dbgi = get_dbg_info(&statement->statement.source_position);
- in[0] = retval;
- ret = new_d_Return(dbgi, get_store(), 1, in);
+ 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);
+ node = do_strict_conv(dbgi, node);
+ in[0] = node;
+ } else {
+ ir_mode *mode;
+ if(is_compound_type(res_type)) {
+ mode = mode_P_data;
+ } else {
+ mode = get_type_mode(res_type);
+ }
+ in[0] = new_Unknown(mode);
+ }
+ in_len = 1;
} else {
- ret = new_d_Return(dbgi, get_store(), 0, NULL);
+ /* build return_value for its side effects */
+ if(statement->return_value != NULL) {
+ expression_to_firm(statement->return_value);
+ }
+ in_len = 0;
}
+
+ ir_node *store = get_store();
+ ir_node *ret = new_d_Return(dbgi, store, in_len, in);
+
ir_node *end_block = get_irg_end_block(current_ir_graph);
add_immBlock_pred(end_block, ret);
set_cur_block(NULL);
}
-static ir_node *expression_statement_to_firm(statement_t *statement)
+static ir_node *expression_statement_to_firm(expression_statement_t *statement)
{
if(get_cur_block() == NULL)
return NULL;
- return expression_to_firm(statement->v.expression);
+ return expression_to_firm(statement->expression);
}
-static ir_node *compound_statement_to_firm(statement_t *compound)
+static ir_node *compound_statement_to_firm(compound_statement_t *compound)
{
ir_node *result = NULL;
- statement_t *statement = compound->v.compound_stmt.statements;
- for( ; statement != NULL; statement = statement->next) {
+ statement_t *statement = compound->statements;
+ for( ; statement != NULL; statement = statement->base.next) {
//context2firm(&statement->context);
- if(statement->next == NULL && statement->type == STATEMENT_EXPRESSION) {
- result = expression_statement_to_firm(statement);
+ if(statement->base.next == NULL
+ && statement->type == STATEMENT_EXPRESSION) {
+ result = expression_statement_to_firm(
+ (expression_statement_t*) statement);
break;
}
statement_to_firm(statement);
return result;
}
-static void if_statement_to_firm(statement_t *statement)
+static void if_statement_to_firm(if_statement_t *statement)
{
ir_node *cur_block = get_cur_block();
/* the true (blocks) */
ir_node *true_block;
- if (statement->v.if_stmt.true_statement != NULL) {
+ if (statement->true_statement != NULL) {
true_block = new_immBlock();
- statement_to_firm(statement->v.if_stmt.true_statement);
+ statement_to_firm(statement->true_statement);
if(get_cur_block() != NULL) {
ir_node *jmp = new_Jmp();
add_immBlock_pred(fallthrough_block, jmp);
/* the false (blocks) */
ir_node *false_block;
- if(statement->v.if_stmt.false_statement != NULL) {
+ if(statement->false_statement != NULL) {
false_block = new_immBlock();
- statement_to_firm(statement->v.if_stmt.false_statement);
+ statement_to_firm(statement->false_statement);
if(get_cur_block() != NULL) {
ir_node *jmp = new_Jmp();
add_immBlock_pred(fallthrough_block, jmp);
/* create the condition */
if(cur_block != NULL) {
set_cur_block(cur_block);
- create_condition_evaluation(statement->v.if_stmt.condition, true_block,
+ create_condition_evaluation(statement->condition, true_block,
false_block);
}
set_cur_block(fallthrough_block);
}
-static void while_statement_to_firm(statement_t *statement)
+static void while_statement_to_firm(while_statement_t *statement)
{
ir_node *jmp = NULL;
if(get_cur_block() != NULL) {
/* the loop body */
ir_node *body_block;
- if (statement->v.while_stmt.body != NULL) {
+ if (statement->body != NULL) {
ir_node *old_continue_label = continue_label;
ir_node *old_break_label = break_label;
continue_label = header_block;
break_label = false_block;
body_block = new_immBlock();
- statement_to_firm(statement->v.while_stmt.body);
+ statement_to_firm(statement->body);
assert(continue_label == header_block);
assert(break_label == false_block);
break_label = old_break_label;
if(get_cur_block() != NULL) {
- ir_node *jmp = new_Jmp();
+ jmp = new_Jmp();
add_immBlock_pred(header_block, jmp);
}
} else {
/* create the condition */
set_cur_block(header_block);
- create_condition_evaluation(statement->v.while_stmt.condition, body_block, false_block);
+ create_condition_evaluation(statement->condition, body_block, false_block);
mature_immBlock(body_block);
mature_immBlock(false_block);
mature_immBlock(header_block);
set_cur_block(false_block);
}
-static void do_while_statement_to_firm(statement_t *statement)
+static void do_while_statement_to_firm(do_while_statement_t *statement)
{
ir_node *jmp = NULL;
if(get_cur_block() != NULL) {
add_immBlock_pred(body_block, jmp);
}
- if (statement->v.while_stmt.body != NULL) {
+ if (statement->body != NULL) {
ir_node *old_continue_label = continue_label;
ir_node *old_break_label = break_label;
continue_label = header_block;
break_label = false_block;
- statement_to_firm(statement->v.while_stmt.body);
+ statement_to_firm(statement->body);
assert(continue_label == header_block);
assert(break_label == false_block);
/* create the condition */
set_cur_block(header_block);
- create_condition_evaluation(statement->v.while_stmt.condition, body_block, false_block);
+ create_condition_evaluation(statement->condition, body_block, false_block);
mature_immBlock(body_block);
mature_immBlock(false_block);
mature_immBlock(header_block);
set_cur_block(false_block);
}
-static void for_statement_to_firm(statement_t *statement)
+static void for_statement_to_firm(for_statement_t *statement)
{
ir_node *jmp = NULL;
if (get_cur_block() != NULL) {
- if(statement->v.for_stmt.initialisation != NULL) {
- expression_to_firm(statement->v.for_stmt.initialisation);
+ if(statement->initialisation != NULL) {
+ expression_to_firm(statement->initialisation);
}
jmp = new_Jmp();
}
/* create the step block */
ir_node *const step_block = new_immBlock();
- if (statement->v.for_stmt.step != NULL) {
- expression_to_firm(statement->v.for_stmt.step);
+ if (statement->step != NULL) {
+ expression_to_firm(statement->step);
}
ir_node *const step_jmp = new_Jmp();
/* the loop body */
ir_node * body_block;
- if (statement->v.for_stmt.body != NULL) {
+ if (statement->body != NULL) {
ir_node *const old_continue_label = continue_label;
ir_node *const old_break_label = break_label;
continue_label = step_block;
break_label = false_block;
body_block = new_immBlock();
- statement_to_firm(statement->v.for_stmt.body);
+ statement_to_firm(statement->body);
assert(continue_label == step_block);
assert(break_label == false_block);
break_label = old_break_label;
if (get_cur_block() != NULL) {
- ir_node *const jmp = new_Jmp();
+ jmp = new_Jmp();
add_immBlock_pred(step_block, jmp);
}
} else {
/* create the condition */
set_cur_block(header_block);
- if (statement->v.for_stmt.condition != NULL) {
- create_condition_evaluation(statement->v.for_stmt.condition, body_block,
+ if (statement->condition != NULL) {
+ create_condition_evaluation(statement->condition, body_block,
false_block);
} else {
keep_alive(header_block);
- ir_node *jmp = new_Jmp();
+ jmp = new_Jmp();
add_immBlock_pred(body_block, jmp);
}
ir_entity *entity = new_entity(parent_type, id, irtype);
set_entity_ld_ident(entity, id);
- declaration->declaration_type = declaration_type;
+ declaration->declaration_type = (unsigned char) declaration_type;
declaration->v.entity = entity;
set_entity_variability(entity, variability_uninitialized);
/* TODO: visibility? */
return path;
}
-static void create_initializer_value(initializer_t *initializer,
+static void create_initializer_value(initializer_value_t *initializer,
ir_entity *entity,
compound_graph_path_entry_t *entry,
int len)
{
- ir_node *node = expression_to_firm(initializer->v.value);
+ ir_node *node = expression_to_firm(initializer->value);
ir_type *type = get_entity_type(entity);
compound_graph_path *path = create_compound_path(type, entry, len);
add_compound_ent_value_w_path(entity, node, path);
}
-static void create_initializer_compound(initializer_t *initializer,
- type_t *type,
+static void create_initializer_compound(initializer_list_t *initializer,
+ compound_type_t *type,
ir_entity *entity,
compound_graph_path_entry_t *last_entry,
int len)
{
- declaration_t *compound_declaration = type->v.compound_type.declaration;
+ declaration_t *compound_declaration = type->declaration;
declaration_t *compound_entry = compound_declaration->context.declarations;
if(compound_entry->namespc != NAMESPACE_NORMAL)
continue;
- if(i >= initializer->v.list.len)
+ if(i >= initializer->len)
break;
entry.v.entity = compound_entry->v.entity;
- initializer_t *sub_initializer = initializer->v.list.initializers[i];
+ initializer_t *sub_initializer = initializer->initializers[i];
assert(compound_entry != NULL);
assert(compound_entry->declaration_type
== DECLARATION_TYPE_COMPOUND_MEMBER);
if(sub_initializer->type == INITIALIZER_VALUE) {
- create_initializer_value(sub_initializer, entity, &entry, len);
+ create_initializer_value(&sub_initializer->value,
+ entity, &entry, len);
} else {
- type_t *type = skip_typeref(compound_entry->type);
- create_initializer_object(sub_initializer, type, entity, &entry,
- len);
+ type_t *entry_type = skip_typeref(compound_entry->type);
+ create_initializer_object(sub_initializer, entry_type, entity,
+ &entry, len);
}
++i;
}
}
-static void create_initializer_array(initializer_t *initializer,
- type_t *type, ir_entity *entity,
+static void create_initializer_array(initializer_list_t *initializer,
+ array_type_t *type, ir_entity *entity,
compound_graph_path_entry_t *last_entry,
int len)
{
- type_t *element_type = type->v.array_type.element_type;
+ type_t *element_type = type->element_type;
element_type = skip_typeref(element_type);
compound_graph_path_entry_t entry;
entry.prev = last_entry;
++len;
- for(size_t i = 0; i < initializer->v.list.len; ++i) {
+ size_t i;
+ for(i = 0; i < initializer->len; ++i) {
entry.v.array_index = i;
- initializer_t *sub_initializer = initializer->v.list.initializers[i];
+ initializer_t *sub_initializer = initializer->initializers[i];
if(sub_initializer->type == INITIALIZER_VALUE) {
- create_initializer_value(sub_initializer, entity, &entry, len);
+ create_initializer_value(&sub_initializer->value,
+ entity, &entry, len);
} else {
- assert(sub_initializer->type == INITIALIZER_LIST);
create_initializer_object(sub_initializer, element_type, entity,
&entry, len);
}
}
+
+#if 0
+ /* TODO: initialize rest... */
+ if(type->size_expression != NULL) {
+ size_t array_len = fold_constant(type->size_expression);
+ for( ; i < array_len; ++i) {
+
+ }
+ }
+#endif
}
-static void create_initializer_string(initializer_t *initializer,
- type_t *type, ir_entity *entity,
+static void create_initializer_string(initializer_string_t *initializer,
+ array_type_t *type, ir_entity *entity,
compound_graph_path_entry_t *last_entry,
int len)
{
- type_t *element_type = type->v.array_type.element_type;
+ type_t *element_type = type->element_type;
element_type = skip_typeref(element_type);
compound_graph_path_entry_t entry;
ir_type *irtype = get_entity_type(entity);
size_t arr_len = get_array_type_size(type);
- const char *p = initializer->v.string;
+ const char *p = initializer->string;
size_t i = 0;
for(i = 0; i < arr_len; ++i, ++p) {
entry.v.array_index = i;
static void create_initializer_object(initializer_t *initializer, type_t *type,
ir_entity *entity, compound_graph_path_entry_t *entry, int len)
{
- if(type->type == TYPE_ARRAY) {
+ if(is_type_array(type)) {
+ array_type_t *array_type = &type->array;
+
if(initializer->type == INITIALIZER_STRING) {
- create_initializer_string(initializer, type, entity, entry, len);
+ initializer_string_t *string = &initializer->string;
+ create_initializer_string(string, array_type, entity, entry, len);
} else {
assert(initializer->type == INITIALIZER_LIST);
- create_initializer_array(initializer, type, entity, entry, len);
+ initializer_list_t *list = &initializer->list;
+ create_initializer_array(list, array_type, entity, entry, len);
}
} else {
assert(initializer->type == INITIALIZER_LIST);
+ initializer_list_t *list = &initializer->list;
- assert(type->type == TYPE_COMPOUND_STRUCT
- || type->type == TYPE_COMPOUND_UNION);
- create_initializer_compound(initializer, type, entity, entry, len);
+ assert(is_type_compound(type));
+ compound_type_t *compound_type = &type->compound;
+ create_initializer_compound(list, compound_type, entity, entry, len);
}
}
ir_node *frame = get_irg_frame(current_ir_graph);
ir_node *addr = new_d_simpleSel(dbgi, nomem, frame, entity);
- if(is_atomic_entity(entity)) {
- assert(initializer->type == INITIALIZER_VALUE);
+ if(initializer->type == INITIALIZER_VALUE) {
+ initializer_value_t *initializer_value = &initializer->value;
- ir_node *value = expression_to_firm(initializer->v.value);
- ir_node *store = new_d_Store(dbgi, memory, addr, value);
- ir_node *store_mem = new_d_Proj(dbgi, store, mode_M, pn_Store_M);
- set_store(store_mem);
+ ir_node *value = expression_to_firm(initializer_value->value);
+ type_t *type = skip_typeref(declaration->type);
+ assign_value(dbgi, addr, type, value);
return;
}
if(initializer == NULL)
return;
- declaration_type_t declaration_type = (declaration_type_t)declaration->declaration_type;
+ declaration_type_t declaration_type
+ = (declaration_type_t) declaration->declaration_type;
if(declaration_type == DECLARATION_TYPE_LOCAL_VARIABLE_ENTITY) {
create_initializer_local_variable_entity(declaration);
return;
}
if(initializer->type == INITIALIZER_VALUE) {
- ir_node *value = expression_to_firm(initializer->v.value);
+ initializer_value_t *initializer_value = &initializer->value;
+
+ ir_node *value = expression_to_firm(initializer_value->value);
if(declaration_type == DECLARATION_TYPE_LOCAL_VARIABLE) {
set_value(declaration->v.value_number, value);
set_atomic_ent_value(entity, value);
}
} else {
- declaration_type_t declaration_type = (declaration_type_t)declaration->declaration_type;
assert(declaration_type == DECLARATION_TYPE_LOCAL_VARIABLE_ENTITY
|| declaration_type == DECLARATION_TYPE_GLOBAL_VARIABLE);
bool needs_entity = declaration->address_taken;
type_t *type = skip_typeref(declaration->type);
- if(type->type == TYPE_ARRAY
- || type->type == TYPE_COMPOUND_STRUCT
- || type->type == TYPE_COMPOUND_UNION) {
+ if(is_type_array(type) || is_type_compound(type)) {
needs_entity = true;
}
current_ir_graph = old_current_ir_graph;
}
-static void declaration_statement_to_firm(statement_t *statement)
+static void declaration_statement_to_firm(declaration_statement_t *statement)
{
- declaration_t *declaration = statement->v.declaration_stmt.begin;
- declaration_t *end = statement->v.declaration_stmt.end->next;
+ declaration_t *declaration = statement->declarations_begin;
+ declaration_t *end = statement->declarations_end->next;
for( ; declaration != end; declaration = declaration->next) {
- type_t *type = declaration->type;
+ type_t *type = skip_typeref(declaration->type);
- switch(declaration->storage_class) {
+ switch ((storage_class_tag_t) declaration->storage_class) {
case STORAGE_CLASS_TYPEDEF:
continue;
case STORAGE_CLASS_STATIC:
case STORAGE_CLASS_NONE:
case STORAGE_CLASS_AUTO:
case STORAGE_CLASS_REGISTER:
- if(type->type == TYPE_FUNCTION) {
+ if(is_type_function(type)) {
panic("nested functions not supported yet");
} else {
create_local_variable(declaration);
}
continue;
+ case STORAGE_CLASS_THREAD:
+ case STORAGE_CLASS_THREAD_EXTERN:
+ case STORAGE_CLASS_THREAD_STATIC:
+ break;
}
panic("invalid storage class found");
}
if(get_cur_block() == NULL)
return;
- dbg_info *dbgi = get_dbg_info(&statement->source_position);
+ dbg_info *dbgi = get_dbg_info(&statement->base.source_position);
ir_node *jump = new_d_Jmp(dbgi);
add_immBlock_pred(target_block, jump);
set_cur_block(NULL);
}
-static void switch_statement_to_firm(const statement_t *statement)
+static void switch_statement_to_firm(const switch_statement_t *statement)
{
- dbg_info *dbgi = get_dbg_info(&statement->source_position);
+ dbg_info *dbgi = get_dbg_info(&statement->statement.source_position);
- ir_node *expression = expression_to_firm(statement->v.switch_stmt.expression);
+ ir_node *expression = expression_to_firm(statement->expression);
ir_node *cond = new_d_Cond(dbgi, expression);
ir_node *break_block = new_immBlock();
current_switch_cond = cond;
break_label = break_block;
- statement_to_firm(statement->v.switch_stmt.body);
+ statement_to_firm(statement->body);
if(get_cur_block() != NULL) {
ir_node *jmp = new_Jmp();
ir_node *cnst = expression_to_firm(expression);
if(!is_Const(cnst)) {
- panic("couldn't fold constant");
+ panic("couldn't fold constantl");
}
tarval *tv = get_Const_tarval(cnst);
if(!tarval_is_long(tv)) {
return res;
}
-static void case_label_to_firm(const statement_t *statement)
+static void case_label_to_firm(const case_label_statement_t *statement)
{
- dbg_info *dbgi = get_dbg_info(&statement->source_position);
+ dbg_info *dbgi = get_dbg_info(&statement->statement.source_position);
ir_node *const fallthrough = (get_cur_block() == NULL ? NULL : new_Jmp());
* node... */
ir_node *proj;
set_cur_block(get_nodes_block(current_switch_cond));
- if(statement->v.case_label_stmt.expression) {
- long pn = fold_constant(statement->v.case_label_stmt.expression);
+ if(statement->expression) {
+ long pn = fold_constant(statement->expression);
if(pn == MAGIC_DEFAULT_PN_NUMBER) {
/* oops someone detected our cheating... */
panic("magic default pn used");
add_immBlock_pred(block, proj);
mature_immBlock(block);
- statement_to_firm(statement->v.case_label_stmt.label_statement);
+ statement_to_firm(statement->label_statement);
}
static ir_node *get_label_block(declaration_t *label)
return block;
}
-static void label_to_firm(const statement_t *statement)
+static void label_to_firm(const label_statement_t *statement)
{
- ir_node *block = get_label_block(statement->v.label_stmt.label);
+ ir_node *block = get_label_block(statement->label);
if(get_cur_block() != NULL) {
ir_node *jmp = new_Jmp();
set_cur_block(block);
keep_alive(block);
- statement_to_firm(statement->v.label_stmt.label_statement);
+ statement_to_firm(statement->label_statement);
}
-static void goto_to_firm(const statement_t *statement)
+static void goto_to_firm(const goto_statement_t *statement)
{
if(get_cur_block() == NULL)
return;
- ir_node *block = get_label_block(statement->v.goto_label);
+ ir_node *block = get_label_block(statement->label);
ir_node *jmp = new_Jmp();
add_immBlock_pred(block, jmp);
static void statement_to_firm(statement_t *statement)
{
switch(statement->type) {
+ case STATEMENT_INVALID:
+ panic("invalid statement found");
case STATEMENT_COMPOUND:
- compound_statement_to_firm(statement);
+ compound_statement_to_firm(&statement->compound);
return;
case STATEMENT_RETURN:
- return_statement_to_firm(statement);
+ return_statement_to_firm(&statement->returns);
return;
case STATEMENT_EXPRESSION:
- expression_statement_to_firm(statement);
+ expression_statement_to_firm(&statement->expression);
return;
case STATEMENT_IF:
- if_statement_to_firm(statement);
+ if_statement_to_firm(&statement->ifs);
return;
case STATEMENT_WHILE:
- while_statement_to_firm(statement);
+ while_statement_to_firm(&statement->whiles);
return;
case STATEMENT_DO_WHILE:
- do_while_statement_to_firm(statement);
+ do_while_statement_to_firm(&statement->do_while);
return;
case STATEMENT_DECLARATION:
- declaration_statement_to_firm(statement);
+ declaration_statement_to_firm(&statement->declaration);
return;
case STATEMENT_BREAK:
create_jump_statement(statement, break_label);
create_jump_statement(statement, continue_label);
return;
case STATEMENT_SWITCH:
- switch_statement_to_firm(statement);
+ switch_statement_to_firm(&statement->switchs);
return;
case STATEMENT_CASE_LABEL:
- case_label_to_firm(statement);
+ case_label_to_firm(&statement->case_label);
return;
case STATEMENT_FOR:
- for_statement_to_firm(statement);
+ for_statement_to_firm(&statement->fors);
return;
case STATEMENT_LABEL:
- label_to_firm(statement);
+ label_to_firm(&statement->label);
return;
case STATEMENT_GOTO:
- goto_to_firm(statement);
+ goto_to_firm(&statement->gotos);
return;
- default:
+ case STATEMENT_ASM:
break;
}
panic("Statement not implemented\n");
case TYPE_ATOMIC:
case TYPE_ENUM:
case TYPE_POINTER:
- if (!decl->address_taken) ++count;
+ if (!decl->address_taken)
+ ++count;
break;
default: break;
static int count_decls_in_stmts(const statement_t *stmt)
{
int count = 0;
- for (; stmt != NULL; stmt = stmt->next) {
+ for (; stmt != NULL; stmt = stmt->base.next) {
switch (stmt->type) {
- case STATEMENT_DECLARATION:
- count += count_local_declarations(stmt->v.declaration_stmt.begin,
- stmt->v.declaration_stmt.end->next);
+ case STATEMENT_DECLARATION: {
+ const declaration_statement_t *const decl_stmt =
+ (const declaration_statement_t*)stmt;
+ count += count_local_declarations(decl_stmt->declarations_begin,
+ decl_stmt->declarations_end->next);
break;
+ }
- case STATEMENT_COMPOUND:
- count += count_decls_in_stmts(stmt->v.compound_stmt.statements);
+ case STATEMENT_COMPOUND: {
+ const compound_statement_t *const comp =
+ (const compound_statement_t*)stmt;
+ count += count_decls_in_stmts(comp->statements);
break;
+ }
- case STATEMENT_IF:
- count += count_decls_in_stmts(stmt->v.if_stmt.true_statement);
- count += count_decls_in_stmts(stmt->v.if_stmt.false_statement);
+ case STATEMENT_IF: {
+ const if_statement_t *const if_stmt = (const if_statement_t*)stmt;
+ count += count_decls_in_stmts(if_stmt->true_statement);
+ count += count_decls_in_stmts(if_stmt->false_statement);
break;
+ }
- case STATEMENT_SWITCH:
- count += count_decls_in_stmts(stmt->v.switch_stmt.body);
+ case STATEMENT_SWITCH: {
+ const switch_statement_t *const switch_stmt =
+ (const switch_statement_t*)stmt;
+ count += count_decls_in_stmts(switch_stmt->body);
break;
+ }
- case STATEMENT_LABEL:
- count += count_decls_in_stmts(stmt->v.label_stmt.label_statement);
+ case STATEMENT_LABEL: {
+ const label_statement_t *const label_stmt =
+ (const label_statement_t*)stmt;
+ count += count_decls_in_stmts(label_stmt->label_statement);
break;
+ }
- case STATEMENT_WHILE:
- count += count_decls_in_stmts(stmt->v.while_stmt.body);
+ case STATEMENT_WHILE: {
+ const while_statement_t *const while_stmt =
+ (const while_statement_t*)stmt;
+ count += count_decls_in_stmts(while_stmt->body);
break;
+ }
- case STATEMENT_DO_WHILE:
- count += count_decls_in_stmts(stmt->v.while_stmt.body);
+ case STATEMENT_DO_WHILE: {
+ const do_while_statement_t *const do_while_stmt =
+ (const do_while_statement_t*)stmt;
+ count += count_decls_in_stmts(do_while_stmt->body);
break;
+ }
case STATEMENT_FOR: {
+ const for_statement_t *const for_stmt =
+ (const for_statement_t*)stmt;
/* TODO initialisation */
- count += count_decls_in_stmts(stmt->v.for_stmt.body);
+ count += count_decls_in_stmts(for_stmt->body);
break;
}
+ case STATEMENT_ASM:
case STATEMENT_BREAK:
case STATEMENT_CASE_LABEL:
case STATEMENT_CONTINUE:
type_t *type = skip_typeref(parameter->type);
bool needs_entity = parameter->address_taken;
- if(type->type == TYPE_COMPOUND_STRUCT
- || type->type == TYPE_COMPOUND_UNION) {
+ assert(!is_type_array(type));
+ if(is_type_compound(type)) {
needs_entity = true;
}
static void create_function(declaration_t *declaration)
{
- ir_entity *entity = get_function_entity(declaration);
+ ir_entity *function_entity = get_function_entity(declaration);
if(declaration->init.statement == NULL)
return;
imature_blocks = NEW_ARR_F(ir_node*, 0);
int n_local_vars = get_function_n_local_vars(declaration);
- ir_graph *irg = new_ir_graph(entity, n_local_vars);
+ ir_graph *irg = new_ir_graph(function_entity, n_local_vars);
ir_node *first_block = get_cur_block();
next_value_number_function = 0;
/* do we have a return statement yet? */
if(get_cur_block() != NULL) {
- assert(declaration->type->type == TYPE_FUNCTION);
- const type_t* const type = declaration->type;
+ type_t *type = skip_typeref(declaration->type);
+ assert(is_type_function(type));
+ const function_type_t *func_type = &type->function;
+ const type_t *return_type
+ = skip_typeref(func_type->return_type);
+
ir_node *ret;
- if (type->v.function_type.result_type == type_void) {
+ if (is_type_atomic(return_type, ATOMIC_TYPE_VOID)) {
ret = new_Return(get_store(), 0, NULL);
} else {
- ir_mode *const mode = get_ir_mode(type->v.function_type.result_type);
- ir_node * in[1];
+ ir_mode *mode;
+ if(is_type_scalar(return_type)) {
+ mode = get_ir_mode(func_type->return_type);
+ } else {
+ mode = mode_P_data;
+ }
+
+ ir_node *in[1];
// ยง5.1.2.2.3 main implicitly returns 0
if (strcmp(declaration->symbol->string, "main") == 0) {
in[0] = new_Const(mode, get_mode_null(mode));
static void create_global_variable(declaration_t *declaration)
{
- ir_type *global_type = get_glob_type();
- create_declaration_entity(declaration, DECLARATION_TYPE_GLOBAL_VARIABLE,
- global_type);
+ ir_visibility vis;
+ ir_type *var_type;
+ switch ((storage_class_tag_t)declaration->storage_class) {
+ case STORAGE_CLASS_STATIC:
+ vis = visibility_local;
+ goto global_var;
- ir_entity *entity = declaration->v.entity;
- if(declaration->storage_class == STORAGE_CLASS_STATIC) {
- set_entity_visibility(entity, visibility_local);
- } else if(declaration->storage_class == STORAGE_CLASS_EXTERN) {
- set_entity_visibility(entity, visibility_external_allocated);
- } else {
- set_entity_visibility(entity, visibility_external_visible);
+ case STORAGE_CLASS_EXTERN:
+ vis = visibility_external_allocated;
+ goto global_var;
+
+ case STORAGE_CLASS_NONE:
+ vis = visibility_external_visible;
+ goto global_var;
+
+ case STORAGE_CLASS_THREAD:
+ vis = visibility_external_visible;
+ goto tls_var;
+
+ case STORAGE_CLASS_THREAD_EXTERN:
+ vis = visibility_external_allocated;
+ goto tls_var;
+
+ case STORAGE_CLASS_THREAD_STATIC:
+ vis = visibility_local;
+ goto tls_var;
+
+tls_var:
+ var_type = get_tls_type();
+ goto create_var;
+
+global_var:
+ var_type = get_glob_type();
+ goto create_var;
+
+create_var:
+ create_declaration_entity(declaration, DECLARATION_TYPE_GLOBAL_VARIABLE,
+ var_type);
+ set_entity_visibility(declaration->v.entity, vis);
+
+ current_ir_graph = get_const_code_irg();
+ create_initializer(declaration);
+ return;
+
+ case STORAGE_CLASS_TYPEDEF:
+ case STORAGE_CLASS_AUTO:
+ case STORAGE_CLASS_REGISTER:
+ case STORAGE_CLASS_ENUM_ENTRY:
+ break;
}
- current_ir_graph = get_const_code_irg();
- create_initializer(declaration);
+ panic("Invalid storage class for global variable");
}
static void context_to_firm(context_t *context)
if(declaration->symbol == NULL)
continue;
- type_t *type = declaration->type;
- if(type->type == TYPE_FUNCTION) {
+ type_t *type = skip_typeref(declaration->type);
+ if(is_type_function(type)) {
get_function_entity(declaration);
} else {
create_global_variable(declaration);
void translation_unit_to_firm(translation_unit_t *unit)
{
+ type_const_char = make_atomic_type(ATOMIC_TYPE_CHAR, TYPE_QUALIFIER_CONST);
+ type_void = make_atomic_type(ATOMIC_TYPE_VOID, TYPE_QUALIFIER_NONE);
+ type_int = make_atomic_type(ATOMIC_TYPE_INT, TYPE_QUALIFIER_NONE);
+
+ ir_type_int = get_ir_type(type_int);
+ ir_type_const_char = get_ir_type(type_const_char);
+ ir_type_wchar_t = get_ir_type(type_wchar_t);
+ ir_type_void = get_ir_type(type_int); /* we don't have a real void
+ type in firm */
+
+ type_void->base.firm_type = ir_type_void;
+
/* just to be sure */
continue_label = NULL;
break_label = NULL;
projects / cparser / blobdiff