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->nr = get_irp_new_node_nr();
#endif /* defined DEBUG_libfirm */
return res;
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
set_type_size_bits(type *tp, int size) {
assert(tp && tp->kind == k_type);
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);
}
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) {
return _is_class_type(clss);
}
-/* 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 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 1;
- if (is_subclass_of(low, get_class_subtype(high, i)))
- return 1;
- }
- return 0;
-}
-
/*----------------------------------------------------------------**/
/* TYPE_STRUCT */
/*----------------------------------------------------------------**/
/* 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;
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));