-/* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
-** All rights reserved.
-**
-** Authors: Martin Trapp, Christian Schaefer &
-** Goetz Lindenmaier
-**
-
-@@@@@@@ Improve documentation: distinguish fields that are
-set by the frontend and contain knowledge specified by the source
-program from fields containing information derived by analysis/optimization
-or lowering phases.
-
-
-** type.h: datastructures to hold type information.
-**
-** This module supplies datastructures to represent all types
-** known in the compiled program. This includes types specified
-** in the program as well as types defined by the language. In the
-** view of the intermediate representation there is no difference
-** between these types.
-** Types are different from the modes defined in irmode: Types are
-** on the level of the programming language, modes at the level of
-** the target processor.
-**
-**
-** General datastructure
-** =====================
-**
-** Firm distinguishes several different type constructs. These are
-** implemented as structs. A union of the individual structs constructs
-** the firm node "type".
-**
-** All type constructs have the following fields:
-**
-** kind A firm_kind tag containing k_type_class. This is useful
-** for dynamically checking the sort of a type. Automatically
-** generated.
-**
-** name An identifier specifying the type name. Set by the frontend.
-**
-** visit A counter for walks of the type information.
-**
-**
-** General functionality
-** =====================
-**
-** is_type(t) Returns true if t is a type node, else false.
-**
-**
-** type_class
-** ==========
-**
-** Type_class represents class types. A list of fields and
-** methods is associated with a class. Further a class can
-** inherit from and bequest to other classes.
-**
-** fields:
-** -------
-**
-** **member All entities belonging to this class. This are methodes
-** which have type_method or fields that can have any of the
-** following types: k_type_class, k_type_strct, k_type_union,
-** k_type_array, k_type_enumeration, k_type_pointer, k_type_primitive.
-**
-** **subtypes A list of direct subclasses.
-**
-** **supertypes A list of direct superclasses.
-**
-**
-** type_strct
-** ==========
-**
-** Type_strct represents aggregate types that consist of a list
-** of fields.
-**
-** fields:
-** -------
-**
-** **member All entities belonging to this class. This are the fields
-** that can have any of the following types: k_type_class,
-** k_type_strct, k_type_union, k_type_array, k_type_enumeration,
-** k_type_pointer, k_type_primitive.
-**
-** type_method
-** ===========
-**
-** Type_method represents method, function and procedure types.
-**
-** fields:
-** -------
-**
-** arity Number of parameters to the procedure. @@@ better n_params
-** A procedure in FIRM has only call by value parameters.
-**
-** **param_type A list with the types of parameters. This list is ordered.
-** The nth type in this list corresponds to the nth element
-** in the parameter tuple that is a result of the start node.
-** (See ircons.h for more information.)
-**
-** n_res The number of results of the method. In general, procedures
-** have zero results, functions one.
-**
-** **res_type A list with the types of parameters. This list is ordered.
-** The nth type in this list corresponds to the nth input to
-** Return nodes. (See ircons.h for more information.)
-**
-**
-** type_union
-** ==========
-**
-** Type_union represents union types.
-**
-** fields:
-** -------
-**
-** **unioned_type A list of unioned types.
-**
-**
-** type_array
-** ==========
-**
-** Type_array represents rectangular multi dimensional arrays.
-**
-** fields:
-** -------
-**
-** n_dimensions Number of array dimensions.
-**
-** *lower_bound Lower bounds of dimensions. Mostly all 0.
-**
-** *upper_bound Upper bounds or dimensions.
-**
-** *element_type The type of the array elements.
-**
-**
-** type_enumeration
-** ================
-**
-** Enumeration types. These need not necessarily be represented explicitly
-** by Firm types, as the frontend can lower them to integer constants as
-** well. For debugging purposes or similar tasks this information is useful.
-**
-** fields:
-** -------
-**
-** **enum The target values representing the constants used to
-** represent individual enumerations.
-**
-** **enum_name Idents containing the source program name of the enumeration
-** constants
-**
-** type_pointer
-** ============
-**
-** Pointer types.
-**
-** fields:
-** -------
-**
-** *mode The mode used to implement a pointer. @@@ So far this field
-** is constant and set to mode_P. Maybe we will move this
-** to a global constant (irprog), or are there processors
-** that require a set of different pointer modes?
-**
-** *points_to The type of the entity this pointer points to.
-**
-** type_primitive
-** ==============
-**
-** Primitive types are types that represent indivisible data values that
-** map directly to modes.
-**
-** fields:
-** -------
-**
-** mode The mode to be used for this type.
-**
-*/
+/****h* libfirm/type
+ *
+ * NAME
+ * file type.h - datastructure to hold type information.
+ * COPYRIGHT
+ * (C) 2001 by Universitaet Karlsruhe
+ * AUTHORS
+ * Goetz Lindenmaier
+ *
+ * NOTES
+ * This module supplies a datastructure to represent all types
+ * known in the compiled program. This includes types specified
+ * in the program as well as types defined by the language. In the
+ * view of the intermediate representation there is no difference
+ * between these types.
+ *
+ * There exist several kinds of types, arranged by the structure of
+ * the type. A type is described by a set of attributes. Some of
+ * these attributes are common to all types, others depend on the
+ * kind of the type.
+ *
+ * Types are different from the modes defined in irmode: Types are
+ * on the level of the programming language, modes at the level of
+ * the target processor.
+ *
+ * SEE ALSO
+ * tpop.h
+ *****
+ */
+
+/* $Id$ */
# ifndef _TYPE_H_
# define _TYPE_H_
+# include "tpop.h"
# include "common.h"
# include "ident.h"
# include "irmode.h"
+# include "bool.h"
+
#ifndef _ENTITY_TYPEDEF_
#define _ENTITY_TYPEDEF_
typedef struct entity entity;
#endif
-/* for recursive type definiton */
-//#ifndef _TYPE_TYPEDEF_
-//#define _TYPE_TYPEDEF_
-/* to resolve recursion between entity.h and irgraph.h */
-typedef union type type;
-//#endif
-
+#ifndef _IR_NODE_TYPEDEF_
+#define _IR_NODE_TYPEDEF_
+typedef struct ir_node ir_node;
+#endif
-/* visited flag to traverse the type information */
+/****s* type/type
+ *
+ * NAME
+ * type - An abstract data type to represent types.
+ * NOTE
+ * This is the abstract data type with which any type known in the
+ * compiled program can be represented. This includes types specified
+ * in the program as well as types defined by the language. In the
+ * view of the intermediate representation there is no difference
+ * between these types.
+ *
+ * There exist several kinds of types, arranged by the structure of
+ * the type. These are distinguished by a type opcode.
+ * A type is described by a set of attributes. Some of these attributes
+ * are common to all types, others depend on the kind of the type.
+ *
+ * The following describes the common attributes. They can only be
+ * accessed by the functions given below.
+ *
+ * ATTRIBUTES
+ * The common fields are:
+ *
+ * firm_kind A firm_kind tag containing k_type. This is useful
+ * for dynamically checking whether a node is a type node.
+ * type_op A tp_op specifying the kind of the type.
+ * mode The mode to be used to represent the type on a machine.
+ * @@@ maybe not global field??
+ * name An identifier specifying the name of the type. To be
+ * set by the frontend.
+ * size The size of the type, i.e. an entity of this type will
+ * occupy size bytes in memory. In several cases this is
+ * determined when fixing the layout of this type (class,
+ * struct, union, array, enumeration).
+ * state The state of the type. The state represents whether the
+ * layout of the type is undefined or fixed (values: layout_undefined
+ * or layout_fixed). Compound types can have an undefined
+ * layout. The layout of the basic types primitive and pointer
+ * is always layout_fixed. If the layout of
+ * compound types is fixed all entities must have an offset
+ * and the size of the type must be set.
+ * A fixed layout for enumeration types means that each enumeration
+ * is associated with an implementation value.
+ * visit A counter for walks of the type information.
+ * link A void* to associate some additional inforamtion with the type.
+ *
+ * These fields can only be accessed via access functions.
+ *
+ * Depending on the value of type_op, i.e., depending on the kind of the
+ * type the adt contains further attributes. These are documented below.
+ * SEE ALSO
+ * class, struct, method, union, array, enumeration, pointer, primitive
+ * SOURCE
+ */
+typedef struct type type;
+
+# include "type_or_entity.h"
+
+void* get_type_link(type *tp);
+void set_type_link(type *tp, void *l);
+tp_op* get_type_tpop(type *tp);
+ident* get_type_tpop_nameid(type *tp);
+const char* get_type_tpop_name(type *tp);
+tp_opcode get_type_tpop_code(type *tp);
+
+/* Returns NULL for all non atomic types. */
+ir_mode* get_type_mode(type *tp);
+/* Only has an effect on primitive and enumeration types */
+void set_type_mode(type *tp, ir_mode* m);
+
+ident* get_type_ident(type *tp);
+void set_type_ident(type *tp, ident* id);
+const char* get_type_name(type *tp);
+
+int get_type_size(type *tp);
+/* For primitives, enumerationsm, pointer and method types the size
+ is always fixed. This call is legal but has no effect. */
+void set_type_size(type *tp, int size);
+
+typedef enum {
+ layout_undefined, /* The layout of this type is not defined.
+ Address computation to access fields is not
+ possible, fields must be accessed by Sel nodes.
+ This is the default value except for pointer and
+ primitive types. */
+ layout_fixed /* The layout is fixed, all component/member entities
+ have an offset assigned. Size of the type is known.
+ Arrays can be accessed by explicit address
+ computation. Default for pointer and primitive types.
+ */
+} type_state;
+
+type_state get_type_state(type *tp);
+/* For primitives, pointer and method types the layout is always fixed.
+ This call is legal but has no effect. */
+void set_type_state(type *tp, type_state state);
+
+unsigned long get_type_visited(type *tp);
+void set_type_visited(type *tp, unsigned long num);
+/* Sets visited field in type to type_visited. */
+void mark_type_visited(type *tp);
+/*****/
+
+/****v* type/visited
+ *
+ * NAME
+ * type_visited - visited flag to traverse the type information
+ * PURPOSE
+ * Increase this flag by one before traversing the type information.
+ * Mark type nodes as visited by set_type_visited(type, type_visited).
+ * Check whether node was already visited by comparing get_type_visited(type)
+ * and type_visited.
+ * Or use the function to walk all types.
+ * SEE ALSO
+ * typewalk
+ * SOURCE
+ */
extern unsigned long type_visited;
+/*****/
+
+/****f* type/is_type
+ *
+ * NAME
+ * is_type - Checks whether a pointer points to a type.
+ * SYNOPSIS
+ * bool is_type (void *thing);
+ * INPUTS
+ * thing - a pointer
+ * RESULT
+ * true if the thing is a type, else false
+ ***
+ */
+int is_type (void *thing);
-/*******************************************************************/
-/** TYPE_CLASS **/
-/*******************************************************************/
-
-typedef struct type_class type_class;
-
-struct type_class {
- firm_kind kind;
- ident *name; /* needs list with it's entities
- does it really??
- Entities can be added during their creation. */
- struct entity **members; /* to represent inheritance */
- type_class **subtypes; /* direct subtypes */
- type_class **supertypes; /* direct supertypes */
- unsigned long visit; /* visited counter for walks of
- the type information */
- int size; /* Size of an entity of this type. This is determined
- when fixing the layout of this class. Size must be
- given in bytes. */
-
-};
-
-
-/* create a new type_class */
-type_class *new_type_class (ident *name);
-
-/* manipulate fields of type_class */
-
-const char *get_class_name (type_class *clss);
-ident *get_class_ident (type_class *clss);
-
-/* Not necessary now!
-void set_class_name (type_class *clss, char *name);
-void set_class_ident (type_class *clss, ident* ident);
-*/
-
-void add_class_member (type_class *clss, entity *member);
-int get_class_n_member (type_class *clss);
-entity *get_class_member (type_class *clss, int pos);
-void set_class_member (type_class *clss, entity *member, int pos);
-
-void add_class_subtype (type_class *clss,type_class *subtype);
-int get_class_n_subtype (type_class *clss);
-type_class *get_class_subtype (type_class *clss, int pos);
-void set_class_subtype (type_class *clss, type_class *subtype, int pos);
-
-void add_class_supertype (type_class *clss, type_class *supertype);
-int get_class_n_supertype (type_class *clss);
-type_class *get_class_supertype (type_class *clss, int pos);
-void set_class_supertype (type_class *clss, type_class *supertype, int pos);
-
-int get_class_size (type_class *clss);
-void set_class_size (type_class *clss, int size);
-
-
-/*******************************************************************/
-/** TYPE_STRCT **/
-/*******************************************************************/
-
-typedef struct {
- firm_kind kind;
- ident *name;
- entity **members;
- unsigned long visit; /* visited counter for walks of the type information */
-} type_strct;
-
-
-/* create a new type_strct */
-type_strct *new_type_strct (ident *name);
-
-/* manipulate fields of type_strct */
-const char *get_strct_name (type_strct *strct);
-ident *get_strct_ident (type_strct *strct);
-
-void add_strct_member (type_strct *strct, entity *member);
-int get_strct_n_member (type_strct *strct);
-entity *get_strct_member (type_strct *strct, int pos);
-void set_strct_member (type_strct *strct, int pos, entity *member);
-
-/*
-void set_strct_name (type_strct *strct, char *name);
-void set_strct_ident (type_strct *strct, ident* ident);
-*/
-
-
-/*******************************************************************/
-/** TYPE_METHOD **/
-/*******************************************************************/
-
-typedef struct {
- firm_kind kind;
- ident *name; /* Name of the method type. Usually method
- types are not explicitly named (but the entity). */
- int arity; /* number of parameters, better n_params */
- type **param_type; /* code generation needs this information.
- Should it be generated by the frontend,
- or does this impose unnecessary work for
- optimizations that change the parameters of
- methods? */
- int n_res; /* number of results */
- type **res_type; /* array with result types */
- unsigned long visit; /* visited counter for walks of the type information */
-} type_method;
-
-/* Create a new type_method.
- Arity is the number of parameters. */
-type_method *new_type_method (ident *name, int arity, int n_res);
-
-/* manipulate fields of type_method */
-const char *get_method_name (type_method *method);
-ident *get_method_ident (type_method *method);
-/*
-void set_method_name (type_method *method, char *name);
-void set_method_ident (type_method *method, ident* ident); */
-
-inline int get_method_n_params (type_method *method);
-inline int get_method_arity (type_method *method);
-/*inline void set_method_arity (type_method *method, int arity);*/
-inline type *get_method_param_type(type_method *method, int pos);
-inline void set_method_param_type(type_method *method, int pos, type* type);
-
-inline int get_method_n_res (type_method *method);
-/*inline void set_method_n_res (type_method *method, int n_res);*/
-inline type *get_method_res_type(type_method *method, int pos);
-inline void set_method_res_type(type_method *method, int pos, type* type);
-
-
-/*******************************************************************/
-/** TYPE_UNION **/
-/*******************************************************************/
-
-typedef struct {
- firm_kind kind;
- ident *name; /* do I need a name? */
- int n_types;
- /* type **unioned_type; ... or something like that? */
- unsigned long visit; /* visited counter for walks of the type information */
-} type_union;
-
-/* create a new type_union -- set unioned types by hand. */
-type_union *new_type_union (ident *name, int n_types);
-
-/* manipulate fields of type_union */
-const char *get_union_name (type_union *uni);
-ident *get_union_ident (type_union *uni);
-/*
-void set_union_name (type_union *union, char *name);
-void set_union_ident (type_union *union, ident* ident);
-*/
-/*
-int get_union_n_types (type_union *union);
-void set_union_n_types (type_union *union, int n);
-type *get_union_unioned_type (type_union *union, int pos);
-void set_union_unioned_type (type_union *union, int pos, type *type);
-*/
+/****** type/class
+ * NAME
+ * Representation of a class type.
+ * NOTE
+ * If the type opcode is set to type_class the type represents class
+ * types. A list of fields and methods is associated with a class.
+ * Further a class can inherit from and bequest to other classes.
+ * @@@ value class???
+ * ATTRIBUTES
+ * The following attributes are private to this type kind.
+ * member All entities belonging to this class. This are methode entities
+ * which have type_method or fields that can have any of the
+ * following type kinds: type_class, type_struct, type_union,
+ * type_array, type_enumeration, type_pointer, type_primitive.
+ *
+ * subtypes A list of direct subclasses.
+ *
+ * supertypes A list of direct superclasses.
+ *
+ * These are dynamic lists that can be grown with an "add_" function,
+ * but not shrinked.
+ * SOURCE
+ */
+/* create a new class type */
+type *new_type_class (ident *name);
+
+/** manipulate private fields of class type **/
+/* Adds the entity as member of the class. */
+void add_class_member (type *clss, entity *member);
+/* Returns the number of members of this class. */
+int get_class_n_member (type *clss);
+/* Returns the member at position pos, 0 <= pos < n_member */
+entity *get_class_member (type *clss, int pos);
+/* Overwrites the member at position pos, 0 <= pos < n_member with
+ the passed entity. */
+void set_class_member (type *clss, entity *member, int pos);
+/* Replaces complete member list in class type by the list passed. Copies the
+ list passed. This function is necessary to reduce the number of members.
+ members is an array of entities, num the size of this array. Sets all
+ owners of the members passed to clss. */
+void set_class_members (type *clss, entity **members, int arity);
+/* Finds member in the list of members and overwrites it with NULL
+ @@@ Doesn't work properly. */
+void remove_class_member(type *clss, entity *member);
+
+
+/* Adds subtype as subtype to clss.
+ Checks whether clss is a supertype of subtype. If not
+ adds also clss as supertype to subtype. */
+void add_class_subtype (type *clss, type *subtype);
+/* Returns the number of subtypes */
+int get_class_n_subtype (type *clss);
+/* Gets the subtype at position pos, 0 <= pos < n_subtype. */
+type *get_class_subtype (type *clss, int pos);
+/* Sets the subtype at positioin pos, 0 <= pos < n_subtype. Does not
+ set the corresponding supertype relation for subtype: this might
+ be a different position! */
+void set_class_subtype (type *clss, type *subtype, int pos);
+/* Finds subtype in the list of subtypes and overwrites it with NULL
+ @@@ Doesn't work properly. */
+void remove_class_subtype(type *clss, type *subtype);
+
+
+/* Adds supertype as supertype to class.
+ Checks whether clss is a subtype of supertype. If not
+ adds also clss as subtype to supertype. */
+void add_class_supertype (type *clss, type *supertype);
+/* Returns the number of supertypes */
+int get_class_n_supertype (type *clss);
+/* Gets the supertype at position pos, 0 <= pos < n_supertype. */
+type *get_class_supertype (type *clss, int pos);
+/* Sets the supertype at postition pos, 0 <= pos < n_subtype. Does not
+ set the corresponding subtype relation for supertype: this might
+ be a different position! */
+void set_class_supertype (type *clss, type *supertype, int pos);
+/* Finds supertype in the list of supertypes and overwrites it with NULL
+ @@@ Doesn't work properly. */
+void remove_class_supertype(type *clss, type *supertype);
+
+/* typecheck */
+bool is_class_type(type *clss);
+/*****/
+
+/****** type/struct
+ * NAME
+ * Representation of a struct type.
+ * NOTE
+ * Type_strct represents aggregate types that consist of a list
+ * of fields.
+ * ATTRIBUTES
+ * member All entities belonging to this class. This are the fields
+ * that can have any of the following types: type_class,
+ * type_struct, type_union, type_array, type_enumeration,
+ * type_pointer, type_primitive.
+ * This is a dynamic list that can be grown with an "add_" function,
+ * but not shrinked.
+ * This is a dynamic list that can be grown with an "add_" function,
+ * but not shrinked.
+ * SOURCE
+ */
+/* create a new type struct */
+type *new_type_struct (ident *name);
+
+/* manipulate private fields of struct */
+void add_struct_member (type *strct, entity *member);
+int get_struct_n_member (type *strct);
+entity *get_struct_member (type *strct, int pos);
+void set_struct_member (type *strct, int pos, entity *member);
+/* Finds member in the list of memberss and overwrites it with NULL
+ @@@ Doesn't work properly. */
+void remove_struct_member (type *strct, entity *member);
+
+/* typecheck */
+bool is_struct_type(type *strct);
+/*****/
+
+/****** type/method
+ * NAME
+ * Representation of a method type.
+ * NOTE
+ * A method type represents a method, function or procedure type.
+ * It contains a list of the parameter and result types, as these
+ * are part of the type description. These lists should not
+ * be changed by a optimization, as a change creates a new method
+ * type. Therefore optimizations should allocated new method types.
+ * The set_ routines are only for construction by a frontend.
+ * ATTRIBUTES
+ * n_params Number of parameters to the procedure.
+ * A procedure in FIRM has only call by value parameters.
+ *
+ * param_type A list with the types of parameters. This list is ordered.
+ * The nth type in this list corresponds to the nth element
+ * in the parameter tuple that is a result of the start node.
+ * (See ircons.h for more information.)
+ *
+ * n_res The number of results of the method. In general, procedures
+ * have zero results, functions one.
+ *
+ * res_type A list with the types of parameters. This list is ordered.
+ * The nth type in this list corresponds to the nth input to
+ * Return nodes. (See ircons.h for more information.)
+ * SOURCE
+ */
+
+/* Create a new method type.
+ N_param is the number of parameters, n_res the number of results.
+ The arrays for the parameter and result types are not initialized by
+ the constructor. */
+type *new_type_method (ident *name, int n_param, int n_res);
+
+/* manipulate private fields of method. */
+int get_method_n_params (type *method);
+type *get_method_param_type(type *method, int pos);
+void set_method_param_type(type *method, int pos, type* type);
+
+int get_method_n_res (type *method);
+type *get_method_res_type(type *method, int pos);
+void set_method_res_type(type *method, int pos, type* type);
+
+/* typecheck */
+bool is_method_type (type *method);
+/*****/
+
+/****** type/union
+ * NAME
+ * Representation of a union type.
+ * NOTE
+ * The union type represents union types.
+ * ATTRIBUTES
+ * n_types Number of unioned types.
+ * members Entities for unioned types. Fixed length array.
+ * This is a dynamic list that can be grown with an "add_" function,
+ * but not shrinked.
+ * SOURCE
+ */
+/* create a new type union */
+type *new_type_union (ident *name);
+
+/* manipulate private fields of struct */
+int get_union_n_members (type *uni);
+void add_union_member (type *uni, entity *member);
+entity *get_union_member (type *uni, int pos);
+void set_union_member (type *uni, int pos, entity *member);
+/* Finds member in the list of members and overwrites it with NULL
+ @@@ Doesn't work properly. */
+void remove_union_member (type *uni, entity *member);
+
+/* typecheck */
+bool is_union_type (type *uni);
+/*****/
+
+#if 0
+/* We don't need these if the union has entities, which it now
+ does. The entities are necessary for the analysis algorithms. */
+type *get_union_unioned_type (type *uni, int pos);
+void set_union_unioned_type (type *uni, int pos, type *type);
+
+ident *get_union_delim_nameid (type *uni, int pos);
+const char *get_union_delim_name (type *uni, int pos);
+void set_union_delim_nameid (type *uni, int pos, ident *id);
+#endif
-/*******************************************************************/
-/** TYPE_ARRAY **/
-/*******************************************************************/
-
-/* multidimensional, polyhedric arrays */
-typedef struct {
- firm_kind kind;
- ident *name;
- int n_dimensions;
- int *lower_bound;
- int *upper_bound;
- type *element_type;
- unsigned long visit; /* visited counter for walks of the type information */
-} type_array;
-
-/* create a new type array -- set dimension sizes independently */
-type_array *new_type_array (ident *name, int n_dimensions);
-
-/* manipulate fields of type_array */
-const char *get_array_name (type_array *array);
-ident *get_array_ident (type_array *array);
-/*
-void set_array_name (type_array *array, char *name);
-void set_array_ident (type_array *array, ident* ident);
+/****** type/array
+ * NAME
+ * Representation of an array type.
+ * NOTE
+ * The array type represents rectangular multi dimensional arrays.
+ * The constants representing the bounds must be allocated to
+ * get_const_code_irg() by setting current_ir_graph accordingly.
+ * ATTRIBUTES
+ * n_dimensions Number of array dimensions.
+ * *lower_bound Lower bounds of dimensions. Usually all 0.
+ * *upper_bound Upper bounds or dimensions.
+ * *element_type The type of the array elements.
+ * *element_ent An entity for the array elements to be used for
+ * element selection with Sel.
+ * @@@ Do we need several entities? One might want
+ * to select a dimension and not a single element in
+ * case of multidim arrays.
+ * SOURCE
+ */
+/* create a new type array --
+ Sets n_dimension to dimension and all dimension entries to NULL.
+ Initializes order to the order of the dimensions.
+ Entity for array elements is built automatically.
+ Set dimension sizes after call to constructor with set_* routines. */
+type *new_type_array (ident *name, int n_dimensions,
+ type *element_type);
+
+/* manipulate private fields of array type */
+int get_array_n_dimensions (type *array);
+/* Allocates Const nodes of mode_I for the array dimensions */
+void set_array_bounds_int (type *array, int dimension, int lower_bound,
+ int upper_bound);
+void set_array_bounds (type *array, int dimension, ir_node *lower_bound,
+ ir_node *upper_bound);
+void set_array_lower_bound (type *array, int dimension, ir_node *lower_bound);
+void set_array_upper_bound (type *array, int dimension, ir_node *upper_bound);
+ir_node * get_array_lower_bound (type *array, int dimension);
+ir_node * get_array_upper_bound (type *array, int dimension);
+
+void set_array_order (type *array, int dimension, int order);
+int get_array_order (type *array, int dimension);
+
+void set_array_element_type (type *array, type *type);
+type *get_array_element_type (type *array);
+
+void set_array_element_entity (type *array, entity *ent);
+entity *get_array_element_entity (type *array);
+
+/* typecheck */
+bool is_array_type (type *array);
+/*****/
+
+/****** type/enumeration
+ * NAME
+ * Representation of an enumeration type.
+ * NOTE
+ * Enumeration types need not necessarily be represented explicitly
+ * by Firm types, as the frontend can lower them to integer constants as
+ * well. For debugging purposes or similar tasks this information is useful.
+ * ATTRIBUTES
+ * *enum The target values representing the constants used to
+ * represent individual enumerations.
+ * *enum_nameid Idents containing the source program name of the enumeration
+ * constants
+ *
+*****
*/
-void set_array_n_dimensions (type_array *array, int n);
-int get_array_n_dimensions (type_array *array);
-
-void set_array_bounds (type_array *array, int dimension, int lower_bound,
- int upper_bound);
-void set_array_lower_bound (type_array *array, int dimension, int lower_bound);
-void set_array_upper_bound (type_array *array, int dimension, int upper_bound);
-int get_array_lower_bound (type_array *array, int dimension);
-int get_array_upper_bound (type_array *array, int dimension);
-
-void set_array_element_type (type_array *array, type *type);
-type *get_array_element_type (type_array *array);
-
-/*******************************************************************/
-/** TYPE_ENUMERATION **/
-/*******************************************************************/
-/** Enums are needed to keep debugging information. They can as well
- be lowered to integers. **/
-
-typedef struct {
- firm_kind kind;
- ident *name;
- /*
- tarval **enum * Contains all constant nodes that represent a member
- of the enum -- enumerators. */
- /*
- ident **enum_name * Contains the names of the enum fields as specified by
- the source program */
- /* is ir_node the propper array member? */
- unsigned long visit; /* visited counter for walks of the type information */
-} type_enumeration;
-
/* create a new type enumeration -- set the enumerators independently */
-type_enumeration *new_type_enumeration (ident *name /* , int n_enums */);
-
-/* manipulate fields of type_enumeration */
-const char *get_enumeration_name (type_enumeration *enumeration);
-ident *get_enumeration_ident (type_enumeration *enumeration);
-/*
-void set_enumeration_name (type_enumeration *enumeration, char *name);
-void set_enumeration_ident (type_enumeration *enumeration, ident* ident);
-*/
-/*
-void set_enumeration_n_enums (type_enumeration *enumeration, int n);
-int *get_enumeration_n_enums (type_enumeration *enumeration);
-void set_enumeration_enum (type_enumeration *enumeration, int pos,
- ir_node const);
-ir_node *get_enumeration_enum (type_enumeration *enumeration, int pos);
-*/
-
-/*******************************************************************/
-/** TYPE_POINTER **/
-/*******************************************************************/
-
-typedef struct {
- firm_kind kind;
- ident *name;
- /* ir_mode *mode; * The mode to be used for this type.
- Not here as there might be several pointer types?
- A method get_pointer_mode should read a unique,
- global variable. */
- type *points_to;
- unsigned long visit; /* visited counter for walks of the type information */
-} type_pointer;
-
-/* create a new type pointer */
-type_pointer *new_type_pointer (ident *name, type *points_to);
+type *new_type_enumeration (ident *name, int n_enums);
+
+/* manipulate fields of enumeration type. */
+int get_enumeration_n_enums (type *enumeration);
+
+void set_enumeration_enum (type *enumeration, int pos, tarval *con);
+tarval *get_enumeration_enum (type *enumeration, int pos);
+
+void set_enumeration_nameid (type *enumeration, int pos, ident *id);
+ident *get_enumeration_nameid (type *enumeration, int pos);
+const char *get_enumeration_name(type *enumeration, int pos);
+
+/* typecheck */
+bool is_enumeration_type (type *enumeration);
+/*****/
+
+/****** type/pointer
+ * NAME
+ * Representation of a pointer type.
+ * NOTE
+ * Pointer types.
+ * ATTRIBUTES
+ * points_to The type of the entity this pointer points to.
+ * SOURCE
+ */
+/* Create a new type pointer */
+type *new_type_pointer (ident *name, type *points_to);
/* manipulate fields of type_pointer */
-const char *get_pointer_name (type_pointer *pointer);
-ident *get_pointer_ident (type_pointer *pointer);
-/*
-void set_pointer_name (type_pointer *pointer, char *name);
-void set_pointer_ident (type_pointer *pointer, ident* ident);
+void set_pointer_points_to_type (type *pointer, type *type);
+type *get_pointer_points_to_type (type *pointer);
+
+/* typecheck */
+bool is_pointer_type (type *pointer);
+/*****/
+
+/****** type/primitive
+ * NAME
+ * Representation of a primitive type.
+ * NOTE
+ * Primitive types are types that represent indivisible data values that
+ * map directly to modes. They don't have a private attribute. The
+ * important information they carry is held in the common mode field.
+ * SOURCE
*/
-void set_pointer_points_to_type (type_pointer *pointer, type *type);
-type *get_pointer_points_to_type (type_pointer *pointer);
-
-/*******************************************************************/
-/** TYPE_PRIMITIVE **/
-/*******************************************************************/
-
-/* primitive, language-defined types */
-/* What is the type of an entity if it is atomic? Are alle basic data
- types classses in Sather? Else this is needed. */
-typedef struct {
- firm_kind kind;
- ident *name;
- ir_mode *mode; /* The mode to be used for this type */
- unsigned long visit; /* visited counter for walks of the type information */
-} type_primitive;
-
/* create a new type primitive */
-type_primitive *new_type_primitive (ident *name, ir_mode *mode);
-
-/* manipulate fields of type_primitive */
-const char *get_primitive_name (type_primitive *primitive);
-ident *get_primitive_ident (type_primitive *primitive);
-/*
-void set_primitive_name (type_primitive *primitive, char *name);
-void set_primitive_ident (type_primitive *primitive, ident* ident);
-*/
-ir_mode *get_primitive_mode (type_primitive *primitive);
-void set_primitive_mode (type_primitive *primitive, ir_mode *mode);
-
-
-
-
-/*******************************************************************/
-/** To manage all different types the same **/
-/*******************************************************************/
-
-union type {
- firm_kind kind;
- type_class clss;
- type_strct strct;
- type_method method;
- type_array array;
- type_union uni; /* union is keyword */
- type_enumeration enumeration;
- type_pointer pointer;
- type_primitive primitive;
-};
-
-
-int is_type (void *thing);
-int is_type_class (void *thing);
-int is_type_strct (void *thing);
-int is_type_method (void *thing);
-int is_type_union (void *thing);
-int is_type_array (void *thing);
-int is_type_pointer (void *thing);
-int is_type_enumeration(void *thing);
-int is_type_primitive (void *thing);
-
-
-
+type *new_type_primitive (ident *name, ir_mode *mode);
+
+/* typecheck */
+bool is_primitive_type (type *primitive);
+/*****/
+
+
+
+/****f* type/is_atomic_type
+ *
+ * NAME
+ * is_atomic_type - Checks whether a type is atomic.
+ * SYNOPSIS
+ * int is_atomic_type(type *tp);
+ * INPUTS
+ * tp - any type
+ * RESULT
+ * true if type is primitive, pointer or enumeration
+ ***
+ */
+int is_atomic_type(type *tp);
+
+/****f* type/is_compound_type
+ *
+ * NAME
+ * is_compound_type - Checks whether a type is compound.
+ * SYNOPSIS
+ * int is_compound_type(type *tp)
+ * INPUTS
+ * tp - any type
+ * RESULT
+ * true if the type is class, structure, union or array type.
+ ***
+ */
+int is_compound_type(type *tp);
# endif /* _TYPE_H_ */
projects / libfirm / blobdiff