nsz Git - libfirm/blob - ir/tr/type.h

   1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
   2 ** All rights reserved.
   3 **
   4 ** Authors: Martin Trapp, Christian Schaefer &
   5 **          Goetz Lindenmaier
   6 **
   7 ** type.h: datastructures to hold type information.
   8 */
   9
  10 # ifndef _TYPE_H_
  11 # define _TYPE_H_
  12
  13 # include "common.h"
  14 # include "ident.h"
  15 # include "irmode.h"
  16
  17 /* for recursive type definiton */
  18 typedef union type type;
  19
  20 /* visited flag to traverse the type information */
  21 extern unsigned long type_visited;
  22
  23 /*******************************************************************/
  24 /** TYPE_CLASS                                                    **/
  25 /*******************************************************************/
  26
  27 typedef struct {
  28   firm_kind kind;
  29   ident *name;
  30   /** needs list with it's entities -- does it really??
  31       Entities can be added during their creation.
  32   int n_members;
  33   entity **member; **/
  34   unsigned long visit;     /* visited counter for walks of the type information */
  35 } type_class;
  36
  37
  38 /* create a new type_class */
  39 type_class *new_type_class (ident *name);
  40
  41 /* manipulate fields of type_class */
  42 char  *get_class_name  (type_class *clss);
  43 ident *get_class_ident (type_class *clss);
  44 /*
  45 void   set_class_name  (type_class *class, char *name);
  46 void   set_class_ident (type_class *class, ident* ident);
  47 */
  48
  49 /*******************************************************************/
  50 /** TYPE_STRCT                                                   **/
  51 /*******************************************************************/
  52
  53 typedef struct {
  54   firm_kind kind;
  55   ident *name;
  56   /** needs list with it's entities -- does it really??
  57       Entities can be added during their creation.
  58   int n_members;
  59   entity **member; **/
  60   unsigned long visit;     /* visited counter for walks of the type information */
  61 } type_strct;
  62
  63
  64 /* create a new type_strct */
  65 type_strct *new_type_strct (ident *name);
  66
  67 /* manipulate fields of type_strct */
  68 char  *get_strct_name  (type_strct *strct);
  69 ident *get_strct_ident (type_strct *strct);
  70 /*
  71 void   set_strct_name  (type_strct *strct, char *name);
  72 void   set_strct_ident (type_strct *strct, ident* ident);
  73 */
  74
  75
  76 /*******************************************************************/
  77 /** TYPE_METHOD                                                   **/
  78 /*******************************************************************/
  79
  80 typedef struct {
  81   firm_kind kind;
  82   ident *name;     // do I need the name, or is the name in entity sufficient?
  83   int arity;                   /* number of parameters, better n_params */
  84   type **param_type;     /* code generation needs this information.
  85                                   Should it be generated by the frontend,
  86                                   or does this impose unnecessary work for
  87                                   optimizatinos that change the parameters of
  88                                   methods? */
  89   int n_res;                   /* number of results */
  90   type **res_type;
  91   /** needs pointer to it's ir_graph ??
  92   ir_graph *graph; **/
  93   unsigned long visit;     /* visited counter for walks of the type information */
  94 } type_method;
  95
  96 /* create a new type_method */
  97 type_method *new_type_method (ident *name, int arity, int n_res);
  98
  99 /* manipulate fields of type_method */
 100
 101 char  *get_method_name  (type_method *method);
 102 ident *get_method_ident (type_method *method);
 103 /* GL 9.2.2000: who commened these in?
 104    I think it's not safe to have these methods.
 105    Please add changes to Changes file.
 106 void   set_method_name  (type_method *method, char *name);
 107 void   set_method_ident (type_method *method, ident* ident); */
 108
 109 inline int   get_method_arity (type_method *method);
 110 inline void  set_method_arity (type_method *method, int arity);
 111 inline type *get_method_param_type(type_method *method, int pos);
 112 inline void  set_method_param_type(type_method *method, int pos, type* type);
 113
 114 inline int   get_method_n_res (type_method *method);
 115 inline void  set_method_n_res (type_method *method, int n_res);
 116 inline type *get_method_res_type(type_method *method, int pos);
 117 inline void  set_method_res_type(type_method *method, int pos, type* type);
 118
 119 /*
 120 ir_graph *get_method_graph(type_method *method);
 121 void *get_method_graph(type_method *method, ir_graph* graph);
 122 */
 123
 124 /*******************************************************************/
 125 /** TYPE_UNION                                                    **/
 126 /*******************************************************************/
 127
 128 typedef struct {
 129   firm_kind kind;
 130   ident *name;             // do I need a name?
 131   int n_types;
 132   /* type **unioned_type;    ... or something like that? */
 133   unsigned long visit;     /* visited counter for walks of the type information */
 134 } type_union;
 135
 136 /* create a new type_union -- set unioned types by hand. */
 137 type_union *new_type_union (ident *name, int n_types);
 138
 139 /* manipulate fields of type_union */
 140 char  *get_union_name  (type_union *uni);
 141 ident *get_union_ident (type_union *uni);
 142 /*
 143 void   set_union_name  (type_union *union, char *name);
 144 void   set_union_ident (type_union *union, ident* ident);
 145 */
 146 /*
 147 int    get_union_n_types (type_union *union);
 148 void   set_union_n_types (type_union *union, int n);
 149 type  *get_union_unioned_type (type_union *union, int pos);
 150 void   set_union_unioned_type (type_union *union, int pos, type *type);
 151 */
 152
 153 /*******************************************************************/
 154 /** TYPE_ARRAY                                                    **/
 155 /*******************************************************************/
 156
 157 /* multidimensional, polyhedric arrays */
 158 typedef struct {
 159   firm_kind kind;
 160   ident *name;
 161   int n_dimensions;   /* Extend Sel to select from multidimensional arrays.  This  */
 162   int *lower_bound;   /* will allow to generate explicit array index computations  */
 163   int *upper_bound;   /* by replacing a single FIRM node.  As long as this is not
 164                          done create arrays with arrays as elements.  */
 165                       /* Should I use tarval? */
 166   type *element_type;
 167   unsigned long visit;     /* visited counter for walks of the type information */
 168 } type_array;
 169
 170 /* create a new type array -- set dimension sizes independently */
 171 type_array *new_type_array (ident *name, int n_dimensions);
 172
 173 /* manipulate fields of type_array */
 174 char  *get_array_name  (type_array *array);
 175 ident *get_array_ident (type_array *array);
 176 /*
 177 void   set_array_name  (type_array *array, char *name);
 178 void   set_array_ident (type_array *array, ident* ident);
 179 */
 180 void  set_array_n_dimensions  (type_array *array, int n);
 181 int   get_array_n_dimensions  (type_array *array);
 182
 183 void  set_array_bounds      (type_array *array, int dimension, int lower_bound,
 184                                                               int upper_bound);
 185 void  set_array_lower_bound (type_array *array, int dimension, int lower_bound);
 186 void  set_array_upper_bound (type_array *array, int dimension, int upper_bound);
 187 int   get_array_lower_bound (type_array *array, int dimension);
 188 int   get_array_upper_bound (type_array *array, int dimension);
 189
 190 void  set_array_element_type (type_array *array, type *type);
 191 type *get_array_element_type (type_array *array);
 192
 193 /*******************************************************************/
 194 /** TYPE_ENUMERATION                                              **/
 195 /*******************************************************************/
 196 /** Enums are needed to keep debugging information.  They can as well
 197     be lowered to integers. **/
 198
 199 typedef struct {
 200   firm_kind kind;
 201   ident *name;
 202   /* int n_enums;
 203   ir_node **enum    * Contains all constant nodes that represent a member
 204                      of the enum -- enumerators. */
 205                     // is ir_node the propper array member?
 206   unsigned long visit;     /* visited counter for walks of the type information */
 207 } type_enumeration;
 208
 209 /* create a new type enumeration -- set the enumerators independently */
 210 type_enumeration *new_type_enumeration (ident *name /* , int n_enums */);
 211
 212 /* manipulate fields of type_enumeration */
 213 char  *get_enumeration_name  (type_enumeration *enumeration);
 214 ident *get_enumeration_ident (type_enumeration *enumeration);
 215 /*
 216 void   set_enumeration_name  (type_enumeration *enumeration, char *name);
 217 void   set_enumeration_ident (type_enumeration *enumeration, ident* ident);
 218 */
 219 /*
 220 void     set_enumeration_n_enums (type_enumeration *enumeration, int n);
 221 int     *get_enumeration_n_enums (type_enumeration *enumeration);
 222 void     set_enumeration_enum    (type_enumeration *enumeration, int pos,
 223                                  ir_node const);
 224 ir_node *get_enumeration_enum    (type_enumeration *enumeration, int pos);
 225 */
 226
 227 /*******************************************************************/
 228 /** TYPE_POINTER                                                  **/
 229 /*******************************************************************/
 230
 231 typedef struct {
 232   firm_kind kind;
 233   ident *name;
 234   /* ir_mode *mode;      * The mode to be used for this type.
 235                             Not here as there might be several pointer types?
 236                             A method get_pointer_mode should read a unique,
 237                             global variable. */
 238   type *points_to;
 239   unsigned long visit;     /* visited counter for walks of the type information */
 240 } type_pointer;
 241
 242 /* create a new type pointer */
 243 type_pointer *new_type_pointer (ident *name, type *points_to);
 244
 245 /* manipulate fields of type_pointer */
 246 char  *get_pointer_name  (type_pointer *pointer);
 247 ident *get_pointer_ident (type_pointer *pointer);
 248 /*
 249 void   set_pointer_name  (type_pointer *pointer, char *name);
 250 void   set_pointer_ident (type_pointer *pointer, ident* ident);
 251 */
 252 void  set_pointer_points_to_type (type_pointer *pointer, type *type);
 253 type *get_pointer_points_to_type (type_pointer *pointer);
 254
 255 /*******************************************************************/
 256 /** TYPE_PRIMITIVE                                                **/
 257 /*******************************************************************/
 258
 259 /* primitive, language-defined types */
 260 /* What is the type of an entity if it is atomic?  Are alle basic data
 261    types classses in Sather? Else this is needed. */
 262 typedef struct {
 263   firm_kind kind;
 264   ident *name;
 265   ir_mode *mode;       /* The mode to be used for this type */
 266   unsigned long visit;     /* visited counter for walks of the type information */
 267 } type_primitive;
 268
 269 /* create a new type primitive */
 270 type_primitive *new_type_primitive (ident *name, ir_mode *mode);
 271
 272 /* manipulate fields of type_primitive */
 273 char  *get_primitive_name  (type_primitive *primitive);
 274 ident *get_primitive_ident (type_primitive *primitive);
 275 /*
 276 void   set_primitive_name  (type_primitive *primitive, char *name);
 277 void   set_primitive_ident (type_primitive *primitive, ident* ident);
 278 */
 279 ir_mode *get_primitive_mode (type_primitive *primitive);
 280 void     set_primitive_mode (type_primitive *primitive, ir_mode *mode);
 281
 282
 283
 284
 285 /*******************************************************************/
 286 /**  To manage all different types the same                       **/
 287 /*******************************************************************/
 288
 289 union type {
 290   firm_kind kind;
 291   type_class clss;
 292   type_strct strct;
 293   type_method method;
 294   type_array array;
 295   type_union uni;  /* union is keyword */
 296   type_enumeration enumeration;
 297   type_pointer pointer;
 298   type_primitive primitive;
 299 };
 300
 301 int is_type(void *thing);
 302
 303
 304
 305
 306 # endif /* _TYPE_H_ */