/* construct none and unknown type. */
firm_none_type = new_type(tpop_none, mode_BAD, new_id_from_str("type_none"), builtin_db);
- set_type_size_bits(firm_none_type, 0);
+ set_type_size_bytes(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"), builtin_db);
- set_type_size_bits(firm_unknown_type, 0);
+ set_type_size_bytes(firm_unknown_type, 0);
set_type_state (firm_unknown_type, layout_fixed);
remove_irp_type(firm_unknown_type);
}
}
/* Returns a human readable string for the enum entry. */
-const char *get_type_state_name(type_state s) {
+const char *get_type_state_name(ir_type_state s) {
#define X(a) case a: return #a;
switch (s) {
X(layout_undefined);
}
-type_state (get_type_state)(const ir_type *tp) {
+ir_type_state (get_type_state)(const ir_type *tp) {
return _get_type_state(tp);
}
void
-set_type_state(ir_type *tp, type_state state) {
+set_type_state(ir_type *tp, ir_type_state state) {
assert(tp && tp->kind == k_type);
if ((tp->type_op == type_pointer) || (tp->type_op == type_primitive) ||
return _type_not_visited(tp);
}
+dbg_info *(get_type_dbg_info)(const ir_type *tp) {
+ return _get_type_dbg_info(tp);
+}
+
+void (set_type_dbg_info)(ir_type *tp, dbg_info *db) {
+ _set_type_dbg_info(tp, db);
+}
+
int (is_type)(const void *thing) {
return _is_type(thing);
}
}
void free_method_entities(ir_type *method) {
+ (void) method;
assert(method && (method->type_op == type_method));
}
}
void free_array_entities (ir_type *array) {
+ (void) array;
assert(array && (array->type_op == type_array));
}
}
void free_enumeration_entities(ir_type *enumeration) {
+ (void) enumeration;
assert(enumeration && (enumeration->type_op == type_enumeration));
}
void free_enumeration_attrs(ir_type *enumeration) {
}
void free_pointer_entities(ir_type *pointer) {
+ (void) pointer;
assert(pointer && (pointer->type_op == type_pointer));
}
void free_pointer_attrs(ir_type *pointer) {
+ (void) pointer;
assert(pointer && (pointer->type_op == type_pointer));
}
ir_type *res = new_type(type_primitive, mode, name, db);
res->size = get_mode_size_bits(mode);
res->flags |= tf_layout_fixed;
+ res->attr.ba.base_type = NULL;
hook_new_type(res);
return res;
}
return new_d_type_primitive(name, mode, NULL);
}
-/* typecheck */
+/* type check */
int (is_Primitive_type)(const ir_type *primitive) {
return _is_primitive_type(primitive);
}
tp->mode = mode;
}
+/* Return the base type of a primitive (bitfield) type or NULL if none. */
+ir_type *get_primitive_base_type(ir_type *tp) {
+ assert(is_Primitive_type(tp));
+ return tp->attr.ba.base_type;
+}
+
+/* Sets the base type of a primitive (bitfield) type. */
+void set_primitive_base_type(ir_type *tp, ir_type *base_tp) {
+ assert(is_Primitive_type(tp));
+ tp->attr.ba.base_type = base_tp;
+}
/*-----------------------------------------------------------------*/
/* common functionality */