- {
- assert(get_type_size_bits(tp) > -1);
- if (tp != get_glob_type()) {
- int n_mem = get_class_n_members(tp);
- for (i = 0; i < n_mem; i++) {
- if (get_entity_offset_bits(get_class_member(tp, i)) <= -1)
- { 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))) ||
- (get_entity_allocation(get_class_member(tp, i)) == allocation_automatic));
- */
+ assert(get_type_size_bits(tp) > -1);
+ if (tp != get_glob_type()) {
+ int n_mem = get_class_n_members(tp);
+ for (i = 0; i < n_mem; i++) {
+ if (get_entity_offset_bits(get_class_member(tp, i)) <= -1)
+ { 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))) ||
+ (get_entity_allocation(get_class_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;
+ 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;
- {
- assert(get_type_mode != NULL);
- for (i = 0; i < get_enumeration_n_enums(tp); i++)
- assert(get_enumeration_enum(tp, i) != NULL);
- } break;
+ assert(get_type_mode != NULL);
+ for (i = get_enumeration_n_enums(tp) - 1; i >= 0; --i) {
+ ir_enum_const *ec = get_enumeration_const(tp, i);
+ tarval *tv = get_enumeration_value(ec);
+ assert(tv != NULL && tv != tarval_bad);
+ }
+ break;
build_value_type(ident *name, int len, tp_ent_pair *tps) {
int i;
ir_type *res = new_type_struct(name);
build_value_type(ident *name, int len, tp_ent_pair *tps) {
int i;
ir_type *res = new_type_struct(name);
/* Remove type from type list. Must be treated differently than other types. */
remove_irp_type(res);
for (i = 0; i < len; i++) {
/* 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);
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);
/* create a new type enumeration -- set the enumerators independently */
ir_type *new_d_type_enumeration(ident *name, int n_enums, dbg_info *db) {
/* create a new type enumeration -- set the enumerators independently */
ir_type *new_d_type_enumeration(ident *name, int n_enums, dbg_info *db) {
- res->attr.ea.n_enums = 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]));
+ assert(n_enums >= 0);
+ res = new_type(type_enumeration, NULL, name, db);
+ res->attr.ea.enumer = NEW_ARR_F(ir_enum_const, n_enums);
}
void free_enumeration_attrs(ir_type *enumeration) {
assert(enumeration && (enumeration->type_op == type_enumeration));
}
void free_enumeration_attrs(ir_type *enumeration) {
assert(enumeration && (enumeration->type_op == type_enumeration));
-void set_enumeration_enum (ir_type *enumeration, int pos, tarval *con) {
- assert(enumeration && (enumeration->type_op == type_enumeration));
- assert(pos >= 0 && pos < get_enumeration_n_enums(enumeration));
- enumeration->attr.ea.enumer[pos] = con;
+
+/* create a new constant */
+void set_enumeration_const(ir_type *enumeration, int pos, ident *nameid, tarval *con) {
+ assert(0 <= pos && pos < ARR_LEN(enumeration->attr.ea.enumer));
+ enumeration->attr.ea.enumer[pos].nameid = nameid;
+ enumeration->attr.ea.enumer[pos].value = con;
+ enumeration->attr.ea.enumer[pos].owner = enumeration;
assert(enumeration && (enumeration->type_op == type_enumeration));
assert(pos >= 0 && pos < get_enumeration_n_enums(enumeration));
assert(enumeration && (enumeration->type_op == type_enumeration));
assert(pos >= 0 && pos < get_enumeration_n_enums(enumeration));
-void set_enumeration_nameid (ir_type *enumeration, int pos, ident *id) {
- assert(enumeration && (enumeration->type_op == type_enumeration));
- assert(pos >= 0 && pos < get_enumeration_n_enums(enumeration));
- enumeration->attr.ea.enum_nameid[pos] = id;
+
+ir_type *get_enumeration_owner(const ir_enum_const *enum_cnst) {
+ return enum_cnst->owner;
-ident *get_enumeration_nameid (const ir_type *enumeration, int pos) {
- assert(enumeration && (enumeration->type_op == type_enumeration));
- assert(pos >= 0 && pos < get_enumeration_n_enums(enumeration));
- return enumeration->attr.ea.enum_nameid[pos];
+void set_enumeration_value(ir_enum_const *enum_cnst, tarval *con) {
+ enum_cnst->value = con;
-const char *get_enumeration_name(const ir_type *enumeration, int pos) {
- assert(enumeration && (enumeration->type_op == type_enumeration));
- assert(pos >= 0 && pos < get_enumeration_n_enums(enumeration));
- return get_id_str(enumeration->attr.ea.enum_nameid[pos]);
+tarval *get_enumeration_value(const ir_enum_const *enum_cnst) {
+ return enum_cnst->value;
+}
+void set_enumeration_nameid(ir_enum_const *enum_cnst, ident *id) {
+ enum_cnst->nameid = id;
+}
+ident *get_enumeration_nameid(const ir_enum_const *enum_cnst) {
+ return enum_cnst->nameid;
+}
+const char *get_enumeration_name(const ir_enum_const *enum_cnst) {
+ return get_id_str(enum_cnst->nameid);
-/* 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 */
-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)