ir_mode_sort sort;
unsigned bit_size = size * 8;
bool is_signed = (flags & ATOMIC_TYPE_FLAG_SIGNED) != 0;
+ unsigned modulo_shift;
ir_mode_arithmetic arithmetic;
if (flags & ATOMIC_TYPE_FLAG_INTEGER) {
bit_size);
sort = irms_int_number;
arithmetic = irma_twos_complement;
+ modulo_shift = bit_size < machine_size ? machine_size : bit_size;
} else {
assert(flags & ATOMIC_TYPE_FLAG_FLOAT);
snprintf(name, sizeof(name), "F%u", bit_size);
sort = irms_float_number;
arithmetic = irma_ieee754;
+ modulo_shift = 0;
}
- /* note: modulo_shift is 0, as in C it's undefined anyway to shift
- * a too big amount */
return new_ir_mode(name, sort, bit_size, is_signed, arithmetic,
- 0);
+ modulo_shift);
}
return NULL;
mode_uint = atomic_modes[ATOMIC_TYPE_UINT];
/* there's no real void type in firm */
- atomic_modes[ATOMIC_TYPE_VOID] = mode_int;
+ atomic_modes[ATOMIC_TYPE_VOID] = atomic_modes[ATOMIC_TYPE_CHAR];
/* initialize pointer modes */
char name[64];
panic("Trying to determine size of invalid type");
}
+static ir_node *get_vla_size(array_type_t *const type)
+{
+ ir_node *size_node = type->size_node;
+ if (size_node == NULL) {
+ size_node = expression_to_firm(type->size_expression);
+ type->size_node = size_node;
+ }
+ return size_node;
+}
+
static ir_node *get_type_size(type_t *type)
{
type = skip_typeref(type);
if (is_type_array(type) && type->array.is_vla) {
- ir_node *size_node = type->array.size_node;
- if (size_node == NULL) {
- size_node = expression_to_firm(type->array.size_expression);
- assert(!is_Const(size_node));
- type->array.size_node = size_node;
- }
-
+ ir_node *size_node = get_vla_size(&type->array);
ir_node *elem_size = get_type_size(type->array.element_type);
ir_mode *mode = get_irn_mode(size_node);
ir_node *real_size = new_d_Mul(NULL, size_node, elem_size, mode);
tv = new_tarval_from_str(buf, len, mode);
}
- return new_d_Const(dbgi, mode, tv);
+ return new_d_Const(dbgi, tv);
}
/**
size_t len = snprintf(buf, sizeof(buf), "%lld", v);
tarval *tv = new_tarval_from_str(buf, len, mode);
- return new_d_Const(dbgi, mode, tv);
+ return new_d_Const(dbgi, tv);
}
/**
size_t len = snprintf(buf, sizeof(buf), "%lld", v);
tarval *tv = new_tarval_from_str(buf, len, mode);
- return new_d_Const(dbgi, mode, tv);
+ return new_d_Const(dbgi, tv);
}
/**
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);
- if (type->base.qualifiers & TYPE_QUALIFIER_VOLATILE) {
+ if (type->base.qualifiers & TYPE_QUALIFIER_VOLATILE && !is_Bad(load)) {
set_Load_volatility(load, volatility_is_volatile);
}
return value;
if (dest_mode == mode_b) {
- ir_node *zero = new_Const(value_mode, get_mode_null(value_mode));
+ ir_node *zero = new_Const(get_mode_null(value_mode));
ir_node *cmp = new_d_Cmp(dbgi, value, zero);
ir_node *proj = new_d_Proj(dbgi, cmp, mode_b, pn_Cmp_Lg);
return proj;
/* make sure the type is constructed */
(void) get_ir_type(type);
- ir_mode *const mode = get_ir_mode(type);
- return new_Const(mode, entity->enum_value.tv);
+ return new_Const(entity->enum_value.tv);
}
static ir_node *reference_expression_to_firm(const reference_expression_t *ref)
case T___builtin_infl: {
ir_mode *mode = get_ir_mode(function_type->function.return_type);
tarval *tv = get_mode_infinite(mode);
- ir_node *res = new_d_Const(dbgi, mode, tv);
+ ir_node *res = new_d_Const(dbgi, tv);
return res;
}
case T___builtin_nan:
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);
+ ir_node *res = new_d_Const(dbgi, tv);
return res;
}
case T___builtin_expect: {
return _expression_to_firm(argument);
}
case T___builtin_va_end:
+ /* evaluate the argument of va_end for its side effects */
+ _expression_to_firm(call->arguments->expression);
return NULL;
default:
- panic("Unsupported builtin found\n");
+ panic("unsupported builtin found");
}
}
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);
- if (type->base.qualifiers & TYPE_QUALIFIER_VOLATILE)
+ if (type->base.qualifiers & TYPE_QUALIFIER_VOLATILE && !is_Bad(store))
set_Store_volatility(store, volatility_is_volatile);
set_store(store_mem);
} else {
int bitsize = get_mode_size_bits(get_type_mode(entity_type));
tarval *mask = create_bitfield_mask(mode, 0, bitsize);
- ir_node *mask_node = new_d_Const(dbgi, mode, mask);
+ ir_node *mask_node = new_d_Const(dbgi, mask);
ir_node *value_masked = new_d_And(dbgi, value, mask_node, mode);
tarval *shiftl = new_tarval_from_long(bitoffset, mode_uint);
- ir_node *shiftcount = new_d_Const(dbgi, mode_uint, shiftl);
+ ir_node *shiftcount = new_d_Const(dbgi, shiftl);
ir_node *value_maskshift = new_d_Shl(dbgi, value_masked, shiftcount, mode);
/* load current value */
ir_node *load_res = new_d_Proj(dbgi, load, mode, pn_Load_res);
tarval *shift_mask = create_bitfield_mask(mode, bitoffset, bitsize);
tarval *inv_mask = tarval_not(shift_mask);
- ir_node *inv_mask_node = new_d_Const(dbgi, mode, inv_mask);
+ ir_node *inv_mask_node = new_d_Const(dbgi, inv_mask);
ir_node *load_res_masked = new_d_And(dbgi, load_res, inv_mask_node, mode);
/* construct new value and store */
set_store(store_mem);
if (set_volatile) {
- set_Load_volatility(load, volatility_is_volatile);
- set_Store_volatility(store, volatility_is_volatile);
+ if (!is_Bad(load))
+ set_Load_volatility(load, volatility_is_volatile);
+ if (!is_Bad(store))
+ set_Store_volatility(store, volatility_is_volatile);
}
}
long shift_bitsl = machine_size - bitoffset - bitsize;
assert(shift_bitsl >= 0);
tarval *tvl = new_tarval_from_long(shift_bitsl, mode_uint);
- ir_node *countl = new_d_Const(dbgi, mode_uint, tvl);
+ ir_node *countl = new_d_Const(dbgi, tvl);
ir_node *shiftl = new_d_Shl(dbgi, load_res, countl, mode_int);
long shift_bitsr = bitoffset + shift_bitsl;
assert(shift_bitsr <= (long) machine_size);
tarval *tvr = new_tarval_from_long(shift_bitsr, mode_uint);
- ir_node *countr = new_d_Const(dbgi, mode_uint, tvr);
+ ir_node *countr = new_d_Const(dbgi, tvr);
ir_node *shiftr;
if (mode_is_signed(mode)) {
shiftr = new_d_Shrs(dbgi, shiftl, countr, mode_int);
offset = get_type_size(pointer_type->points_to);
} else {
assert(is_type_arithmetic(type));
- offset = new_Const(mode, get_mode_one(mode));
+ offset = new_Const(get_mode_one(mode));
}
ir_node *result;
* produces a 0/1 depending of the value of a mode_b node
*/
static ir_node *produce_condition_result(const expression_t *expression,
- dbg_info *dbgi)
+ ir_mode *mode, dbg_info *dbgi)
{
- ir_mode *mode = get_ir_mode(expression->base.type);
ir_node *cur_block = get_cur_block();
ir_node *one_block = new_immBlock();
- ir_node *one = new_Const(mode, get_mode_one(mode));
+ set_cur_block(one_block);
+ ir_node *one = new_Const(get_mode_one(mode));
ir_node *jmp_one = new_d_Jmp(dbgi);
ir_node *zero_block = new_immBlock();
- ir_node *zero = new_Const(mode, get_mode_null(mode));
+ set_cur_block(zero_block);
+ ir_node *zero = new_Const(get_mode_null(mode));
ir_node *jmp_zero = new_d_Jmp(dbgi);
set_cur_block(cur_block);
static ir_node *adjust_for_pointer_arithmetic(dbg_info *dbgi,
ir_node *value, type_t *type)
{
+ ir_mode *const mode = get_ir_mode(type_ptrdiff_t);
+ assert(is_type_pointer(type));
pointer_type_t *const pointer_type = &type->pointer;
type_t *const points_to = skip_typeref(pointer_type->points_to);
unsigned elem_size = get_type_size_const(points_to);
+ value = create_conv(dbgi, value, mode);
+
/* gcc extension: allow arithmetic with void * and function * */
if ((elem_size == 0 && is_type_atomic(points_to, ATOMIC_TYPE_VOID)) ||
is_type_function(points_to)) {
if (elem_size == 1)
return value;
- value = create_conv(dbgi, value, mode_int);
- ir_node *const cnst = new_Const_long(mode_int, (long)elem_size);
- ir_node *const mul = new_d_Mul(dbgi, value, cnst, mode_int);
+ ir_node *const cnst = new_Const_long(mode, (long)elem_size);
+ ir_node *const mul = new_d_Mul(dbgi, value, cnst, mode);
return mul;
}
default:
normal_node:
- mode = get_irn_mode(right);
+ mode = get_ir_mode(type_right);
left = create_conv(dbgi, left, mode);
break;
}
long val = fold_constant(expression->left);
expression_kind_t ekind = expression->base.kind;
assert(ekind == EXPR_BINARY_LOGICAL_AND || ekind == EXPR_BINARY_LOGICAL_OR);
- if ((ekind == EXPR_BINARY_LOGICAL_AND && val != 0) ||
- (ekind == EXPR_BINARY_LOGICAL_OR && val == 0)) {
- return expression_to_firm(expression->right);
+ if (ekind == EXPR_BINARY_LOGICAL_AND) {
+ if (val == 0) {
+ return new_Const(get_mode_null(mode));
+ }
} else {
- return new_Const(mode, get_mode_one(mode));
+ if (val != 0) {
+ return new_Const(get_mode_one(mode));
+ }
+ }
+
+ if (is_constant_expression(expression->right)) {
+ long const valr = fold_constant(expression->left);
+ return valr != 0 ?
+ new_Const(get_mode_one(mode)) :
+ new_Const(get_mode_null(mode));
}
+
+ return produce_condition_result(expression->right, mode, dbgi);
}
- return produce_condition_result((const expression_t*) expression, dbgi);
+ return produce_condition_result((const expression_t*) expression, mode,
+ dbgi);
}
typedef ir_node * (*create_arithmetic_func)(dbg_info *dbgi, ir_node *left,
static ir_node *array_access_addr(const array_access_expression_t *expression)
{
- 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);
-
- type_t *offset_type = skip_typeref(expression->index->base.type);
- ir_mode *mode;
- if (is_type_signed(offset_type)) {
- mode = get_ir_mode(type_ssize_t);
- } else {
- mode = get_ir_mode(type_size_t);
- }
- offset = create_conv(dbgi, offset, mode);
-
- 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;
-
- ir_node *elem_size_const = get_type_size(pointer_type->points_to);
- elem_size_const = create_conv(dbgi, elem_size_const, mode);
- ir_node *real_offset = new_d_Mul(dbgi, offset, elem_size_const,
- mode);
- ir_node *result = new_d_Add(dbgi, base_addr, real_offset, mode_P_data);
+ 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);
+ type_t *ref_type = skip_typeref(expression->array_ref->base.type);
+ ir_node *real_offset = adjust_for_pointer_arithmetic(dbgi, offset, ref_type);
+ ir_node *result = new_d_Add(dbgi, base_addr, real_offset, mode_P_data);
return result;
}
tarval *tv = new_tarval_from_long(offset, mode);
dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
- return new_d_Const(dbgi, mode, tv);
+ return new_d_Const(dbgi, tv);
}
static void create_local_initializer(initializer_t *initializer, dbg_info *dbgi,
current_ir_graph = old_current_ir_graph;
if (!is_Const(cnst)) {
- panic("couldn't fold constant\n");
+ panic("couldn't fold constant");
}
tarval *tv = get_Const_tarval(cnst);
if (!tarval_is_long(tv)) {
- panic("result of constant folding is not integer\n");
+ panic("result of constant folding is not integer");
}
constant_folding = constant_folding_old;
/* create the true block */
ir_node *true_block = new_immBlock();
+ set_cur_block(true_block);
ir_node *true_val = expression->true_expression != NULL ?
expression_to_firm(expression->true_expression) : NULL;
/* create the false block */
ir_node *false_block = new_immBlock();
+ set_cur_block(false_block);
ir_node *false_val = expression_to_firm(expression->false_expression);
ir_node *false_jmp = new_Jmp();
} else {
/* Condition ended with a short circuit (&&, ||, !) operation.
* Generate a "1" as value for the true branch. */
- ir_mode *const mode = mode_Is;
- true_val = new_Const(mode, get_mode_one(mode));
+ true_val = new_Const(get_mode_one(mode_Is));
}
}
mature_immBlock(true_block);
entity_t *entry = expression->compound_entry;
assert(entry->kind == ENTITY_COMPOUND_MEMBER);
assert(entry->declaration.kind == DECLARATION_KIND_COMPOUND_MEMBER);
- ir_entity *irentity = entry->compound_member.entity;
- assert(irentity != NULL);
-
- ir_node *sel = new_d_simpleSel(dbgi, new_NoMem(), compound_addr, irentity);
-
- return sel;
+ if (constant_folding) {
+ ir_mode *mode = get_irn_mode(compound_addr);
+ /* FIXME: here, we need an integer mode with the same number of bits as mode */
+ ir_node *ofs = new_Const_long(mode_uint, entry->compound_member.offset);
+ return new_d_Add(dbgi, compound_addr, ofs, mode);
+ } else {
+ ir_entity *irentity = entry->compound_member.entity;
+ assert(irentity != NULL);
+ return new_d_simpleSel(dbgi, new_NoMem(), compound_addr, irentity);
+ }
}
static ir_node *select_to_firm(const select_expression_t *expression)
tc = void_type_class;
goto make_const;
+ case ATOMIC_TYPE_WCHAR_T: /* gcc handles this as integer */
case ATOMIC_TYPE_CHAR: /* gcc handles this as integer */
case ATOMIC_TYPE_SCHAR: /* gcc handles this as integer */
case ATOMIC_TYPE_UCHAR: /* gcc handles this as integer */
make_const:;
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);
+ tarval *const tv = new_tarval_from_long(tc, mode_int);
+ return new_d_Const(dbgi, tv);
}
static ir_node *function_name_to_firm(
static ir_node *expression_to_addr(const expression_t *expression)
{
switch(expression->kind) {
- case EXPR_REFERENCE:
- return reference_addr(&expression->reference);
case EXPR_ARRAY_ACCESS:
return array_access_addr(&expression->array_access);
- case EXPR_SELECT:
- return select_addr(&expression->select);
case EXPR_CALL:
return call_expression_to_firm(&expression->call);
- case EXPR_UNARY_DEREFERENCE: {
+ case EXPR_COMPOUND_LITERAL:
+ return compound_literal_to_firm(&expression->compound_literal);
+ case EXPR_REFERENCE:
+ return reference_addr(&expression->reference);
+ case EXPR_SELECT:
+ return select_addr(&expression->select);
+ case EXPR_UNARY_DEREFERENCE:
return dereference_addr(&expression->unary);
- }
default:
break;
}
ir_graph *rem = current_ir_graph;
current_ir_graph = current_function;
- ir_node *old_cur_block = get_cur_block();
- ir_node *block = new_immBlock();
- set_cur_block(old_cur_block);
+ ir_node *block = new_immBlock();
label->block = block;
/* simply create a NULL pointer */
ir_mode *mode = get_ir_mode(type_void_ptr);
- tarval *tv = new_tarval_from_long(0, mode);
- ir_node *res = new_Const(mode, tv);
+ ir_node *res = new_Const_long(mode, 0);
return res;
}
/* we have to produce a 0/1 from the mode_b expression */
dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
- return produce_condition_result(expression, dbgi);
+ ir_mode *mode = get_ir_mode(expression->base.type);
+ return produce_condition_result(expression, mode, dbgi);
}
/**
case EXPR_BINARY_LOGICAL_AND: {
const binary_expression_t *binary_expression = &expression->binary;
- ir_node *cur_block = get_cur_block();
ir_node *extra_block = new_immBlock();
- set_cur_block(cur_block);
create_condition_evaluation(binary_expression->left, extra_block,
false_block);
mature_immBlock(extra_block);
case EXPR_BINARY_LOGICAL_OR: {
const binary_expression_t *binary_expression = &expression->binary;
- ir_node *cur_block = get_cur_block();
ir_node *extra_block = new_immBlock();
- set_cur_block(cur_block);
create_condition_evaluation(binary_expression->left, true_block,
extra_block);
mature_immBlock(extra_block);
}
add_immBlock_pred(true_block, true_proj);
- if (false_block != NULL) {
- add_immBlock_pred(false_block, false_proj);
- }
+ add_immBlock_pred(false_block, false_proj);
set_cur_block(NULL);
return cond_expr;
if (is_atomic_type(type)) {
ir_mode *mode = get_type_mode(type);
tarval *zero = get_mode_null(mode);
- ir_node *cnst = new_d_Const(dbgi, mode, zero);
+ ir_node *cnst = new_d_Const(dbgi, zero);
/* TODO: bitfields */
ir_node *mem = get_store();
if (is_Array_type(type)) {
ir_entity *entity = get_array_element_entity(type);
tarval *index_tv = new_tarval_from_long(i, mode_uint);
- ir_node *cnst = new_d_Const(dbgi, mode_uint, index_tv);
+ ir_node *cnst = new_d_Const(dbgi, index_tv);
ir_node *in[1] = { cnst };
irtype = get_array_element_type(type);
addr = new_d_Sel(dbgi, new_NoMem(), base_addr, 1, in, entity);
case IR_INITIALIZER_TARVAL: {
tarval *tv = get_initializer_tarval_value(initializer);
ir_mode *mode = get_tarval_mode(tv);
- ir_node *cnst = new_d_Const(dbgi, mode, tv);
+ ir_node *cnst = new_d_Const(dbgi, tv);
ir_type *ent_type = get_entity_type(entity);
/* is it a bitfield type? */
ir_entity *sub_entity;
if (is_Array_type(type)) {
tarval *index_tv = new_tarval_from_long(i, mode_uint);
- ir_node *cnst = new_d_Const(dbgi, mode_uint, index_tv);
+ ir_node *cnst = new_d_Const(dbgi, index_tv);
ir_node *in[1] = { cnst };
irtype = get_array_element_type(type);
sub_entity = get_array_element_entity(type);
static void declaration_statement_to_firm(declaration_statement_t *statement)
{
- entity_t *entity = statement->declarations_begin;
- entity_t *end = statement->declarations_end->base.next;
- for ( ; entity != end; entity = entity->base.next) {
- if (!is_declaration(entity))
- continue;
- initialize_local_declaration(entity);
+ entity_t * entity = statement->declarations_begin;
+ entity_t *const last = statement->declarations_end;
+ if (entity != NULL) {
+ for ( ;; entity = entity->base.next) {
+ if (is_declaration(entity)) {
+ initialize_local_declaration(entity);
+ } else if (entity->kind == ENTITY_TYPEDEF) {
+ type_t *const type = entity->typedefe.type;
+ if (is_type_array(type) && type->array.is_vla)
+ get_vla_size(&type->array);
+ }
+ if (entity == last)
+ break;
+ }
}
}
ir_node *true_block = NULL;
if (statement->true_statement != NULL) {
true_block = new_immBlock();
+ set_cur_block(true_block);
statement_to_firm(statement->true_statement);
if (get_cur_block() != NULL) {
ir_node *jmp = new_Jmp();
ir_node *false_block = NULL;
if (statement->false_statement != NULL) {
false_block = new_immBlock();
+ set_cur_block(false_block);
statement_to_firm(statement->false_statement);
if (get_cur_block() != NULL) {
break_label = NULL;
ir_node *body_block = new_immBlock();
+ set_cur_block(body_block);
statement_to_firm(statement->body);
ir_node *false_block = break_label;
continue_label = header_block;
break_label = NULL;
+ set_cur_block(body_block);
statement_to_firm(statement->body);
ir_node *false_block = break_label;
create_condition_evaluation(statement->condition, body_block, false_block);
mature_immBlock(body_block);
mature_immBlock(header_block);
- if (false_block != NULL) {
- mature_immBlock(false_block);
- }
+ mature_immBlock(false_block);
set_cur_block(false_block);
}
/* create the step block */
ir_node *const step_block = new_immBlock();
+ set_cur_block(step_block);
if (statement->step != NULL) {
expression_to_firm(statement->step);
}
/* create the header block */
ir_node *const header_block = new_immBlock();
+ set_cur_block(header_block);
if (jmp != NULL) {
add_immBlock_pred(header_block, jmp);
}
ir_node *const false_block = new_immBlock();
/* the loop body */
- ir_node * body_block;
+ ir_node *body_block;
if (statement->body != NULL) {
ir_node *const old_continue_label = continue_label;
ir_node *const old_break_label = break_label;
break_label = false_block;
body_block = new_immBlock();
+ set_cur_block(body_block);
statement_to_firm(statement->body);
assert(continue_label == step_block);
static ir_node *get_break_label(void)
{
if (break_label == NULL) {
- ir_node *cur_block = get_cur_block();
break_label = new_immBlock();
- set_cur_block(cur_block);
}
return break_label;
}
ir_node *const fallthrough = (get_cur_block() == NULL ? NULL : new_Jmp());
ir_node *proj;
- ir_node *old_block = get_nodes_block(current_switch_cond);
ir_node *block = new_immBlock();
- set_cur_block(old_block);
+ set_cur_block(get_nodes_block(current_switch_cond));
if (statement->expression != NULL) {
long pn = statement->first_case;
long end_pn = statement->last_case;
case STATEMENT_LABEL:
label_to_firm(&statement->label);
return;
- case STATEMENT_LOCAL_LABEL:
- /* local labels transform the semantics of labels while parsing
- * they don't need any special treatment here */
- return;
case STATEMENT_GOTO:
goto_to_firm(&statement->gotos);
return;
leave_statement_to_firm(&statement->leave);
return;
}
- panic("Statement not implemented\n");
+ panic("statement not implemented");
}
static int count_local_variables(const entity_t *entity,
- const entity_t *const end)
+ const entity_t *const last)
{
int count = 0;
- for (; entity != end; entity = entity->base.next) {
+ for (; entity != NULL; entity = entity->base.next) {
type_t *type;
bool address_taken;
if (!address_taken && is_type_scalar(type))
++count;
+
+ if (entity == last)
+ break;
}
return count;
}
case STATEMENT_DECLARATION: {
const declaration_statement_t *const decl_stmt = &stmt->declaration;
*count += count_local_variables(decl_stmt->declarations_begin,
- decl_stmt->declarations_end->base.next);
+ decl_stmt->declarations_end);
break;
}
*/
static void handle_decl_modifier_irg(ir_graph_ptr irg, decl_modifiers_t decl_modifiers)
{
+ if (decl_modifiers & DM_RETURNS_TWICE) {
+ /* TRUE if the declaration includes __attribute__((returns_twice)) */
+ set_irg_additional_property(irg, mtp_property_returns_twice);
+ }
if (decl_modifiers & DM_NORETURN) {
/* TRUE if the declaration includes the Microsoft
__declspec(noreturn) specifier. */
ir_node *in[1];
/* ยง5.1.2.2.3 main implicitly returns 0 */
if (is_main(entity)) {
- in[0] = new_Const(mode, get_mode_null(mode));
+ in[0] = new_Const(get_mode_null(mode));
} else {
in[0] = new_Unknown(mode);
}
projects / cparser / blobdiff