/**
*
- * file type.c - implementation of the datastructure to hold
- * type information.
+ * @file type.c
+ *
+ * Implementation of the datastructure to hold
+ * type information.
+ *
* (C) 2001 by Universitaet Karlsruhe
* Goetz Lindenmaier
*
# include "array.h"
-/*******************************************************************/
+/*-----------------------------------------------------------------*/
/** TYPE **/
-/*******************************************************************/
+/*-----------------------------------------------------------------*/
-type *none_type; type *get_none_type(void) { return none_type; }
-type *unknown_type; type *get_unknown_type(void) { return unknown_type; }
+type *firm_none_type; type *get_none_type(void) { return firm_none_type; }
+type *firm_unknown_type; type *get_unknown_type(void) { return firm_unknown_type; }
#ifdef DEBUG_libfirm
-/** Returns a new, unique number to number nodes or the like. */
+/* Returns a new, unique number to number nodes or the like. */
int get_irp_new_node_nr(void);
#endif
value_ress_suffix = new_id_from_str(VALUE_RESS_SUFFIX);
/* construct none and unknown type. */
- none_type = new_type(tpop_none, mode_BAD, new_id_from_str("type_none"));
- 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_bits(unknown_type, 0);
- set_type_state (unknown_type, layout_fixed);
- remove_irp_type(unknown_type);
+ firm_none_type = new_type(tpop_none, mode_BAD, new_id_from_str("type_none"));
+ set_type_size_bits(firm_none_type, 0);
+ set_type_state (firm_none_type, layout_fixed);
+ remove_irp_type(firm_none_type);
+ firm_unknown_type = new_type(tpop_unknown, mode_ANY, new_id_from_str("type_unknown"));
+ set_type_size_bits(firm_unknown_type, 0);
+ set_type_state (firm_unknown_type, layout_fixed);
+ remove_irp_type(firm_unknown_type);
}
unsigned long 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(); }
+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 *
memset(res, 0, 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->align = -1;
- res->visit = 0;
- res -> link = NULL;
+ res->kind = k_type;
+ res->type_op = type_op;
+ res->mode = mode;
+ res->name = name;
+ res->visibility = visibility_external_allocated;
+ res->state = layout_undefined;
+ res->size = -1;
+ res->align = -1;
+ res->visit = 0;
+ res -> link = NULL;
#ifdef DEBUG_libfirm
- res->nr = get_irp_new_node_nr();
- res->c_name = (char*) get_id_str (name);
+ res->nr = get_irp_new_node_nr();
#endif /* defined DEBUG_libfirm */
return res;
/* Free the attributes of the type. */
free_type_attrs(tp);
/* Free entities automatically allocated with the type */
- if (is_array_type(tp))
+ if (is_Array_type(tp))
free_entity(get_array_element_entity(tp));
/* And now the type itself... */
tp->kind = k_BAD;
/* set/get the link field */
void *(get_type_link)(const type *tp)
{
- return __get_type_link(tp);
+ return _get_type_link(tp);
}
void (set_type_link)(type *tp, void *l)
{
- __set_type_link(tp, l);
+ _set_type_link(tp, l);
}
-tp_op *(get_type_tpop)(const type *tp) {
- return __get_type_tpop(tp);
+const tp_op *(get_type_tpop)(const type *tp) {
+ return _get_type_tpop(tp);
}
ident *(get_type_tpop_nameid)(const type *tp) {
- return __get_type_tpop_nameid(tp);
+ return _get_type_tpop_nameid(tp);
}
const char* get_type_tpop_name(const type *tp) {
}
tp_opcode (get_type_tpop_code)(const type *tp) {
- return __get_type_tpop_code(tp);
+ return _get_type_tpop_code(tp);
}
ir_mode *(get_type_mode)(const type *tp) {
- return __get_type_mode(tp);
+ return _get_type_mode(tp);
}
void set_type_mode(type *tp, ir_mode* m) {
}
ident *(get_type_ident)(const type *tp) {
- return __get_type_ident(tp);
+ return _get_type_ident(tp);
}
void (set_type_ident)(type *tp, ident* id) {
- __set_type_ident(tp, id);
+ _set_type_ident(tp, id);
}
/* Outputs a unique number for this node */
-long (get_type_nr)(const type *tp) {
- return __get_type_nr(tp);
+long get_type_nr(const type *tp) {
+ assert(tp);
+#ifdef DEBUG_libfirm
+ return tp->nr;
+#else
+ return (long)tp;
+#endif
}
const char* get_type_name(const type *tp) {
}
int (get_type_size_bytes)(const type *tp) {
- return __get_type_size_bytes(tp);
+ return _get_type_size_bytes(tp);
}
int (get_type_size_bits)(const type *tp) {
- return __get_type_size_bits(tp);
+ return _get_type_size_bits(tp);
+}
+
+
+visibility get_type_visibility (const type *tp) {
+#if 0
+ visibility res = visibility_local;
+ if (is_compound_type(tp)) {
+
+ if (is_Array_type(tp)) {
+ entity *mem = get_array_element_entity(tp);
+ if (get_entity_visibility(mem) != visibility_local)
+ res = visibility_external_visible;
+ } else {
+ int i, n_mems = get_compound_n_members(tp);
+ for (i = 0; i < n_mems; ++i) {
+ entity *mem = get_compound_member(tp, i);
+ if (get_entity_visibility(mem) != visibility_local)
+ res = visibility_external_visible;
+ }
+ }
+ }
+ return res;
+#endif
+ assert(is_type(tp));
+ return tp->visibility;
+}
+
+void set_type_visibility (type *tp, visibility v) {
+ assert(is_type(tp));
+#if 0
+ /* check for correctness */
+ if (v != visibility_external_allocated) {
+ visibility res = visibility_local;
+ if (is_compound_type(tp)) {
+ if (is_Array_type(tp)) {
+ entity *mem = get_array_element_entity(tp);
+ if (get_entity_visibility(mem) > res)
+ res = get_entity_visibility(mem);
+ } else {
+ int i, n_mems = get_compound_n_members(tp);
+ for (i = 0; i < n_mems; ++i) {
+ entity *mem = get_compound_member(tp, i);
+ if (get_entity_visibility(mem) > res)
+ res = get_entity_visibility(mem);
+ }
+ }
+ }
+ assert(res < v);
+ }
+#endif
+ tp->visibility = v;
}
void
/* alignment NOT set calculate it "on demand" */
if (tp->mode)
align = get_mode_size_bits(tp->mode);
- else if (is_array_type(tp))
+ else if (is_Array_type(tp))
align = get_type_alignment_bits(get_array_element_type(tp));
else if (is_compound_type(tp)) {
int i, n = get_compound_n_members(tp);
align = a;
}
}
- else if (is_method_type(tp))
+ else if (is_Method_type(tp))
align = 0;
/* write back */
set_type_size_bits(tp, 8*align);
}
+/* Returns a human readable string for the enum entry. */
+const char *get_type_state_name(type_state s) {
+#define X(a) case a: return #a;
+ switch (s) {
+ X(layout_undefined);
+ X(layout_fixed);
+ }
+ return "<unknown>";
+#undef X
+}
+
+
type_state (get_type_state)(const type *tp) {
- return __get_type_state(tp);
+ return _get_type_state(tp);
}
void
{ DDMT(tp); DDME(get_class_member(tp, i)); }
assert(get_entity_offset_bits(get_class_member(tp, i)) > -1);
/* TR ??
- assert(is_method_type(get_entity_type(get_class_member(tp, i))) ||
+ 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_bits(tp) > -1);
- for (i = 0; i < get_struct_n_members(tp); i++) {
- assert(get_entity_offset_bits(get_struct_member(tp, i)) > -1);
- assert((get_entity_allocation(get_struct_member(tp, i)) == allocation_automatic));
- }
+ assert(get_type_size_bits(tp) > -1);
+ for (i = 0; i < get_struct_n_members(tp); i++) {
+ assert(get_entity_offset_bits(get_struct_member(tp, i)) > -1);
+ assert((get_entity_allocation(get_struct_member(tp, i)) == allocation_automatic));
+ }
} break;
case tpo_union:
{ /* ?? */
} break;
case tpo_array:
{ /* ??
- Check order?
- Assure that only innermost dimension is dynamic? */
+ 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);
+ 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) */
}
unsigned long (get_type_visited)(const type *tp) {
- return __get_type_visited(tp);
+ return _get_type_visited(tp);
}
void (set_type_visited)(type *tp, unsigned long num) {
- __set_type_visited(tp, num);
+ _set_type_visited(tp, num);
}
/* Sets visited field in type to type_visited. */
void (mark_type_visited)(type *tp) {
- __mark_type_visited(tp);
+ _mark_type_visited(tp);
}
/* @@@ name clash with master flag
int (type_visited)(const type *tp) {
- return __type_visited(tp);
+ return _type_visited(tp);
}*/
int (type_not_visited)(const type *tp) {
- return __type_not_visited(tp);
+ return _type_not_visited(tp);
}
int (is_type)(const void *thing) {
- return __is_type(thing);
+ return _is_type(thing);
}
-bool equal_type(type *typ1, type *typ2) {
+/* Checks whether two types are structural equal.*/
+int equal_type(type *typ1, type *typ2) {
entity **m;
type **t;
int i, j;
- if (typ1 == typ2) return true;
+ if (typ1 == typ2) return 1;
if ((get_type_tpop_code(typ1) != get_type_tpop_code(typ2)) ||
(get_type_ident(typ1) != get_type_ident(typ2)) ||
(get_type_mode(typ1) != get_type_mode(typ2)) ||
(get_type_state(typ1) != get_type_state(typ2)))
- return false;
+ return 0;
if ((get_type_state(typ1) == layout_fixed) &&
(get_type_size_bits(typ1) != get_type_size_bits(typ2)))
- return false;
+ return 0;
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;
+ if (get_class_n_members(typ1) != get_class_n_members(typ2)) return 0;
+ if (get_class_n_subtypes(typ1) != get_class_n_subtypes(typ2)) return 0;
+ if (get_class_n_supertypes(typ1) != get_class_n_supertypes(typ2)) return 0;
+ if (get_class_peculiarity(typ1) != get_class_peculiarity(typ2)) return 0;
/** Compare the members **/
m = alloca(sizeof(entity *) * get_class_n_members(typ1));
memset(m, 0, sizeof(entity *) * get_class_n_members(typ1));
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;
+ 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;
+ !equal_entity(get_class_member(typ1, i), m[i]))
+ return 0;
}
/** Compare the supertypes **/
t = alloca(sizeof(entity *) * get_class_n_supertypes(typ1));
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_ident(t2) == get_type_ident(t1))
- t[i] = t2;
+ type *t2 = get_class_supertype(typ2, j);
+ if (get_type_ident(t2) == get_type_ident(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;
+ get_class_supertype(typ1, i) != t[i])
+ return 0;
}
} break;
case tpo_struct: {
- if (get_struct_n_members(typ1) != get_struct_n_members(typ2)) return false;
+ if (get_struct_n_members(typ1) != get_struct_n_members(typ2)) return 0;
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;
+ 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;
+ !equal_entity(get_struct_member(typ1, i), m[i]))
+ return 0;
}
} break;
case tpo_method: {
int n_param1, n_param2;
- if (get_method_variadicity(typ1) != get_method_variadicity(typ2)) return false;
- if (get_method_n_ress(typ1) != get_method_n_ress(typ2)) return false;
+ if (get_method_variadicity(typ1) != get_method_variadicity(typ2)) return 0;
+ if (get_method_n_ress(typ1) != get_method_n_ress(typ2)) return 0;
if (get_method_variadicity(typ1) == variadicity_non_variadic) {
n_param1 = get_method_n_params(typ1);
n_param2 = get_method_first_variadic_param_index(typ2);
}
- if (n_param1 != n_param2) return false;
+ if (n_param1 != n_param2) return 0;
for (i = 0; i < n_param1; i++) {
if (!equal_type(get_method_param_type(typ1, i), get_method_param_type(typ2, i)))
- return false;
+ return 0;
}
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;
+ return 0;
}
} break;
case tpo_union: {
- if (get_union_n_members(typ1) != get_union_n_members(typ2)) return false;
+ if (get_union_n_members(typ1) != get_union_n_members(typ2)) return 0;
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;
+ 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;
+ !equal_entity(get_union_member(typ1, i), m[i]))
+ return 0;
}
} break;
case tpo_array: {
if (get_array_n_dimensions(typ1) != get_array_n_dimensions(typ2))
- return false;
+ return 0;
if (!equal_type(get_array_element_type(typ1), get_array_element_type(typ2)))
- return false;
+ return 0;
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;
+ get_array_upper_bound(typ1, i) != get_array_upper_bound(typ2, i))
+ return 0;
if (get_array_order(typ1, i) != get_array_order(typ2, i))
- assert(0 && "type compare with different dimension orders not implemented");
+ assert(0 && "type compare with different dimension orders not implemented");
}
} break;
case tpo_enumeration: {
} break;
case tpo_pointer: {
if (get_pointer_points_to_type(typ1) != get_pointer_points_to_type(typ2))
- return false;
+ return 0;
} break;
case tpo_primitive: {
} break;
default: break;
}
- return true;
+ return 1;
}
-bool smaller_type (type *st, type *lt) {
+/* Checks whether two types are structural comparable. */
+int smaller_type (type *st, type *lt) {
entity **m;
int i, j;
- if (st == lt) return true;
+ if (st == lt) return 1;
if (get_type_tpop_code(st) != get_type_tpop_code(lt))
- return false;
+ return 0;
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;
+ if (get_struct_n_members(st) != get_struct_n_members(lt)) return 0;
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++) {
if (!m[i] || /* Found no counterpart */
- !smaller_type(get_entity_type(get_struct_member(st, i)),
- get_entity_type(m[i])))
- return false;
+ !smaller_type(get_entity_type(get_struct_member(st, i)),
+ get_entity_type(m[i])))
+ return 0;
}
} break;
case tpo_method: {
- /** FIXME: is this still true? */
- 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;
+ /** FIXME: is this still 1? */
+ if (get_method_variadicity(st) != get_method_variadicity(lt)) return 0;
+ if (get_method_n_params(st) != get_method_n_params(lt)) return 0;
+ if (get_method_n_ress(st) != get_method_n_ress(lt)) return 0;
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;
+ return 0;
}
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;
+ return 0;
}
} break;
case tpo_union: {
- if (get_union_n_members(st) != get_union_n_members(lt)) return false;
+ if (get_union_n_members(st) != get_union_n_members(lt)) return 0;
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;
- }
+ 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;
+ !smaller_type(get_entity_type(get_union_member(st, i)),
+ get_entity_type(m[i])))
+ return 0;
}
} break;
case tpo_array: {
type *set, *let; /* small/large elt. type */
if (get_array_n_dimensions(st) != get_array_n_dimensions(lt))
- return false;
+ return 0;
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. */
+ 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;
+ (get_type_state(let) != layout_fixed))
+ return 0;
if (!smaller_type(set, let) ||
- get_type_size_bits(set) != get_type_size_bits(let))
- return false;
+ get_type_size_bits(set) != get_type_size_bits(let))
+ return 0;
}
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_lower_bound(st, i) != get_array_lower_bound(lt, i))
+ return 0;
if (get_array_upper_bound(lt, i))
- if(get_array_upper_bound(st, i) != get_array_upper_bound(lt, i))
- return false;
+ if(get_array_upper_bound(st, i) != get_array_upper_bound(lt, i))
+ return 0;
}
} break;
case tpo_enumeration: {
case tpo_pointer: {
if (!smaller_type(get_pointer_points_to_type(st),
get_pointer_points_to_type(lt)))
- return false;
+ return 0;
} break;
case tpo_primitive: {
if (!smaller_mode(get_type_mode(st), get_type_mode(lt)))
- return false;
+ return 0;
} break;
default: break;
}
- return true;
+ return 1;
}
/*-----------------------------------------------------------------*/
/* manipulate private fields of class type */
void add_class_member (type *clss, entity *member) {
assert(clss && (clss->type_op == type_class));
+ assert(clss != get_entity_type(member) && "recursive type");
ARR_APP1 (entity *, clss->attr.ca.members, member);
}
int (get_class_n_members) (const type *clss) {
- return __get_class_n_members(clss);
+ return _get_class_n_members(clss);
}
int get_class_member_index(type *clss, entity *mem) {
}
entity *(get_class_member) (const type *clss, int pos) {
- return __get_class_member(clss, pos);
+ return _get_class_member(clss, pos);
}
entity *get_class_member_by_name(type *clss, ident *name) {
assert(pos >= 0 && pos < get_class_n_subtypes(clss));
return clss->attr.ca.subtypes[pos] = skip_tid(clss->attr.ca.subtypes[pos]);
}
+int get_class_subtype_index(type *clss, const type *subclass) {
+ int i, n_subtypes = get_class_n_subtypes(clss);
+ assert(is_Class_type(subclass));
+ for (i = 0; i < n_subtypes; ++i) {
+ if (get_class_subtype(clss, i) == subclass) return i;
+ }
+ return -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));
return (ARR_LEN (clss->attr.ca.supertypes));
}
int get_class_supertype_index(type *clss, type *super_clss) {
- int i;
- assert(clss && (clss->type_op == type_class));
+ int i, n_supertypes = get_class_n_supertypes(clss);
assert(super_clss && (super_clss->type_op == type_class));
- for (i = 0; i < get_class_n_supertypes(clss); i++)
+ for (i = 0; i < n_supertypes; i++)
if (get_class_supertype(clss, i) == super_clss)
return i;
return -1;
}
const char *get_peculiarity_string(peculiarity p) {
+#define X(a) case a: return #a
switch (p) {
- case peculiarity_description:
- return "peculiarity_description";
- case peculiarity_inherited:
- return "peculiarity_inherited";
- default:
- return "peculiarity_existent";
+ X(peculiarity_description);
+ X(peculiarity_inherited);
+ X(peculiarity_existent);
}
+#undef X
+ return "invalid peculiarity";
}
peculiarity get_class_peculiarity (const type *clss) {
}
/* typecheck */
-int (is_class_type)(const type *clss) {
- return __is_class_type(clss);
-}
-
-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;
+int (is_Class_type)(const type *clss) {
+ return _is_class_type(clss);
}
/*----------------------------------------------------------------**/
assert(strct && (strct->type_op == type_struct));
assert(get_type_tpop(get_entity_type(member)) != type_method);
/* @@@ lowerfirm geht nicht durch */
+ assert(strct != get_entity_type(member) && "recursive type");
ARR_APP1 (entity *, strct->attr.sa.members, member);
}
}
/* typecheck */
-int (is_struct_type)(const type *strct) {
- return __is_struct_type(strct);
+int (is_Struct_type)(const type *strct) {
+ return _is_struct_type(strct);
}
/*******************************************************************/
res->state = layout_fixed;
res->size = get_mode_size_bits(mode_P_mach);
res->attr.ma.n_params = n_param;
- res->attr.ma.param_type = xmalloc(sizeof(*res->attr.ma.param_type) * n_param);
+ res->attr.ma.param_type = xcalloc(n_param, sizeof(res->attr.ma.param_type[0]));
res->attr.ma.value_params = NULL;
res->attr.ma.n_res = n_res;
- res->attr.ma.res_type = xmalloc(sizeof(*res->attr.ma.res_type) * n_res);
+ res->attr.ma.res_type = xcalloc(n_res, sizeof(res->attr.ma.res_type[0]));
res->attr.ma.value_ress = NULL;
res->attr.ma.variadicity = variadicity_non_variadic;
res->attr.ma.first_variadic_param = -1;
}
/* typecheck */
-int (is_method_type)(const type *method) {
- return __is_method_type(method);
+int (is_Method_type)(const type *method) {
+ return _is_method_type(method);
}
/*-----------------------------------------------------------------*/
type *new_type_union (ident *name) {
type *res;
res = new_type(type_union, NULL, name);
- /*res->attr.ua.unioned_type = xmalloc(sizeof(*res->attr.ua.unioned_type) * n_types);
- res->attr.ua.delim_names = xmalloc(sizeof(*res->attr.ua.delim_names) * n_types); */
+ /*res->attr.ua.unioned_type = xcalloc(n_types, sizeof(res->attr.ua.unioned_type[0]));
+ res->attr.ua.delim_names = xcalloc(n_types, sizeof(res->attr.ua.delim_names[0])); */
res->attr.ua.members = NEW_ARR_F (entity *, 0);
return res;
}
}
void add_union_member (type *uni, entity *member) {
assert(uni && (uni->type_op == type_union));
+ assert(uni != get_entity_type(member) && "recursive type");
ARR_APP1 (entity *, uni->attr.ua.members, member);
}
entity *get_union_member (const type *uni, int pos) {
}
/* typecheck */
-int (is_union_type)(const type *uni) {
- return __is_union_type(uni);
+int (is_Union_type)(const type *uni) {
+ return _is_union_type(uni);
}
/*-----------------------------------------------------------------*/
/* create a new type array -- set dimension sizes independently */
-type *new_type_array (ident *name, int n_dimensions,
- type *element_type) {
+type *new_type_array(ident *name, int n_dimensions, type *element_type) {
type *res;
int i;
ir_graph *rem = current_ir_graph;
- assert(!is_method_type(element_type));
+ 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 = xmalloc(sizeof(*res->attr.aa.lower_bound) * n_dimensions);
- res->attr.aa.upper_bound = xmalloc(sizeof(*res->attr.aa.upper_bound) * n_dimensions);
- res->attr.aa.order = xmalloc(sizeof(*res->attr.aa.order) * n_dimensions);
+ res->attr.aa.lower_bound = xcalloc(n_dimensions, sizeof(*res->attr.aa.lower_bound));
+ res->attr.aa.upper_bound = xcalloc(n_dimensions, sizeof(*res->attr.aa.upper_bound));
+ res->attr.aa.order = xcalloc(n_dimensions, sizeof(*res->attr.aa.order));
current_ir_graph = get_const_code_irg();
for (i = 0; i < n_dimensions; i++) {
- res->attr.aa.lower_bound[i] = new_Unknown(mode_Iu);
- res->attr.aa.upper_bound[i] = new_Unknown(mode_Iu);
- res->attr.aa.order[i] = i;
+ res->attr.aa.lower_bound[i] = new_Unknown(mode_Iu);
+ res->attr.aa.upper_bound[i] = new_Unknown(mode_Iu);
+ res->attr.aa.order[i] = i;
}
current_ir_graph = rem;
assert(array && (array->type_op == type_array));
array->attr.aa.order[dimension] = order;
}
+
int get_array_order (const type *array, int dimension) {
assert(array && (array->type_op == type_array));
return array->attr.aa.order[dimension];
}
+int find_array_dimension(const type *array, int order) {
+ int dim;
+
+ assert(array && (array->type_op == type_array));
+
+ for (dim = 0; dim < array->attr.aa.n_dimensions; ++dim) {
+ if (array->attr.aa.order[dim] == order)
+ return dim;
+ }
+ return -1;
+}
+
void set_array_element_type (type *array, type *tp) {
assert(array && (array->type_op == type_array));
- assert(!is_method_type(tp));
+ assert(!is_Method_type(tp));
array->attr.aa.element_type = tp;
}
type *get_array_element_type (type *array) {
}
/* typecheck */
-int (is_array_type)(const type *array) {
- return __is_array_type(array);
+int (is_Array_type)(const type *array) {
+ return _is_array_type(array);
}
/*-----------------------------------------------------------------*/
type *res;
res = new_type(type_enumeration, NULL, name);
res->attr.ea.n_enums = n_enums;
- res->attr.ea.enumer = xmalloc(sizeof(res->attr.ea.enumer[0]) * n_enums);
- res->attr.ea.enum_nameid = xmalloc(sizeof(res->attr.ea.enum_nameid[0]) * n_enums);
- memset(res->attr.ea.enumer, 0, sizeof(res->attr.ea.enumer[0]) * n_enums);
- memset(res->attr.ea.enum_nameid, 0, sizeof(res->attr.ea.enum_nameid[0]) * n_enums);
+ res->attr.ea.enumer = xcalloc(n_enums, sizeof(res->attr.ea.enumer[0]));
+ res->attr.ea.enum_nameid = xcalloc(n_enums, sizeof(res->attr.ea.enum_nameid[0]));
return res;
}
type *new_d_type_enumeration (ident *name, int n_enums, dbg_info* db) {
}
/* typecheck */
-int (is_enumeration_type)(const type *enumeration) {
- return __is_enumeration_type(enumeration);
+int (is_Enumeration_type)(const type *enumeration) {
+ return _is_enumeration_type(enumeration);
}
/*-----------------------------------------------------------------*/
}
/* typecheck */
-int (is_pointer_type)(const type *pointer) {
- return __is_pointer_type(pointer);
+int (is_Pointer_type)(const type *pointer) {
+ return _is_pointer_type(pointer);
}
/* Returns the first pointer type that has as points_to tp.
* Not efficient: O(#types).
- * If not found returns unknown_type. */
+ * If not found returns firm_unknown_type. */
type *find_pointer_type_to_type (type *tp) {
int i;
for (i = 0; i < get_irp_n_types(); ++i) {
type *found = get_irp_type(i);
- if (is_pointer_type(found) && get_pointer_points_to_type(found) == tp)
+ if (is_Pointer_type(found) && get_pointer_points_to_type(found) == tp)
return (found);
}
- return unknown_type;
+ return firm_unknown_type;
}
}
/* typecheck */
-int (is_primitive_type)(const type *primitive) {
- return __is_primitive_type(primitive);
+int (is_Primitive_type)(const type *primitive) {
+ return _is_primitive_type(primitive);
}
/*-----------------------------------------------------------------*/
int (is_atomic_type)(const type *tp) {
- return __is_atomic_type(tp);
+ return _is_atomic_type(tp);
}
/*
{
int res = 0;
- if (is_struct_type(tp))
+ if (is_Struct_type(tp))
res = get_struct_n_members(tp);
- else if (is_class_type(tp))
+ else if (is_Class_type(tp))
res = get_class_n_members(tp);
- else if (is_union_type(tp))
+ else if (is_Union_type(tp))
res = get_union_n_members(tp);
else
assert(0 && "need struct, union or class for member count");
{
entity *res;
- if (is_struct_type(tp))
+ if (is_Struct_type(tp))
res = get_struct_member(tp, pos);
- else if (is_class_type(tp))
+ else if (is_Class_type(tp))
res = get_class_member(tp, pos);
- else if (is_union_type(tp))
+ else if (is_Union_type(tp))
res = get_union_member(tp, pos);
else
{
int is_compound_type(const 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));
+ return tp->type_op->flags & TP_OP_FLAG_COMPOUND;
}
projects / libfirm / blobdiff