#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 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;
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 */
-
- type_void->base.firm_type = ir_type_void;
-
- symbol_alloca = symbol_table_insert("__builtin_alloca");
}
void exit_ast2firm(void)
static ir_type *create_method_type(const function_type_t *function_type)
{
- type_t *result_type = function_type->result_type;
+ type_t *return_type = function_type->return_type;
ident *id = unique_ident("functiontype");
int n_parameters = count_parameters(function_type);
- int n_results = result_type == type_void ? 0 : 1;
+ 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);
}
literal->value);
}
+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)
{
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);
+ }
+}
+
static ir_node *reference_expression_to_firm(const reference_expression_t *ref)
{
dbg_info *dbgi = get_dbg_info(&ref->expression.source_position);
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);
- ir_type *irtype = get_entity_type(entity);
- return deref_address(irtype, 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);
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;
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;
+
+ 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;
- if(symbol == symbol_alloca) {
+ 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");
}
}
}
ir_node *callee = expression_to_firm(function);
- type_t *type = function->base.datatype;
- assert(type->type == TYPE_POINTER);
- pointer_type_t *const ptr_type = &type->pointer;
- assert(ptr_type->points_to->type == TYPE_FUNCTION);
- function_type_t *function_type = &ptr_type->points_to->function;
+ 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;
}
+ 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(function_type->variadic || function_type->unspecified_parameters) {
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->base.datatype);
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 = skip_typeref(function_type->result_type);
+ type_t *return_type = skip_typeref(function_type->return_type);
ir_node *result = NULL;
- if(!is_type_atomic(result_type, ATOMIC_TYPE_VOID)) {
+ if(!is_type_atomic(return_type, ATOMIC_TYPE_VOID)) {
ir_mode *mode;
- if(is_type_scalar(result_type)) {
- mode = get_ir_mode(result_type);
+ if(is_type_scalar(return_type)) {
+ mode = get_ir_mode(return_type);
} else {
mode = mode_P_data;
}
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->base.source_position);
ir_node *addr = expression_to_addr(expression);
ir_node *memory = get_store();
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) {
+ 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);
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:
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);
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);
}
}
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) {
+ } 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);
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);
}
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);
return const_to_firm(&expression->conste);
case EXPR_STRING_LITERAL:
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(&expression->reference);
case EXPR_CALL:
set_cur_block(NULL);
}
-
static void return_statement_to_firm(return_statement_t *statement)
{
if(get_cur_block() == NULL)
if(get_method_n_ress(func_irtype) > 0) {
ir_type *res_type = get_method_res_type(func_irtype, 0);
- if(is_compound_type(res_type)) {
- ir_entity *entity = get_method_value_res_ent(func_irtype, 0);
-
- ir_node *frame = get_irg_frame(current_ir_graph);
- ir_node *nomem = new_NoMem();
- ir_node *source_addr = expression_to_addr(statement->return_value);
- ir_node *dest_addr = new_simpleSel(nomem, frame, entity);
-
- ir_node *store = get_store();
- ir_node *copyb = new_d_CopyB(dbgi, store, dest_addr, source_addr,
- res_type);
-
- ir_node *copyb_mem = new_Proj(copyb, mode_M, pn_CopyB_M_regular);
- set_store(copyb_mem);
-
- in[0] = dest_addr;
- in_len = 1;
+ if(statement->return_value != NULL) {
+ ir_node *node = expression_to_firm(statement->return_value);
+ node = do_strict_conv(dbgi, node);
+ in[0] = node;
} else {
- in_len = 1;
- if(statement->return_value != NULL) {
- in[0] = expression_to_firm(statement->return_value);
+ ir_mode *mode;
+ if(is_compound_type(res_type)) {
+ mode = mode_P_data;
} else {
- ir_mode *mode = get_type_mode(res_type);
- in[0] = new_Unknown(mode);
+ mode = get_type_mode(res_type);
}
+ in[0] = new_Unknown(mode);
}
+ in_len = 1;
} else {
/* build return_value for its side effects */
if(statement->return_value != NULL) {
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) {
assert(initializer->type == INITIALIZER_LIST);
initializer_list_t *list = &initializer->list;
- assert(type->type == TYPE_COMPOUND_STRUCT
- || type->type == TYPE_COMPOUND_UNION);
+ assert(is_type_compound(type));
compound_type_t *compound_type = &type->compound;
create_initializer_compound(list, compound_type, entity, entry, len);
}
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;
}
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");
}
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((compound_statement_t*) statement);
+ compound_statement_to_firm(&statement->compound);
return;
case STATEMENT_RETURN:
- return_statement_to_firm((return_statement_t*) statement);
+ return_statement_to_firm(&statement->returns);
return;
case STATEMENT_EXPRESSION:
- expression_statement_to_firm((expression_statement_t*) statement);
+ expression_statement_to_firm(&statement->expression);
return;
case STATEMENT_IF:
- if_statement_to_firm((if_statement_t*) statement);
+ if_statement_to_firm(&statement->ifs);
return;
case STATEMENT_WHILE:
- while_statement_to_firm((while_statement_t*) statement);
+ while_statement_to_firm(&statement->whiles);
return;
case STATEMENT_DO_WHILE:
- do_while_statement_to_firm((do_while_statement_t*) statement);
+ do_while_statement_to_firm(&statement->do_while);
return;
case STATEMENT_DECLARATION:
- declaration_statement_to_firm((declaration_statement_t*) 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((switch_statement_t*) statement);
+ switch_statement_to_firm(&statement->switchs);
return;
case STATEMENT_CASE_LABEL:
- case_label_to_firm((case_label_statement_t*) statement);
+ case_label_to_firm(&statement->case_label);
return;
case STATEMENT_FOR:
- for_statement_to_firm((for_statement_t*) statement);
+ for_statement_to_firm(&statement->fors);
return;
case STATEMENT_LABEL:
- label_to_firm((label_statement_t*) statement);
+ label_to_firm(&statement->label);
return;
case STATEMENT_GOTO:
- goto_to_firm((goto_statement_t*) statement);
+ goto_to_firm(&statement->gotos);
return;
- default:
+ case STATEMENT_ASM:
break;
}
panic("Statement not implemented\n");
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;
}
/* do we have a return statement yet? */
if(get_cur_block() != NULL) {
- assert(declaration->type->type == TYPE_FUNCTION);
- const function_type_t* const func_type = &declaration->type->function;
+ 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 (func_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(func_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