if (state == layout_fixed)
tp->flags |= tf_layout_fixed;
else
- tp->flags &= tf_layout_fixed;
+ tp->flags &= ~tf_layout_fixed;
}
unsigned long (get_type_visited)(const ir_type *tp) {
res->attr.ca.supertypes = NEW_ARR_F (ir_type *, 0);
res->attr.ca.peculiarity = peculiarity_existent;
res->attr.ca.type_info = NULL;
- res->attr.ca.final = 0;
+ res->attr.ca.vtable_size = 0;
+ res->attr.ca.clss_flags = cf_none;
res->attr.ca.dfn = 0;
hook_new_type(res);
return res;
clss->attr.ca.type_info = ent;
}
-const char *get_peculiarity_string(peculiarity p) {
+const char *get_peculiarity_name(peculiarity p) {
#define X(a) case a: return #a
switch (p) {
X(peculiarity_description);
clss->attr.ca.peculiarity = pec;
}
+/* Returns the size of the virtual function table. */
+unsigned (get_class_vtable_size)(const ir_type *clss) {
+ return _get_class_vtable_size(clss);
+}
+
+/* Sets a new size of the virtual function table. */
+void (set_class_vtable_size)(ir_type *clss, unsigned size) {
+ _set_class_vtable_size(clss, size);
+}
+
+/* Returns non-zero if a class is final. */
int (is_class_final)(const ir_type *clss) {
return _is_class_final(clss);
}
-void (set_class_final)(ir_type *clss, int final) {
- _set_class_final(clss, final);
+/* Sets if a class is final. */
+void (set_class_final)(ir_type *clss, int flag) {
+ _set_class_final(clss, flag);
+}
+
+/* Returns non-zero if a class is an interface. */
+int (is_class_interface)(const ir_type *clss) {
+ return _is_class_interface(clss);
+}
+
+/* Sets the class interface flag. */
+void (set_class_interface)(ir_type *clss, int flag) {
+ _set_class_interface(clss, flag);
+}
+
+/* Returns non-zero if a class is abstract. */
+int (is_class_abstract)(const ir_type *clss) {
+ return _is_class_abstract(clss);
+}
+
+/* Sets the class abstract flag. */
+void (set_class_abstract)(ir_type *clss, int final) {
+ _set_class_abstract(clss, final);
}
void set_class_dfn (ir_type *clss, int dfn) {
build_value_type(ident *name, int len, tp_ent_pair *tps) {
int i;
ir_type *res = new_type_struct(name);
+ res->flags |= tf_value_param_type;
/* Remove type from type list. Must be treated differently than other types. */
remove_irp_type(res);
for (i = 0; i < len; i++) {
ir_type *elt_type = tps[i].tp ? tps[i].tp : res;
tps[i].ent = new_entity(res, mangle_u(name, get_type_ident(elt_type)), elt_type);
+ set_entity_allocation(tps[i].ent, allocation_parameter);
}
return res;
}
assert(array && (array->type_op == type_array));
free(array->attr.aa.lower_bound);
free(array->attr.aa.upper_bound);
+ free(array->attr.aa.order);
}
/* manipulate private fields of array ir_type */
return tp->type_op->flags & TP_OP_FLAG_COMPOUND;
}
-/* Checks, whether a type is a frame ir_type */
+/* Checks, whether a type is a frame type */
int is_frame_type(const ir_type *tp) {
return tp->flags & tf_frame_type;
}
-/* Checks, whether a type is a lowered ir_type */
+/* Checks, whether a type is a value parameter type */
+int is_value_param_type(const ir_type *tp) {
+ return tp->flags & tf_value_param_type;
+}
+
+/* Checks, whether a type is a lowered type */
int is_lowered_type(const ir_type *tp) {
return tp->flags & tf_lowered_type;
}
* at the start or the end of a frame type.
* The frame type must have already an fixed layout.
*/
-entity *frame_alloc_area(type *frame_type, int size, int alignment, int at_start)
+entity *frame_alloc_area(ir_type *frame_type, int size, int alignment, int at_start)
{
entity *area;
ir_type *tp;