# 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
* 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, enumerations, 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.
*/
/* 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
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. */
+/* 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 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. */
+ 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;
INLINE peculiarity get_class_peculiarity (type *clss);
INLINE void set_class_peculiarity (type *clss, peculiarity pec);
-/* Set and get a class' dfn */
-void set_class_dfn (type*, int);
-int get_class_dfn (type*);
+/* 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 *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