/** 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
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;
}
/* 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) {
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++) {
if (!m[i] || /* Found no counterpart */
!equal_entity(get_class_member(typ1, i), m[i]))
- return false;
+ return 0;
}
/** Compare the supertypes **/
t = alloca(sizeof(entity *) * get_class_n_supertypes(typ1));
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;
+ 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++) {
if (!m[i] || /* Found no counterpart */
!equal_entity(get_struct_member(typ1, i), m[i]))
- return false;
+ 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++) {
if (!m[i] || /* Found no counterpart */
!equal_entity(get_union_member(typ1, i), m[i]))
- return false;
+ 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;
+ return 0;
if (get_array_order(typ1, i) != get_array_order(typ2, i))
assert(0 && "type compare with different dimension orders not implemented");
}
} 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 */
if (!m[i] || /* Found no counterpart */
!smaller_type(get_entity_type(get_struct_member(st, i)),
get_entity_type(m[i])))
- return false;
+ 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 */
if (!m[i] || /* Found no counterpart */
!smaller_type(get_entity_type(get_union_member(st, i)),
get_entity_type(m[i])))
- return false;
+ 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) {
be fixed. */
if ((get_type_state(set) != layout_fixed) ||
(get_type_state(let) != layout_fixed))
- return false;
+ return 0;
if (!smaller_type(set, let) ||
get_type_size_bits(set) != get_type_size_bits(let))
- return false;
+ 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;
+ return 0;
if (get_array_upper_bound(lt, i))
if(get_array_upper_bound(st, i) != get_array_upper_bound(lt, i))
- return false;
+ 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;
}
/*-----------------------------------------------------------------*/
return __is_class_type(clss);
}
-bool is_subclass_of(type *low, type *high) {
+/* Returns true if low is subclass of high. */
+int is_subclass_of(type *low, type *high) {
int i;
assert(is_class_type(low) && is_class_type(high));
- if (low == high) return true;
+ if (low == high) return 1;
/* 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;
+ return 1;
if (is_subclass_of(low, get_class_subtype(high, i)))
- return true;
+ return 1;
}
- return false;
+ return 0;
}
/*----------------------------------------------------------------**/
/* 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) {
if (is_pointer_type(found) && get_pointer_points_to_type(found) == tp)
return (found);
}
- return unknown_type;
+ return firm_unknown_type;
}