#include "warning.h"
#include "diagnostic.h"
#include "printer.h"
-#include "driver/firm_cmdline.h"
/** The default calling convention. */
cc_kind_t default_calling_convention = CC_CDECL;
-static struct obstack _type_obst;
-struct obstack *type_obst = &_type_obst;
-static bool print_implicit_array_size = false;
+static struct obstack type_obst;
+static bool print_implicit_array_size = false;
static void intern_print_type_pre(const type_t *type);
static void intern_print_type_post(const type_t *type);
[TYPE_ENUM] = sizeof(enum_type_t),
[TYPE_FUNCTION] = sizeof(function_type_t),
[TYPE_POINTER] = sizeof(pointer_type_t),
+ [TYPE_REFERENCE] = sizeof(reference_type_t),
[TYPE_ARRAY] = sizeof(array_type_t),
- [TYPE_BUILTIN] = sizeof(builtin_type_t),
[TYPE_TYPEDEF] = sizeof(typedef_type_t),
[TYPE_TYPEOF] = sizeof(typeof_type_t),
};
type_t *allocate_type_zero(type_kind_t kind)
{
- size_t size = get_type_struct_size(kind);
- type_t *res = obstack_alloc(type_obst, size);
+ size_t const size = get_type_struct_size(kind);
+ type_t *const res = obstack_alloc(&type_obst, size);
memset(res, 0, size);
res->base.kind = kind;
| ATOMIC_TYPE_FLAG_SIGNED,
},
[ATOMIC_TYPE_LONG_DOUBLE] = {
- .size = 12,
+ .size = (unsigned) -1, /* will be filled in later */
.alignment = (unsigned) -1,
.flags = ATOMIC_TYPE_FLAG_FLOAT | ATOMIC_TYPE_FLAG_ARITHMETIC
| ATOMIC_TYPE_FLAG_SIGNED,
/* complex and imaginary types are set in init_types */
};
+static inline bool is_po2(unsigned x)
+{
+ return (x & (x-1)) == 0;
+}
+
void init_types(void)
{
- obstack_init(type_obst);
+ obstack_init(&type_obst);
atomic_type_properties_t *props = atomic_type_properties;
}
unsigned int_size = machine_size < 32 ? 2 : 4;
- unsigned long_size = machine_size < 64 ? 4 : 8;
+ /* long is always 32bit on windows */
+ unsigned long_size = c_mode & _MS ? 4 : (machine_size < 64 ? 4 : 8);
unsigned llong_size = machine_size < 32 ? 4 : 8;
props[ATOMIC_TYPE_INT].size = int_size;
/* TODO: backend specific, need a way to query the backend for this.
* The following are good settings for x86 */
- props[ATOMIC_TYPE_FLOAT].alignment = 4;
- props[ATOMIC_TYPE_DOUBLE].alignment = 4;
- props[ATOMIC_TYPE_LONG_DOUBLE].alignment = 4;
- props[ATOMIC_TYPE_LONGLONG].alignment = 4;
- props[ATOMIC_TYPE_ULONGLONG].alignment = 4;
- if (firm_opt.os_support == OS_SUPPORT_MACHO) {
- props[ATOMIC_TYPE_LONG_DOUBLE].size = 16;
- props[ATOMIC_TYPE_LONG_DOUBLE].alignment = 16;
+ if (machine_size <= 32) {
+ props[ATOMIC_TYPE_FLOAT].alignment = 4;
+ props[ATOMIC_TYPE_DOUBLE].alignment = 4;
+ props[ATOMIC_TYPE_LONG_DOUBLE].alignment = 4;
+ props[ATOMIC_TYPE_LONGLONG].alignment = 4;
+ props[ATOMIC_TYPE_ULONGLONG].alignment = 4;
+ } else {
+ props[ATOMIC_TYPE_FLOAT].alignment = 4;
+ props[ATOMIC_TYPE_DOUBLE].alignment = 8;
+ props[ATOMIC_TYPE_LONG_DOUBLE].alignment = 8;
+ props[ATOMIC_TYPE_LONGLONG].alignment = 8;
+ props[ATOMIC_TYPE_ULONGLONG].alignment = 8;
+ }
+
+ if (long_double_size > 0) {
+ props[ATOMIC_TYPE_LONG_DOUBLE].size = long_double_size;
+ if (is_po2(long_double_size)) {
+ props[ATOMIC_TYPE_LONG_DOUBLE].alignment = long_double_size;
+ }
+ } else {
+ props[ATOMIC_TYPE_LONG_DOUBLE] = props[ATOMIC_TYPE_DOUBLE];
}
/* TODO: make this configurable for platforms which do not use byte sized
void exit_types(void)
{
- obstack_free(type_obst, NULL);
+ obstack_free(&type_obst, NULL);
}
-void print_type_qualifiers(type_qualifiers_t qualifiers)
+void print_type_qualifiers(type_qualifiers_t const qualifiers, QualifierSeparators const q)
{
+ size_t sep = q & QUAL_SEP_START ? 0 : 1;
if (qualifiers & TYPE_QUALIFIER_CONST) {
- print_string("const ");
+ print_string(" const" + sep);
+ sep = 0;
}
if (qualifiers & TYPE_QUALIFIER_VOLATILE) {
- print_string("volatile ");
+ print_string(" volatile" + sep);
+ sep = 0;
}
if (qualifiers & TYPE_QUALIFIER_RESTRICT) {
- print_string("restrict ");
+ print_string(" restrict" + sep);
+ sep = 0;
}
+ if (sep == 0 && q & QUAL_SEP_END)
+ print_char(' ');
}
const char *get_atomic_kind_name(atomic_type_kind_t kind)
*/
static void print_atomic_type(const atomic_type_t *type)
{
- print_type_qualifiers(type->base.qualifiers);
+ print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
print_atomic_kinds(type->akind);
}
*/
static void print_complex_type(const complex_type_t *type)
{
- print_type_qualifiers(type->base.qualifiers);
+ print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
print_string("_Complex");
print_atomic_kinds(type->akind);
}
*/
static void print_imaginary_type(const imaginary_type_t *type)
{
- print_type_qualifiers(type->base.qualifiers);
+ print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
print_string("_Imaginary ");
print_atomic_kinds(type->akind);
}
break;
}
- print_type_qualifiers(type->base.qualifiers);
+ print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
intern_print_type_pre(type->return_type);
} else {
print_string(", ");
}
- const type_t *const type = parameter->declaration.type;
- if (type == NULL) {
+ const type_t *const param_type = parameter->declaration.type;
+ if (param_type == NULL) {
print_string(parameter->base.symbol->string);
} else {
- print_type_ext(type, parameter->base.symbol, NULL);
+ print_type_ext(param_type, parameter->base.symbol, NULL);
}
}
}
print_string(") ");
}
print_string("*");
- type_qualifiers_t const qual = type->base.qualifiers;
- if (qual != 0)
- print_string(" ");
- print_type_qualifiers(qual);
+ print_type_qualifiers(type->base.qualifiers, QUAL_SEP_START);
}
/**
if (type->is_static) {
print_string("static ");
}
- print_type_qualifiers(type->base.qualifiers);
+ print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
if (type->size_expression != NULL
&& (print_implicit_array_size || !type->has_implicit_size)) {
print_expression(type->size_expression);
/* skip the implicit cast */
expression_t *expression = entry->enum_value.value;
- if (expression->kind == EXPR_UNARY_CAST_IMPLICIT) {
- expression = expression->unary.value;
- }
print_expression(expression);
}
print_string(",\n");
*/
static void print_type_enum(const enum_type_t *type)
{
- print_type_qualifiers(type->base.qualifiers);
+ print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
print_string("enum ");
enum_t *enume = type->enume;
*/
static void print_compound_type(const compound_type_t *type)
{
- print_type_qualifiers(type->base.qualifiers);
+ print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
if (type->base.kind == TYPE_COMPOUND_STRUCT) {
print_string("struct ");
*/
static void print_typedef_type_pre(const typedef_type_t *const type)
{
- print_type_qualifiers(type->base.qualifiers);
+ print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
print_string(type->typedefe->base.symbol->string);
}
case TYPE_COMPOUND_UNION:
print_compound_type(&type->compound);
return;
- case TYPE_BUILTIN:
- print_string(type->builtin.symbol->string);
- return;
case TYPE_FUNCTION:
print_function_type_pre(&type->function);
return;
case TYPE_ENUM:
case TYPE_COMPOUND_STRUCT:
case TYPE_COMPOUND_UNION:
- case TYPE_BUILTIN:
case TYPE_TYPEOF:
case TYPE_TYPEDEF:
break;
void print_type_ext(const type_t *const type, const symbol_t *symbol,
const scope_t *parameters)
{
- if (type == NULL) {
- print_string("nil type");
- return;
- }
-
intern_print_type_pre(type);
if (symbol != NULL) {
print_string(" ");
{
size_t size = get_type_struct_size(type->kind);
- type_t *copy = obstack_alloc(type_obst, size);
+ type_t *const copy = obstack_alloc(&type_obst, size);
memcpy(copy, type, size);
copy->base.firm_type = NULL;
copy = duplicate_type(type);
copy->array.element_type = qual_element_type;
} else if (is_type_valid(type)) {
- if ((type->base.qualifiers & qual) == qual)
+ if ((type->base.qualifiers & qual) == (int)qual)
return orig_type;
copy = duplicate_type(type);
{
assert(!is_typeref(type));
- switch (type->kind) {
- case TYPE_POINTER: return true;
- case TYPE_BUILTIN: return is_type_scalar(type->builtin.real_type);
- default: break;
- }
+ if (type->kind == TYPE_POINTER)
+ return true;
return is_type_arithmetic(type);
}
case TYPE_FUNCTION:
case TYPE_POINTER:
case TYPE_REFERENCE:
- case TYPE_BUILTIN:
case TYPE_ERROR:
return false;
return !is_type_function(type) && !is_type_incomplete(type);
}
-bool is_builtin_va_list(type_t *type)
-{
- type_t *tp = skip_typeref(type);
-
- return tp->kind == type_valist->kind &&
- tp->builtin.symbol == type_valist->builtin.symbol;
-}
-
/**
* Check if two function types are compatible.
*/
break;
}
case TYPE_ENUM:
- case TYPE_BUILTIN:
/* TODO: not implemented */
break;
}
case TYPE_BITFIELD:
return 0;
- case TYPE_BUILTIN:
- return get_type_size(type->builtin.real_type);
case TYPE_TYPEDEF:
return get_type_size(type->typedeft.typedefe->type);
case TYPE_TYPEOF:
return get_type_alignment(type->array.element_type);
case TYPE_BITFIELD:
return 0;
- case TYPE_BUILTIN:
- return get_type_alignment(type->builtin.real_type);
case TYPE_TYPEDEF: {
il_alignment_t alignment
= get_type_alignment(type->typedeft.typedefe->type);
case TYPE_BITFIELD:
case TYPE_ARRAY:
return 0;
- case TYPE_BUILTIN:
- return get_type_modifiers(type->builtin.real_type);
case TYPE_TYPEDEF: {
decl_modifiers_t modifiers = type->typedeft.typedefe->modifiers;
modifiers |= get_type_modifiers(type->typedeft.typedefe->type);
{
type_t *result = typehash_insert(type);
if (result != type) {
- obstack_free(type_obst, type);
+ obstack_free(&type_obst, type);
}
return result;
}
*/
type_t *make_atomic_type(atomic_type_kind_t akind, type_qualifiers_t qualifiers)
{
- type_t *type = obstack_alloc(type_obst, sizeof(atomic_type_t));
- memset(type, 0, sizeof(atomic_type_t));
-
- type->kind = TYPE_ATOMIC;
+ type_t *const type = allocate_type_zero(TYPE_ATOMIC);
type->base.qualifiers = qualifiers;
type->atomic.akind = akind;
*/
type_t *make_complex_type(atomic_type_kind_t akind, type_qualifiers_t qualifiers)
{
- type_t *type = obstack_alloc(type_obst, sizeof(complex_type_t));
- memset(type, 0, sizeof(complex_type_t));
-
- type->kind = TYPE_COMPLEX;
+ type_t *const type = allocate_type_zero(TYPE_COMPLEX);
type->base.qualifiers = qualifiers;
type->complex.akind = akind;
*/
type_t *make_imaginary_type(atomic_type_kind_t akind, type_qualifiers_t qualifiers)
{
- type_t *type = obstack_alloc(type_obst, sizeof(imaginary_type_t));
- memset(type, 0, sizeof(imaginary_type_t));
-
- type->kind = TYPE_IMAGINARY;
+ type_t *const type = allocate_type_zero(TYPE_IMAGINARY);
type->base.qualifiers = qualifiers;
type->imaginary.akind = akind;
*/
type_t *make_pointer_type(type_t *points_to, type_qualifiers_t qualifiers)
{
- type_t *type = obstack_alloc(type_obst, sizeof(pointer_type_t));
- memset(type, 0, sizeof(pointer_type_t));
-
- type->kind = TYPE_POINTER;
+ type_t *const type = allocate_type_zero(TYPE_POINTER);
type->base.qualifiers = qualifiers;
type->pointer.points_to = points_to;
type->pointer.base_variable = NULL;
*/
type_t *make_reference_type(type_t *refers_to)
{
- type_t *type = obstack_alloc(type_obst, sizeof(reference_type_t));
- memset(type, 0, sizeof(reference_type_t));
-
- type->kind = TYPE_REFERENCE;
- type->base.qualifiers = 0;
+ type_t *const type = allocate_type_zero(TYPE_REFERENCE);
+ type->base.qualifiers = TYPE_QUALIFIER_NONE;
type->reference.refers_to = refers_to;
return identify_new_type(type);
type_t *make_based_pointer_type(type_t *points_to,
type_qualifiers_t qualifiers, variable_t *variable)
{
- type_t *type = obstack_alloc(type_obst, sizeof(pointer_type_t));
- memset(type, 0, sizeof(pointer_type_t));
-
- type->kind = TYPE_POINTER;
+ type_t *const type = allocate_type_zero(TYPE_POINTER);
type->base.qualifiers = qualifiers;
type->pointer.points_to = points_to;
type->pointer.base_variable = variable;
type_t *make_array_type(type_t *element_type, size_t size,
type_qualifiers_t qualifiers)
{
- type_t *type = obstack_alloc(type_obst, sizeof(array_type_t));
- memset(type, 0, sizeof(array_type_t));
-
- type->kind = TYPE_ARRAY;
+ type_t *const type = allocate_type_zero(TYPE_ARRAY);
type->base.qualifiers = qualifiers;
type->array.element_type = element_type;
type->array.size = size;
entity_t *member;
for (member = first; member != NULL; member = member->base.next) {
if (member->kind != ENTITY_COMPOUND_MEMBER)
- break;
+ continue;
type_t *type = member->declaration.type;
if (type->kind != TYPE_BITFIELD)
}
}
- member->compound_member.offset = offset;
- member->compound_member.bit_offset = bit_offset;
+ if (byte_order_big_endian) {
+ size_t base_size = get_type_size(base_type) * BITS_PER_BYTE;
+ member->compound_member.offset = offset & ~alignment_mask;
+ member->compound_member.bit_offset = base_size - bit_offset - bit_size;
+ } else {
+ member->compound_member.offset = offset;
+ member->compound_member.bit_offset = bit_offset;
+ }
bit_offset += bit_size;
offset += bit_offset / BITS_PER_BYTE;
*struct_offset = offset;
*struct_alignment = alignment;
-
return member;
}
}
}
+ source_position_t const *const pos = &compound->base.source_position;
if (need_pad) {
- if (warning.padded) {
- warningf(&compound->base.source_position, "'%T' needs padding",
- type);
- }
- } else if (compound->packed && warning.packed) {
- warningf(&compound->base.source_position,
- "superfluous packed attribute on '%T'", type);
+ warningf(WARN_PADDED, pos, "'%T' needs padding", type);
+ } else if (compound->packed) {
+ warningf(WARN_PACKED, pos, "superfluous packed attribute on '%T'", type);
}
compound->size = offset;
compound->alignment = alignment;
}
-static function_parameter_t *allocate_parameter(type_t *const type)
+function_parameter_t *allocate_parameter(type_t *const type)
{
- function_parameter_t *const param
- = obstack_alloc(type_obst, sizeof(*param));
+ function_parameter_t *const param = obstack_alloc(&type_obst, sizeof(*param));
memset(param, 0, sizeof(*param));
param->type = type;
return param;
type->function.modifiers |= modifiers;
type->function.linkage = LINKAGE_C;
- function_parameter_t *last = NULL;
+ function_parameter_t **anchor = &type->function.parameters;
for (int i = 0; i < n_types; ++i) {
function_parameter_t *parameter = allocate_parameter(argument_types[i]);
- if (last == NULL) {
- type->function.parameters = parameter;
- } else {
- last->next = parameter;
- }
- last = parameter;
+ *anchor = parameter;
+ anchor = ¶meter->next;
}
return identify_new_type(type);
projects / cparser / blobdiff