X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Ftype.c;h=720c37bb2b3d68ac9f754870823319d1e367a28f;hb=f3157bda5e3b46233ea4ec9abd8499a8e7bb83ff;hp=05fdbb1f18891d5b373f072902bc6841c72c570b;hpb=5052f2d2fc507aefb5d39aa7d6cc41ca55b3a2c9;p=libfirm diff --git a/ir/tr/type.c b/ir/tr/type.c index 05fdbb1f1..720c37bb2 100644 --- a/ir/tr/type.c +++ b/ir/tr/type.c @@ -1,14 +1,10 @@ -/****h* libfirm/type.c +/** * - * NAME * file type.c - implementation of the datastructure to hold * type information. - * COPYRIGHT * (C) 2001 by Universitaet Karlsruhe - * AUTHORS * Martin Trapp, Christian Schaefer, Goetz Lindenmaier * - * NOTES * This module supplies a datastructure to represent all types * known in the compiled program. This includes types specified * in the program as well as types defined by the language. In the @@ -24,15 +20,14 @@ * on the level of the programming language, modes at the level of * the target processor. * - * SEE ALSO - * type_t.h type tpop - ***** + * @see type_t.h type tpop */ /* $Id$ */ # include # include +# include # include "type_t.h" # include "tpop_t.h" # include "typegmod_t.h" @@ -40,14 +35,30 @@ # include "irprog.h" # include "mangle.h" # include "tv.h" +# include "ircons.h" /*******************************************************************/ /** TYPE **/ /*******************************************************************/ unsigned long type_visited; +INLINE void set_master_type_visited(unsigned long val) { type_visited = val; } +INLINE unsigned long get_master_type_visited() { return type_visited; } +INLINE void inc_master_type_visited() { type_visited++; } -inline type * +void free_type(type *tp) { + /* Remove from list of all types */ + remove_irp_type(tp); + /* Free the attributes of the type. */ + free_type_attrs(tp); + /* Free entities automatically allocated with the type */ + if (is_array_type(tp)) + free_entity(get_array_element_entity(tp)); + /* And now the type itself... */ + free(tp); +} + +INLINE type * new_type(tp_op *type_op, ir_mode *mode, ident* name) { type *res; int node_size ; @@ -87,108 +98,167 @@ void free_type_attrs(type *tp) { /* set/get the link field */ void *get_type_link(type *tp) { - assert(tp); + assert(tp && tp->kind == k_type); return(tp -> link); } void set_type_link(type *tp, void *l) { - assert(tp); + assert(tp && tp->kind == k_type); tp -> link = l; } tp_op* get_type_tpop(type *tp) { - assert(tp); + assert(tp && tp->kind == k_type); return tp->type_op; } ident* get_type_tpop_nameid(type *tp) { - assert(tp); + assert(tp && tp->kind == k_type); return tp->type_op->name; } const char* get_type_tpop_name(type *tp) { - assert(tp); + assert(tp && tp->kind == k_type); return id_to_str(tp->type_op->name); } tp_opcode get_type_tpop_code(type *tp) { - assert(tp); + assert(tp && tp->kind == k_type); return tp->type_op->code; } ir_mode* get_type_mode(type *tp) { - assert(tp); + assert(tp && tp->kind == k_type); return tp->mode; } void set_type_mode(type *tp, ir_mode* m) { - assert(tp); - tp->mode = m; - /* For pointer and primitive size depends on the mode. */ - if ((tp->type_op == type_pointer) || (tp->type_op == type_primitive)) - tp->size == get_mode_size(m); + assert(tp && tp->kind == k_type); + + assert(((tp->type_op != type_primitive) || mode_is_data(m)) && + /* Modes of primitives must be data */ + ((tp->type_op != type_enumeration) || mode_is_int(m))); + /* Modes of enumerations must be integers */ + + if ((tp->type_op == type_primitive) || (tp->type_op == type_enumeration)) { + /* For pointer, primitive and enumeration size depends on the mode. */ + tp->size = get_mode_size(m); + tp->mode = m; + } } ident* get_type_ident(type *tp) { - assert(tp); + assert(tp && tp->kind == k_type); return tp->name; } void set_type_ident(type *tp, ident* id) { - assert(tp); + assert(tp && tp->kind == k_type); tp->name = id; } const char* get_type_name(type *tp) { - assert(tp); - return id_to_str(tp->name); + assert(tp && tp->kind == k_type); + return (id_to_str(tp->name)); } int get_type_size(type *tp) { - assert(tp); + assert(tp && tp->kind == k_type); return tp->size; } void set_type_size(type *tp, int size) { - assert(tp); - /* For pointer and primitive size depends on the mode. */ - if ((tp->type_op != type_pointer) && (tp->type_op != type_primitive)) + assert(tp && tp->kind == k_type); + /* For pointer enumeration and primitive size depends on the mode. + Methods don't have a size. */ + if ((tp->type_op != type_pointer) && (tp->type_op != type_primitive) && + (tp->type_op != type_enumeration) && (tp->type_op != type_method)) tp->size = size; } type_state get_type_state(type *tp) { - assert(tp); + assert(tp && tp->kind == k_type); return tp->state; } void set_type_state(type *tp, type_state state) { - assert(tp); - /* For pointer and primitive always fixed. */ - if ((tp->type_op != type_pointer) && (tp->type_op != type_primitive)) { - /* @@@ assert that the layout really is fixed!!! */ - tp->state = state; + assert(tp && tp->kind == k_type); + + if ((tp->type_op == type_pointer) && (tp->type_op == type_primitive) && + (tp->type_op == type_method)) + return; + + /* Just a correctness check: */ + if (state == layout_fixed) { + int i; + switch (get_type_tpop_code(tp)) { + case tpo_class: + { + assert(get_type_size(tp) > -1); + if (tp != get_glob_type()) + for (i = 0; i < get_class_n_members(tp); i++) { + assert(get_entity_offset(get_class_member(tp, i)) > -1); + assert(is_method_type(get_entity_type(get_class_member(tp, i))) || + (get_entity_allocation(get_class_member(tp, i)) == automatic_allocated)); + } + } break; + case tpo_struct: + { + /* assert(get_type_size(tp) > -1); @@@ lowerfirm geht nicht durch */ + for (i = 0; i < get_struct_n_members(tp); i++) { + assert(get_entity_offset(get_struct_member(tp, i)) > -1); + assert((get_entity_allocation(get_struct_member(tp, i)) == automatic_allocated)); + } + } break; + case tpo_union: + { /* ?? */ + } break; + case tpo_array: + { /* ?? + Check order? + Assure that only innermost dimension is dynamic? */ + } break; + case tpo_enumeration: + { + assert(get_type_mode != NULL); + for (i = 0; i < get_enumeration_n_enums(tp); i++) + assert(get_enumeration_enum(tp, i) != NULL); + } break; + default: break; + } /* switch (tp) */ } + tp->state = state; } unsigned long get_type_visited(type *tp) { - assert(tp); + assert(tp && tp->kind == k_type); return tp->visit; } void set_type_visited(type *tp, unsigned long num) { - assert(tp); + assert(tp && tp->kind == k_type); tp->visit = num; } /* Sets visited field in type to type_visited. */ void mark_type_visited(type *tp) { - assert(tp); + assert(tp && tp->kind == k_type); assert(tp->visit < type_visited); tp->visit = type_visited; } +/* @@@ name clash with master flag +bool type_visited(type *tp) { + assert(tp && tp->kind == k_type); + return tp->visit >= type_visited; + }*/ +bool type_not_visited(type *tp) { + assert(tp && tp->kind == k_type); + return tp->visit < type_visited; +} + int is_type (void *thing) { assert(thing); @@ -198,12 +268,258 @@ int is_type (void *thing) { return 0; } + +bool equal_type(type *typ1, type *typ2) { + entity **m; + type **t; + int i, j; + + if (typ1 == typ2) return true; + + if ((get_type_tpop_code(typ1) != get_type_tpop_code(typ2)) || + (get_type_name(typ1) != get_type_name(typ2)) || + (get_type_mode(typ1) != get_type_mode(typ2)) || + (get_type_state(typ1) != get_type_state(typ2))) + return false; + if ((get_type_state(typ1) == layout_fixed) && + (get_type_size(typ1) != get_type_size(typ2))) + return false; + + switch(get_type_tpop_code(typ1)) { + case tpo_class: { + if (get_class_n_members(typ1) != get_class_n_members(typ2)) return false; + if (get_class_n_subtypes(typ1) != get_class_n_subtypes(typ2)) return false; + if (get_class_n_supertypes(typ1) != get_class_n_supertypes(typ2)) return false; + if (get_class_peculiarity(typ1) != get_class_peculiarity(typ2)) return false; + /** Compare the members **/ + m = alloca(sizeof(entity *) * get_class_n_members(typ1)); + memset(m, 0, sizeof(entity *) * get_class_n_members(typ1)); + /* First sort the members of typ2 */ + for (i = 0; i < get_class_n_members(typ1); i++) { + entity *e1 = get_class_member(typ1, i); + for (j = 0; j < get_class_n_members(typ2); j++) { + entity *e2 = get_class_member(typ2, j); + if (get_entity_name(e1) == get_entity_name(e2)) + m[i] = e2; + } + } + for (i = 0; i < get_class_n_members(typ1); i++) { + if (!m[i] || /* Found no counterpart */ + !equal_entity(get_class_member(typ1, i), m[i])) + return false; + } + /** Compare the supertypes **/ + t = alloca(sizeof(entity *) * get_class_n_supertypes(typ1)); + memset(t, 0, sizeof(entity *) * get_class_n_supertypes(typ1)); + /* First sort the supertypes of typ2 */ + for (i = 0; i < get_class_n_supertypes(typ1); i++) { + type *t1 = get_class_supertype(typ1, i); + for (j = 0; j < get_class_n_supertypes(typ2); j++) { + type *t2 = get_class_supertype(typ2, j); + if (get_type_name(t2) == get_type_name(t1)) + t[i] = t2; + } + } + for (i = 0; i < get_class_n_supertypes(typ1); i++) { + if (!t[i] || /* Found no counterpart */ + get_class_supertype(typ1, i) != t[i]) + return false; + } + } break; + case tpo_struct: { + if (get_struct_n_members(typ1) != get_struct_n_members(typ2)) return false; + m = alloca(sizeof(entity *) * get_struct_n_members(typ1)); + memset(m, 0, sizeof(entity *) * get_struct_n_members(typ1)); + /* First sort the members of lt */ + for (i = 0; i < get_struct_n_members(typ1); i++) { + entity *e1 = get_struct_member(typ1, i); + for (j = 0; j < get_struct_n_members(typ2); j++) { + entity *e2 = get_struct_member(typ2, j); + if (get_entity_name(e1) == get_entity_name(e2)) + m[i] = e2; + } + } + for (i = 0; i < get_struct_n_members(typ1); i++) { + if (!m[i] || /* Found no counterpart */ + !equal_entity(get_struct_member(typ1, i), m[i])) + return false; + } + } break; + case tpo_method: { + if (get_method_variadicity(typ1) != get_method_variadicity(typ2)) return false; + if (get_method_n_params(typ1) != get_method_n_params(typ2)) return false; + if (get_method_n_ress(typ1) != get_method_n_ress(typ2)) return false; + for (i = 0; i < get_method_n_params(typ1); i++) { + if (!equal_type(get_method_param_type(typ1, i), get_method_param_type(typ2, i))) + return false; + } + for (i = 0; i < get_method_n_ress(typ1); i++) { + if (!equal_type(get_method_res_type(typ1, i), get_method_res_type(typ2, i))) + return false; + } + } break; + case tpo_union: { + if (get_union_n_members(typ1) != get_union_n_members(typ2)) return false; + m = alloca(sizeof(entity *) * get_union_n_members(typ1)); + memset(m, 0, sizeof(entity *) * get_union_n_members(typ1)); + /* First sort the members of lt */ + for (i = 0; i < get_union_n_members(typ1); i++) { + entity *e1 = get_union_member(typ1, i); + for (j = 0; j < get_union_n_members(typ2); j++) { + entity *e2 = get_union_member(typ2, j); + if (get_entity_name(e1) == get_entity_name(e2)) + m[i] = e2; + } + } + for (i = 0; i < get_union_n_members(typ1); i++) { + if (!m[i] || /* Found no counterpart */ + !equal_entity(get_union_member(typ1, i), m[i])) + return false; + } + } break; + case tpo_array: { + if (get_array_n_dimensions(typ1) != get_array_n_dimensions(typ2)) + return false; + if (!equal_type(get_array_element_type(typ1), get_array_element_type(typ2))) + return false; + for(i = 0; i < get_array_n_dimensions(typ1); i++) { + if (get_array_lower_bound(typ1, i) != get_array_lower_bound(typ2, i) || + get_array_upper_bound(typ1, i) != get_array_upper_bound(typ2, i)) + return false; + if (get_array_order(typ1, i) != get_array_order(typ2, i)) + assert(0 && "type compare with different dimension orders not implemented"); + } + } break; + case tpo_enumeration: { + assert(0 && "enumerations not implemented"); + } break; + case tpo_pointer: { + if (get_pointer_points_to_type(typ1) != get_pointer_points_to_type(typ2)) + return false; + } break; + case tpo_primitive: { + } break; + default: break; + } + return true; +} + +bool smaller_type (type *st, type *lt) { + entity **m; + int i, j; + + if (st == lt) return true; + + if (get_type_tpop_code(st) != get_type_tpop_code(lt)) + return false; + + switch(get_type_tpop_code(st)) { + case tpo_class: { + return is_subclass_of(st, lt); + } break; + case tpo_struct: { + if (get_struct_n_members(st) != get_struct_n_members(lt)) return false; + m = alloca(sizeof(entity *) * get_struct_n_members(st)); + memset(m, 0, sizeof(entity *) * get_struct_n_members(st)); + /* First sort the members of lt */ + for (i = 0; i < get_struct_n_members(st); i++) { + entity *se = get_struct_member(st, i); + for (j = 0; j < get_struct_n_members(lt); j++) { + entity *le = get_struct_member(lt, j); + if (get_entity_name(le) == get_entity_name(se)) + m[i] = le; + } + } + for (i = 0; i < get_struct_n_members(st); i++) { + if (!m[i] || /* Found no counterpart */ + !smaller_type(get_entity_type(get_struct_member(st, i)), + get_entity_type(m[i]))) + return false; + } + } break; + case tpo_method: { + if (get_method_variadicity(st) != get_method_variadicity(lt)) return false; + if (get_method_n_params(st) != get_method_n_params(lt)) return false; + if (get_method_n_ress(st) != get_method_n_ress(lt)) return false; + for (i = 0; i < get_method_n_params(st); i++) { + if (!smaller_type(get_method_param_type(st, i), get_method_param_type(lt, i))) + return false; + } + for (i = 0; i < get_method_n_ress(st); i++) { + if (!smaller_type(get_method_res_type(st, i), get_method_res_type(lt, i))) + return false; + } + } break; + case tpo_union: { + if (get_union_n_members(st) != get_union_n_members(lt)) return false; + m = alloca(sizeof(entity *) * get_union_n_members(st)); + memset(m, 0, sizeof(entity *) * get_union_n_members(st)); + /* First sort the members of lt */ + for (i = 0; i < get_union_n_members(st); i++) { + entity *se = get_union_member(st, i); + for (j = 0; j < get_union_n_members(lt); j++) { + entity *le = get_union_member(lt, j); + if (get_entity_name(le) == get_entity_name(se)) + m[i] = le; + } + } + for (i = 0; i < get_union_n_members(st); i++) { + if (!m[i] || /* Found no counterpart */ + !smaller_type(get_entity_type(get_union_member(st, i)), + get_entity_type(m[i]))) + return false; + } + } break; + case tpo_array: { + type *set, *let; /* small/large elt. type */ + if (get_array_n_dimensions(st) != get_array_n_dimensions(lt)) + return false; + set = get_array_element_type(st); + let = get_array_element_type(lt); + if (set != let) { + /* If the elt types are different, set must be convertible + to let, and they must have the same size so that address + computations work out. To have a size the layout must + be fixed. */ + if ((get_type_state(set) != layout_fixed) || + (get_type_state(let) != layout_fixed)) + return false; + if (!smaller_type(set, let) || + get_type_size(set) != get_type_size(let)) + return false; + } + for(i = 0; i < get_array_n_dimensions(st); i++) { + if (get_array_lower_bound(lt, i)) + if(get_array_lower_bound(st, i) != get_array_lower_bound(lt, i)) + return false; + if (get_array_upper_bound(lt, i)) + if(get_array_upper_bound(st, i) != get_array_upper_bound(lt, i)) + return false; + } + } break; + case tpo_enumeration: { + assert(0 && "enumerations not implemented"); + } break; + case tpo_pointer: { + if (!smaller_type(get_pointer_points_to_type(st), + get_pointer_points_to_type(lt))) + return false; + } break; + case tpo_primitive: { + if (!smaller_mode(get_type_mode(st), get_type_mode(lt))) + return false; + } break; + default: break; + } + return true; +} + /*******************************************************************/ /** TYPE_CLASS **/ /*******************************************************************/ /* create a new class type */ -type *new_type_class (ident *name) { +INLINE type *new_type_class (ident *name) { type *res; res = new_type(type_class, NULL, name); @@ -211,72 +527,103 @@ type *new_type_class (ident *name) { res->attr.ca.members = NEW_ARR_F (entity *, 1); res->attr.ca.subtypes = NEW_ARR_F (type *, 1); res->attr.ca.supertypes = NEW_ARR_F (type *, 1); + res->attr.ca.peculiarity = existent; + res->attr.ca.dfn = 0; return res; } -inline void free_class_attrs(type *clss) { +type *new_d_type_class (ident *name, dbg_info* db) { + type *res = new_type_class (name); + set_type_dbg_info(res, db); + return res; +} +INLINE void free_class_attrs(type *clss) { assert(clss && (clss->type_op == type_class)); DEL_ARR_F(clss->attr.ca.members); DEL_ARR_F(clss->attr.ca.subtypes); DEL_ARR_F(clss->attr.ca.supertypes); } + /* manipulate private fields of class type */ void add_class_member (type *clss, entity *member) { assert(clss && (clss->type_op == type_class)); ARR_APP1 (entity *, clss->attr.ca.members, member); } -int get_class_n_member (type *clss) { +int get_class_n_members (type *clss) { assert(clss && (clss->type_op == type_class)); return (ARR_LEN (clss->attr.ca.members))-1; } +int get_class_member_index(type *clss, entity *mem) { + int i; + assert(clss && (clss->type_op == type_class)); + for (i = 0; i < get_class_n_members(clss); i++) + if (get_class_member(clss, i) == mem) + return i; + return -1; +} entity *get_class_member (type *clss, int pos) { assert(clss && (clss->type_op == type_class)); + assert(pos >= 0 && pos < get_class_n_members(clss)); return clss->attr.ca.members[pos+1]; } void set_class_member (type *clss, entity *member, int pos) { assert(clss && (clss->type_op == type_class)); + assert(pos >= 0 && pos < get_class_n_members(clss)); clss->attr.ca.members[pos+1] = member; } +void set_class_members (type *clss, entity **members, int arity) { + int i; + assert(clss && (clss->type_op == type_class)); + DEL_ARR_F(clss->attr.ca.members); + clss->attr.ca.members = NEW_ARR_F (entity *, 1); + for (i = 0; i < arity; i++) { + set_entity_owner(members[i], clss); + ARR_APP1 (entity *, clss->attr.ca.members, members[i]); + } +} void remove_class_member(type *clss, entity *member) { int i; assert(clss && (clss->type_op == type_class)); - for (i = 1; i < (ARR_LEN (clss->attr.ca.members))-1; i++) - if (clss->attr.ca.members[i+1] == member) { - for(i++; i < (ARR_LEN (clss->attr.ca.members)) - 1; i++) + for (i = 1; i < (ARR_LEN (clss->attr.ca.members)); i++) { + if (clss->attr.ca.members[i] == member) { + for(; i < (ARR_LEN (clss->attr.ca.members)) - 1; i++) clss->attr.ca.members[i] = clss->attr.ca.members[i + 1]; ARR_SETLEN(entity*, clss->attr.ca.members, ARR_LEN(clss->attr.ca.members) - 1); break; } + } } void add_class_subtype (type *clss, type *subtype) { int i; assert(clss && (clss->type_op == type_class)); ARR_APP1 (type *, clss->attr.ca.subtypes, subtype); - for (i = 0; i < get_class_n_supertype(subtype); i++) + for (i = 0; i < get_class_n_supertypes(subtype); i++) if (get_class_supertype(subtype, i) == clss) /* Class already registered */ return; ARR_APP1 (type *, subtype->attr.ca.supertypes, clss); } -int get_class_n_subtype (type *clss) { +int get_class_n_subtypes (type *clss) { assert(clss && (clss->type_op == type_class)); return (ARR_LEN (clss->attr.ca.subtypes))-1; } type *get_class_subtype (type *clss, int pos) { assert(clss && (clss->type_op == type_class)); + assert(pos >= 0 && pos < get_class_n_subtypes(clss)); return clss->attr.ca.subtypes[pos+1] = skip_tid(clss->attr.ca.subtypes[pos+1]); } void set_class_subtype (type *clss, type *subtype, int pos) { assert(clss && (clss->type_op == type_class)); + assert(pos >= 0 && pos < get_class_n_subtypes(clss)); clss->attr.ca.subtypes[pos+1] = subtype; } void remove_class_subtype(type *clss, type *subtype) { int i; assert(clss && (clss->type_op == type_class)); - for (i = 1; i < (ARR_LEN (clss->attr.ca.subtypes))-1; i++) - if (clss->attr.ca.subtypes[i+1] == subtype) { - for(i++; i < (ARR_LEN (clss->attr.ca.subtypes))-1; i++) + for (i = 1; i < (ARR_LEN (clss->attr.ca.subtypes)); i++) + if (clss->attr.ca.subtypes[i] == subtype) { + for(; i < (ARR_LEN (clss->attr.ca.subtypes))-1; i++) clss->attr.ca.subtypes[i] = clss->attr.ca.subtypes[i+1]; ARR_SETLEN(entity*, clss->attr.ca.subtypes, ARR_LEN(clss->attr.ca.subtypes) - 1); break; @@ -288,84 +635,142 @@ void add_class_supertype (type *clss, type *supertype) { assert(clss && (clss->type_op == type_class)); assert(supertype && (supertype -> type_op == type_class)); ARR_APP1 (type *, clss->attr.ca.supertypes, supertype); - for (i = 0; i < get_class_n_subtype(supertype); i++) + for (i = 0; i < get_class_n_subtypes(supertype); i++) if (get_class_subtype(supertype, i) == clss) /* Class already registered */ return; ARR_APP1 (type *, supertype->attr.ca.subtypes, clss); } -int get_class_n_supertype (type *clss) { +int get_class_n_supertypes (type *clss) { assert(clss && (clss->type_op == type_class)); return (ARR_LEN (clss->attr.ca.supertypes))-1; } +int get_class_supertype_index(type *clss, type *super_clss) { + int i; + assert(clss && (clss->type_op == type_class)); + assert(super_clss && (super_clss->type_op == type_class)); + for (i = 0; i < get_class_n_supertypes(clss); i++) + if (get_class_supertype(clss, i) == super_clss) + return i; + return -1; +} type *get_class_supertype (type *clss, int pos) { assert(clss && (clss->type_op == type_class)); + assert(pos >= 0 && pos < get_class_n_supertypes(clss)); return clss->attr.ca.supertypes[pos+1] = skip_tid(clss->attr.ca.supertypes[pos+1]); } void set_class_supertype (type *clss, type *supertype, int pos) { assert(clss && (clss->type_op == type_class)); + assert(pos >= 0 && pos < get_class_n_supertypes(clss)); clss->attr.ca.supertypes[pos+1] = supertype; } void remove_class_supertype(type *clss, type *supertype) { int i; assert(clss && (clss->type_op == type_class)); - for (i = 1; i < (ARR_LEN (clss->attr.ca.supertypes))-1; i++) - if (clss->attr.ca.supertypes[i+1] == supertype) { - for(i++; i < (ARR_LEN (clss->attr.ca.supertypes))-1; i++) + for (i = 1; i < (ARR_LEN (clss->attr.ca.supertypes)); i++) + if (clss->attr.ca.supertypes[i] == supertype) { + for(; i < (ARR_LEN (clss->attr.ca.supertypes))-1; i++) clss->attr.ca.supertypes[i] = clss->attr.ca.supertypes[i+1]; ARR_SETLEN(entity*, clss->attr.ca.supertypes, ARR_LEN(clss->attr.ca.supertypes) - 1); break; } } + +INLINE peculiarity get_class_peculiarity (type *clss) { + assert(clss && (clss->type_op == type_class)); + return clss->attr.ca.peculiarity; +} +INLINE void set_class_peculiarity (type *clss, peculiarity pec) { + assert(clss && (clss->type_op == type_class)); + assert(pec != inherited); /* There is no inheritance of types in libFirm. */ + clss->attr.ca.peculiarity = pec; +} + +void set_class_dfn (type *clss, int dfn) +{ + clss->attr.ca.dfn = dfn; +} + +int get_class_dfn (type *clss) +{ + return (clss->attr.ca.dfn); +} + /* typecheck */ bool is_class_type(type *clss) { assert(clss); if (clss->type_op == type_class) return 1; else return 0; } +bool is_subclass_of(type *low, type *high) { + int i; + assert(is_class_type(low) && is_class_type(high)); + if (low == high) return true; + /* depth first search from high downwards. */ + for (i = 0; i < get_class_n_subtypes(high); i++) { + if (low == get_class_subtype(high, i)) + return true; + if (is_subclass_of(low, get_class_subtype(high, i))) + return true; + } + return false; +} + /*******************************************************************/ /** TYPE_STRUCT **/ /*******************************************************************/ /* create a new type struct */ -type *new_type_struct (ident *name) { +INLINE type *new_type_struct (ident *name) { type *res; res = new_type(type_struct, NULL, name); res->attr.sa.members = NEW_ARR_F (entity *, 1); return res; } -inline void free_struct_attrs (type *strct) { +type *new_d_type_struct (ident *name, dbg_info* db) { + type *res = new_type_struct (name); + set_type_dbg_info(res, db); + return res; +} +INLINE void free_struct_attrs (type *strct) { assert(strct && (strct->type_op == type_struct)); DEL_ARR_F(strct->attr.sa.members); } + /* manipulate private fields of struct */ -void add_struct_member (type *strct, entity *member) { +int get_struct_n_members (type *strct) { assert(strct && (strct->type_op == type_struct)); - ARR_APP1 (entity *, strct->attr.sa.members, member); + return (ARR_LEN (strct->attr.sa.members))-1; } -int get_struct_n_member (type *strct) { +void add_struct_member (type *strct, entity *member) { assert(strct && (strct->type_op == type_struct)); - return (ARR_LEN (strct->attr.sa.members))-1; + assert(get_type_tpop(get_entity_type(member)) != type_method); + /* @@@ lowerfirm geht nicht durch */ + ARR_APP1 (entity *, strct->attr.sa.members, member); } entity *get_struct_member (type *strct, int pos) { assert(strct && (strct->type_op == type_struct)); + assert(pos >= 0 && pos < get_struct_n_members(strct)); return strct->attr.sa.members[pos+1]; } void set_struct_member (type *strct, int pos, entity *member) { assert(strct && (strct->type_op == type_struct)); + assert(pos >= 0 && pos < get_struct_n_members(strct)); + assert(get_entity_type(member)->type_op != type_method);/* @@@ lowerfirm !!*/ strct->attr.sa.members[pos+1] = member; } void remove_struct_member(type *strct, entity *member) { int i; assert(strct && (strct->type_op == type_struct)); - for (i = 1; i < (ARR_LEN (strct->attr.sa.members))-1; i++) - if (strct->attr.sa.members[i+1] == member) { - for(i++; i < (ARR_LEN (strct->attr.sa.members))-1; i++) + for (i = 1; i < (ARR_LEN (strct->attr.sa.members)); i++) + if (strct->attr.sa.members[i] == member) { + for(; i < (ARR_LEN (strct->attr.sa.members))-1; i++) strct->attr.sa.members[i] = strct->attr.sa.members[i+1]; ARR_SETLEN(entity*, strct->attr.sa.members, ARR_LEN(strct->attr.sa.members) - 1); break; } } + /* typecheck */ bool is_struct_type(type *strct) { assert(strct); @@ -378,16 +783,24 @@ bool is_struct_type(type *strct) { /* Create a new method type. N_param is the number of parameters, n_res the number of results. */ -type *new_type_method (ident *name, int n_param, int n_res) { +INLINE type *new_type_method (ident *name, int n_param, int n_res) { type *res; - res = new_type(type_method, NULL, name); + res = new_type(type_method, mode_P, name); + res->state = layout_fixed; + res->size = get_mode_size(mode_P); res->attr.ma.n_params = n_param; res->attr.ma.param_type = (type **) xmalloc (sizeof (type *) * n_param); res->attr.ma.n_res = n_res; res->attr.ma.res_type = (type **) xmalloc (sizeof (type *) * n_res); + res->attr.ma.variadicity = non_variadic; + return res; +} +type *new_d_type_method (ident *name, int n_param, int n_res, dbg_info* db) { + type *res = new_type_method (name, n_param, n_res); + set_type_dbg_info(res, db); return res; } -inline void free_method_attrs(type *method) { +INLINE void free_method_attrs(type *method) { assert(method && (method->type_op == type_method)); free(method->attr.ma.param_type); free(method->attr.ma.res_type); @@ -399,24 +812,40 @@ int get_method_n_params (type *method) { } type *get_method_param_type(type *method, int pos) { assert(method && (method->type_op == type_method)); + assert(pos >= 0 && pos < get_method_n_params(method)); return method->attr.ma.param_type[pos] = skip_tid(method->attr.ma.param_type[pos]); } -void set_method_param_type(type *method, int pos, type* type) { +void set_method_param_type(type *method, int pos, type* tp) { assert(method && (method->type_op == type_method)); - method->attr.ma.param_type[pos] = type; + assert(pos >= 0 && pos < get_method_n_params(method)); + method->attr.ma.param_type[pos] = tp; } -int get_method_n_res (type *method) { +int get_method_n_ress (type *method) { assert(method && (method->type_op == type_method)); return method->attr.ma.n_res; } type *get_method_res_type(type *method, int pos) { assert(method && (method->type_op == type_method)); + assert(pos >= 0 && pos < get_method_n_ress(method)); return method->attr.ma.res_type[pos] = skip_tid(method->attr.ma.res_type[pos]); } -void set_method_res_type(type *method, int pos, type* type) { +void set_method_res_type(type *method, int pos, type* tp) { assert(method && (method->type_op == type_method)); - method->attr.ma.res_type[pos] = type; + assert(pos >= 0 && pos < get_method_n_ress(method)); + method->attr.ma.res_type[pos] = tp; +} + +variadicity get_method_variadicity(type *method) +{ + assert(method && (method->type_op == type_method)); + return method->attr.ma.variadicity; +} + +void set_method_variadicity(type *method, variadicity vari) +{ + assert(method && (method->type_op == type_method)); + method->attr.ma.variadicity = vari; } /* typecheck */ @@ -424,14 +853,13 @@ bool is_method_type (type *method) { assert(method); if (method->type_op == type_method) return 1; else return 0; } -/*****/ /*******************************************************************/ /** TYPE_UNION **/ /*******************************************************************/ /* create a new type uni */ -type *new_type_uni (ident *name) { +INLINE type *new_type_union (ident *name) { type *res; res = new_type(type_union, NULL, name); /*res->attr.ua.unioned_type = (type **) xmalloc (sizeof (type *) * n_types); @@ -439,11 +867,16 @@ type *new_type_uni (ident *name) { res->attr.ua.members = NEW_ARR_F (entity *, 1); return res; } -inline void free_union_attrs (type *uni) { +type *new_d_type_union (ident *name, dbg_info* db) { + type *res = new_type_union (name); + set_type_dbg_info(res, db); + return res; +} +INLINE void free_union_attrs (type *uni) { assert(uni && (uni->type_op == type_union)); DEL_ARR_F(uni->attr.ua.members); } -/* manipulate private fields of struct */ +/* manipulate private fields of union */ #if 0 int get_union_n_types (type *uni) { assert(uni && (uni->type_op == type_union)); @@ -451,22 +884,27 @@ int get_union_n_types (type *uni) { } type *get_union_unioned_type (type *uni, int pos) { assert(uni && (uni->type_op == type_union)); + assert(pos >= 0 && pos < get_union_n_types(uni)); return uni->attr.ua.unioned_type[pos] = skip_tid(uni->attr.ua.unioned_type[pos]); } -void set_union_unioned_type (type *uni, int pos, type *type) { +void set_union_unioned_type (type *uni, int pos, type *tp) { assert(uni && (uni->type_op == type_union)); - uni->attr.ua.unioned_type[pos] = type; + assert(pos >= 0 && pos < get_union_n_types(uni)); + uni->attr.ua.unioned_type[pos] = tp; } ident *get_union_delim_nameid (type *uni, int pos) { assert(uni && (uni->type_op == type_union)); + assert(pos >= 0 && pos < get_union_n_types(uni)); return uni->attr.ua.delim_names[pos]; } const char *get_union_delim_name (type *uni, int pos) { assert(uni && (uni->type_op == type_union)); + assert(pos >= 0 && pos < get_union_n_types(uni)); return id_to_str(uni->attr.ua.delim_names[pos]); } void set_union_delim_nameid (type *uni, int pos, ident *id) { assert(uni && (uni->type_op == type_union)); + assert(pos >= 0 && pos < get_union_n_types(uni)); uni->attr.ua.delim_names[pos] = id; } #endif @@ -480,18 +918,20 @@ void add_union_member (type *uni, entity *member) { } entity *get_union_member (type *uni, int pos) { assert(uni && (uni->type_op == type_union)); + assert(pos >= 0 && pos < get_union_n_members(uni)); return uni->attr.ua.members[pos+1]; } void set_union_member (type *uni, int pos, entity *member) { assert(uni && (uni->type_op == type_union)); + assert(pos >= 0 && pos < get_union_n_members(uni)); uni->attr.ua.members[pos+1] = member; } void remove_union_member(type *uni, entity *member) { int i; assert(uni && (uni->type_op == type_union)); - for (i = 1; i < (ARR_LEN (uni->attr.ua.members))-1; i++) - if (uni->attr.ua.members[i+1] == member) { - for(i++; i < (ARR_LEN (uni->attr.ua.members))-1; i++) + for (i = 1; i < (ARR_LEN (uni->attr.ua.members)); i++) + if (uni->attr.ua.members[i] == member) { + for(; i < (ARR_LEN (uni->attr.ua.members))-1; i++) uni->attr.ua.members[i] = uni->attr.ua.members[i+1]; ARR_SETLEN(entity*, uni->attr.ua.members, ARR_LEN(uni->attr.ua.members) - 1); break; @@ -510,18 +950,34 @@ bool is_union_type (type *uni) { /* create a new type array -- set dimension sizes independently */ -type *new_type_array (ident *name, int n_dimensions, +INLINE type *new_type_array (ident *name, int n_dimensions, type *element_type) { type *res; + int i; + assert(!is_method_type(element_type)); res = new_type(type_array, NULL, name); res->attr.aa.n_dimensions = n_dimensions; res->attr.aa.lower_bound = (ir_node **) xmalloc (sizeof (ir_node *) * n_dimensions); res->attr.aa.upper_bound = (ir_node **) xmalloc (sizeof (ir_node *) * n_dimensions); + res->attr.aa.order = (int *) xmalloc (sizeof (int) * n_dimensions); + + for (i = 0; i < n_dimensions; i++) { + res->attr.aa.lower_bound[i] = NULL; + res->attr.aa.upper_bound[i] = NULL; + res->attr.aa.order[i] = i; + } res->attr.aa.element_type = element_type; - new_entity(res, mangle(name, id_from_str("elem_ent", 8)), element_type); + new_entity(res, mangle_u(name, id_from_str("elem_ent", 8)), element_type); + return res; +} +type *new_d_type_array (ident *name, int n_dimensions, + type *element_type, dbg_info* db) { + type *res = new_type_array (name, n_dimensions, element_type); + set_type_dbg_info(res, db); return res; } -inline void free_array_attrs (type *array) { + +INLINE void free_array_attrs (type *array) { assert(array && (array->type_op == type_array)); free(array->attr.aa.lower_bound); free(array->attr.aa.upper_bound); @@ -532,33 +988,48 @@ int get_array_n_dimensions (type *array) { assert(array && (array->type_op == type_array)); return array->attr.aa.n_dimensions; } -void set_array_bounds_int (type *array, int dimension, int lower_bound, - int upper_bound) { - ir_graph *rem; - assert(array && (array->type_op == type_array)); - rem = current_ir_graph; - current_ir_graph = get_const_code_irg(); - array->attr.aa.lower_bound[dimension] = - new_Const(mode_I, tarval_from_long (mode_I, lower_bound)); - array->attr.aa.upper_bound[dimension] = - new_Const(mode_I, tarval_from_long (mode_I, upper_bound)); - current_ir_graph = rem; -} -void set_array_bounds (type *array, int dimension, ir_node * lower_bound, - ir_node * upper_bound) { +INLINE void +set_array_bounds (type *array, int dimension, ir_node * lower_bound, + ir_node * upper_bound) { assert(array && (array->type_op == type_array)); array->attr.aa.lower_bound[dimension] = lower_bound; array->attr.aa.upper_bound[dimension] = upper_bound; } -void set_array_lower_bound (type *array, int dimension, ir_node * lower_bound) { +void +set_array_bounds_int (type *array, int dimension, int lower_bound, + int upper_bound) { + ir_graph *rem = current_ir_graph; + current_ir_graph = get_const_code_irg(); + set_array_bounds (array, dimension, + new_Const(mode_Iu, tarval_from_long (mode_Iu, lower_bound)), + new_Const(mode_Iu, tarval_from_long (mode_Iu, upper_bound))); + current_ir_graph = rem; +} +INLINE void +set_array_lower_bound (type *array, int dimension, ir_node * lower_bound) { assert(array && (array->type_op == type_array)); array->attr.aa.lower_bound[dimension] = lower_bound; } -void set_array_upper_bound (type *array, int dimension, ir_node * upper_bound) { +void set_array_lower_bound_int (type *array, int dimension, int lower_bound) { + ir_graph *rem = current_ir_graph; + current_ir_graph = get_const_code_irg(); + set_array_lower_bound (array, dimension, + new_Const(mode_Iu, tarval_from_long (mode_Iu, lower_bound))); + current_ir_graph = rem; +} +INLINE void +set_array_upper_bound (type *array, int dimension, ir_node * upper_bound) { assert(array && (array->type_op == type_array)); array->attr.aa.upper_bound[dimension] = upper_bound; } +void set_array_upper_bound_int (type *array, int dimension, int upper_bound) { + ir_graph *rem = current_ir_graph; + current_ir_graph = get_const_code_irg(); + set_array_upper_bound (array, dimension, + new_Const(mode_Iu, tarval_from_long (mode_Iu, upper_bound))); + current_ir_graph = rem; +} ir_node * get_array_lower_bound (type *array, int dimension) { assert(array && (array->type_op == type_array)); return array->attr.aa.lower_bound[dimension]; @@ -567,17 +1038,31 @@ ir_node * get_array_upper_bound (type *array, int dimension) { assert(array && (array->type_op == type_array)); return array->attr.aa.upper_bound[dimension]; } -void set_array_element_type (type *array, type *type) { + +void set_array_order (type *array, int dimension, int order) { + assert(array && (array->type_op == type_array)); + array->attr.aa.order[dimension] = order; +} +int get_array_order (type *array, int dimension) { assert(array && (array->type_op == type_array)); - array->attr.aa.element_type = type; + return array->attr.aa.order[dimension]; +} + +void set_array_element_type (type *array, type *tp) { + assert(array && (array->type_op == type_array)); + assert(!is_method_type(tp)); + array->attr.aa.element_type = tp; } type *get_array_element_type (type *array) { assert(array && (array->type_op == type_array)); return array->attr.aa.element_type = skip_tid(array->attr.aa.element_type); } + void set_array_element_entity (type *array, entity *ent) { assert(array && (array->type_op == type_array)); + assert((get_entity_type(ent)->type_op != type_method)); array->attr.aa.element_ent = ent; + array->attr.aa.element_type = get_entity_type(ent); } entity *get_array_element_entity (type *array) { assert(array && (array->type_op == type_array)); @@ -595,15 +1080,26 @@ bool is_array_type (type *array) { /*******************************************************************/ /* create a new type enumeration -- set the enumerators independently */ -type *new_type_enumeration (ident *name, int n_enums) { +INLINE type *new_type_enumeration (ident *name, int n_enums) { type *res; + int i; res = new_type(type_enumeration, NULL, name); res->attr.ea.n_enums = n_enums; res->attr.ea.enumer = (tarval **) xmalloc (sizeof (tarval *) * n_enums); res->attr.ea.enum_nameid = (ident **) xmalloc (sizeof (ident *) * n_enums); + for (i = 0; i < n_enums; i++) { + res->attr.ea.enumer[i] = NULL; + res->attr.ea.enum_nameid = NULL; + } + return res; +} +type *new_d_type_enumeration (ident *name, int n_enums, dbg_info* db) { + type *res = new_type_enumeration (name, n_enums); + set_type_dbg_info(res, db); return res; } -inline void free_enumeration_attrs(type *enumeration) { + +INLINE void free_enumeration_attrs(type *enumeration) { assert(enumeration && (enumeration->type_op == type_enumeration)); free(enumeration->attr.ea.enumer); free(enumeration->attr.ea.enum_nameid); @@ -616,22 +1112,27 @@ int get_enumeration_n_enums (type *enumeration) { } void set_enumeration_enum (type *enumeration, int pos, tarval *con) { assert(enumeration && (enumeration->type_op == type_enumeration)); + assert(pos >= 0 && pos < get_enumeration_n_enums(enumeration)); enumeration->attr.ea.enumer[pos] = con; } tarval *get_enumeration_enum (type *enumeration, int pos) { assert(enumeration && (enumeration->type_op == type_enumeration)); + assert(pos >= 0 && pos < get_enumeration_n_enums(enumeration)); return enumeration->attr.ea.enumer[pos]; } void set_enumeration_nameid (type *enumeration, int pos, ident *id) { assert(enumeration && (enumeration->type_op == type_enumeration)); + assert(pos >= 0 && pos < get_enumeration_n_enums(enumeration)); enumeration->attr.ea.enum_nameid[pos] = id; } ident *get_enumeration_nameid (type *enumeration, int pos) { assert(enumeration && (enumeration->type_op == type_enumeration)); + assert(pos >= 0 && pos < get_enumeration_n_enums(enumeration)); return enumeration->attr.ea.enum_nameid[pos]; } const char *get_enumeration_name(type *enumeration, int pos) { assert(enumeration && (enumeration->type_op == type_enumeration)); + assert(pos >= 0 && pos < get_enumeration_n_enums(enumeration)); return id_to_str(enumeration->attr.ea.enum_nameid[pos]); } @@ -646,21 +1147,26 @@ bool is_enumeration_type (type *enumeration) { /*******************************************************************/ /* Create a new type pointer */ -type *new_type_pointer (ident *name, type *points_to) { +INLINE type *new_type_pointer (ident *name, type *points_to) { type *res; - res = new_type(type_pointer, mode_p, name); + res = new_type(type_pointer, mode_P, name); res->attr.pa.points_to = points_to; res->size = get_mode_size(res->mode); res->state = layout_fixed; return res; } -inline void free_pointer_attrs (type *pointer) { +type *new_d_type_pointer (ident *name, type *points_to, dbg_info* db) { + type *res = new_type_pointer (name, points_to); + set_type_dbg_info(res, db); + return res; +} +INLINE void free_pointer_attrs (type *pointer) { assert(pointer && (pointer->type_op == type_pointer)); } /* 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) { assert(pointer && (pointer->type_op == type_pointer)); - pointer->attr.pa.points_to = type; + pointer->attr.pa.points_to = tp; } type *get_pointer_points_to_type (type *pointer) { assert(pointer && (pointer->type_op == type_pointer)); @@ -679,28 +1185,41 @@ bool is_pointer_type (type *pointer) { /*******************************************************************/ /* create a new type primitive */ -type *new_type_primitive (ident *name, ir_mode *mode) { +INLINE type *new_type_primitive (ident *name, ir_mode *mode) { type *res; + /* @@@ assert( mode_is_data(mode) && (!mode == mode_P)); */ res = new_type(type_primitive, mode, name); res->size = get_mode_size(mode); res->state = layout_fixed; return res; } -inline void free_primitive_attrs (type *primitive) { +type *new_d_type_primitive (ident *name, ir_mode *mode, dbg_info* db) { + type *res = new_type_primitive (name, mode); + set_type_dbg_info(res, db); + return res; +} +INLINE void free_primitive_attrs (type *primitive) { assert(primitive && (primitive->type_op == type_primitive)); } /* typecheck */ bool is_primitive_type (type *primitive) { - assert(primitive); + assert(primitive && primitive->kind == k_type); if (primitive->type_op == type_primitive) return 1; else return 0; } -int is_atomic_type(type *tp) { +/*******************************************************************/ +/** common functionality **/ +/*******************************************************************/ + + +INLINE int is_atomic_type(type *tp) { + assert(tp && tp->kind == k_type); return (is_primitive_type(tp) || is_pointer_type(tp) || is_enumeration_type(tp)); } -int is_compound_type(type *tp) { +INLINE int is_compound_type(type *tp) { + assert(tp && tp->kind == k_type); return (is_class_type(tp) || is_struct_type(tp) || is_array_type(tp) || is_union_type(tp)); }