-/* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
-** All rights reserved.
-**
-** Authors: Martin Trapp, Christian Schaefer &
-** Goetz Lindenmaier
-**
-** type.h: datastructures to hold type information.
-*/
+/**
+ *
+ * @file type.h
+ *
+ * Project: libFIRM <br>
+ * File name: ir/tr/type.h <br>
+ * Purpose: Representation of types. <br>
+ * Author: Goetz Lindenmaier <br>
+ * Modified by: <br>
+ * Created: <br>
+ * Copyright: (c) 2001-2003 Universität Karlsruhe <br>
+ * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. <br>
+ * CVS-ID: $Id$
+ *
+ *
+ * Datastructure to hold type information.
+ *
+ * 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. Finally it specifies some auxiliary 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 tpop.h
+ */
# ifndef _TYPE_H_
# define _TYPE_H_
-# include "common.h"
+# include <stdbool.h>
+
+# include "tpop.h"
+# include "firm_common.h"
# include "ident.h"
# include "irmode.h"
-
-/* for recursive type definiton */
-typedef union type type;
-
-/* visited flag to traverse the type information */
-extern unsigned long type_visited;
-
-/*******************************************************************/
-/** TYPE_CLASS **/
-/*******************************************************************/
-
-typedef struct {
- firm_kind kind;
- ident *name;
- /** needs list with it's entities -- does it really??
- Entities can be added during their creation.
- int n_members;
- entity **member; **/
- unsigned long visit; /* visited counter for walks of the type information */
-} type_class;
-
-
-/* create a new type_class */
-type_class *new_type_class (ident *name);
-
-/* manipulate fields of type_class */
-char *get_class_name (type_class *clss);
-ident *get_class_ident (type_class *clss);
-/*
-void set_class_name (type_class *class, char *name);
-void set_class_ident (type_class *class, ident* ident);
-*/
-
-/*******************************************************************/
-/** TYPE_STRCT **/
-/*******************************************************************/
-
-typedef struct {
- firm_kind kind;
- ident *name;
- /** needs list with it's entities -- does it really??
- Entities can be added during their creation.
- int n_members;
- entity **member; **/
- 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 */
-char *get_strct_name (type_strct *strct);
-ident *get_strct_ident (type_strct *strct);
-/*
-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; /* do I need the name,
- or is the name in entity sufficient? */
- 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
- optimizatinos that change the parameters of
- methods? */
- int n_res; /* number of results */
- type **res_type;
- /** needs pointer to it's ir_graph ??
- ir_graph *graph; **/
- unsigned long visit; /* visited counter for walks of the type information */
-} type_method;
-
-/* create a new type_method */
-type_method *new_type_method (ident *name, int arity, int n_res);
-
-/* manipulate fields of type_method */
-
-char *get_method_name (type_method *method);
-ident *get_method_ident (type_method *method);
-/* GL 9.2.2000: who commened these in?
- I think it's not safe to have these methods.
- Please add changes to Changes file.
-void set_method_name (type_method *method, char *name);
-void set_method_ident (type_method *method, ident* ident); */
-
-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);
-
-/*
-ir_graph *get_method_graph(type_method *method);
-void *get_method_graph(type_method *method, ir_graph* graph);
-*/
-
-/*******************************************************************/
-/** 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 */
-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);
+# include "dbginfo.h"
+
+
+/* to resolve recursion between entity.h and type.h */
+#ifndef _ENTITY_TYPEDEF_
+#define _ENTITY_TYPEDEF_
+typedef struct entity entity;
+#endif
+
+#ifndef _IR_NODE_TYPEDEF_
+#define _IR_NODE_TYPEDEF_
+typedef struct ir_node ir_node;
+#endif
+
+/**
+ * An abstract data type to represent types.
+ *
+ * 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.
+ *
+ * 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.
+ * - 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 bits in memory. In several cases this is
+ * determined when fixing the layout of this type (class,
+ * struct, union, array, enumeration).
+ * - alignment The alignment of the type, i.e. an entity of this type will
+ * be allocated an an address in memory with this alignment.
+ * In several cases this is determined when fixing the layout
+ * of this type (class, struct, union, array)
+ * - 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 information with the type.
+ *
+ * These fields can only be accessed via access functions.
+ *
+ * Depending on the value of @c type_op, i.e., depending on the kind of the
+ * type the adt contains further attributes. These are documented below.
+ *
+ * @see
+ *
+ * @link class_type class @endlink, @link struct_type struct @endlink,
+ * @link method_type method @endlink, @link union_type union @endlink,
+ * @link array_type array @endlink, @link enumeration_type enumeration @endlink,
+ * @link pointer_type pointer @endlink, @link primitive_type primitive @endlink
+ *
+ * @todo
+ * mode maybe not global field??
+ */
+#ifndef _TYPE_TYPEDEF_
+#define _TYPE_TYPEDEF_
+typedef struct type type;
+#endif
+
+# include "type_or_entity.h"
+
+/** frees all entities associated with a type.
+ Does not free array entity.
+ Warning: make sure these entities are not referenced anywhere else.
*/
-
-/*******************************************************************/
-/** TYPE_ARRAY **/
-/*******************************************************************/
-
-/* multidimensional, polyhedric arrays */
-typedef struct {
- firm_kind kind;
- ident *name;
- int n_dimensions; /* Extend Sel to select from multidimensional arrays. This */
- int *lower_bound; /* will allow to generate explicit array index computations */
- int *upper_bound; /* by replacing a single FIRM node. As long as this is not
- done create arrays with arrays as elements. */
- /* Should I use tarval? */
- 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 */
-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);
-*/
-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;
- /* int n_enums;
- ir_node **enum * Contains all constant nodes that represent a member
- of the enum -- enumerators. */
- /* 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 */
-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);
-
-/* manipulate fields of type_pointer */
-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 *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 */
-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);
+void free_type_entities(type *tp);
+
+/** Frees the memory used by the type.
+ *
+ * Removes the type from the type list. Does not free the entities
+ * belonging to the type, except for the array element entity. Does
+ * not free if tp is "none" or "unknown". Frees entities in value
+ * param subtypes of method types!!! Make sure these are not
+ * referenced any more. Further make sure there is no pointer type
+ * that refers to this type. */
+void free_type(type *tp);
+
+tp_op* get_type_tpop(const type *tp);
+ident* get_type_tpop_nameid(const type *tp);
+const char* get_type_tpop_name(const type *tp);
+tp_opcode get_type_tpop_code(const type *tp);
+
+ident* get_type_ident(const type *tp);
+void set_type_ident(type *tp, ident* id);
+const char* get_type_name(const type *tp);
+
+/** The state of the type layout. */
+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, primitive and method 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, primitive and method
+ types. */
+} type_state;
+
+/** Returns the type layout state of a type. */
+type_state get_type_state(const type *tp);
+
+/** Sets the type layout state of a type.
+ *
+ * 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);
+
+/** Returns the mode of a type.
+ *
+ * Returns NULL for all non atomic types.
+ */
+ir_mode* get_type_mode(const type *tp);
+
+/** Sets the mode of a type.
+ *
+ * Only has an effect on primitive, enumeration and pointer types.
+ */
+void set_type_mode(type *tp, ir_mode* m);
+
+/** Returns the size of a type in bytes, returns -1 if the size is NOT
+ * a byte size, ie not dividable by 8. */
+int get_type_size_bytes(const type *tp);
+
+/** Returns the size of a type in bits. */
+int get_type_size_bits(const type *tp);
+
+/** Sets the size of a type in bytes.
+ *
+ * For primitive, enumeration, pointer and method types the size
+ * is always fixed. This call is legal but has no effect.
+ */
+void set_type_size_bytes(type *tp, int size);
+
+/** Sets the size of a type in bits.
+ *
+ * For primitive, enumeration, pointer and method types the size
+ * is always fixed. This call is legal but has no effect.
+ */
+void set_type_size_bits(type *tp, int size);
+
+/** Returns the alignment of a type in bytes, returns -1 if the alignment is NOT
+ * a byte size, ie not dividable by 8. Calls get_type_alignment_bits(). */
+int get_type_alignment_bytes(type *tp);
+
+/** Returns the alignment of a type in bits. If the alignment of a type is
+ * not set, it is calculated here according to the following rules:
+ * 1.) if a type has a mode, the aligment is the mode size.
+ * 2.) compound types have the alignment of it's biggest member.
+ * 3.) array types have the alignment of its element type.
+ * 4.) method types return 0 here.
+ * 5.) all other types return 8 here (i.e. aligned at byte).
+ */
+int get_type_alignment_bits(type *tp);
+
+/** Sets the alignment of a type in bytes. */
+void set_type_alignment_bytes(type *tp, int size);
+
+/** Sets the alignment of a type in bits.
+ *
+ * For method types the alignment is always fixed.
+ * This call is legal but has no effect.
+ */
+void set_type_alignment_bits(type *tp, int size);
+
+unsigned long get_type_visited(const 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);
+/* @@@ name clash!! int type_visited(const type *tp); */
+int type_not_visited(const type *tp);
+
+void* get_type_link(const type *tp);
+void set_type_link(type *tp, void *l);
+
+/**
+ * Visited flag to traverse the type information.
+ *
+ * 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 typewalk
+ */
+extern unsigned long type_visited;
+void set_master_type_visited(unsigned long val);
+unsigned long get_master_type_visited(void);
+void inc_master_type_visited(void);
+
+/**
+ * Checks whether a pointer points to a type.
+ *
+ * @param thing an arbitrary pointer
+ *
+ * @return
+ * true if the thing is a type, else false
+ */
+int is_type (const void *thing);
+
+/**
+ * Checks whether two types are structural equal.
+ *
+ * @param st pointer type
+ * @param lt pointer type
+ *
+ * @return
+ * true if the types are equal, else false.
+ * Types are equal if :
+ * - they are the same type kind
+ * - they have the same name
+ * - they have the same mode (if applicable)
+ * - they have the same type_state and, ev., the same size
+ * - they are class types and have
+ * - the same members (see same_entity in entity.h)
+ * - the same supertypes -- the C-pointers are compared --> no recursive call.
+ * - the same number of subtypes. Subtypes are not compared,
+ * as this could cause a cyclic test.
+ * - the same peculiarity
+ * - they are structure types and have the same members
+ * - they are method types and have
+ * - the same parameter types
+ * - the same result types
+ * - they are union types and have the same members
+ * - they are array types and have
+ * - the same number of dimensions
+ * - the same dimension bounds
+ * - the same dimension order
+ * - the same element type
+ * - they are enumeration types and have the same enumerator names
+ * - they are pointer types and have the identical points_to type
+ * (i.e., the same C-struct to represent the type, type_id is skipped.
+ * This is to avoid endless recursions; with pointer types circlic
+ * type graphs are possible.)
+ */
+bool equal_type(type *tpy1, type *typ2);
+
+/**
+ * Checks whether two types are structural comparable.
+ *
+ * @param st pointer type
+ * @param lt pointer type
+ *
+ * @return
+ * true if type st is smaller than type lt, i.e. whenever
+ * lt is expected a st can be used.
+ * This is true if
+ * - they are the same type kind
+ * - mode(st) < mode (lt) (if applicable)
+ * - they are class types and st is (transitive) subtype of lt,
+ * - they are structure types and
+ * - the members of st have exactly one counterpart in lt with the same name,
+ * - the counterpart has a bigger type.
+ * - they are method types and have
+ * - the same number of parameter and result types,
+ * - the parameter types of st are smaller than those of lt,
+ * - the result types of st are smaller than those of lt
+ * - they are union types and have the members of st have exactly one
+ * @return counterpart in lt and the type is smaller
+ * - they are array types and have
+ * - the same number of dimensions
+ * - all bounds of lt are bound of st
+ * - the same dimension order
+ * - the same element type
+ * @return or
+ * - the element type of st is smaller than that of lt
+ * - the element types have the same size and fixed layout.
+ * - they are enumeration types and have the same enumerator names
+ * - they are pointer types and have the points_to type of st is
+ * @return smaller than the points_to type of lt.
+ *
+ */
+bool smaller_type (type *st, type *lt);
+
+/**
+ * @page class_type Representation of a class type
+ *
+ * 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???
+ * 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.
+ *
+ * The following two are dynamic lists that can be grown with an "add_" function,
+ * but not shrinked:
+ *
+ * - subtypes: A list of direct subclasses.
+ *
+ * - supertypes: A list of direct superclasses.
+ *
+ * - peculiarity: The peculiarity of this class. If the class is of peculiarity
+ * "description" it only is a description of requirememts to a class,
+ * as, e.g., a Java interface. The class will never be allocated.
+ * Peculiatity inherited is only possible for entities. An entity
+ * is of peculiarity inherited if the compiler generated the entity
+ * to explicitly resolve inheritance. An inherited method entity has
+ * no value for irg.
+ * Values: description, existent, inherited. Default: existent.
+ *
+ */
+
+/** Creates a new class type. */
+type *new_type_class (ident *name);
+
+/** Creates a new class type with debug information. */
+type *new_d_type_class (ident *name, dbg_info *db);
+
+/* --- 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_members (const type *clss);
+
+/** Returns the member at position pos, 0 <= pos < n_member */
+entity *get_class_member (const type *clss, int pos);
+
+/** Returns index of mem in clss, -1 if not contained. */
+int get_class_member_index(type *clss, entity *mem);
+
+/** Finds the member with name 'name'. If several members with the same
+ name returns one of them. Returns NULL if no member found. */
+entity *get_class_member_by_name(type *clss, ident *name);
+
+/** 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 removes it.
+ Shrinks the member list, so iterate from the end!!!
+ Does not deallocate the entity. */
+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_subtypes (const 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 removes it */
+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_supertypes (const type *clss);
+
+/** Returns the index of an supertype in a type. */
+int get_class_supertype_index(type *clss, type *super_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 removes it */
+void remove_class_supertype(type *clss, type *supertype);
+
+/** This enumeration flags the peculiarity of entities and types. */
+typedef enum peculiarity {
+ peculiarity_description, /**< Represents only a description. The entity/type is never
+ allocated, no code/data exists for this entity/type.
+ @@@ eventually rename to descriptive (adjectiv as the others!)*/
+ peculiarity_inherited, /**< Describes explicitly that other entities are
+ inherited to the owner of this entity.
+ Overwrites must refer to at least one other
+ entity. If this is a method entity there exists
+ no irg for this entity, only for one of the
+ overwritten ones.
+ Only for entity. */
+ peculiarity_existent /**< The entity/type (can) exist.
+ @@@ eventually rename to 'real' i.e., 'echt'
+ This serves better as opposition to description _and_ inherited.*/
+} peculiarity;
+const char *get_peculiarity_string(peculiarity p);
+
+/* The peculiarity of the class. The enumeration peculiarity is defined
+ in entity.h */
+peculiarity get_class_peculiarity (const type *clss);
+void set_class_peculiarity (type *clss, peculiarity pec);
+
+/* Set and get a class' dfn --
+ @todo This is an undocumented field, subject to change! */
+void set_class_dfn (type *clss, int dfn);
+int get_class_dfn (const type *clss);
+
+/** Returns true if a type is a class type. */
+int is_class_type(const type *clss);
+
+/** Returns true if low is subclass of high. */
+bool is_subclass_of(type *low, type *high);
+
+/**
+ * @page struct_type Representation of a struct type
+ *
+ * Type_strct represents aggregate types that consist of a list
+ * of fields.
+ * The following attributes are private to this type kind:
+ * - 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.
+ */
+/** Creates a new type struct */
+type *new_type_struct (ident *name);
+/** Creates a new type struct with debug information. */
+type *new_d_type_struct (ident *name, dbg_info* db);
+
+/* --- manipulate private fields of struct --- */
+
+/** Adds the entity as member of the struct. */
+void add_struct_member (type *strct, entity *member);
+
+/** Returns the number of members of this struct. */
+int get_struct_n_members (const type *strct);
+
+/** Returns the member at position pos, 0 <= pos < n_member */
+entity *get_struct_member (const type *strct, int pos);
+
+/** Returns index of member in strct, -1 if not contained. */
+int get_struct_member_index(type *strct, entity *member);
+
+/** Overwrites the member at position pos, 0 <= pos < n_member with
+ the passed entity. */
+void set_struct_member (type *strct, int pos, entity *member);
+
+/** Finds member in the list of members and removes it. */
+void remove_struct_member (type *strct, entity *member);
+
+/** Returns true if a type is a struct type. */
+int is_struct_type(const type *strct);
+
+/**
+ * @page method_type Representation of a method type
+ *
+ * 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.
+ *
+ * - 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.)
+ *
+ * - value_param_ents
+ * A list of entities (whose owner is a struct private to the
+ * method type) that represent parameters passed by value.
+ *
+ * - 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.)
+ *
+ * - value_res_ents
+ * A list of entities (whose owner is a struct private to the
+ * method type) that represent results passed by value.
+ */
+
+/* These makros define the suffixes for the types and entities used
+ to represent value parameters / results. */
+#define VALUE_PARAMS_SUFFIX "val_param"
+#define VALUE_RESS_SUFFIX "val_res"
+
+/** Create a new method type.
+ *
+ * @param name the name (ident) of this type
+ * @param n_param the number of parameters
+ * @param 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);
+
+/** Create a new method type with debug information.
+ *
+ * @param name the name (ident) of this type
+ * @param n_param the number of parameters
+ * @param n_res the number of results
+ * @param db user defined debug information
+ *
+ * The arrays for the parameter and result types are not initialized by
+ * the constructor.
+ */
+type *new_d_type_method (ident *name, int n_param, int n_res, dbg_info* db);
+
+/* -- manipulate private fields of method. -- */
+
+/** Returns the number of parameters of this method. */
+int get_method_n_params (const type *method);
+
+/** Returns the type of the parameter at position pos of a method. */
+type *get_method_param_type(type *method, int pos);
+/** Sets the type of the parameter at position pos of a method.
+ Also changes the type in the pass-by-value representation by just
+ changing the type of the corresponding entity if the representation is constructed. */
+void set_method_param_type(type *method, int pos, type* tp);
+/** Returns an entity that represents the copied value argument. Only necessary
+ for compounds passed by value. This information is constructed only on demand. */
+entity *get_method_value_param_ent(type *method, int pos);
+/**
+ * Returns a type that represents the copied value arguments.
+ */
+type *get_method_value_param_type(const type *method);
+
+int get_method_n_ress (const type *method);
+type *get_method_res_type(type *method, int pos);
+/** Sets the type of the result at position pos of a method.
+ Also changes the type in the pass-by-value representation by just
+ changing the type of the corresponding entity if the representation is constructed. */
+void set_method_res_type(type *method, int pos, type* tp);
+/** Returns an entity that represents the copied value result. Only necessary
+ for compounds passed by value. This information is constructed only on demand. */
+entity *get_method_value_res_ent(type *method, int pos);
+
+/**
+ * Returns a type that represents the copied value results.
+ */
+type *get_method_value_res_type(const type *method);
+
+/**
+ * this enum flags the variadicity of methods (methods with a
+ * variable amount of arguments (e.g. C's printf). Default is
+ * non_variadic.
+ */
+typedef enum variadicity {
+ variadicity_non_variadic, /**< non variadic */
+ variadicity_variadic /**< variadic */
+} variadicity;
+
+/** Returns the null-terminated name of this variadicity. */
+const char *get_variadicity_name(variadicity vari);
+
+/** Returns the variadicity of a method. */
+variadicity get_method_variadicity(const type *method);
+
+/** Sets the variadicity of a method. */
+void set_method_variadicity(type *method, variadicity vari);
+
+/**
+ * Returns the first variadic parameter index of a type.
+ * If this index was NOT set, the index of the last parameter
+ * of the method type plus one is returned for variadic functions.
+ * Non-variadic function types always return -1 here.
+ */
+int get_method_first_variadic_param_index(const type *method);
+
+/**
+ * Sets the first variadic parameter index. This allows to specify
+ * a complete call type (containing the type of all parameters)
+ * but still have the knowledge, which parameter must be passed as
+ * variadic one.
+ */
+void set_method_first_variadic_param_index(type *method, int index);
+
+/** Returns true if a type is a method type. */
+int is_method_type (const type *method);
+
+/**
+ * @page union_type Representation of a union type.
+ *
+ * The union type represents union types.
+ * - 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.
+ */
+/** Creates a new type union. */
+type *new_type_union (ident *name);
+
+/** Creates a new type union with debug information. */
+type *new_d_type_union (ident *name, dbg_info* db);
+
+/* --- manipulate private fields of struct --- */
+
+/** Returns the number of unioned types of this union */
+int get_union_n_members (const type *uni);
+
+/** Adds a new entity to a union type */
+void add_union_member (type *uni, entity *member);
+
+/** Returns the entity at position pos of a union */
+entity *get_union_member (const type *uni, int pos);
+
+/** Overwrites a entity at position pos in a union type. */
+void set_union_member (type *uni, int pos, entity *member);
+
+/** Finds member in the list of members and removes it. */
+void remove_union_member (type *uni, entity *member);
+
+/** Returns true if a type is a union type. */
+int is_union_type (const type *uni);
+
+/**
+ * @page array_type Representation of an array type
+ *
+ * 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.
+ *
+ * - 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.
+ * @todo
+ * Do we need several entities? One might want
+ * to select a dimension and not a single element in case of multidim arrays.
+ */
+
+/** Create a new type array.
+ *
+ * Sets n_dimension to dimension and all dimension entries to NULL.
+ * Initializes order to the order of the dimensions.
+ * The 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);
+
+/** Create a new type array with debug information.
+ *
+ * Sets n_dimension to dimension and all dimension entries to NULL.
+ * Initializes order to the order of the dimensions.
+ * The entity for array elements is built automatically.
+ * Set dimension sizes after call to constructor with set_* routines.
+ * A legal array type must have at least one dimension set.
+ */
+type *new_d_type_array (ident *name, int n_dimensions,
+ type *element_type, dbg_info* db);
+
+/* --- manipulate private fields of array type --- */
+
+/** Returns the number of array dimensions of this type. */
+int get_array_n_dimensions (const 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_lower_bound_int (type *array, int dimension, int lower_bound);
+void set_array_upper_bound (type *array, int dimension, ir_node *upper_bound);
+void set_array_upper_bound_int (type *array, int dimension, int lower_bound);
+/** returns true if lower bound != Unknown */
+int has_array_lower_bound (const type *array, int dimension);
+ir_node * get_array_lower_bound (const type *array, int dimension);
+/** Works only if bound is Const node with tarval that can be converted to long. */
+long get_array_lower_bound_int (const type *array, int dimension);
+/** returns true if lower bound != Unknown */
+int has_array_upper_bound (const type *array, int dimension);
+ir_node * get_array_upper_bound (const type *array, int dimension);
+/** Works only if bound is Const node with tarval that can be converted to long. */
+long get_array_upper_bound_int (const type *array, int dimension);
+
+void set_array_order (type *array, int dimension, int order);
+int get_array_order (const type *array, int dimension);
+
+void set_array_element_type (type *array, type *tp);
+type *get_array_element_type (type *array);
+
+void set_array_element_entity (type *array, entity *ent);
+entity *get_array_element_entity (const type *array);
+
+/** Returns true if a type is an array type. */
+int is_array_type(const type *array);
+
+/**
+ * @page enumeration_type Representation of an enumeration type
+ *
+ * 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.
+ *
+ * - *enum: The target values representing the constants used to
+ * represent individual enumerations.
+ * - *enum_nameid: Idents containing the source program name of the enumeration
+ * constants
+ */
+/** Create a new type enumeration -- set the enumerators independently. */
+type *new_type_enumeration (ident *name, int n_enums);
+
+/** Create a new type enumeration with debug information -- set the enumerators independently. */
+type *new_d_type_enumeration (ident *name, int n_enums, dbg_info* db);
+
+/* --- manipulate fields of enumeration type. --- */
+
+/** Returns the number of enumeration values of this enumeration */
+int get_enumeration_n_enums (const type *enumeration);
+
+/** Sets the enumeration value at a given position. */
+void set_enumeration_enum (type *enumeration, int pos, tarval *con);
+
+/** Returns the enumeration value at a given position. */
+tarval *get_enumeration_enum (const type *enumeration, int pos);
+
+/** Assign an ident to an enumeration value at a given position. */
+void set_enumeration_nameid (type *enumeration, int pos, ident *id);
+
+/** Returns the assigned ident of an enumeration value at a given position. */
+ident *get_enumeration_nameid (const type *enumeration, int pos);
+
+/** Returns the assigned name of an enumeration value at a given position. */
+const char *get_enumeration_name(const type *enumeration, int pos);
+
+/** Returns true if a type is a enumeration type. */
+int is_enumeration_type (const type *enumeration);
+
+/**
+ * @page pointer_type Representation of a pointer type
+ *
+ * The mode of the pointer type must be a mode_reference.
+ *
+ * Pointer types:
+ * - points_to: The type of the entity this pointer points to.
+ */
+
+/** Creates a new type pointer with mode mode_p. */
+#define new_type_pointer(N, P) new_type_pointer_mode(N, P, mode_P_mach)
+
+/** Creates a new type pointer with given pointer mode. */
+type *new_type_pointer_mode (ident *name, type *points_to, ir_mode *ptr_mode);
+
+/** Creates a new type pointer given pointer mode and with debug information. */
+type *new_d_type_pointer (ident *name, type *points_to, ir_mode *ptr_mode, dbg_info* db);
+
+/* --- manipulate fields of type_pointer --- */
+
+/** Sets the type to which a pointer points to. */
+void set_pointer_points_to_type (type *pointer, type *tp);
+
+/** Returns the type to which a pointer points to. */
+type *get_pointer_points_to_type (type *pointer);
+
+/** Returns true if a type is a pointer type. */
+int is_pointer_type (const type *pointer);
+
+/** Returns the first pointer type that has as points_to tp.
+ * Not efficient: O(#types).
+ * If not found returns unknown_type. */
+type *find_pointer_type_to_type (type *tp);
+
+/**
+ * @page primitive_type Representation of a primitive type
+ *
+ * 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.
*/
-ir_mode *get_primitive_mode (type_primitive *primitive);
-void set_primitive_mode (type_primitive *primitive, ir_mode *mode);
-
-
-
+/** Creates a new primitive type. */
+type *new_type_primitive (ident *name, ir_mode *mode);
+
+/** Creates a new primitive type with debug information. */
+type *new_d_type_primitive (ident *name, ir_mode *mode, dbg_info* db);
+
+/** Returns true if a type is a primitive type. */
+int is_primitive_type (const type *primitive);
+
+
+/**
+ * @page none_type
+ *
+ * This type is an auxiliary type dedicated to support type analyses.
+ *
+ * The none type represents that there is no type. The type can be used to
+ * initialize fields of type* that actually can not contain a type or that
+ * are initialized for an analysis. There exists exactly one type none.
+ * This type is not on the type list in ir_prog. It is
+ * allocated when initializing the type module.
+ *
+ * The following values are set:
+ * mode: mode_BAD
+ * name: "type_none"
+ * state: layout_fixed
+ * size: 0
+ */
+/* A variable that contains the only none type. */
+extern type *none_type;
+/* Returns the none type */
+type *get_none_type(void);
+
+/**
+ * @page unknown_type
+ *
+ * This type is an auxiliary type dedicated to support type analyses.
+ *
+ * The unknown type represents that there could be a type, but it is not
+ * known. This type can be used to initialize fields before an analysis (not known
+ * yet) or to represent the top of a lattice (could not be determined). There exists
+ * exactly one type unknown. This type is not on the type list in ir_prog. It is
+ * allocated when initializing the type module.
+ *
+ * The following values are set:
+ * mode: mode_ANY
+ * name: "type_unknown"
+ * state: layout_fixed
+ * size: 0
+ */
+/* A variable that contains the only unknown type. */
+extern type *unknown_type;
+/* Returns the unknown type */
+type *get_unknown_type(void);
+
+
+/**
+ * Checks whether a type is atomic.
+ * @param tp - any type
+ * @return true if type is primitive, pointer or enumeration
+ */
+int is_atomic_type(const type *tp);
+
+/* --- Support for compound types --- */
+
+/**
+ * Gets the number of elements in a firm compound type.
+ *
+ * This is just a comforability function, because structs and
+ * classes can often be treated be the same code, but they have
+ * different access functions to their members.
+ *
+ * @param tp The type (must be struct, union or class).
+ *
+ * @return Number of members in the compound type.
+ */
+int get_compound_n_members(const type *tp);
+
+/**
+ * Gets the member of a firm compound type at position pos.
+ *
+ * @param tp The type (must be struct, union or class).
+ * @param pos The number of the member.
+ *
+ * @return The member entity at position pos.
+ *
+ * @see get_compound_n_members() for justifaction of existence.
+ */
+entity *get_compound_member(const type *tp, int pos);
+
+/**
+ * Checks whether a type is compound.
+ *
+ * @param tp - any type
+ *
+ * @return true if the type is class, structure, union or array type.
+ */
+int is_compound_type(const type *tp);
+
+
+/**
+ * Outputs a unique number for this type if libfirm is compiled for
+ * debugging, (configure with --enable-debug) else returns the address
+ * of the type cast to long.
+ */
+long get_type_nr(const type *tp);
/*******************************************************************/
-/** To manage all different types the same **/
+/** Debug aides **/
/*******************************************************************/
-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);
-
projects / libfirm / blobdiff