# 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"
* 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. */
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);
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);
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;
/* Set and get a class' dfn --
@@@ This is an undocumented field, subject to change! */
-void set_class_dfn (type*, int);
-int get_class_dfn (type*);
+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_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);
-
-/* @@@ fuer emitter.h von cggg */
-#define get_method_n_res(X) get_method_n_ress(X)
+void set_method_param_type(type *method, int pos, type* tp);
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.
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_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