#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;
[TYPE_FUNCTION] = sizeof(function_type_t),
[TYPE_POINTER] = sizeof(pointer_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),
};
}
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 (force_long_double_size > 0) {
+ props[ATOMIC_TYPE_LONG_DOUBLE].size = force_long_double_size;
+ props[ATOMIC_TYPE_LONG_DOUBLE].alignment = force_long_double_size;
}
/* TODO: make this configurable for platforms which do not use byte sized
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);
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);
*/
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(" ");
{
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);
return identify_new_type(type);
}
-static entity_t *pack_bitfield_members_big_endian(il_size_t *struct_offset,
- il_alignment_t *struct_alignment, bool packed, entity_t *first)
-{
- type_t *current_base_type = NULL;
- il_size_t offset = *struct_offset;
- il_alignment_t alignment = *struct_alignment;
- size_t bit_offset = 0;
-
- if (packed)
- panic("packed bitfields on big-endian arch not supported yet");
-
- entity_t *member;
- for (member = first; member != NULL; member = member->base.next) {
- if (member->kind != ENTITY_COMPOUND_MEMBER)
- continue;
-
- type_t *type = member->declaration.type;
- if (type->kind != TYPE_BITFIELD)
- break;
-
- size_t bit_size = type->bitfield.bit_size;
- type_t *base_type = skip_typeref(type->bitfield.base_type);
-
- /* see if we need to start a new "bucket" */
- if (base_type != current_base_type || bit_size > bit_offset) {
- if (current_base_type != NULL)
- offset += get_type_size(current_base_type);
-
- current_base_type = base_type;
- il_alignment_t base_alignment = get_type_alignment(base_type);
- il_alignment_t alignment_mask = base_alignment-1;
- if (base_alignment > alignment)
- alignment = base_alignment;
- offset = (offset + base_alignment-1) & ~alignment_mask;
- bit_offset = get_type_size(base_type) * BITS_PER_BYTE;
- assert(bit_offset >= bit_size);
- }
-
- bit_offset -= bit_size;
- member->compound_member.offset = offset;
- member->compound_member.bit_offset = bit_offset;
- }
-
- if (current_base_type != NULL)
- offset += get_type_size(current_base_type);
-
- *struct_offset = offset;
- *struct_alignment = alignment;
- return member;
-}
-
static entity_t *pack_bitfield_members(il_size_t *struct_offset,
il_alignment_t *struct_alignment,
bool packed, entity_t *first)
}
}
- 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;
}
if (skipped->kind == TYPE_BITFIELD) {
- if (byte_order_big_endian) {
- entry = pack_bitfield_members_big_endian(&offset, &alignment,
- compound->packed,
- entry);
- } else {
- entry = pack_bitfield_members(&offset, &alignment,
- compound->packed, entry);
- }
+ entry = pack_bitfield_members(&offset, &alignment,
+ compound->packed, entry);
continue;
}
projects / cparser / blobdiff