X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Ftype.c;h=9aaab6ad630e7e213c3a69872c923fa5d3480cfb;hb=55a613a794cc2fadd5508dcf721c342d70f342cc;hp=8afb859262cdc56e1852bf2137fd7118bdaf2a32;hpb=167eae6f6c027f7194dee8eaee1c8b394eed0b47;p=libfirm diff --git a/ir/tr/type.c b/ir/tr/type.c index 8afb85926..9aaab6ad6 100644 --- a/ir/tr/type.c +++ b/ir/tr/type.c @@ -33,6 +33,7 @@ # include # include +# include # include "type_t.h" # include "tpop_t.h" # include "typegmod_t.h" @@ -47,11 +48,20 @@ /*******************************************************************/ 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++; } -void -free_type(type *tp) { - /* @@@ not implemented */ +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 * @@ -255,12 +265,257 @@ 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_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: { + type *set, *let; /* small/large elt. type */ + 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_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); @@ -273,6 +528,11 @@ type *new_type_class (ident *name) { return res; } +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); @@ -312,13 +572,14 @@ void set_class_members (type *clss, entity **members, int arity) { 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) { @@ -348,9 +609,9 @@ void set_class_subtype (type *clss, type *subtype, int pos) { 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; @@ -385,9 +646,9 @@ void set_class_supertype (type *clss, type *supertype, int pos) { 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; @@ -420,17 +681,36 @@ bool is_class_type(type *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; } +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); @@ -461,9 +741,9 @@ void set_struct_member (type *strct, int pos, entity *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; @@ -482,17 +762,22 @@ 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, mode_p, name); + res = new_type(type_method, mode_P, name); res->state = layout_fixed; - res->size = get_mode_size(mode_p); + 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); 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) { assert(method && (method->type_op == type_method)); free(method->attr.ma.param_type); @@ -508,10 +793,10 @@ type *get_method_param_type(type *method, int pos) { 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)); assert(pos >= 0 && pos < get_method_n_params(method)); - method->attr.ma.param_type[pos] = type; + method->attr.ma.param_type[pos] = tp; } int get_method_n_ress (type *method) { @@ -523,10 +808,10 @@ type *get_method_res_type(type *method, int pos) { 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)); assert(pos >= 0 && pos < get_method_n_ress(method)); - method->attr.ma.res_type[pos] = type; + method->attr.ma.res_type[pos] = tp; } /* typecheck */ @@ -541,7 +826,7 @@ bool is_method_type (type *method) { /*******************************************************************/ /* 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); @@ -549,6 +834,11 @@ type *new_type_uni (ident *name) { res->attr.ua.members = NEW_ARR_F (entity *, 1); return res; } +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); @@ -564,10 +854,10 @@ type *get_union_unioned_type (type *uni, int pos) { 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)); assert(pos >= 0 && pos < get_union_n_types(uni)); - uni->attr.ua.unioned_type[pos] = type; + uni->attr.ua.unioned_type[pos] = tp; } ident *get_union_delim_nameid (type *uni, int pos) { assert(uni && (uni->type_op == type_union)); @@ -606,9 +896,9 @@ void set_union_member (type *uni, int pos, entity *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; @@ -627,7 +917,7 @@ 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; @@ -647,6 +937,12 @@ type *new_type_array (ident *name, int n_dimensions, 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) { assert(array && (array->type_op == type_array)); @@ -673,8 +969,8 @@ set_array_bounds_int (type *array, int dimension, int lower_bound, ir_graph *rem = current_ir_graph; current_ir_graph = get_const_code_irg(); set_array_bounds (array, dimension, - new_Const(mode_I, tarval_from_long (mode_I, lower_bound)), - new_Const(mode_I, tarval_from_long (mode_I, upper_bound))); + 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 @@ -686,7 +982,7 @@ 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_I, tarval_from_long (mode_I, lower_bound))); + new_Const(mode_Iu, tarval_from_long (mode_Iu, lower_bound))); current_ir_graph = rem; } INLINE void @@ -698,7 +994,7 @@ 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_I, tarval_from_long (mode_I, upper_bound))); + 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) { @@ -719,10 +1015,10 @@ int get_array_order (type *array, int dimension) { return array->attr.aa.order[dimension]; } -void set_array_element_type (type *array, type *type) { +void set_array_element_type (type *array, type *tp) { assert(array && (array->type_op == type_array)); - assert(!is_method_type(type)); - array->attr.aa.element_type = type; + 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)); @@ -751,7 +1047,7 @@ 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); @@ -764,6 +1060,11 @@ type *new_type_enumeration (ident *name, int n_enums) { } 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) { assert(enumeration && (enumeration->type_op == type_enumeration)); @@ -813,21 +1114,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; } +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)); @@ -846,14 +1152,19 @@ 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)); */ + /* @@@ 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; } +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)); }