X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Ftype.c;h=04ce12feb124a35584c45ba6aa6fc5fc5ef6f438;hb=d91fc73ffae404c44bda8152edf08c86a15be1af;hp=7220f709cfd54137c4407631f9419daa145634bc;hpb=20533f792cd13cb8b16cb580de49d448693d3e7e;p=libfirm diff --git a/ir/tr/type.c b/ir/tr/type.c index 7220f709c..04ce12feb 100644 --- a/ir/tr/type.c +++ b/ir/tr/type.c @@ -39,19 +39,20 @@ # include #endif - # include # include # include + # include "type_t.h" -# include "tpop_t.h" + # include "irprog_t.h" +# include "ircons.h" +# include "tpop_t.h" # include "typegmod.h" -# include "array.h" -# include "irprog.h" # include "mangle.h" -# include "tv.h" -# include "ircons.h" +# include "tv_t.h" + +# include "array.h" /*******************************************************************/ /** TYPE **/ @@ -76,19 +77,20 @@ void init_type(void) { /* construct none and unknown type. */ none_type = new_type(tpop_none, mode_BAD, new_id_from_str("type_none")); - set_type_size (none_type, 0); + set_type_size_bits(none_type, 0); set_type_state (none_type, layout_fixed); remove_irp_type(none_type); unknown_type = new_type(tpop_unknown, mode_ANY, new_id_from_str("type_unknown")); - set_type_size (unknown_type, 0); + set_type_size_bits(unknown_type, 0); set_type_state (unknown_type, layout_fixed); remove_irp_type(unknown_type); } unsigned long type_visited; -void set_master_type_visited(unsigned long val) { type_visited = val; } -unsigned long get_master_type_visited() { return type_visited; } -void inc_master_type_visited() { type_visited++; } + +void (set_master_type_visited)(unsigned long val) { __set_master_type_visited(val); } +unsigned long (get_master_type_visited)(void) { return __get_master_type_visited(); } +void (inc_master_type_visited)(void) { __inc_master_type_visited(); } type * @@ -99,20 +101,20 @@ new_type(tp_op *type_op, ir_mode *mode, ident* name) { assert(type_op != type_id); assert(!id_contains_char(name, ' ') && "type name should not contain spaces"); - node_size = offsetof (type, attr) + type_op->attr_size; + node_size = offsetof(type, attr) + type_op->attr_size; res = (type *) xmalloc (node_size); add_irp_type(res); /* Remember the new type global. */ - res->kind = k_type; + res->kind = k_type; res->type_op = type_op; - res->mode = mode; - res->name = name; - res->state = layout_undefined; - res->size = -1; - res->visit = 0; - res -> link = NULL; + res->mode = mode; + res->name = name; + res->state = layout_undefined; + res->size = -1; + res->visit = 0; + res -> link = NULL; #ifdef DEBUG_libfirm - res->nr = get_irp_new_node_nr(); + res->nr = get_irp_new_node_nr(); #endif return res; @@ -162,26 +164,22 @@ void free_type_attrs(type *tp) { } /* set/get the link field */ -void *get_type_link(type *tp) +void *(get_type_link)(type *tp) { - assert(tp && tp->kind == k_type); - return(tp -> link); + return __get_type_link(tp); } -void set_type_link(type *tp, void *l) +void (set_type_link)(type *tp, void *l) { - assert(tp && tp->kind == k_type); - tp -> link = l; + __set_type_link(tp, l); } -tp_op* get_type_tpop(type *tp) { - assert(tp && tp->kind == k_type); - return tp->type_op; +tp_op *(get_type_tpop)(type *tp) { + return __get_type_tpop(tp); } -ident* get_type_tpop_nameid(type *tp) { - assert(tp && tp->kind == k_type); - return tp->type_op->name; +ident *(get_type_tpop_nameid)(type *tp) { + return __get_type_tpop_nameid(tp); } const char* get_type_tpop_name(type *tp) { @@ -189,14 +187,12 @@ const char* get_type_tpop_name(type *tp) { return get_id_str(tp->type_op->name); } -tp_opcode get_type_tpop_code(type *tp) { - assert(tp && tp->kind == k_type); - return tp->type_op->code; +tp_opcode (get_type_tpop_code)(type *tp) { + return __get_type_tpop_code(tp); } -ir_mode* get_type_mode(type *tp) { - assert(tp && tp->kind == k_type); - return tp->mode; +ir_mode *(get_type_mode)(type *tp) { + return __get_type_mode(tp); } void set_type_mode(type *tp, ir_mode* m) { @@ -209,35 +205,43 @@ void set_type_mode(type *tp, ir_mode* m) { ((tp->type_op != type_pointer) || mode_is_reference(m)) ); /* Modes of pointers must be references. */ - if ((tp->type_op == type_primitive) || - (tp->type_op == type_enumeration) || - (tp->type_op == type_pointer) ) { - /* For pointer, primitive and enumeration size depends on the mode. */ - assert((get_mode_size_bytes(m) != -1) && "unorthodox modes not implemented"); - tp->size = get_mode_size_bytes(m); + switch (get_type_tpop_code(tp)) { + case tpo_primitive: + /* For primitive size depends on the mode. */ + tp->size = get_mode_size_bits(m); + tp->mode = m; + break; + case tpo_enumeration: + case tpo_pointer: + /* For pointer and enumeration size depends on the mode, but only byte size allowed. */ + assert((get_mode_size_bits(m) & 7) == 0 && "unorthodox modes not implemented"); + tp->size = get_mode_size_bits(m); + tp->mode = m; + break; + case tpo_struct: + case tpo_class: + /* for classes and structs we allow to set a mode if the layout is fixed AND the size matches */ + assert(get_type_state(tp) == layout_fixed && + tp->size == get_mode_size_bits(m) && + "mode don't match struct/class layout"); tp->mode = m; + break; + default: + assert(0 && "setting a mode is NOT allowed for this type"); } } -ident* get_type_ident(type *tp) { - assert(tp && tp->kind == k_type); - return tp->name; +ident *(get_type_ident)(type *tp) { + return __get_type_ident(tp); } -void set_type_ident(type *tp, ident* id) { - assert(tp && tp->kind == k_type); - tp->name = id; +void (set_type_ident)(type *tp, ident* id) { + __set_type_ident(tp, id); } /* Outputs a unique number for this node */ -long -get_type_nr(type *tp) { - assert(tp); -#ifdef DEBUG_libfirm - return tp->nr; -#else - return (long)tp; -#endif +long (get_type_nr)(type *tp) { + return __get_type_nr(tp); } const char* get_type_name(type *tp) { @@ -245,25 +249,38 @@ const char* get_type_name(type *tp) { return (get_id_str(tp->name)); } -int get_type_size(type *tp) { - assert(tp && tp->kind == k_type); - return tp->size; +int (get_type_size_bytes)(type *tp) { + return __get_type_size_bytes(tp); +} + +int (get_type_size_bits)(type *tp) { + return __get_type_size_bits(tp); } void -set_type_size(type *tp, int size) { +set_type_size_bits(type *tp, int size) { 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; + (tp->type_op != type_enumeration) && (tp->type_op != type_method)) { + if (tp->type_op == type_primitive) + tp->size = size; + else { + /* argh: we must allow to set negative values as "invalid size" */ + tp->size = (size >= 0) ? (size + 7) & ~7 : size; + assert(tp->size == size && "setting a bit size is NOT allowed for this type"); + } + } } -type_state -get_type_state(type *tp) { - assert(tp && tp->kind == k_type); - return tp->state; +void +set_type_size_bytes(type *tp, int size) { + set_type_size_bits(tp, 8*size); +} + +type_state (get_type_state)(type *tp) { + return __get_type_state(tp); } void @@ -280,23 +297,25 @@ set_type_state(type *tp, type_state state) { 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++) { - if (get_entity_offset(get_class_member(tp, i)) <= -1) + assert(get_type_size_bits(tp) > -1); + if (tp != get_glob_type()) { + int n_mem = get_class_n_members(tp); + for (i = 0; i < n_mem; i++) { + if (get_entity_offset_bits(get_class_member(tp, i)) <= -1) { DDMT(tp); DDME(get_class_member(tp, i)); } - assert(get_entity_offset(get_class_member(tp, i)) > -1); + assert(get_entity_offset_bits(get_class_member(tp, i)) > -1); /* TR ?? assert(is_method_type(get_entity_type(get_class_member(tp, i))) || (get_entity_allocation(get_class_member(tp, i)) == allocation_automatic)); */ } + } } break; case tpo_struct: { - assert(get_type_size(tp) > -1); + assert(get_type_size_bits(tp) > -1); for (i = 0; i < get_struct_n_members(tp); i++) { - assert(get_entity_offset(get_struct_member(tp, i)) > -1); + assert(get_entity_offset_bits(get_struct_member(tp, i)) > -1); assert((get_entity_allocation(get_struct_member(tp, i)) == allocation_automatic)); } } break; @@ -320,40 +339,31 @@ set_type_state(type *tp, type_state state) { tp->state = state; } -unsigned long get_type_visited(type *tp) { - assert(tp && tp->kind == k_type); - return tp->visit; +unsigned long (get_type_visited)(type *tp) { + return __get_type_visited(tp); } -void set_type_visited(type *tp, unsigned long num) { - assert(tp && tp->kind == k_type); - tp->visit = num; +void (set_type_visited)(type *tp, unsigned long num) { + __set_type_visited(tp, num); } + /* Sets visited field in type to type_visited. */ -void mark_type_visited(type *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; +void (mark_type_visited)(type *tp) { + __mark_type_visited(tp); } +/* @@@ name clash with master flag +int (type_visited)(type *tp) { + return __type_visited(tp); +}*/ -int is_type (void *thing) { - assert(thing); - if (get_kind(thing) == k_type) - return 1; - else - return 0; +int (type_not_visited)(type *tp) { + return __type_not_visited(tp); } +int (is_type)(void *thing) { + return __is_type(thing); +} bool equal_type(type *typ1, type *typ2) { entity **m; @@ -368,7 +378,7 @@ bool equal_type(type *typ1, type *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))) + (get_type_size_bits(typ1) != get_type_size_bits(typ2))) return false; switch(get_type_tpop_code(typ1)) { @@ -585,7 +595,7 @@ bool smaller_type (type *st, type *lt) { (get_type_state(let) != layout_fixed)) return false; if (!smaller_type(set, let) || - get_type_size(set) != get_type_size(let)) + get_type_size_bits(set) != get_type_size_bits(let)) return false; } for(i = 0; i < get_array_n_dimensions(st); i++) { @@ -624,9 +634,9 @@ type *new_type_class (ident *name) { res = new_type(type_class, NULL, 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.members = NEW_ARR_F (entity *, 0); + res->attr.ca.subtypes = NEW_ARR_F (type *, 0); + res->attr.ca.supertypes = NEW_ARR_F (type *, 0); res->attr.ca.peculiarity = peculiarity_existent; res->attr.ca.dfn = 0; @@ -658,9 +668,8 @@ void add_class_member (type *clss, entity *member) { ARR_APP1 (entity *, clss->attr.ca.members, member); } -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_n_members) (type *clss) { + return __get_class_n_members(clss); } int get_class_member_index(type *clss, entity *mem) { @@ -672,10 +681,8 @@ int get_class_member_index(type *clss, entity *mem) { 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]; +entity *(get_class_member) (type *clss, int pos) { + return __get_class_member(clss, pos); } entity *get_class_member_by_name(type *clss, ident *name) { @@ -692,13 +699,13 @@ entity *get_class_member_by_name(type *clss, ident *name) { 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; + clss->attr.ca.members[pos] = 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); + clss->attr.ca.members = NEW_ARR_F (entity *, 0); for (i = 0; i < arity; i++) { set_entity_owner(members[i], clss); ARR_APP1 (entity *, clss->attr.ca.members, members[i]); @@ -707,7 +714,7 @@ 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)); i++) { + for (i = 0; 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]; @@ -729,22 +736,22 @@ void add_class_subtype (type *clss, type *subtype) { } int get_class_n_subtypes (type *clss) { assert(clss && (clss->type_op == type_class)); - return (ARR_LEN (clss->attr.ca.subtypes))-1; + return (ARR_LEN (clss->attr.ca.subtypes)); } 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]); + return clss->attr.ca.subtypes[pos] = skip_tid(clss->attr.ca.subtypes[pos]); } 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; + clss->attr.ca.subtypes[pos] = 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)); i++) + for (i = 0; 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]; @@ -766,7 +773,7 @@ void add_class_supertype (type *clss, type *supertype) { } int get_class_n_supertypes (type *clss) { assert(clss && (clss->type_op == type_class)); - return (ARR_LEN (clss->attr.ca.supertypes))-1; + return (ARR_LEN (clss->attr.ca.supertypes)); } int get_class_supertype_index(type *clss, type *super_clss) { int i; @@ -780,17 +787,17 @@ int get_class_supertype_index(type *clss, type *super_clss) { 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]); + return clss->attr.ca.supertypes[pos] = skip_tid(clss->attr.ca.supertypes[pos]); } 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; + clss->attr.ca.supertypes[pos] = 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)); i++) + for (i = 0; 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]; @@ -828,9 +835,8 @@ int get_class_dfn (type *clss) } /* typecheck */ -bool is_class_type(type *clss) { - assert(clss); - if (clss->type_op == type_class) return 1; else return 0; +int (is_class_type)(type *clss) { + return __is_class_type(clss); } bool is_subclass_of(type *low, type *high) { @@ -855,7 +861,7 @@ bool is_subclass_of(type *low, type *high) { type *new_type_struct (ident *name) { type *res; res = new_type(type_struct, NULL, name); - res->attr.sa.members = NEW_ARR_F (entity *, 1); + res->attr.sa.members = NEW_ARR_F (entity *, 0); return res; } type *new_d_type_struct (ident *name, dbg_info* db) { @@ -877,7 +883,7 @@ void free_struct_attrs (type *strct) { /* manipulate private fields of struct */ int get_struct_n_members (type *strct) { assert(strct && (strct->type_op == type_struct)); - return (ARR_LEN (strct->attr.sa.members))-1; + return (ARR_LEN (strct->attr.sa.members)); } void add_struct_member (type *strct, entity *member) { @@ -890,7 +896,7 @@ void add_struct_member (type *strct, entity *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]; + return strct->attr.sa.members[pos]; } int get_struct_member_index(type *strct, entity *mem) { @@ -906,12 +912,12 @@ 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; + strct->attr.sa.members[pos] = 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)); i++) + for (i = 0; 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]; @@ -921,9 +927,8 @@ void remove_struct_member(type *strct, entity *member) { } /* typecheck */ -bool is_struct_type(type *strct) { - assert(strct); - if (strct->type_op == type_struct) return 1; else return 0; +int (is_struct_type)(type *strct) { + return __is_struct_type(strct); } /*******************************************************************/ @@ -961,7 +966,7 @@ type *new_type_method (ident *name, int n_param, int n_res) { assert((get_mode_size_bytes(mode_P_mach) != -1) && "unorthodox modes not implemented"); res = new_type(type_method, mode_P_mach, name); res->state = layout_fixed; - res->size = get_mode_size_bytes(mode_P_mach); + res->size = get_mode_size_bits(mode_P_mach); res->attr.ma.n_params = n_param; res->attr.ma.param_type = (type **) xmalloc (sizeof (type *) * n_param); res->attr.ma.value_params = NULL; @@ -1155,9 +1160,8 @@ void set_method_first_variadic_param_index(type *method, int index) } /* typecheck */ -bool is_method_type (type *method) { - assert(method); - return (method->type_op == type_method); +int (is_method_type)(type *method) { + return __is_method_type(method); } /*-----------------------------------------------------------------*/ @@ -1170,7 +1174,7 @@ type *new_type_union (ident *name) { res = new_type(type_union, NULL, name); /*res->attr.ua.unioned_type = (type **) xmalloc (sizeof (type *) * n_types); res->attr.ua.delim_names = (ident **) xmalloc (sizeof (ident *) * n_types); */ - res->attr.ua.members = NEW_ARR_F (entity *, 1); + res->attr.ua.members = NEW_ARR_F (entity *, 0); return res; } type *new_d_type_union (ident *name, dbg_info* db) { @@ -1222,7 +1226,7 @@ void set_union_delim_nameid (type *uni, int pos, ident *id) { #endif int get_union_n_members (type *uni) { assert(uni && (uni->type_op == type_union)); - return (ARR_LEN (uni->attr.ua.members))-1; + return (ARR_LEN (uni->attr.ua.members)); } void add_union_member (type *uni, entity *member) { assert(uni && (uni->type_op == type_union)); @@ -1231,17 +1235,17 @@ 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]; + return uni->attr.ua.members[pos]; } 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; + uni->attr.ua.members[pos] = 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)); i++) + for (i = 0; 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]; @@ -1251,9 +1255,8 @@ void remove_union_member(type *uni, entity *member) { } /* typecheck */ -bool is_union_type (type *uni) { - assert(uni); - if (uni->type_op == type_union) return 1; else return 0; +int (is_union_type)(type *uni) { + return __is_union_type(uni); } /*-----------------------------------------------------------------*/ @@ -1284,10 +1287,11 @@ type *new_type_array (ident *name, int n_dimensions, current_ir_graph = rem; res->attr.aa.element_type = element_type; - new_entity(res, mangle_u(name, id_from_str("elem_ent", 8)), element_type); + new_entity(res, mangle_u(name, new_id_from_chars("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); @@ -1298,6 +1302,7 @@ type *new_d_type_array (ident *name, int n_dimensions, void free_array_entities (type *array) { assert(array && (array->type_op == type_array)); } + void free_array_attrs (type *array) { assert(array && (array->type_op == type_array)); free(array->attr.aa.lower_bound); @@ -1356,14 +1361,21 @@ void set_array_upper_bound_int (type *array, int dimension, int upper_bound) { new_Const(mode_Iu, new_tarval_from_long (upper_bound, mode_Iu))); current_ir_graph = rem; } -int has_array_lower_bound (type *array, int dimension) { +int has_array_lower_bound (type *array, int dimension) { assert(array && (array->type_op == type_array)); return (get_irn_op(array->attr.aa.lower_bound[dimension]) != op_Unknown); } -ir_node * get_array_lower_bound (type *array, int dimension) { +ir_node *get_array_lower_bound (type *array, int dimension) { assert(array && (array->type_op == type_array)); return array->attr.aa.lower_bound[dimension]; } +long get_array_lower_bound_int (type *array, int dimension) { + ir_node *node; + assert(array && (array->type_op == type_array)); + node = array->attr.aa.lower_bound[dimension]; + assert(get_irn_op(node) == op_Const); + return get_tarval_long(get_Const_tarval(node)); +} int has_array_upper_bound (type *array, int dimension) { assert(array && (array->type_op == type_array)); return (get_irn_op(array->attr.aa.upper_bound[dimension]) != op_Unknown); @@ -1372,6 +1384,13 @@ ir_node * get_array_upper_bound (type *array, int dimension) { assert(array && (array->type_op == type_array)); return array->attr.aa.upper_bound[dimension]; } +long get_array_upper_bound_int (type *array, int dimension) { + ir_node *node; + assert(array && (array->type_op == type_array)); + node = array->attr.aa.upper_bound[dimension]; + assert(get_irn_op(node) == op_Const); + return get_tarval_long(get_Const_tarval(node)); +} void set_array_order (type *array, int dimension, int order) { assert(array && (array->type_op == type_array)); @@ -1404,9 +1423,8 @@ entity *get_array_element_entity (type *array) { } /* typecheck */ -bool is_array_type (type *array) { - assert(array); - if (array->type_op == type_array) return 1; else return 0; +int (is_array_type)(type *array) { + return __is_array_type(array); } /*-----------------------------------------------------------------*/ @@ -1471,9 +1489,8 @@ const char *get_enumeration_name(type *enumeration, int pos) { } /* typecheck */ -bool is_enumeration_type (type *enumeration) { - assert(enumeration); - if (enumeration->type_op == type_enumeration) return 1; else return 0; +int (is_enumeration_type)(type *enumeration) { + return __is_enumeration_type(enumeration); } /*-----------------------------------------------------------------*/ @@ -1487,7 +1504,7 @@ type *new_type_pointer_mode (ident *name, type *points_to, ir_mode *ptr_mode) { res = new_type(type_pointer, ptr_mode, name); res->attr.pa.points_to = points_to; assert((get_mode_size_bytes(res->mode) != -1) && "unorthodox modes not implemented"); - res->size = get_mode_size_bytes(res->mode); + res->size = get_mode_size_bits(res->mode); res->state = layout_fixed; return res; } @@ -1513,9 +1530,8 @@ type *get_pointer_points_to_type (type *pointer) { } /* typecheck */ -bool is_pointer_type (type *pointer) { - assert(pointer); - if (pointer->type_op == type_pointer) return 1; else return 0; +int (is_pointer_type)(type *pointer) { + return __is_pointer_type(pointer); } /* Returns the first pointer type that has as points_to tp. @@ -1542,8 +1558,7 @@ type *new_type_primitive (ident *name, ir_mode *mode) { type *res; /* @@@ assert( mode_is_data(mode) && (!mode_is_reference(mode))); */ res = new_type(type_primitive, mode, name); - assert((get_mode_size_bytes(mode) != -1) && "unorthodox modes not implemented"); - res->size = get_mode_size_bytes(mode); + res->size = get_mode_size_bits(mode); res->state = layout_fixed; return res; } @@ -1560,9 +1575,8 @@ void free_primitive_attrs (type *primitive) { } /* typecheck */ -bool is_primitive_type (type *primitive) { - assert(primitive && primitive->kind == k_type); - if (primitive->type_op == type_primitive) return 1; else return 0; +int (is_primitive_type)(type *primitive) { + return __is_primitive_type(primitive); } /*-----------------------------------------------------------------*/ @@ -1570,10 +1584,8 @@ bool is_primitive_type (type *primitive) { /*-----------------------------------------------------------------*/ -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_atomic_type)(type *tp) { + return __is_atomic_type(tp); } /* @@ -1639,8 +1651,8 @@ void dump_type (type *tp) { printf("\n members: "); for (i = 0; i < get_class_n_members(tp); ++i) { entity *mem = get_class_member(tp, i); - printf("\n (%2d) %s:\t %s", - get_entity_offset(mem), get_type_name(get_entity_type(mem)), get_entity_name(mem)); + printf("\n (%3d) %s:\t %s", + get_entity_offset_bits(mem), get_type_name(get_entity_type(mem)), get_entity_name(mem)); } printf("\n supertypes: "); for (i = 0; i < get_class_n_supertypes(tp); ++i) { @@ -1661,8 +1673,8 @@ void dump_type (type *tp) { printf("\n members: "); for (i = 0; i < get_compound_n_members(tp); ++i) { entity *mem = get_compound_member(tp, i); - printf("\n (%2d) %s:\t %s", - get_entity_offset(mem), get_type_name(get_entity_type(mem)), get_entity_name(mem)); + printf("\n (%3d) %s:\t %s", + get_entity_offset_bits(mem), get_type_name(get_entity_type(mem)), get_entity_name(mem)); } break;