X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type_t.h;h=b0c21ac41c31779dfe46a49f3b93f2dd66d8d5be;hb=441f7b19fce3fb2baf035f62630c3aeea0e1b09c;hp=b4f922036540900816dbf6b41c60f3885c46d4ca;hpb=f109471af0f1a95e840a66c9e136409d0973021c;p=cparser diff --git a/type_t.h b/type_t.h index b4f9220..b0c21ac 100644 --- a/type_t.h +++ b/type_t.h @@ -1,6 +1,6 @@ /* * This file is part of cparser. - * Copyright (C) 2007-2008 Matthias Braun + * Copyright (C) 2007-2009 Matthias Braun * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License @@ -31,11 +31,8 @@ #include "ast_t.h" #include "adt/obst.h" -extern struct obstack *type_obst; - typedef enum type_kind_t { - TYPE_INVALID, - TYPE_ERROR, + TYPE_ERROR = 1, TYPE_ATOMIC, TYPE_COMPLEX, TYPE_IMAGINARY, @@ -46,49 +43,26 @@ typedef enum type_kind_t { TYPE_POINTER, TYPE_REFERENCE, TYPE_ARRAY, - TYPE_BITFIELD, - TYPE_BUILTIN, TYPE_TYPEDEF, TYPE_TYPEOF, } type_kind_t; -typedef enum type_modifier_t { - TYPE_MODIFIER_NONE = 0, - TYPE_MODIFIER_TRANSPARENT_UNION = 1 << 0, -} type_modifier_t; -typedef unsigned short type_modifiers_t; - struct type_base_t { type_kind_t kind; - il_size_t size; /**< The size of this type. */ type_qualifiers_t qualifiers; - type_modifiers_t modifiers; - il_alignment_t alignment; /**< The extra alignment of the type, 0 for default. */ + /* cached ast2firm infos */ ir_type *firm_type; }; +/** + * used for atomic types, complex and imaginary + */ struct atomic_type_t { type_base_t base; atomic_type_kind_t akind; }; -struct complex_type_t { - type_base_t base; - atomic_type_kind_t akind; -}; - -struct imaginary_type_t { - type_base_t base; - atomic_type_kind_t akind; -}; - -struct builtin_type_t { - type_base_t base; - symbol_t *symbol; - type_t *real_type; -}; - struct pointer_type_t { type_base_t base; type_t *points_to; @@ -125,8 +99,7 @@ struct function_parameter_t { /** Linkage specifications. */ typedef enum linkage_kind_t { - LINKAGE_INVALID, - LINKAGE_C, /**< C linkage. */ + LINKAGE_C = 1, /**< C linkage. */ LINKAGE_CXX /**< C++ linkage. */ } linkage_kind_t; @@ -148,6 +121,7 @@ struct function_type_t { function_parameter_t *parameters; /**< A list of the parameter types. */ linkage_kind_t linkage; cc_kind_t calling_convention; /**< The specified calling convention. */ + decl_modifiers_t modifiers; bool variadic : 1; bool unspecified_parameters : 1; bool kr_style_parameters : 1; @@ -162,8 +136,7 @@ struct compound_type_t { }; struct enum_type_t { - type_base_t base; - atomic_type_kind_t akind; /**< underlying atomic type */ + atomic_type_t base; /** the enum entity. You can find the enum entries by walking the * enum->base.next list until you don't find ENTITY_ENUM_VALUE entities * anymore */ @@ -183,20 +156,10 @@ struct typeof_type_t { type_t *resolved_type; }; -struct bitfield_type_t { - type_base_t base; - type_t *base_type; - expression_t *size_expression; /**< The expression for the bit size. */ - il_size_t bit_size; /**< Size of this bitfield in bits. */ -}; - union type_t { type_kind_t kind; type_base_t base; atomic_type_t atomic; - complex_type_t complex; - imaginary_type_t imaginary; - builtin_type_t builtin; pointer_type_t pointer; reference_type_t reference; array_type_t array; @@ -204,10 +167,29 @@ union type_t { compound_type_t compound; enum_type_t enumt; typedef_type_t typedeft; - bitfield_type_t bitfield; typeof_type_t typeoft; }; +typedef struct atomic_type_properties_t atomic_type_properties_t; +struct atomic_type_properties_t { + unsigned size; /**< type size in bytes */ + unsigned alignment; /**< type alignment in bytes */ + /** some ABIs are broken and require an alignment different from the + * recommended/best alignment inside structs. Fixing ABIs is difficult + * so people rather stick with the wrong values for compatibility. + * (double type on x86 System V ABI) + */ + unsigned struct_alignment; + unsigned flags; /**< type flags from atomic_type_flag_t */ + unsigned rank; /**< integer conversion rank */ +}; + +extern atomic_type_properties_t atomic_type_properties[ATOMIC_TYPE_LAST+1]; +extern atomic_type_properties_t pointer_properties; + +/** The default calling convention for functions. */ +extern cc_kind_t default_calling_convention; + type_t *make_atomic_type(atomic_type_kind_t type, type_qualifiers_t qualifiers); type_t *make_complex_type(atomic_type_kind_t type, type_qualifiers_t qualifiers); type_t *make_imaginary_type(atomic_type_kind_t type, type_qualifiers_t qualifiers); @@ -217,8 +199,18 @@ type_t *make_based_pointer_type(type_t *points_to, type_qualifiers_t qualifiers, variable_t *variable); type_t *make_array_type(type_t *element_type, size_t size, type_qualifiers_t qualifiers); +function_parameter_t *allocate_parameter(type_t*); +/** + * Duplicates a type. + * + * @param type The type to copy. + * @return A copy of the type. + * + * @note This does not produce a deep copy! + */ type_t *duplicate_type(const type_t *type); + type_t *identify_new_type(type_t *type); static inline bool is_typeref(const type_t *type) @@ -237,6 +229,11 @@ static inline bool is_type_atomic(const type_t *type, atomic_type_kind_t atype) return atomic_type->akind == atype; } +static inline bool is_type_void(type_t const *const type) +{ + return is_type_atomic(type, ATOMIC_TYPE_VOID); +} + static inline bool is_type_pointer(const type_t *type) { assert(!is_typeref(type)); @@ -273,12 +270,6 @@ static inline bool is_type_struct(const type_t *type) return type->kind == TYPE_COMPOUND_STRUCT; } -static inline bool is_type_builtin(const type_t *type) -{ - assert(!is_typeref(type)); - return type->kind == TYPE_BUILTIN; -} - static inline bool is_type_compound(const type_t *type) { assert(!is_typeref(type)); @@ -292,4 +283,66 @@ static inline bool is_type_valid(const type_t *type) return type->kind != TYPE_ERROR; } +/** + * return integer conversion rank of an atomic type kind + */ +static inline unsigned get_akind_rank(atomic_type_kind_t akind) +{ + return atomic_type_properties[akind].rank; +} + +/** + * Allocate a type node of given kind and initialize all + * fields with zero. + * + * @param kind type kind to allocate + */ +type_t *allocate_type_zero(type_kind_t kind); + +/** + * Creates a return_type (func)(void) function type if not + * already exists. + * + * @param return_type the return type + */ +type_t *make_function_0_type(type_t *return_type, + decl_modifiers_t modifiers); + +/** + * Creates a return_type (func)(argument_type) function type if not + * already exists. + * + * @param return_type the return type + * @param argument_type the argument type + */ +type_t *make_function_1_type(type_t *return_type, type_t *argument_type1, + decl_modifiers_t modifiers); + + +/** + * Creates a return_type (func)(argument_type1,argument_type2) function type + * if not already exists. + */ +type_t *make_function_2_type(type_t *return_type, type_t *argument_type1, + type_t *argument_type2, + decl_modifiers_t modifiers); + +/** + * Creates a return_type (func)(argument_type, ...) function type if not + * already exists. + * + * @param return_type the return type + * @param argument_type the argument type + */ +type_t *make_function_1_type_variadic(type_t *return_type, + type_t *argument_type, + decl_modifiers_t modifiers); + +/** + * Create a function type with n parameters + */ +type_t *make_function_type(type_t *return_type, int n_types, + type_t *const *argument_types, + decl_modifiers_t modifiers); + #endif