X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Ftype.h;h=ebf815e099089c06c6c4817c2dcc4b93754f2c7a;hb=d49a8741d0780f324c8ee35176cb37b0188ec8f2;hp=845a9761ed6055354ad46c80fc399340bfa75768;hpb=a59e7e475485a1f7c7e5fb3c2d2d754b7c87016c;p=libfirm
diff --git a/ir/tr/type.h b/ir/tr/type.h
index 845a9761e..ebf815e09 100644
--- a/ir/tr/type.h
+++ b/ir/tr/type.h
@@ -1,17 +1,18 @@
+/*
+ * Project: libFIRM
+ * File name: ir/tr/type.h
+ * Purpose: Representation of types.
+ * Author: Goetz Lindenmaier
+ * Modified by: Michael Beck
+ * Created:
+ * Copyright: (c) 2001-2003 Universität Karlsruhe
+ * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
+ * CVS-ID: $Id$
+ */
+
/**
* @file type.h
*
- * Project: libFIRM
- * File name: ir/tr/type.h
- * Purpose: Representation of types.
- * Author: Goetz Lindenmaier
- * Modified by:
- * Created:
- * Copyright: (c) 2001-2003 Universität Karlsruhe
- * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
- * CVS-ID: $Id$
- *
- *
* Datastructure to hold type information.
*
* This module supplies a datastructure to represent all types
@@ -31,17 +32,13 @@
*
* @see tpop.h
*/
+#ifndef _FIRM_TR_TYPE_H_
+#define _FIRM_TR_TYPE_H_
-# ifndef _TYPE_H_
-# define _TYPE_H_
-
-# include "firm_types.h"
-# include "tpop.h"
-# include "firm_common.h"
-# include "ident.h"
-# include "irmode.h"
-# include "dbginfo.h"
-# include "tr_inheritance.h"
+#include "firm_types.h"
+#include "tpop.h"
+#include "firm_common.h"
+#include "dbginfo.h"
/**
* An abstract data type to represent types.
@@ -62,31 +59,33 @@
*
* 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.
+ * - 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.
+ * - name: An identifier specifying the name of the type. To be
+ * set by the frontend.
+ * - visibility: The visibility of this type.
+ * - 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)
+ * - mode: The mode to be used to represent the type on a machine.
+ * - 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.
+ * - assoc_type: The associated lowered/upper type.
+ * - 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.
*
@@ -110,10 +109,10 @@ typedef struct ir_type ir_type;
# 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.
-*/
+/** Frees all entities associated with a type.
+ * Does not free the array entity.
+ * Warning: ensure these entities are not referenced anywhere else.
+ */
void free_type_entities(ir_type *tp);
/** Frees the memory used by the type.
@@ -142,21 +141,21 @@ const char* get_type_name(const ir_type *tp);
*/
typedef enum {
visibility_local, /**< The entity is only visible locally. This is the default for
- entities.
- The type is only visible locally. All instances are allocated
- locally, and no pointer to entities of this type are passed
- out of this compilation unit. */
+ entities.
+ The type is only visible locally. All instances are allocated
+ locally, and no pointer to entities of this type are passed
+ out of this compilation unit. */
visibility_external_visible, /**< The entity is visible to other external program parts, but
- it is defined here. It may not be optimized away. The entity must
- be static_allocated.
- For types: entities of this type can be accessed externally. No
- instances of this type are allocated externally. */
+ it is defined here. It may not be optimized away. The entity must
+ be static_allocated.
+ For types: entities of this type can be accessed externally. No
+ instances of this type are allocated externally. */
visibility_external_allocated /**< The entity is defined and allocated externally. This compilation
- must not allocate memory for this entity. The entity must
- be static_allocated. This can also be an external defined
- method.
- For types: entities of this type are allocated and accessed from
- external code. Default for types. */
+ must not allocate memory for this entity. The entity must
+ be static_allocated. This can also be an external defined
+ method.
+ For types: entities of this type are allocated and accessed from
+ external code. Default for types. */
} visibility;
/** The visibility of a type.
@@ -205,15 +204,15 @@ void set_type_visibility (ir_type *tp, visibility v);
/** 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. */
+ 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. */
+ 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 a human readable string for the enum entry. */
@@ -290,11 +289,15 @@ void set_type_alignment_bytes(ir_type *tp, int size);
*/
void set_type_alignment_bits(ir_type *tp, int size);
+/** Returns the visited count of a type. */
unsigned long get_type_visited(const ir_type *tp);
+/** Sets the visited count of a type to num. */
void set_type_visited(ir_type *tp, unsigned long num);
-/* Sets visited field in type to type_visited. */
+/** Sets visited field in type to type_visited. */
void mark_type_visited(ir_type *tp);
+/** Returns non-zero if the type is already visited */
int type_visited(const ir_type *tp);
+/** Returns non-zero if the type is not yet visited */
int type_not_visited(const ir_type *tp);
/** Returns the associated link field of a type. */
@@ -409,7 +412,7 @@ int smaller_type (ir_type *st, ir_type *lt);
* 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 method entities
* which have type_method or fields that can have any of the
@@ -438,11 +441,24 @@ int smaller_type (ir_type *st, ir_type *lt);
* representing this type. This information is useful for lowering
* of InstOf and TypeChk nodes. Default: NULL
*
+ * - vtable_size: The size of this class virtual function table.
+ * Default: 0
+ *
* - final: A final class is always a leaf in the class hierarchy. Final
* classes cannot be super classes of other ones. As this information
* can only be computed in whole world compilations, we allow to
* set this flag. It is used in optimizations if get_opt_closed_world()
* is false. Default: false
+ *
+ * - interface: The class represents an interface. This flag can be set to distinguish
+ * between interfaces, abstract classes and other classes that all may
+ * have the peculiarity peculiarity_description. Depending on this flag
+ * the lowering might do different actions. Default: false
+ *
+ * - abstract : The class represents an abstract class. This flag can be set to distinguish
+ * between interfaces, abstract classes and other classes that all may
+ * have the peculiarity peculiarity_description. Depending on this flag
+ * the lowering might do different actions. Default: false
*/
/** Creates a new class type. */
@@ -581,7 +597,9 @@ typedef enum peculiarity {
@@@ eventually rename to 'real' i.e., 'echt'
This serves better as opposition to description _and_ inherited.*/
} peculiarity;
-const char *get_peculiarity_string(peculiarity p);
+
+/** Returns a human readable string for a peculiarity. */
+const char *get_peculiarity_name(peculiarity p);
/** Returns the peculiarity of the class. */
peculiarity get_class_peculiarity (const ir_type *clss);
@@ -594,13 +612,31 @@ entity *get_class_type_info(const ir_type *clss);
/** Set a type info entity for the class. */
void set_class_type_info(ir_type *clss, entity *ent);
+/** Returns the size of the virtual function table. */
+unsigned get_class_vtable_size(const ir_type *clss);
+
+/** Sets a new size of the virtual function table. */
+void set_class_vtable_size(ir_type *clss, unsigned size);
+
/** Returns non-zero if a class is final. */
int is_class_final(const ir_type *clss);
-/** Sets if a class is final. */
+/** Sets the class final flag. */
void set_class_final(ir_type *clss, int flag);
-/* Set and get a class' dfn --
+/** Return non-zero if a class is an interface */
+int is_class_interface(const ir_type *clss);
+
+/** Sets the class interface flag. */
+void set_class_interface(ir_type *clss, int flag);
+
+/** Return non-zero if a class is an abstract class. */
+int is_class_abstract(const ir_type *clss);
+
+/** Sets the class abstract flag. */
+void set_class_abstract(ir_type *clss, int flag);
+
+/** Set and get a class' dfn --
@todo This is an undocumented field, subject to change! */
void set_class_dfn (ir_type *clss, int dfn);
int get_class_dfn (const ir_type *clss);
@@ -611,8 +647,9 @@ int is_Class_type(const ir_type *clss);
/**
* @page struct_type Representation of a struct type
*
- * Type_strct represents aggregate types that consist of a list
+ * A struct type 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,
@@ -729,7 +766,8 @@ void set_method_param_type(ir_type *method, int pos, ir_type *tp);
for compounds passed by value. This information is constructed only on demand. */
entity *get_method_value_param_ent(ir_type *method, int pos);
/**
- * Returns a type that represents the copied value arguments.
+ * Returns a type that represents the copied value arguments if one
+ * was allocated, else NULL.
*/
ir_type *get_method_value_param_type(const ir_type *method);
@@ -786,9 +824,9 @@ int get_method_first_variadic_param_index(const ir_type *method);
void set_method_first_variadic_param_index(ir_type *method, int index);
/**
- * additional method type properties:
- * Tell about special properties of a method type. Some
- * of these may be discovered by analyses.
+ * Additional method type properties:
+ * Tell about special properties of a method type. Some
+ * of these may be discovered by analyses.
*/
typedef enum {
mtp_no_property = 0x00000000, /**< no additional properties, default */
@@ -796,7 +834,7 @@ typedef enum {
its return values solely from its parameters.
GCC: __attribute__((const)). */
mtp_property_pure = 0x00000002, /**< This method did NOT write to memory and calculates
- its return values solely form its parameters and
+ its return values solely from its parameters and
the memory they points to (or global vars).
GCC: __attribute__((pure)). */
mtp_property_noreturn = 0x00000004, /**< This method did not return due to an aborting system
@@ -810,8 +848,8 @@ typedef enum {
GCC: __attribute__((malloc)). */
mtp_property_intrinsic = 0x00000040, /**< This method is intrinsic. It is expected that
a lowering phase will remove all calls to it. */
- mtp_property_inherited = 0x40000000 /**< used only in irg's, means property is inherited
- from type. */
+ mtp_property_inherited = (1<<31) /**< Internal. Used only in irg's, means property is
+ inherited from type. */
} mtp_additional_property;
/** Returns the mask of the additional graph properties. */
@@ -824,26 +862,28 @@ void set_method_additional_properties(ir_type *method, unsigned property_mask);
void set_method_additional_property(ir_type *method, mtp_additional_property flag);
/**
- * calling conventions: lower 24 bits are the number of register parameters,
- * upper 8 encode the calling conventions
+ * Calling conventions: lower 24 bits are the number of register parameters,
+ * upper 8 encode the calling conventions.
*/
typedef enum {
cc_reg_param = 0x01000000, /**< Transmit parameters in registers, else the stack is used.
This flag may be set as default on some architectures. */
cc_last_on_top = 0x02000000, /**< The last non-register parameter is transmitted on top of
- the stack. This is equivalent to the stdcall or pascal
- calling convention. If this flag is not set, the first
- non-register parameter is used (cdecl calling convention) */
+ the stack. This is equivalent to the pascal
+ calling convention. If this flag is not set, the first
+ non-register parameter is used (stdcall or cdecl
+ calling convention) */
cc_callee_clear_stk = 0x04000000, /**< The callee clears the stack. This forbids variadic
function calls (stdcall). */
cc_this_call = 0x08000000, /**< The first parameter is a this pointer and is transmitted
in a special way. */
-
cc_bits = (0xFF << 24) /**< the calling convention bits */
} calling_convention;
-/* some often used cases: made as defines for firmjni */
+/* some often used cases: made as defines because firmjni cannot handle two
+ equal enum values. */
+
/** cdecl calling convention */
#define cc_cdecl_set (0)
/** stdcall calling convention */
@@ -851,7 +891,7 @@ typedef enum {
/** fastcall calling convention */
#define cc_fastcall_set (cc_reg_param|cc_callee_clear_stk)
-/** return the default calling convention for method types */
+/** Returns the default calling convention for method types. */
unsigned get_default_cc_mask(void);
/**
@@ -870,17 +910,17 @@ unsigned get_default_cc_mask(void);
#define IS_FASTCALL(cc_mask) (((cc_mask) & cc_bits) == cc_fastcall_set)
/**
- * set the CDECL convention bits
+ * Sets the CDECL convention bits.
*/
#define SET_CDECL(cc_mask) (((cc_mask) & ~cc_bits) | cc_cdecl_set)
/**
- * set the STDCALL convention bits
+ * Set. the STDCALL convention bits.
*/
#define SET_STDCALL(cc_mask) (((cc_mask) & ~cc_bits) | cc_stdcall_set)
/**
- * set the FASTCALL convention bits
+ * Sets the FASTCALL convention bits.
*/
#define SET_FASTCALL(cc_mask) (((cc_mask) & ~cc_bits) | cc_fastcall_set)
@@ -902,7 +942,10 @@ int is_Method_type (const ir_type *method);
/**
* @page union_type Representation of a union (variant) type.
*
- * The union type represents union types.
+ * The union type represents union types. Note that this representation
+ * resembles the C union type. For tagged variant types like in Pascal or Modula
+ * a combination of a struct and a union type must be used.
+ *
* - 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,
@@ -983,7 +1026,7 @@ ir_type *new_d_type_array (ident *name, int n_dimensions,
int get_array_n_dimensions (const ir_type *array);
/**
- * Allocates Const nodes of mode_I for one array dimension.
+ * Allocates Const nodes of mode_Is for one array dimension.
* Upper bound in Firm is the element next to the last, i.e. [lower,upper[
*/
void set_array_bounds_int (ir_type *array, int dimension, int lower_bound,
@@ -997,14 +1040,14 @@ void set_array_bounds (ir_type *array, int dimension, ir_node *lower_boun
/** Sets the lower bound for one array dimension, i.e. [lower,upper[ */
void set_array_lower_bound (ir_type *array, int dimension, ir_node *lower_bound);
-/** Allocates Const nodes of mode_I for the lower bound of an array
+/** Allocates Const nodes of mode_Is for the lower bound of an array
dimension, i.e. [lower,upper[ */
void set_array_lower_bound_int (ir_type *array, int dimension, int lower_bound);
/** Sets the upper bound for one array dimension, i.e. [lower,upper[ */
void set_array_upper_bound (ir_type *array, int dimension, ir_node *upper_bound);
-/** Allocates Const nodes of mode_I for the upper bound of an array
+/** Allocates Const nodes of mode_Is for the upper bound of an array
dimension, i.e. [lower,upper[. */
void set_array_upper_bound_int (ir_type *array, int dimension, int upper_bound);
@@ -1061,7 +1104,7 @@ int is_Array_type(const ir_type *array);
ir_type *new_type_enumeration (ident *name, int n_enums);
/** Create a new type enumeration with debug information -- set the enumerators independently. */
-ir_type *new_d_type_enumeration (ident *name, int n_enums, dbg_info* db);
+ir_type *new_d_type_enumeration (ident *name, int n_enums, dbg_info *db);
/* --- manipulate fields of enumeration type. --- */
@@ -1114,16 +1157,16 @@ int is_Pointer_type (const ir_type *pointer);
/** Returns the first pointer type that has as points_to tp.
* Not efficient: O(#types).
- * If not found returns unknown_type. */
+ * If not found returns firm_unknown_type. */
ir_type *find_pointer_type_to_type (ir_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
+ * Primitive types are types that represent atomic data values that
+ * map directly to modes. They don't have private attributes. The
* important information they carry is held in the common mode field.
-*/
+ */
/** Creates a new primitive type. */
ir_type *new_type_primitive (ident *name, ir_mode *mode);
@@ -1135,7 +1178,7 @@ int is_Primitive_type (const ir_type *primitive);
/**
- * @page none_type
+ * @page none_type The None type
*
* This type is an auxiliary type dedicated to support type analyses.
*
@@ -1153,7 +1196,8 @@ int is_Primitive_type (const ir_type *primitive);
*/
/** A variable that contains the only none type. */
extern ir_type *firm_none_type;
-/** Returns the none type */
+
+/** Returns the none type. */
ir_type *get_none_type(void);
/**
@@ -1175,7 +1219,8 @@ ir_type *get_none_type(void);
*/
/** A variable that contains the only unknown type. */
extern ir_type *firm_unknown_type;
-/** Returns the unknown type */
+
+/** Returns the unknown type. */
ir_type *get_unknown_type(void);
@@ -1189,7 +1234,7 @@ int is_atomic_type(const ir_type *tp);
/* --- Support for compound types --- */
/**
- * Gets the number of elements in a firm compound type.
+ * Gets the number of elements in a Firm compound type.
*
* This is just a comfortability function, because structs and
* classes can often be treated be the same code, but they have
@@ -1202,7 +1247,7 @@ int is_atomic_type(const ir_type *tp);
int get_compound_n_members(const ir_type *tp);
/**
- * Gets the member of a firm compound type at position pos.
+ * 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.
@@ -1217,7 +1262,7 @@ entity *get_compound_member(const ir_type *tp, int pos);
int get_compound_member_index(const ir_type *tp, entity *member);
/**
- * Checks whether a type is compound.
+ * Checks whether a type is a compound type.
*
* @param tp - any type
*
@@ -1226,16 +1271,52 @@ int get_compound_member_index(const ir_type *tp, entity *member);
int is_compound_type(const ir_type *tp);
/**
- * Checks, whether a type is a frame type
+ * Checks, whether a type is a frame type.
*/
int is_frame_type(const ir_type *tp);
+/**
+ * Checks, whether a type is a value parameter type.
+ */
+int is_value_param_type(const ir_type *tp);
+
+/**
+ * Checks, whether a type is a lowered type.
+ */
+int is_lowered_type(const ir_type *tp);
+
/**
* Makes a new frame type. Frame types are class types,
* so all class access functions work.
* Frame types are not in the global list of types.
*/
-ir_type *new_type_frame(ident *name);
+ir_type *new_type_frame(ident *name);
+
+/**
+ * Sets a lowered type for a type. This sets both associations
+ * and marks lowered_type as a "lowered" one.
+ */
+void set_lowered_type(ir_type *tp, ir_type *lowered_type);
+
+/**
+ * Gets the lowered/unlowered type of a type or NULL if this type
+ * has no lowered/unlowered one.
+ */
+ir_type *get_associated_type(const ir_type *tp);
+
+/**
+ * Allocate an area of size bytes aligned at alignment
+ * at the start or the end of a frame type.
+ * The frame type must already have a fixed layout.
+ *
+ * @param frame_type a frame type
+ * @param size the size of the entity
+ * @param alignment the alignment of the entity
+ * @param at_start if true, put the area at the frame type's start, else at end
+ *
+ * @return the entity representing the area
+ */
+entity *frame_alloc_area(ir_type *frame_type, int size, int alignment, int at_start);
/*-----------------------------------------------------------------*/
/** Debug aides **/
@@ -1248,5 +1329,4 @@ ir_type *new_type_frame(ident *name);
*/
long get_type_nr(const ir_type *tp);
-
-# endif /* _TYPE_H_ */
+#endif /* _FIRM_TR_TYPE_H_ */