/**
* Creates a new based pointer type.
*
* @param points_to The points-to type for the new type.
* @param qualifiers Type qualifiers for the new type.
* @param variable The based variable
*/
type_t *make_based_pointer_type(type_t *points_to,
type_qualifiers_t qualifiers, variable_t *variable)
{
type_t *const type = allocate_type_zero(TYPE_POINTER);
type->base.qualifiers = qualifiers;
type->pointer.points_to = points_to;
type->pointer.base_variable = variable;
return identify_new_type(type);
}
type_t *make_function_0_type(type_t *return_type, decl_modifiers_t modifiers)
{
type_t *type = allocate_type_zero(TYPE_FUNCTION);
type->function.return_type = return_type;
type->function.parameters = NULL;
type->function.modifiers |= modifiers;
type->function.linkage = LINKAGE_C;
return identify_new_type(type);
}
type_t *make_array_type(type_t *element_type, size_t size,
type_qualifiers_t qualifiers)
{
type_t *const type = allocate_type_zero(TYPE_ARRAY);
type->base.qualifiers = qualifiers;
type->array.element_type = element_type;
type->array.size = size;
type->array.size_constant = true;
return identify_new_type(type);
}
type_t *get_unqualified_type(type_t *type)
{
assert(!is_typeref(type));
if (type->base.qualifiers == TYPE_QUALIFIER_NONE)
return type;
type_t *unqualified_type = duplicate_type(type);
unqualified_type->base.qualifiers = TYPE_QUALIFIER_NONE;
return identify_new_type(unqualified_type);
}
static type_t *add_modifiers(type_t *type, decl_modifiers_t modifiers)
{
if (is_typeref(type) || !is_type_function(type)) {
return type;
}
if ((type->function.modifiers & modifiers) == modifiers)
return type;
type_t* new_type = duplicate_type(type);
new_type->function.modifiers |= modifiers;
return identify_new_type(new_type);
}
static type_t *change_calling_convention(type_t *type, cc_kind_t cconv)
{
if (is_typeref(type) || !is_type_function(type)) {
return type;
}
if (type->function.calling_convention == cconv)
return type;
type_t* new_type = duplicate_type(type);
new_type->function.calling_convention = cconv;
return identify_new_type(new_type);
}
type_t *make_function_1_type(type_t *return_type, type_t *argument_type,
decl_modifiers_t modifiers)
{
function_parameter_t *const parameter = allocate_parameter(argument_type);
type_t *type = allocate_type_zero(TYPE_FUNCTION);
type->function.return_type = return_type;
type->function.parameters = parameter;
type->function.modifiers |= modifiers;
type->function.linkage = LINKAGE_C;
return identify_new_type(type);
}
type_t *handle_attribute_mode(const attribute_t *attribute, type_t *orig_type)
{
type_t *type = skip_typeref(orig_type);
/* at least: byte, word, pointer, list of machine modes
* __XXX___ is interpreted as XXX */
/* This isn't really correct, the backend should provide a list of machine
* specific modes (according to gcc philosophy that is...) */
attribute_argument_t *arg = attribute->a.arguments;
if (arg == NULL) {
errorf(&attribute->pos, "__attribute__((mode(X))) misses argument");
return orig_type;
}
const char *symbol_str = arg->v.symbol->string;
bool sign = is_type_signed(type);
atomic_type_kind_t akind;
if (streq_underscore("QI", symbol_str) ||
streq_underscore("byte", symbol_str)) {
akind = sign ? ATOMIC_TYPE_CHAR : ATOMIC_TYPE_UCHAR;
} else if (streq_underscore("HI", symbol_str)) {
akind = sign ? ATOMIC_TYPE_SHORT : ATOMIC_TYPE_USHORT;
} else if (streq_underscore("SI", symbol_str)
|| streq_underscore("word", symbol_str)
|| streq_underscore("pointer", symbol_str)) {
akind = sign ? ATOMIC_TYPE_INT : ATOMIC_TYPE_UINT;
} else if (streq_underscore("DI", symbol_str)) {
akind = sign ? ATOMIC_TYPE_LONGLONG : ATOMIC_TYPE_ULONGLONG;
} else {
warningf(WARN_OTHER, &attribute->pos, "ignoring unknown mode '%s'",
symbol_str);
return orig_type;
}
if (type->kind == TYPE_ATOMIC || type->kind == TYPE_ENUM) {
type_t *copy = duplicate_type(type);
copy->atomic.akind = akind;
return identify_new_type(copy);
} else if (is_type_pointer(type)) {
warningf(WARN_OTHER, &attribute->pos, "__attribute__((mode)) on pointers not implemented yet (ignored)");
return type;
}
errorf(&attribute->pos,
"__attribute__((mode)) only allowed on integer, enum or pointer type");
return orig_type;
}
/**
* Skip all typerefs and return the underlying type.
*/
type_t *skip_typeref(type_t *type)
{
type_qualifiers_t qualifiers = TYPE_QUALIFIER_NONE;
while (true) {
switch (type->kind) {
case TYPE_ERROR:
return type;
case TYPE_TYPEDEF: {
qualifiers |= type->base.qualifiers;
const typedef_type_t *typedef_type = &type->typedeft;
if (typedef_type->resolved_type != NULL) {
type = typedef_type->resolved_type;
break;
}
type = typedef_type->typedefe->type;
continue;
}
case TYPE_TYPEOF:
qualifiers |= type->base.qualifiers;
type = type->typeoft.typeof_type;
continue;
default:
break;
}
break;
}
if (qualifiers != TYPE_QUALIFIER_NONE) {
type_t *const copy = duplicate_type(type);
/* for const with typedefed array type the element type has to be
* adjusted */
if (is_type_array(copy)) {
type_t *element_type = copy->array.element_type;
element_type = duplicate_type(element_type);
element_type->base.qualifiers |= qualifiers;
copy->array.element_type = element_type;
} else {
copy->base.qualifiers |= qualifiers;
}
type = identify_new_type(copy);
}
return type;
}
type_t *make_function_type(type_t *return_type, int n_types,
type_t *const *argument_types,
decl_modifiers_t modifiers)
{
type_t *type = allocate_type_zero(TYPE_FUNCTION);
type->function.return_type = return_type;
type->function.modifiers |= modifiers;
type->function.linkage = LINKAGE_C;
function_parameter_t **anchor = &type->function.parameters;
for (int i = 0; i < n_types; ++i) {
function_parameter_t *parameter = allocate_parameter(argument_types[i]);
*anchor = parameter;
anchor = ¶meter->next;
}
return identify_new_type(type);
}
type_t *make_void_type(type_qualifiers_t const qualifiers)
{
type_t *const type = allocate_type_zero(TYPE_VOID);
type->base.qualifiers = qualifiers;
return identify_new_type(type);
}
void init_predefined_types(void)
{
static const type_base_t error = { TYPE_ERROR, TYPE_QUALIFIER_NONE, NULL };
type_error_type = (type_t*)&error;
type_bool = make_atomic_type(ATOMIC_TYPE_BOOL, TYPE_QUALIFIER_NONE);
type_signed_char = make_atomic_type(ATOMIC_TYPE_SCHAR, TYPE_QUALIFIER_NONE);
type_unsigned_char = make_atomic_type(ATOMIC_TYPE_UCHAR, TYPE_QUALIFIER_NONE);
type_short = make_atomic_type(ATOMIC_TYPE_SHORT, TYPE_QUALIFIER_NONE);
type_unsigned_short = make_atomic_type(ATOMIC_TYPE_USHORT, TYPE_QUALIFIER_NONE);
type_int = make_atomic_type(ATOMIC_TYPE_INT, TYPE_QUALIFIER_NONE);
type_unsigned_int = make_atomic_type(ATOMIC_TYPE_UINT, TYPE_QUALIFIER_NONE);
type_long = make_atomic_type(ATOMIC_TYPE_LONG, TYPE_QUALIFIER_NONE);
type_unsigned_long = make_atomic_type(ATOMIC_TYPE_ULONG, TYPE_QUALIFIER_NONE);
type_long_long = make_atomic_type(ATOMIC_TYPE_LONGLONG, TYPE_QUALIFIER_NONE);
type_unsigned_long_long = make_atomic_type(ATOMIC_TYPE_ULONGLONG, TYPE_QUALIFIER_NONE);
type_long_double = make_atomic_type(ATOMIC_TYPE_LONG_DOUBLE, TYPE_QUALIFIER_NONE);
type_double = make_atomic_type(ATOMIC_TYPE_DOUBLE, TYPE_QUALIFIER_NONE);
type_float = make_atomic_type(ATOMIC_TYPE_FLOAT, TYPE_QUALIFIER_NONE);
type_char = make_atomic_type(ATOMIC_TYPE_CHAR, TYPE_QUALIFIER_NONE);
type_void = make_void_type(TYPE_QUALIFIER_NONE);
type_const_void = make_void_type(TYPE_QUALIFIER_CONST);
type_builtin_template = allocate_type_zero(TYPE_BUILTIN_TEMPLATE);
type_builtin_template = identify_new_type(type_builtin_template);
int8_type_kind = find_signed_int_atomic_type_kind_for_size(1);
int16_type_kind = find_signed_int_atomic_type_kind_for_size(2);
int32_type_kind = find_signed_int_atomic_type_kind_for_size(4);
int64_type_kind = find_signed_int_atomic_type_kind_for_size(8);
type_int32_t = make_atomic_type(int32_type_kind, TYPE_QUALIFIER_NONE);
type_int64_t = make_atomic_type(int64_type_kind, TYPE_QUALIFIER_NONE);
/* pointer types */
type_void_ptr = make_pointer_type(type_void, TYPE_QUALIFIER_NONE);
type_const_void_ptr = make_pointer_type(type_const_void, TYPE_QUALIFIER_NONE);
type_void_ptr_restrict = make_pointer_type(type_void, TYPE_QUALIFIER_RESTRICT);
type_const_void_ptr_restrict = make_pointer_type(type_const_void, TYPE_QUALIFIER_RESTRICT);
type_char_ptr = make_pointer_type(type_char, TYPE_QUALIFIER_NONE);
type_char_ptr_restrict = make_pointer_type(type_char, TYPE_QUALIFIER_RESTRICT);
type_signed_char_ptr = make_pointer_type(type_signed_char, TYPE_QUALIFIER_NONE);
type_short_ptr = make_pointer_type(type_short, TYPE_QUALIFIER_NONE);
type_int_ptr = make_pointer_type(type_int, TYPE_QUALIFIER_NONE);
type_long_ptr = make_pointer_type(type_long, TYPE_QUALIFIER_NONE);
type_unsigned_char_ptr = make_pointer_type(type_unsigned_char, TYPE_QUALIFIER_NONE);
type_unsigned_short_ptr = make_pointer_type(type_unsigned_short, TYPE_QUALIFIER_NONE);
type_unsigned_int_ptr = make_pointer_type(type_unsigned_int, TYPE_QUALIFIER_NONE);
type_unsigned_long_ptr = make_pointer_type(type_unsigned_long, TYPE_QUALIFIER_NONE);
type_unsigned_long_long_ptr = make_pointer_type(type_unsigned_long, TYPE_QUALIFIER_NONE);
type_long_long_ptr = make_pointer_type(type_long_long, TYPE_QUALIFIER_NONE);
type_long_double_ptr = make_pointer_type(type_long_double, TYPE_QUALIFIER_NONE);
type_double_ptr = make_pointer_type(type_double, TYPE_QUALIFIER_NONE);
type_float_ptr = make_pointer_type(type_float, TYPE_QUALIFIER_NONE);
type_char_ptr_ptr = make_pointer_type(type_char_ptr, TYPE_QUALIFIER_NONE);
type_builtin_template_ptr = make_pointer_type(type_builtin_template, TYPE_QUALIFIER_NONE);
backend_params const *const be_params = be_get_backend_param();
ir_type *be_va_list_type = be_params->vararg.va_list_type;
if (!be_va_list_type) {
/* Backend has no vararg support. Just hope the the program will not be
* using any. If it does, the parse_va_* functions will complain. */
type_valist = type_error_type;
type_valist_arg = type_error_type;
} else if (is_Pointer_type(be_va_list_type)) {
type_valist = type_void_ptr;
type_valist_arg = type_void_ptr;
} else if (is_Struct_type(be_va_list_type)) {
entity_t *ent = allocate_entity_zero(ENTITY_STRUCT, NAMESPACE_NORMAL, sym_anonymous, &builtin_position);
ent->compound.alignment = get_type_alignment_bytes(be_va_list_type);
ent->compound.size = get_type_size_bytes(be_va_list_type);
ent->compound.complete = true;
ent->compound.members = (scope_t){
.first_entity = NULL,
.last_entity = NULL,
.depth = 0
};
type_t *type_valist_struct = allocate_type_zero(TYPE_COMPOUND_STRUCT);
type_valist_struct->base.firm_type = be_va_list_type;
type_valist_struct->compound.compound = &ent->compound;
type_valist = make_array_type(type_valist_struct, 1, TYPE_QUALIFIER_NONE);
type_valist_arg = automatic_type_conversion(type_valist);
}
/* const character types */
type_const_char = make_atomic_type(ATOMIC_TYPE_CHAR, TYPE_QUALIFIER_CONST);
type_const_char_ptr = make_pointer_type(type_const_char, TYPE_QUALIFIER_NONE);
type_const_char_ptr_restrict = make_pointer_type(type_const_char, TYPE_QUALIFIER_RESTRICT);
atomic_type_kind_t pointer_sized_int = dialect.pointer_sized_int;
atomic_type_kind_t pointer_sized_uint = dialect.pointer_sized_uint;
type_size_t = make_atomic_type(pointer_sized_uint, TYPE_QUALIFIER_NONE);
type_ssize_t = make_atomic_type(pointer_sized_int, TYPE_QUALIFIER_NONE);
type_uptrdiff_t = type_size_t;
type_ptrdiff_t = type_ssize_t;
type_intmax_t = type_long_long;
type_uintmax_t = type_unsigned_long_long;
type_wint_t = type_unsigned_int;
type_intmax_t_ptr = make_pointer_type(type_intmax_t, TYPE_QUALIFIER_NONE);
type_uintmax_t_ptr = make_pointer_type(type_uintmax_t, TYPE_QUALIFIER_NONE);
type_ptrdiff_t_ptr = make_pointer_type(type_ptrdiff_t, TYPE_QUALIFIER_NONE);
type_uptrdiff_t_ptr = make_pointer_type(type_uptrdiff_t, TYPE_QUALIFIER_NONE);
type_ssize_t_ptr = make_pointer_type(type_ssize_t, TYPE_QUALIFIER_NONE);
type_size_t_ptr = make_pointer_type(type_size_t, TYPE_QUALIFIER_NONE);
atomic_type_kind_t akind
= dialect.cpp ? ATOMIC_TYPE_WCHAR_T : dialect.wchar_atomic_kind;
type_wchar_t = make_atomic_type(akind, TYPE_QUALIFIER_NONE);
type_const_wchar_t = make_atomic_type(akind, TYPE_QUALIFIER_CONST);
type_wchar_t_ptr = make_pointer_type(type_wchar_t, TYPE_QUALIFIER_NONE);
type_const_wchar_t_ptr
= make_pointer_type(type_const_wchar_t, TYPE_QUALIFIER_NONE);
atomic_type_kind_t const u2 = find_unsigned_int_atomic_type_kind_for_size(2);
type_char16_t = make_atomic_type(u2, TYPE_QUALIFIER_NONE);
type_char16_t_const = make_atomic_type(u2, TYPE_QUALIFIER_CONST);
type_char16_t_ptr = make_pointer_type(type_char16_t, TYPE_QUALIFIER_NONE);
type_char16_t_const_ptr = make_pointer_type(type_char16_t_const, TYPE_QUALIFIER_NONE);
atomic_type_kind_t const u4 = find_unsigned_int_atomic_type_kind_for_size(4);
type_char32_t = make_atomic_type(u4, TYPE_QUALIFIER_NONE);
type_char32_t_const = make_atomic_type(u4, TYPE_QUALIFIER_CONST);
type_char32_t_ptr = make_pointer_type(type_char32_t, TYPE_QUALIFIER_NONE);
type_char32_t_const_ptr = make_pointer_type(type_char32_t_const, TYPE_QUALIFIER_NONE);
if (dialect.ms)
init_ms_types();
}
