nsz Git - cparser/blob - type_t.h

   1 /*
   2  * This file is part of cparser.
   3  * Copyright (C) 2007-2009 Matthias Braun <matze@braunis.de>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  18  * 02111-1307, USA.
  19  */
  20 #ifndef TYPE_T_H
  21 #define TYPE_T_H
  22
  23 #include <stdbool.h>
  24 #include <assert.h>
  25
  26 #include <libfirm/firm_types.h>
  27
  28 #include "type.h"
  29 #include "symbol.h"
  30 #include "token_t.h"
  31 #include "ast_t.h"
  32 #include "adt/obst.h"
  33
  34 typedef enum type_kind_t {
  35         TYPE_ERROR = 1,
  36         TYPE_ATOMIC,
  37         TYPE_COMPLEX,
  38         TYPE_IMAGINARY,
  39         TYPE_COMPOUND_STRUCT,
  40         TYPE_COMPOUND_UNION,
  41         TYPE_ENUM,
  42         TYPE_FUNCTION,
  43         TYPE_POINTER,
  44         TYPE_REFERENCE,
  45         TYPE_ARRAY,
  46         TYPE_TYPEDEF,
  47         TYPE_TYPEOF,
  48 } type_kind_t;
  49
  50 struct type_base_t {
  51         type_kind_t       kind;
  52         type_qualifiers_t qualifiers;
  53
  54         /* cached ast2firm infos */
  55         ir_type          *firm_type;
  56 };
  57
  58 struct atomic_type_t {
  59         type_base_t         base;
  60         atomic_type_kind_t  akind;
  61 };
  62
  63 struct complex_type_t {
  64         type_base_t         base;
  65         atomic_type_kind_t  akind;
  66 };
  67
  68 struct imaginary_type_t {
  69         type_base_t         base;
  70         atomic_type_kind_t  akind;
  71 };
  72
  73 struct pointer_type_t {
  74         type_base_t  base;
  75         type_t      *points_to;
  76         variable_t  *base_variable;  /**< Microsoft __based() extension: base variable or NULL. */
  77 };
  78
  79 struct reference_type_t {
  80         type_base_t  base;
  81         type_t      *refers_to;
  82 };
  83
  84 struct array_type_t {
  85         type_base_t   base;
  86         type_t       *element_type;
  87         expression_t *size_expression;
  88         size_t        size;
  89
  90         ir_node      *size_node; /**< used by ast2firm phase */
  91
  92         bool          is_static         : 1; /**< a [static] type */
  93         bool          is_variable       : 1; /**< a [*] type */
  94         bool          has_implicit_size : 1;
  95         bool          size_constant     : 1; /**< size expression is constant */
  96         bool          is_vla            : 1; /**< it's a variable length array */
  97 };
  98
  99 /**
 100  * An entry in the parameter list of a function type.
 101  */
 102 struct function_parameter_t {
 103         type_t               *type;  /**< The parameter type. */
 104         function_parameter_t *next;  /**< Points to the next type in the parameter list.*/
 105 };
 106
 107 /** Linkage specifications. */
 108 typedef enum linkage_kind_t {
 109         LINKAGE_INVALID,
 110         LINKAGE_C,       /**< C linkage. */
 111         LINKAGE_CXX      /**< C++ linkage. */
 112 } linkage_kind_t;
 113
 114 /** Calling conventions. */
 115 typedef enum cc_kind_t {
 116         CC_DEFAULT,      /**< default calling convention. */
 117         CC_CDECL,        /**< cdecl calling convention. */
 118         CC_STDCALL,      /**< stdcall calling convention. */
 119         CC_FASTCALL,     /**< fastcall calling convention. */
 120         CC_THISCALL      /**< thiscall calling convention. */
 121 } cc_kind_t;
 122
 123 /**
 124  * A function type.
 125  */
 126 struct function_type_t {
 127         type_base_t           base;
 128         type_t               *return_type;        /**< The return type. */
 129         function_parameter_t *parameters;         /**< A list of the parameter types. */
 130         linkage_kind_t        linkage;
 131         cc_kind_t             calling_convention; /**< The specified calling convention. */
 132         decl_modifiers_t      modifiers;
 133         bool                  variadic : 1;
 134         bool                  unspecified_parameters : 1;
 135         bool                  kr_style_parameters : 1;
 136 };
 137
 138 struct compound_type_t {
 139         type_base_t     base;
 140         bool            packed : 1; /**< Set if packed was specified. */
 141         /** the declaration of the compound type, the scope of the declaration
 142          *  contains the compound entries. */
 143         compound_t     *compound;
 144 };
 145
 146 struct enum_type_t {
 147         type_base_t         base;
 148         atomic_type_kind_t  akind; /**< underlying atomic type */
 149         /** the enum entity. You can find the enum entries by walking the
 150          *  enum->base.next list until you don't find ENTITY_ENUM_VALUE entities
 151          *  anymore */
 152         enum_t             *enume;
 153 };
 154
 155 struct typedef_type_t {
 156         type_base_t  base;
 157         typedef_t   *typedefe;
 158         type_t      *resolved_type;
 159 };
 160
 161 struct typeof_type_t {
 162         type_base_t   base;
 163         expression_t *expression;
 164         type_t       *typeof_type;
 165         type_t       *resolved_type;
 166 };
 167
 168 union type_t {
 169         type_kind_t      kind;
 170         type_base_t      base;
 171         atomic_type_t    atomic;
 172         complex_type_t   complex;
 173         imaginary_type_t imaginary;
 174         pointer_type_t   pointer;
 175         reference_type_t reference;
 176         array_type_t     array;
 177         function_type_t  function;
 178         compound_type_t  compound;
 179         enum_type_t      enumt;
 180         typedef_type_t   typedeft;
 181         typeof_type_t    typeoft;
 182 };
 183
 184 typedef struct atomic_type_properties_t atomic_type_properties_t;
 185 struct atomic_type_properties_t {
 186         unsigned   size;              /**< type size in bytes */
 187         unsigned   alignment;         /**< type alignment in bytes */
 188         /** some ABIs are broken and require an alignment different from the
 189          * recommended/best alignment inside structs. Fixing ABIs is difficult
 190          * so people rather stick with the wrong values for compatibility.
 191          * (double type on x86 System V ABI)
 192          */
 193         unsigned   struct_alignment;
 194         unsigned   flags;             /**< type flags from atomic_type_flag_t */
 195 };
 196
 197 extern atomic_type_properties_t atomic_type_properties[ATOMIC_TYPE_LAST+1];
 198 extern atomic_type_properties_t pointer_properties;
 199
 200 /** The default calling convention for functions. */
 201 extern cc_kind_t default_calling_convention;
 202
 203 type_t *make_atomic_type(atomic_type_kind_t type, type_qualifiers_t qualifiers);
 204 type_t *make_complex_type(atomic_type_kind_t type, type_qualifiers_t qualifiers);
 205 type_t *make_imaginary_type(atomic_type_kind_t type, type_qualifiers_t qualifiers);
 206 type_t *make_pointer_type(type_t *points_to, type_qualifiers_t qualifiers);
 207 type_t *make_reference_type(type_t *refers_to);
 208 type_t *make_based_pointer_type(type_t *points_to,
 209                                                                 type_qualifiers_t qualifiers, variable_t *variable);
 210 type_t *make_array_type(type_t *element_type, size_t size,
 211                         type_qualifiers_t qualifiers);
 212 function_parameter_t *allocate_parameter(type_t*);
 213
 214 type_t *duplicate_type(const type_t *type);
 215 type_t *identify_new_type(type_t *type);
 216
 217 static inline bool is_typeref(const type_t *type)
 218 {
 219         return type->kind == TYPE_TYPEDEF || type->kind == TYPE_TYPEOF;
 220 }
 221
 222 static inline bool is_type_atomic(const type_t *type, atomic_type_kind_t atype)
 223 {
 224         assert(!is_typeref(type));
 225
 226         if(type->kind != TYPE_ATOMIC)
 227                 return false;
 228         const atomic_type_t *atomic_type = &type->atomic;
 229
 230         return atomic_type->akind == atype;
 231 }
 232
 233 static inline bool is_type_pointer(const type_t *type)
 234 {
 235         assert(!is_typeref(type));
 236         return type->kind == TYPE_POINTER;
 237 }
 238
 239 static inline bool is_type_reference(const type_t *type)
 240 {
 241         assert(!is_typeref(type));
 242         return type->kind == TYPE_REFERENCE;
 243 }
 244
 245 static inline bool is_type_array(const type_t *type)
 246 {
 247         assert(!is_typeref(type));
 248         return type->kind == TYPE_ARRAY;
 249 }
 250
 251 static inline bool is_type_function(const type_t *type)
 252 {
 253         assert(!is_typeref(type));
 254         return type->kind == TYPE_FUNCTION;
 255 }
 256
 257 static inline bool is_type_union(const type_t *type)
 258 {
 259         assert(!is_typeref(type));
 260         return type->kind == TYPE_COMPOUND_UNION;
 261 }
 262
 263 static inline bool is_type_struct(const type_t *type)
 264 {
 265         assert(!is_typeref(type));
 266         return type->kind == TYPE_COMPOUND_STRUCT;
 267 }
 268
 269 static inline bool is_type_compound(const type_t *type)
 270 {
 271         assert(!is_typeref(type));
 272         return type->kind == TYPE_COMPOUND_STRUCT
 273                 || type->kind == TYPE_COMPOUND_UNION;
 274 }
 275
 276 static inline bool is_type_valid(const type_t *type)
 277 {
 278         assert(!is_typeref(type));
 279         return type->kind != TYPE_ERROR;
 280 }
 281
 282 /**
 283  * Allocate a type node of given kind and initialize all
 284  * fields with zero.
 285  *
 286  * @param kind             type kind to allocate
 287  */
 288 type_t *allocate_type_zero(type_kind_t kind);
 289
 290 /**
 291  * Creates a return_type (func)(void) function type if not
 292  * already exists.
 293  *
 294  * @param return_type    the return type
 295  */
 296 type_t *make_function_0_type(type_t *return_type);
 297
 298 /**
 299  * Creates a return_type (func)(argument_type) function type if not
 300  * already exists.
 301  *
 302  * @param return_type    the return type
 303  * @param argument_type  the argument type
 304  */
 305 type_t *make_function_1_type(type_t *return_type, type_t *argument_type1);
 306
 307
 308 /**
 309  * Creates a return_type (func)(argument_type1,argument_type2) function type
 310  * if not already exists.
 311  */
 312 type_t *make_function_2_type(type_t *return_type, type_t *argument_type1,
 313                              type_t *argument_type2);
 314
 315 /**
 316  * Creates a return_type (func)(argument_type, ...) function type if not
 317  * already exists.
 318  *
 319  * @param return_type    the return type
 320  * @param argument_type  the argument type
 321  */
 322 type_t *make_function_1_type_variadic(type_t *return_type, type_t *argument_type);
 323
 324 /**
 325  * Create a function type with n parameters
 326  */
 327 type_t *make_function_type(type_t *return_type, int n_types,
 328                            type_t *const *argument_types,
 329                                                    decl_modifiers_t modifiers);
 330
 331 #endif