X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Ftype.c;h=5588894011c56731c86b5dd0635205ad721749bc;hb=aeccc4a872226c8e08e6241bcd56b846e400c52d;hp=d1d6dc44f7a0acf4d3669c2ca213ea21d92ee201;hpb=3d16844cfe86402baf7e82c87facf630ee336b73;p=libfirm diff --git a/ir/tr/type.c b/ir/tr/type.c index d1d6dc44f..558889401 100644 --- a/ir/tr/type.c +++ b/ir/tr/type.c @@ -1,557 +1,655 @@ -/* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe -** All rights reserved. -** -** Authors: Martin Trapp, Christian Schaefer & -** Goetz Lindenmaier -** -** type.c: datastructures to hold type information. -*/ - -# include "type.h" -# include "irprog.h" /* So that constructors can add the type to global - data structure. */ +/****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 + * view of the intermediate representation there is no difference + * between these types. + * + * There exist several kinds of types, arranged by the structure of + * the type. A type is described by a set of attributes. Some of + * these attributes are common to all types, others depend on the + * kind of the type. + * + * Types are different from the modes defined in irmode: Types are + * on the level of the programming language, modes at the level of + * the target processor. + * + * SEE ALSO + * type_t.h type tpop + ***** + */ +# include +# include +# include "type_t.h" +# include "tpop_t.h" +# include "typegmod_t.h" # include "array.h" -# include "ident_t.h" - -unsigned long type_visited = 0; - -void -init (void) -{ -} /*******************************************************************/ -/** TYPE_CLASS **/ +/** TYPE **/ /*******************************************************************/ -type_class * -new_type_class (ident *name)//, int members) -{ - type_class *res; +unsigned long type_visited; - res = (type_class *) xmalloc (sizeof (type_class)); - add_irp_type((type *) res); /* Remember the new type global. */ - res->kind = k_type_class; - res->name = name; +inline type * +new_type(tp_op *type_op, ir_mode *mode, ident* name) { + type *res; + int node_size ; - res->members = NEW_ARR_F (entity *, 1); - res->subtypes = NEW_ARR_F (type_class *, 1); - res->supertypes = NEW_ARR_F (type_class *, 1); + assert(type_op != type_id); + 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->type_op = type_op; + res->mode = mode; + res->name = name; + res->state = layout_undefined; + res->size = -1; res->visit = 0; + res -> link = NULL; return res; } -/* manipulate fields of type_class */ -const char * -get_class_name (type_class *class) { - assert(class); - return id_to_str(class->name); +void free_type_attrs(type *tp) { + switch(get_type_tpop_code(tp)) { + case tpo_class: { free_class_attrs(tp); } break; + case tpo_struct: { free_struct_attrs(tp); } break; + case tpo_method: { free_method_attrs(tp); } break; + case tpo_union: { free_union_attrs(tp); } break; + case tpo_array: { free_array_attrs(tp); } break; + case tpo_enumeration: { free_enumeration_attrs(tp); } break; + case tpo_pointer: { free_pointer_attrs(tp); } break; + case tpo_primitive: { free_primitive_attrs(tp); } break; + default: break; + } } -/* field: ident */ -ident * -get_class_ident (type_class *class) { - assert(class); - return class->name; -} - -/* -void set_class_name (type_class *class, char *name); -void set_class_ident (type_class *class, ident* ident); -*/ - -/* field: member */ -void -add_class_member (type_class *class, entity *member) +/* set/get the link field */ +void *get_type_link(type *tp) { - ARR_APP1 (entity *, class->members, member); + assert(tp); + return(tp -> link); } -entity * -get_class_member (type_class *class, int pos) +void set_type_link(type *tp, void *l) { - assert (class); - return class->members[pos+1]; + assert(tp); + tp -> link = l; } -void -set_class_member (type_class *class, entity *member, int pos) -{ - class->members[pos+1] = member; +tp_op* get_type_tpop(type *tp) { + assert(tp); + return tp->type_op; } -int -get_class_n_member (type_class *class) -{ - int res; - - assert(class); - res = (ARR_LEN (class->members))-1; - return res; +ident* get_type_tpop_nameid(type *tp) { + assert(tp); + return tp->type_op->name; } -/* field: subtype */ -void -add_class_subtype (type_class *class, type_class *subtype) -{ - ARR_APP1 (type_class *, class->subtypes, subtype); +const char* get_type_tpop_name(type *tp) { + assert(tp); + return id_to_str(tp->type_op->name); } -type_class * -get_class_subtype (type_class *class, int pos) -{ - assert (class); - return class->subtypes[pos+1]; +tp_opcode get_type_tpop_code(type *tp) { + assert(tp); + return tp->type_op->code; } -void -set_class_subtype (type_class *class, type_class *subtype, int pos) -{ - class->subtypes[pos+1] = subtype; +ir_mode* get_type_mode(type *tp) { + assert(tp); + return tp->mode; } -int -get_class_n_subtype (type_class *class) -{ - assert(class); - return (ARR_LEN (class->subtypes))-1; +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); } -/* field: supertype */ -void -add_class_supertype (type_class *class, type_class *supertype) -{ - ARR_APP1 (type_class *, class->supertypes, supertype); +ident* get_type_ident(type *tp) { + assert(tp); + return tp->name; } -type_class * -get_class_supertype (type_class *class, int pos) -{ - assert (class); - return class->supertypes[pos+1]; +void set_type_ident(type *tp, ident* id) { + assert(tp); + tp->name = id; } -void -set_class_supertype (type_class *class, type_class *supertype, int pos) -{ - class->supertypes[pos+1] = supertype; +const char* get_type_name(type *tp) { + assert(tp); + return id_to_str(tp->name); } -int -get_class_n_supertype (type_class *class) -{ - assert(class); - return (ARR_LEN (class->supertypes))-1; +int get_type_size(type *tp) { + assert(tp); + return tp->size; } -/*******************************************************************/ -/** TYPE_STRCT **/ -/*******************************************************************/ - -type_strct * -new_type_strct (ident *name)//, int members) -{ - type_strct *res; - - res = (type_strct *) xmalloc (sizeof (type_strct)); - add_irp_type((type *) res); /* Remember the new type global. */ - res->kind = k_type_strct; - res->name = name; - - res->members = NEW_ARR_F (entity *, 1); - res->visit = 0; - - return res; +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)) + tp->size = size; } -/* manipulate fields of type_strct */ - -const char * -get_strct_name (type_strct *strct) { - assert(strct); - return ID_TO_STR(strct->name); +type_state +get_type_state(type *tp) { + assert(tp); + return tp->state; } - -ident * -get_strct_ident (type_strct *strct) { - assert(strct); - return strct->name; +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)) + tp->state = state; } -int -get_strct_n_member (type_strct *strct) -{ - int res; - - assert(strct); - res = (ARR_LEN (strct->members))-1; - return res; +unsigned long get_type_visited(type *tp) { + assert(tp); + return tp->visit; } -void -add_strct_member (type_strct *strct, entity *member) -{ - ARR_APP1 (type_strct *, strct->members, member); +void set_type_visited(type *tp, unsigned long num) { + assert(tp); + tp->visit = num; } - -entity * -get_strct_member (type_strct *strct, int pos) -{ - assert (strct); - return strct->members[pos+1]; +/* Sets visited field in type to type_visited. */ +void mark_type_visited(type *tp) { + assert(tp); + assert(tp->visit < type_visited); + tp->visit = type_visited; } -void -set_strct_member (type_strct *strct, int pos, entity *member) -{ - strct->members[pos+1] = member; +int is_type (void *thing) { + assert(thing); + if (get_kind(thing) == k_type) + return 1; + else + return 0; } -/* -void set_strct_name (type_strct *strct, char *name); -void set_strct_ident (type_strct *strct, ident* ident); -*/ - - /*******************************************************************/ -/** TYPE_METHOD **/ +/** TYPE_CLASS **/ /*******************************************************************/ -/* create a new type_method */ -type_method * -new_type_method (ident *name, int arity, int n_res) -{ - type_method *res; +/* create a new class type */ +type *new_type_class (ident *name) { + type *res; - res = (type_method *) xmalloc (sizeof (type_method)); - add_irp_type((type *) res); /* Remember the new type global. */ - res->kind = k_type_method; - res->name = name; // do I need the name, or is the name in entity sufficient? - res->arity = arity; - res->param_type = (type **) xmalloc (sizeof (type *) * arity); - res->n_res = n_res; - res->res_type = (type **) xmalloc (sizeof (type *) * n_res); + res = new_type(type_class, NULL, name); - res->visit = 0; + 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); return res; } - -/* manipulate fields of type_method */ -const char * -get_method_name (type_method *method) { - assert(method); - return ID_TO_STR(method->name); +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) { + assert(clss && (clss->type_op == type_class)); + return (ARR_LEN (clss->attr.ca.members))-1; +} +entity *get_class_member (type *clss, int pos) { + assert(clss && (clss->type_op == type_class)); + return clss->attr.ca.members[pos+1]; +} +void set_class_member (type *clss, entity *member, int pos) { + assert(clss && (clss->type_op == type_class)); + clss->attr.ca.members[pos+1] = member; +} +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++) + 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++) + 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) { + 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)); + 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)); + 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++) + 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; + } +} + +void add_class_supertype (type *clss, type *supertype) { + int i; + 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++) + 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) { + assert(clss && (clss->type_op == type_class)); + return (ARR_LEN (clss->attr.ca.supertypes))-1; +} +type *get_class_supertype (type *clss, int pos) { + assert(clss && (clss->type_op == type_class)); + 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)); + 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++) + 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; + } +} +/* typecheck */ +bool is_class_type(type *clss) { + assert(clss); + if (clss->type_op == type_class) return 1; else return 0; } -ident * -get_method_ident (type_method *method) { - assert(method); - return method->name; -} +/*******************************************************************/ +/** TYPE_STRUCT **/ +/*******************************************************************/ -/* -void set_method_name (type_method *method, char *name); -void set_method_ident (type_method *method, ident* ident); -*/ +/* create a new type struct */ +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) { + 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) { + assert(strct && (strct->type_op == type_struct)); + ARR_APP1 (entity *, strct->attr.sa.members, member); +} +int get_struct_n_member (type *strct) { + assert(strct && (strct->type_op == type_struct)); + return (ARR_LEN (strct->attr.sa.members))-1; +} +entity *get_struct_member (type *strct, int pos) { + assert(strct && (strct->type_op == type_struct)); + return strct->attr.sa.members[pos+1]; +} +void set_struct_member (type *strct, int pos, entity *member) { + assert(strct && (strct->type_op == type_struct)); + 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++) + 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); + if (strct->type_op == type_struct) return 1; else return 0; +} +/*******************************************************************/ +/** TYPE_METHOD **/ +/*******************************************************************/ -inline int -get_method_n_params (type_method *method) { - return method->arity; +/* 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) { + type *res; + res = new_type(type_method, NULL, name); + 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; } - -inline int -get_method_arity (type_method *method) { - return method->arity; +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); } - -/* -inline void -set_method_arity (type_method *method, int arity) { - method->arity = arity; - / change array size, somehow copy. * +/* manipulate private fields of method. */ +int get_method_n_params (type *method) { + assert(method && (method->type_op == type_method)); + return method->attr.ma.n_params; } -*/ - -inline type * -get_method_param_type(type_method *method, int pos) { - return method->param_type[pos]; +type *get_method_param_type(type *method, int pos) { + assert(method && (method->type_op == type_method)); + return method->attr.ma.param_type[pos] = skip_tid(method->attr.ma.param_type[pos]); } - -inline void -set_method_param_type(type_method *method, int pos, type* type) { - method->param_type[pos] = type; +void set_method_param_type(type *method, int pos, type* type) { + assert(method && (method->type_op == type_method)); + method->attr.ma.param_type[pos] = type; } - -inline int -get_method_n_res (type_method *method) { - return method->n_res; +int get_method_n_res (type *method) { + assert(method && (method->type_op == type_method)); + return method->attr.ma.n_res; } - -/* -inline void -set_method_n_res (type_method *method, int n_res) { - method->n_res = n_res; +type *get_method_res_type(type *method, int pos) { + assert(method && (method->type_op == type_method)); + return method->attr.ma.res_type[pos] = skip_tid(method->attr.ma.res_type[pos]); } -*/ - -inline type * -get_method_res_type(type_method *method, int pos) { - return method->res_type[pos]; +void set_method_res_type(type *method, int pos, type* type) { + assert(method && (method->type_op == type_method)); + method->attr.ma.res_type[pos] = type; } -inline void -set_method_res_type(type_method *method, int pos, type* type) { - method->res_type[pos] = type; +/* typecheck */ +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_union -- set unioned types by hand. */ -type_union * -new_type_union (ident *name, int n_types) -{ - type_union *res; - - res = (type_union *) xmalloc (sizeof (type_union)); - add_irp_type((type *) res); /* Remember the new type global. */ - res->kind = k_type_union; - res->name = name; // do I need a name? - res->n_types = n_types; - /* - res->unioned_type = (int *) xmalloc (sizeof (int) * n_types); - */ - - res->visit = 0; - +/* create a new type uni */ +type *new_type_uni (ident *name) { + type *res; + 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); return res; } - -/* manipulate fields of type_union */ -/* -char * -get_union_name (type_union *uni) { - assert(uni); - return ID_TO_STR(uni->name); -} -*/ - -ident * -get_union_ident (type_union *uni) { +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 */ +#if 0 +int get_union_n_types (type *uni) { + assert(uni && (uni->type_op == type_union)); + return uni->attr.ua.n_types; +} +type *get_union_unioned_type (type *uni, int pos) { + assert(uni && (uni->type_op == type_union)); + 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) { + assert(uni && (uni->type_op == type_union)); + uni->attr.ua.unioned_type[pos] = type; +} +ident *get_union_delim_nameid (type *uni, int pos) { + assert(uni && (uni->type_op == type_union)); + return uni->attr.ua.delim_names[pos]; +} +const char *get_union_delim_name (type *uni, int pos) { + assert(uni && (uni->type_op == type_union)); + 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)); + uni->attr.ua.delim_names[pos] = id; +} +#endif +int get_union_n_members (type *uni) { + assert(uni && (uni->type_op == type_union)); + return (ARR_LEN (uni->attr.ua.members))-1; +} +void add_union_member (type *uni, entity *member) { + assert(uni && (uni->type_op == type_union)); + ARR_APP1 (entity *, uni->attr.ua.members, member); +} +entity *get_union_member (type *uni, int pos) { + assert(uni && (uni->type_op == type_union)); + return uni->attr.ua.members[pos+1]; +} +void set_union_member (type *uni, int pos, entity *member) { + assert(uni && (uni->type_op == type_union)); + 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++) + 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; + } +} + +/* typecheck */ +bool is_union_type (type *uni) { assert(uni); - return uni->name; + if (uni->type_op == type_union) return 1; else return 0; } -/* -void set_union_name (type_union *union, char *name); -void set_union_ident (type_union *union, ident* ident); -*/ -/* -int get_union_n_types (type_union *union); -void set_union_n_types (type_union *union, int n); -type *get_union_unioned_type (type_union *union, int pos); -void set_union_unioned_type (type_union *union, int pos, type *type); -*/ - /*******************************************************************/ /** TYPE_ARRAY **/ /*******************************************************************/ -/* create a new type_array */ -inline type_array * -new_type_array (ident *name, int n_dimensions) -{ - type_array *res; - - res = (type_array *) xmalloc (sizeof (type_array)); - add_irp_type((type *) res); /* Remember the new type global. */ - res->kind = k_type_array; - res->name = name; - res->n_dimensions = n_dimensions; - res->lower_bound = (int *) xmalloc (sizeof (int) * n_dimensions); - res->upper_bound = (int *) xmalloc (sizeof (int) * n_dimensions); - - res->visit = 0; +/* create a new type array -- set dimension sizes independently */ +type *new_type_array (ident *name, int n_dimensions, + type *element_type) { + type *res; + 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.element_type = element_type; + new_entity(res, name, element_type); return res; } - -/* manipulate fields of type_array */ -/* -char * -get_array_name (type_array *array) { - assert(array); - return ID_TO_STR(array->name); +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); } -*/ -ident * -get_array_ident (type_array *array) { - assert(array); - return array->name; +/* manipulate private fields of array type */ +int get_array_n_dimensions (type *array) { + assert(array && (array->type_op == type_array)); + return array->attr.aa.n_dimensions; } - -/* -void set_array_name (type_array *array, char *name); -void set_array_ident (type_array *array, ident* ident); -*/ - -inline void -set_array_dimensions (type_array* array, int n) { - array->n_dimensions = n; +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; } - -inline int -get_array_dimensions (type_array* array) { - return array->n_dimensions; +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; } - -inline void -set_array_bounds (type_array* array, int dimension, int lower_bound, - int upper_bound) { - array->lower_bound[dimension-1] = lower_bound; - array->upper_bound[dimension-1] = upper_bound; +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; } - -inline void -set_array_lower_bound (type_array* array, int dimension, int lower_bound) { - array->lower_bound[dimension-1] = lower_bound; +ir_node * get_array_lower_bound (type *array, int dimension) { + assert(array && (array->type_op == type_array)); + return array->attr.aa.lower_bound[dimension]; } - -inline void -set_array_upper_bound (type_array* array, int dimension, int upper_bound) { - array->upper_bound[dimension-1] = upper_bound; +ir_node * get_array_upper_bound (type *array, int dimension) { + assert(array && (array->type_op == type_array)); + return array->attr.aa.upper_bound[dimension]; } - -inline int -get_array_lower_bound (type_array* array, int dimension) { - return array->lower_bound[dimension-1]; +void set_array_element_type (type *array, type *type) { + assert(array && (array->type_op == type_array)); + array->attr.aa.element_type = type; } - -inline int -get_array_upper_bound (type_array* array, int dimension) { - return array->upper_bound[dimension-1]; +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); } - -inline void set_array_element_type (type_array *array, type *type) { - array->element_type = type; +void set_array_element_entity (type *array, entity *ent) { + assert(array && (array->type_op == type_array)); + array->attr.aa.element_ent = ent; } - -inline type * -get_array_element_type (type_array *array) { - return array->element_type; +entity *get_array_element_entity (type *array) { + assert(array && (array->type_op == type_array)); + return array->attr.aa.element_ent; } +/* typecheck */ +bool is_array_type (type *array) { + assert(array); + if (array->type_op == type_array) return 1; else return 0; +} /*******************************************************************/ /** TYPE_ENUMERATION **/ /*******************************************************************/ /* create a new type enumeration -- set the enumerators independently */ -type_enumeration * -new_type_enumeration (ident *name /* , int n_enums */) -{ - type_enumeration *res; - - res = (type_enumeration *) xmalloc (sizeof (type_enumeration)); - add_irp_type((type *) res); /* Remember the new type global. */ - res->kind = k_type_enumeration; - res->name = name; - /* - res->n_enums = n_enums; - res->enum = (int *) xmalloc (sizeof (int) * n_enums); - */ - - res->visit = 0; - +type *new_type_enumeration (ident *name, int n_enums) { + type *res; + 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); return res; } +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); +} -/* manipulate fields of type_enumeration */ -/* -char * -get_enumeration_name (type_enumeration *enumeration) { - assert(enumeration); - return ID_TO_STR(enumeration->name); +/* manipulate fields of enumeration type. */ +int get_enumeration_n_enums (type *enumeration) { + assert(enumeration && (enumeration->type_op == type_enumeration)); + return enumeration->attr.ea.n_enums; +} +void set_enumeration_enum (type *enumeration, int pos, tarval *con) { + assert(enumeration && (enumeration->type_op == type_enumeration)); + enumeration->attr.ea.enumer[pos] = con; +} +tarval *get_enumeration_enum (type *enumeration, int pos) { + assert(enumeration && (enumeration->type_op == type_enumeration)); + return enumeration->attr.ea.enumer[pos]; +} +void set_enumeration_nameid (type *enumeration, int pos, ident *id) { + assert(enumeration && (enumeration->type_op == type_enumeration)); + enumeration->attr.ea.enum_nameid[pos] = id; +} +ident *get_enumeration_nameid (type *enumeration, int pos) { + assert(enumeration && (enumeration->type_op == type_enumeration)); + return enumeration->attr.ea.enum_nameid[pos]; +} +const char *get_enumeration_name(type *enumeration, int pos) { + assert(enumeration && (enumeration->type_op == type_enumeration)); + return id_to_str(enumeration->attr.ea.enum_nameid[pos]); } -*/ -ident * -get_enumeration_ident (type_enumeration *enumeration) { +/* typecheck */ +bool is_enumeration_type (type *enumeration) { assert(enumeration); - return enumeration->name; + if (enumeration->type_op == type_enumeration) return 1; else return 0; } -/* -void set_enumeration_name (type_enumeration *enumeration, char *name); -void set_enumeration_ident (type_enumeration *enumeration, ident* ident); -*/ -/* -void set_enumeration_n_enums (type_enumeration *enumeration, int n); -int *get_enumeration_n_enums (type_enumeration *enumeration); -void set_enumeration_enum (type_enumeration *enumeration, int pos, - ir_node const); -ir_node *get_enumeration_enum (type_enumeration *enumeration, int pos); -*/ - - /*******************************************************************/ /** TYPE_POINTER **/ /*******************************************************************/ -/* create a new type pointer */ -type_pointer * -new_type_pointer (ident *name, type *points_to) -{ - type_pointer *res; - - res = (type_pointer *) xmalloc (sizeof (type_pointer)); - add_irp_type((type *) res); /* Remember the new type global. */ - res->kind = k_type_pointer; - res->name = name; - res->points_to = points_to; - - res->visit = 0; - +/* Create a new type pointer */ +type *new_type_pointer (ident *name, type *points_to) { + type *res; + 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; } - -/* manipulate fields of type_pointer */ -/* -char * -get_pointer_name (type_pointer *pointer) { - assert(pointer); - return ID_TO_STR(pointer->name); +inline void free_pointer_attrs (type *pointer) { + assert(pointer && (pointer->type_op == type_pointer)); } -*/ - -ident * -get_pointer_ident (type_pointer *pointer) { - assert(pointer); - return pointer->name; +/* manipulate fields of type_pointer */ +void set_pointer_points_to_type (type *pointer, type *type) { + assert(pointer && (pointer->type_op == type_pointer)); + pointer->attr.pa.points_to = type; } - -/* -void set_pointer_name (type_pointer *pointer, char *name); -void set_pointer_ident (type_pointer *pointer, ident* ident); -*/ - -inline void -set_pointer_points_to_type (type_pointer *pointer, type* type) { - pointer->points_to = type; +type *get_pointer_points_to_type (type *pointer) { + assert(pointer && (pointer->type_op == type_pointer)); + return pointer->attr.pa.points_to = skip_tid(pointer->attr.pa.points_to); } -inline type * -get_pointer_points_to_type (type_pointer *pointer) { - return pointer->points_to; +/* typecheck */ +bool is_pointer_type (type *pointer) { + assert(pointer); + if (pointer->type_op == type_pointer) return 1; else return 0; } @@ -559,75 +657,20 @@ get_pointer_points_to_type (type_pointer *pointer) { /** TYPE_PRIMITIVE **/ /*******************************************************************/ -/* create a new type_primitive */ -inline type_primitive * -new_type_primitive (ident *name, ir_mode *mode) -{ - type_primitive *res; - - res = (type_primitive *) xmalloc (sizeof (type_primitive)); - add_irp_type((type *) res); /* Remember the new type global. */ - res->kind = k_type_primitive; - res->name = name; - res->mode = mode; - - res->visit = 0; - +/* create a new type primitive */ +type *new_type_primitive (ident *name, ir_mode *mode) { + type *res; + res = new_type(type_primitive, mode, name); + res->size = get_mode_size(mode); + res->state = layout_fixed; return res; } - -/* manipulate fields of type_primitive */ -/* - -char * -get_primitive_name (type_primitive *primitive) { - assert(primitive); - return ID_TO_STR(primitive->name); +inline void free_primitive_attrs (type *primitive) { + assert(primitive && (primitive->type_op == type_primitive)); } -*/ -ident * -get_primitive_ident (type_primitive *primitive) { +/* typecheck */ +bool is_primitive_type (type *primitive) { assert(primitive); - return primitive->name; -} -/* -void set_primitive_name (type_primitive *primitive, char *name); -void set_primitive_ident (type_primitive *primitive, ident* ident); -*/ - -inline ir_mode * -get_primitive_mode (type_primitive *primitive) { - return primitive->mode; -} - -inline void -set_primitive_mode (type_primitive *primitive, ir_mode *mode) { - primitive->mode = mode; -} - - - - -/*******************************************************************/ -/** To manage all different types the same **/ -/*******************************************************************/ - - -int -is_type(void *thing) { - firm_kind kind; - - kind = get_kind(thing); - if ( (kind == k_type_class) - || (kind == k_type_strct) - || (kind == k_type_method) - || (kind == k_type_union) - || (kind == k_type_array) - || (kind == k_type_enumeration) - || (kind == k_type_pointer) - || (kind == k_type_primitive)) - return 1; - else - return 0; + if (primitive->type_op == type_primitive) return 1; else return 0; }