-/****h* libfirm/type
+/****h* libfirm/type6 2002/03/19 13:08:33
*
* NAME
* file type.h - datastructure to hold type information.
# define _TYPE_H_
# include "tpop.h"
-# include "common.h"
+# include "firm_common.h"
# include "ident.h"
# include "irmode.h"
# include "bool.h"
+# include "dbginfo.h"
+/* to resolve recursion between entity.h and type.h */
#ifndef _ENTITY_TYPEDEF_
#define _ENTITY_TYPEDEF_
-/* to resolve recursion between entity.h and type.h */
typedef struct entity entity;
#endif
* 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.
+ * link A void* to associate some additional information with the type.
*
* These fields can only be accessed via access functions.
*
* class, struct, method, union, array, enumeration, pointer, primitive
* SOURCE
*/
+#ifndef _TYPE_TYPEDEF_
+#define _TYPE_TYPEDEF_
typedef struct type type;
+#endif
# include "type_or_entity.h"
-void* get_type_link(type *tp);
-void set_type_link(type *tp, void *l);
+/* Frees the memory used by the type. Does not free the entities
+ belonging to the type, except for the array element entity. */
+void free_type(type *tp);
+
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. */
+ 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 and primitive types.
- */
+ computation. Default for pointer, primitive ane method
+ 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);
+/* 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);
+
+int get_type_size(type *tp);
+/* For primitive, enumeration, 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);
+
+
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);
+
+void* get_type_link(type *tp);
+void set_type_link(type *tp, void *l);
/*****/
/****v* type/visited
* SOURCE
*/
extern unsigned long type_visited;
+void set_master_type_visited(unsigned long val);
+unsigned long get_master_type_visited();
+void inc_master_type_visited();
/*****/
/****f* type/is_type
*/
int is_type (void *thing);
+/****f* type/equal_types
+ *
+ * NAME
+ * equal_type - Checks whether two types are structural equal.
+ * SYNOPSIS
+ * bool equal_types (type *typ1, type *typ2);
+ * INPUTS
+ * two pointer types
+ * RESULT
+ * 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);
+
+/****f* type/smaller_type
+ *
+ * NAME
+ * smaller_type - Checks whether two types are structural comparable.
+ * SYNOPSIS
+ * bool smaller_type (type *st, type *lt);
+ * INPUTS
+ * two pointer type
+ * RESULT
+ * 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
+ * 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
+ * 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
+ * smaller than the points_to type of lt.
+ ***
+ */
+bool smaller_type (type *st, type *lt);
+
/****** type/class
* NAME
* Representation of a class type.
* 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.
- * Values: description, existent. Default: existent.
+ * 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.
*
* SOURCE
*/
/* create a new class type */
type *new_type_class (ident *name);
+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_member (type *clss);
+int get_class_n_members (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
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 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 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);
+int get_class_n_subtypes (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. */
+/* Finds subtype in the list of subtypes and removes it */
void remove_class_subtype(type *clss, type *subtype);
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);
+int get_class_n_supertypes (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. */
+/* 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 {
+typedef enum peculiarity {
description, /* Represents only a description. The entity/type is never
allocated, no code/data exists for this entity/type. */
+ 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. */
existent /* The entity/type (can) exist. */
} peculiarity;
/* The peculiarity of the class. The enumeration peculiarity is defined
in entity.h */
-inline peculiarity get_class_peculiarity (type *clss);
-inline void set_class_peculiarity (type *clss, peculiarity pec);
+INLINE peculiarity get_class_peculiarity (type *clss);
+INLINE void set_class_peculiarity (type *clss, peculiarity pec);
+
+/* Set and get a class' dfn --
+ @@@ This is an undocumented field, subject to change! */
+void set_class_dfn (type *clss, int dfn);
+int get_class_dfn (type *clss);
/* typecheck */
-bool is_class_type(type *clss);
+bool is_class_type(type *clss);
+/* Returns true if low is subclass of high. */
+bool is_subclass_of(type *low, type *high);
/*****/
/****** type/struct
*/
/* create a new type struct */
type *new_type_struct (ident *name);
+type *new_d_type_struct (ident *name, dbg_info* db);
/* manipulate private fields of struct */
void add_struct_member (type *strct, entity *member);
-int get_struct_n_member (type *strct);
+int get_struct_n_members (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. */
+/* Finds member in the list of memberss and removees it */
void remove_struct_member (type *strct, entity *member);
/* typecheck */
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);
+type *new_d_type_method (ident *name, int n_param, int n_res, dbg_info* db);
/* 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);
+void set_method_param_type(type *method, int pos, type* tp);
-int get_method_n_res (type *method);
+int get_method_n_ress (type *method);
type *get_method_res_type(type *method, int pos);
-void set_method_res_type(type *method, int pos, type* type);
+void set_method_res_type(type *method, int pos, type* tp);
/* typecheck */
bool is_method_type (type *method);
*/
/* create a new type union */
type *new_type_union (ident *name);
+type *new_d_type_union (ident *name, dbg_info* db);
/* 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. */
+/* Finds member in the list of members and removes it. */
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
* NAME
* Representation of an array type.
/* 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.
+ 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);
+type *new_d_type_array (ident *name, int n_dimensions,
+ type *element_type, dbg_info* db);
/* manipulate private fields of array type */
int get_array_n_dimensions (type *array);
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);
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);
+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);
*/
/* create a new type enumeration -- set the enumerators independently */
type *new_type_enumeration (ident *name, int n_enums);
+type *new_d_type_enumeration (ident *name, int n_enums, dbg_info* db);
/* manipulate fields of enumeration type. */
int get_enumeration_n_enums (type *enumeration);
*/
/* Create a new type pointer */
type *new_type_pointer (ident *name, type *points_to);
+type *new_d_type_pointer (ident *name, type *points_to, dbg_info* db);
/* manipulate fields of type_pointer */
-void set_pointer_points_to_type (type *pointer, type *type);
+void set_pointer_points_to_type (type *pointer, type *tp);
type *get_pointer_points_to_type (type *pointer);
/* typecheck */
*/
/* create a new type primitive */
type *new_type_primitive (ident *name, ir_mode *mode);
+type *new_d_type_primitive (ident *name, ir_mode *mode, dbg_info* db);
/* typecheck */
bool is_primitive_type (type *primitive);
projects / libfirm / blobdiff