X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ir%2Ftr%2Ftype_t.h;h=e61a951bb2d3c6b92b108679f373b4310dc1a5d4;hb=af82344c3d1ede9a28e652302a8c2bac7bb1c743;hp=7f9c33fdf23c4b5b5fb3abfb298d8cd1a7d09530;hpb=0064ee54b41c007b5d33b557d053e602ac3be2cc;p=libfirm diff --git a/ir/tr/type_t.h b/ir/tr/type_t.h index 7f9c33fdf..e61a951bb 100644 --- a/ir/tr/type_t.h +++ b/ir/tr/type_t.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -61,22 +61,19 @@ typedef struct { /** A (type, ir_entity) pair. */ typedef struct { - ir_type *tp; /**< A type. */ - ir_entity *ent; /**< An ir_entity. */ - ident *param_name; /**< For debugging purposes: the name of the parameter */ + ir_type *tp; /**< A type. */ + ir_entity *ent; /**< An ir_entity. */ } tp_ent_pair; /** Method type attributes. */ typedef struct { - int n_params; /**< Number of parameters. */ + size_t n_params; /**< Number of parameters. */ tp_ent_pair *params; /**< Array of parameter type/value entities pairs. */ - ir_type *value_params; /**< A type whose entities represent copied value arguments. */ - int n_res; /**< Number of results. */ + ir_type *value_params; /**< A type whose entities represent copied value arguments. */ + size_t n_res; /**< Number of results. */ tp_ent_pair *res_type; /**< Array of result type/value ir_entity pairs. */ - ir_type *value_ress; /**< A type whose entities represent copied value results. */ - ir_variadicity variadicity; /**< The variadicity of the method. */ - int first_variadic_param; /**< The index of the first variadic parameter or -1 if non-variadic .*/ - unsigned additional_properties; /**< Set of additional method properties. */ + ir_variadicity variadicity; /**< The variadicity of the method. */ +mtp_additional_properties additional_properties; /**< Set of additional method properties. */ unsigned irg_calling_conv; /**< A set of calling convention flags. */ } mtd_attr; @@ -87,10 +84,10 @@ typedef struct { /** Array type attributes. */ typedef struct { - int n_dimensions; /**< Number of array dimensions. */ + size_t n_dimensions; /**< Number of array dimensions. */ ir_node **lower_bound; /**< Lower bounds of dimensions. Usually all 0. */ ir_node **upper_bound; /**< Upper bounds or dimensions. */ - int *order; /**< Ordering of dimensions. */ + size_t *order; /**< Ordering of dimensions. */ ir_type *element_type; /**< The type of the array elements. */ ir_entity *element_ent; /**< entity for the array elements, to be used for element selection with a Sel node. */ @@ -98,7 +95,7 @@ typedef struct { /** An enumerator constant. */ struct ir_enum_const { - tarval *value; /**< The constants that represents this enumerator identifier. */ + ir_tarval *value; /**< The constants that represents this enumerator identifier. */ ident *nameid; /**< The name of the enumerator identifier. */ ir_type *owner; /**< owner type of this enumerator constant. */ }; @@ -216,7 +213,7 @@ struct ir_type { when fixing the layout of this class. Size must be given in bytes. */ unsigned align; /**< Alignment of an ir_entity of this type. This should be - set according to the source language needs. If not set it's + set according to the source language needs. If not set, it's calculated automatically by get_type_alignment(). Alignment must be given in bytes. */ ir_mode *mode; /**< The mode for atomic types */ @@ -278,13 +275,18 @@ void set_union_size(ir_type *tp, unsigned bytes); void set_array_size(ir_type *tp, unsigned bytes); void set_default_size(ir_type *tp, unsigned bytes); +/** Set and get a class' dfn -- + * 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); + void add_compound_member(ir_type *compound, ir_entity *entity); -void remove_compound_member(ir_type *compound, ir_entity *entity); -/** - * Initialize the type module. - */ -void firm_init_type(void); +/** Initialize the type module. */ +void ir_init_type(void); + +/** free internal datastructures of type module */ +void ir_finish_type(void); /** Clone an existing method type. * @@ -306,6 +308,28 @@ static inline void _set_master_type_visited(ir_visited_t val) { firm_type_visite static inline ir_visited_t _get_master_type_visited(void) { return firm_type_visited; } static inline void _inc_master_type_visited(void) { ++firm_type_visited; } +static inline int is_lowered_type(const ir_type *tp) +{ + return tp->flags & tf_lowered_type; +} + +/** + * Gets the lowered/unlowered type of a type or NULL if this type + * has no lowered/unlowered one. + */ +static inline ir_type *get_associated_type(const ir_type *tp) +{ + return tp->assoc_type; +} + +static inline void set_lowered_type(ir_type *tp, ir_type *lowered_type) +{ + assert (is_type(tp) && is_type(lowered_type)); + lowered_type->flags |= tf_lowered_type; + tp->assoc_type = lowered_type; + lowered_type->assoc_type = tp; +} + static inline void *_get_type_link(const ir_type *tp) { assert(tp && tp->kind == k_type); @@ -397,49 +421,48 @@ static inline void _set_type_dbg_info(ir_type *tp, type_dbg_info *db) static inline int _is_type(const void *thing) { - return (get_kind(thing) == k_type); + return get_kind(thing) == k_type; } static inline int _is_class_type(const ir_type *clss) { - assert(clss); - return (clss->type_op == type_class); + return clss->type_op == type_class; } -static inline int _get_class_n_members (const ir_type *clss) +static inline size_t _get_class_n_members(const ir_type *clss) { - assert(clss && (clss->type_op == type_class)); - return (ARR_LEN (clss->attr.ca.members)); + assert(clss->type_op == type_class); + return ARR_LEN(clss->attr.ca.members); } -static inline ir_entity *_get_class_member(const ir_type *clss, int pos) +static inline ir_entity *_get_class_member(const ir_type *clss, size_t pos) { - assert(clss && (clss->type_op == type_class)); - assert(pos >= 0 && pos < _get_class_n_members(clss)); + assert(clss->type_op == type_class); + assert(pos < _get_class_n_members(clss)); return clss->attr.ca.members[pos]; } static inline unsigned _get_class_vtable_size(const ir_type *clss) { - assert(clss && (clss->type_op == type_class)); + assert(clss->type_op == type_class); return clss->attr.ca.vtable_size; } static inline void _set_class_vtable_size(ir_type *clss, unsigned vtable_size) { - assert(clss && (clss->type_op == type_class)); + assert(clss->type_op == type_class); clss->attr.ca.vtable_size = vtable_size; } static inline int _is_class_final(const ir_type *clss) { - assert(clss && (clss->type_op == type_class)); + assert(clss->type_op == type_class); return clss->attr.ca.clss_flags & cf_final_class; } static inline void _set_class_final(ir_type *clss, int final) { - assert(clss && (clss->type_op == type_class)); + assert(clss->type_op == type_class); if (final) clss->attr.ca.clss_flags |= cf_final_class; else @@ -448,13 +471,13 @@ static inline void _set_class_final(ir_type *clss, int final) static inline int _is_class_interface(const ir_type *clss) { - assert(clss && (clss->type_op == type_class)); + assert(clss->type_op == type_class); return clss->attr.ca.clss_flags & cf_interface_class; } static inline void _set_class_interface(ir_type *clss, int final) { - assert(clss && (clss->type_op == type_class)); + assert(clss->type_op == type_class); if (final) clss->attr.ca.clss_flags |= cf_interface_class; else @@ -463,13 +486,13 @@ static inline void _set_class_interface(ir_type *clss, int final) static inline int _is_class_abstract(const ir_type *clss) { - assert(clss && (clss->type_op == type_class)); + assert(clss->type_op == type_class); return clss->attr.ca.clss_flags & cf_absctract_class; } static inline void _set_class_abstract(ir_type *clss, int final) { - assert(clss && (clss->type_op == type_class)); + assert(clss->type_op == type_class); if (final) clss->attr.ca.clss_flags |= cf_absctract_class; else @@ -478,84 +501,78 @@ static inline void _set_class_abstract(ir_type *clss, int final) static inline int _is_struct_type(const ir_type *strct) { - assert(strct); return (strct->type_op == type_struct); } static inline int _is_method_type(const ir_type *method) { - assert(method); return (method->type_op == type_method); } static inline int _is_union_type(const ir_type *uni) { - assert(uni); return (uni->type_op == type_union); } static inline int _is_array_type(const ir_type *array) { - assert(array); return (array->type_op == type_array); } static inline int _is_enumeration_type(const ir_type *enumeration) { - assert(enumeration); return (enumeration->type_op == type_enumeration); } static inline int _is_pointer_type(const ir_type *pointer) { - assert(pointer); return (pointer->type_op == type_pointer); } /** Returns true if a type is a primitive type. */ static inline int _is_primitive_type(const ir_type *primitive) { - assert(primitive && primitive->kind == k_type); + assert(primitive->kind == k_type); return (primitive->type_op == type_primitive); } static inline int _is_atomic_type(const ir_type *tp) { - assert(tp && tp->kind == k_type); + assert(tp->kind == k_type); return (_is_primitive_type(tp) || _is_pointer_type(tp) || _is_enumeration_type(tp)); } -static inline int _get_method_n_params(const ir_type *method) +static inline size_t _get_method_n_params(const ir_type *method) { - assert(method && (method->type_op == type_method)); + assert(method->type_op == type_method); return method->attr.ma.n_params; } -static inline int _get_method_n_ress(const ir_type *method) +static inline size_t _get_method_n_ress(const ir_type *method) { - assert(method && (method->type_op == type_method)); + assert(method->type_op == type_method); return method->attr.ma.n_res; } -static inline unsigned _get_method_additional_properties(const ir_type *method) +static inline mtp_additional_properties _get_method_additional_properties(const ir_type *method) { - assert(method && (method->type_op == type_method)); + assert(method->type_op == type_method); return method->attr.ma.additional_properties; } -static inline void _set_method_additional_properties(ir_type *method, unsigned mask) +static inline void _set_method_additional_properties(ir_type *method, mtp_additional_properties mask) { - assert(method && (method->type_op == type_method)); + assert(method->type_op == type_method); /* do not allow to set the mtp_property_inherited flag or * the automatic inheritance of flags will not work */ method->attr.ma.additional_properties = mask & ~mtp_property_inherited; } -static inline void _set_method_additional_property(ir_type *method, mtp_additional_property flag) +static inline void _add_method_additional_properties(ir_type *method, mtp_additional_properties flag) { - assert(method && (method->type_op == type_method)); + assert(method->type_op == type_method); /* do not allow to set the mtp_property_inherited flag or * the automatic inheritance of flags will not work */ @@ -564,13 +581,13 @@ static inline void _set_method_additional_property(ir_type *method, mtp_addition static inline unsigned _get_method_calling_convention(const ir_type *method) { - assert(method && (method->type_op == type_method)); + assert(method->type_op == type_method); return method->attr.ma.irg_calling_conv; } static inline void _set_method_calling_convention(ir_type *method, unsigned cc_mask) { - assert(method && (method->type_op == type_method)); + assert(method->type_op == type_method); method->attr.ma.irg_calling_conv = cc_mask; } @@ -617,7 +634,7 @@ static inline void _set_method_calling_convention(ir_type *method, unsigned cc_m #define get_method_n_ress(method) _get_method_n_ress(method) #define get_method_additional_properties(method) _get_method_additional_properties(method) #define set_method_additional_properties(method, mask) _set_method_additional_properties(method, mask) -#define set_method_additional_property(method, flag) _set_method_additional_property(method, flag) +#define add_method_additional_properties(method, flag) _add_method_additional_properties(method, flag) #define get_method_calling_convention(method) _get_method_calling_convention(method) #define set_method_calling_convention(method, cc_mask) _set_method_calling_convention(method, cc_mask)