unsigned size = get_atomic_type_size(kind);
if ((flags & ATOMIC_TYPE_FLAG_FLOAT)
&& !(flags & ATOMIC_TYPE_FLAG_COMPLEX)) {
- if (size == 4) {
- return get_modeF();
- } else if (size == 8) {
- return get_modeD();
- } else {
- panic("unexpected kind");
+ switch (size) {
+ case 4: return get_modeF();
+ case 8: return get_modeD();
+ default: panic("unexpected kind");
}
} else if (flags & ATOMIC_TYPE_FLAG_INTEGER) {
char name[64];
{
assert(entity->kind == ENTITY_COMPOUND_MEMBER);
type_t *base = skip_typeref(entity->declaration.type);
- assert(base->kind == TYPE_ATOMIC || base->kind == TYPE_ENUM);
+ assert(is_type_integer(base));
ir_type *irbase = get_ir_type(base);
unsigned bit_size = entity->compound_member.bit_size;
- assert(!is_type_float(base));
if (is_type_signed(base)) {
return get_signed_int_type_for_bit_size(irbase, bit_size, base);
} else {
/* anonymous bitfield member, skip */
if (entry->compound_member.bitfield)
continue;
- assert(entry_type->kind == TYPE_COMPOUND_STRUCT
- || entry_type->kind == TYPE_COMPOUND_UNION);
+ assert(is_type_compound(entry_type));
ident = id_unique("anon.%u");
} else {
ident = new_id_from_str(symbol->string);
static ir_type *get_ir_type_incomplete(type_t *type)
{
- assert(type != NULL);
type = skip_typeref(type);
if (type->base.firm_type != NULL) {
ir_type *get_ir_type(type_t *type)
{
- assert(type != NULL);
-
type = skip_typeref(type);
if (type->base.firm_type != NULL) {
*/
static ir_node *string_to_firm(source_position_t const *const src_pos, char const *const id_prefix, string_encoding_t const enc, string_t const *const value)
{
- size_t slen;
- ir_type *elem_type;
- ir_initializer_t *initializer;
+ size_t const slen = get_string_len(enc, value) + 1;
+ ir_initializer_t *const initializer = create_initializer_compound(slen);
+ ir_type * elem_type;
switch (enc) {
case STRING_ENCODING_CHAR: {
- slen = value->size + 1;
- elem_type = ir_type_char;
- initializer = create_initializer_compound(slen);
+ elem_type = ir_type_char;
ir_mode *const mode = get_type_mode(elem_type);
char const *p = value->begin;
}
case STRING_ENCODING_WIDE: {
- slen = wstrlen(value) + 1;
- elem_type = ir_type_wchar_t;
- initializer = create_initializer_compound(slen);
+ elem_type = ir_type_wchar_t;
ir_mode *const mode = get_type_mode(elem_type);
char const *p = value->begin;
default:
break;
}
- panic("trying to get pn_Cmp from non-comparison binexpr type");
+ panic("trying to get ir_relation from non-comparison binexpr type");
}
/**
case EXPR_BINARY_MOD:
case EXPR_BINARY_MOD_ASSIGN: {
ir_node *pin = new_Pin(new_NoMem());
- assert(!mode_is_float(mode));
ir_node *op = new_d_Mod(dbgi, pin, left, right, mode,
op_pin_state_floats);
ir_node *res = new_d_Proj(dbgi, op, mode, pn_Mod_res);
case EXPR_BINARY_SHIFTRIGHT_ASSIGN:
return create_assign_binop(expression);
default:
- panic("TODO binexpr type");
+ panic("invalid binexpr type");
}
}
compound_t *compound = type->compound.compound;
entity_t *iter = compound->members.entities;
- for ( ; iter != NULL; iter = iter->base.next) {
- if (iter->base.symbol == symbol) {
- break;
- }
- }
- assert(iter != NULL);
+ for (; iter->base.symbol != symbol; iter = iter->base.next) {}
assert(iter->kind == ENTITY_COMPOUND_MEMBER);
assert(iter->declaration.kind == DECLARATION_KIND_COMPOUND_MEMBER);
compound_t *compound = type->compound.compound;
entity_t *iter = compound->members.entities;
- for ( ; iter != NULL; iter = iter->base.next, ++index) {
- if (iter->base.symbol == symbol) {
- assert(iter->kind == ENTITY_COMPOUND_MEMBER);
- break;
- }
- }
- assert(iter != NULL);
+ for (; iter->base.symbol != symbol; iter = iter->base.next, ++index) {}
+ assert(iter->kind == ENTITY_COMPOUND_MEMBER);
/* revert previous initialisations of other union elements */
if (type->kind == TYPE_COMPOUND_UNION) {
orig_type = iter->declaration.type;
} else {
expression_t *array_index = designator->array_index;
- assert(designator->array_index != NULL);
assert(is_type_array(type));
long index = fold_constant_to_int(array_index);
- assert(index >= 0);
-#ifndef NDEBUG
- if (type->array.size_constant) {
- long array_size = type->array.size;
- assert(index < array_size);
- }
-#endif
+ assert(0 <= index && (!type->array.size_constant || (size_t)index < type->array.size));
top->type = orig_type;
top->index = (size_t) index;
break;
descend_into_subtype(&path);
}
- } else if (sub_initializer->kind == INITIALIZER_STRING
- || sub_initializer->kind == INITIALIZER_WIDE_STRING) {
+ } else if (sub_initializer->kind == INITIALIZER_STRING) {
/* we might have to descend into types until we're at a scalar
* type */
while (true) {
return result;
}
-static ir_initializer_t *create_ir_initializer_string(
- const initializer_string_t *initializer, type_t *type)
+static ir_initializer_t *create_ir_initializer_string(initializer_string_t const *const initializer, type_t *type)
{
type = skip_typeref(type);
- size_t string_len = initializer->string.size;
assert(type->kind == TYPE_ARRAY);
assert(type->array.size_constant);
- size_t len = type->array.size;
- ir_initializer_t *irinitializer = create_initializer_compound(len);
-
- const char *string = initializer->string.begin;
- ir_mode *mode = get_ir_mode_storage(type->array.element_type);
-
- for (size_t i = 0; i < len; ++i) {
- char c = 0;
- if (i < string_len)
- c = string[i];
-
- ir_tarval *tv = new_tarval_from_long(c, mode);
- ir_initializer_t *char_initializer = create_initializer_tarval(tv);
-
- set_initializer_compound_value(irinitializer, i, char_initializer);
- }
-
- return irinitializer;
-}
-
-static ir_initializer_t *create_ir_initializer_wide_string(
- const initializer_wide_string_t *initializer, type_t *type)
-{
- assert(type->kind == TYPE_ARRAY);
- assert(type->array.size_constant);
- size_t len = type->array.size;
- size_t string_len = wstrlen(&initializer->string);
- ir_initializer_t *irinitializer = create_initializer_compound(len);
-
- const char *p = initializer->string.begin;
- ir_mode *mode = get_type_mode(ir_type_wchar_t);
-
- for (size_t i = 0; i < len; ++i) {
- utf32 c = 0;
- if (i < string_len) {
- c = read_utf8_char(&p);
+ size_t const str_len = initializer->string.size;
+ size_t const arr_len = type->array.size;
+ ir_initializer_t *const irinit = create_initializer_compound(arr_len);
+ ir_mode *const mode = get_ir_mode_storage(type->array.element_type);
+ char const * p = initializer->string.begin;
+ switch (initializer->encoding) {
+ case STRING_ENCODING_CHAR:
+ for (size_t i = 0; i != arr_len; ++i) {
+ char const c = i < str_len ? *p++ : 0;
+ ir_tarval *const tv = new_tarval_from_long(c, mode);
+ ir_initializer_t *const tvinit = create_initializer_tarval(tv);
+ set_initializer_compound_value(irinit, i, tvinit);
}
- ir_tarval *tv = new_tarval_from_long(c, mode);
- ir_initializer_t *char_initializer = create_initializer_tarval(tv);
+ break;
- set_initializer_compound_value(irinitializer, i, char_initializer);
+ case STRING_ENCODING_WIDE:
+ for (size_t i = 0; i != arr_len; ++i) {
+ utf32 const c = i < str_len ? read_utf8_char(&p) : 0;
+ ir_tarval *const tv = new_tarval_from_long(c, mode);
+ ir_initializer_t *const tvinit = create_initializer_tarval(tv);
+ set_initializer_compound_value(irinit, i, tvinit);
+ }
+ break;
}
- return irinitializer;
+ return irinit;
}
static ir_initializer_t *create_ir_initializer(
case INITIALIZER_STRING:
return create_ir_initializer_string(&initializer->string, type);
- case INITIALIZER_WIDE_STRING:
- return create_ir_initializer_wide_string(&initializer->wide_string,
- type);
-
case INITIALIZER_LIST:
return create_ir_initializer_list(&initializer->list, type);
projects / cparser / blobdiff