* Modified by: Michael Beck
* Created:
* CVS-ID: $Id$
- * Copyright: (c) 2001-2003 Universität Karlsruhe
+ * Copyright: (c) 2001-2006 Universität Karlsruhe
* Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
*/
# include "config.h"
#endif
-#ifdef HAVE_ALLOCA_H
-#include <alloca.h>
-#endif
-#ifdef HAVE_MALLOC_H
-#include <malloc.h>
-#endif
#ifdef HAVE_STRING_H
# include <string.h>
#endif
# include <stdlib.h>
#endif
-# include <stddef.h>
+#include <stddef.h>
-# include "type_t.h"
+#include "type_t.h"
-# include "xmalloc.h"
-# include "irprog_t.h"
-# include "ircons.h"
-# include "tpop_t.h"
-# include "typegmod.h"
-# include "mangle.h"
-# include "tv_t.h"
-# include "irhooks.h"
-# include "irtools.h"
+#include "xmalloc.h"
+#include "irprog_t.h"
+#include "ircons.h"
+#include "tpop_t.h"
+#include "typegmod.h"
+#include "mangle.h"
+#include "tv_t.h"
+#include "irhooks.h"
+#include "irtools.h"
+#include "entity_t.h"
-# include "array.h"
+#include "array.h"
/*-----------------------------------------------------------------*/
/** TYPE **/
}
-visibility get_type_visibility (const ir_type *tp) {
+ir_visibility get_type_visibility (const ir_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);
+ ir_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);
+ ir_entity *mem = get_compound_member(tp, i);
if (get_entity_visibility(mem) != visibility_local)
res = visibility_external_visible;
}
return tp->visibility;
}
-void set_type_visibility (ir_type *tp, visibility v) {
+void set_type_visibility (ir_type *tp, ir_visibility v) {
assert(is_type(tp));
#if 0
/* check for correctness */
visibility res = visibility_local;
if (is_compound_type(tp)) {
if (is_Array_type(tp)) {
- entity *mem = get_array_element_entity(tp);
+ ir_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);
+ ir_entity *mem = get_compound_member(tp, i);
if (get_entity_visibility(mem) > res)
res = get_entity_visibility(mem);
}
int i;
switch (get_type_tpop_code(tp)) {
case tpo_class:
- {
- 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++) {
+ assert(get_entity_offset(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));
+ */
+ }
}
- }
- } break;
+ break;
case tpo_struct:
- {
- 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(get_struct_member(tp, i)) > -1);
+ assert((get_entity_allocation(get_struct_member(tp, i)) == allocation_automatic));
+ }
+ break;
case tpo_union:
- { /* ?? */
- } break;
+ /* ?? */
+ break;
case tpo_array:
- { /* ??
+ /* ??
Check order?
Assure that only innermost dimension is dynamic? */
- } break;
+ break;
case tpo_enumeration:
- {
- assert(get_type_mode != NULL);
- for (i = 0; i < get_enumeration_n_enums(tp); i++)
- assert(get_enumeration_enum(tp, i) != NULL);
- } break;
+#ifndef NDEBUG
+ 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);
+ }
+#endif
+ break;
default: break;
} /* switch (tp) */
}
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) {
/* Checks whether two types are structural equal.*/
int equal_type(ir_type *typ1, ir_type *typ2) {
- entity **m;
+ ir_entity **m;
ir_type **t;
int i, j;
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));
+ m = alloca(sizeof(ir_entity *) * get_class_n_members(typ1));
+ memset(m, 0, sizeof(ir_entity *) * get_class_n_members(typ1));
/* First sort the members of typ2 */
for (i = 0; i < get_class_n_members(typ1); i++) {
- entity *e1 = get_class_member(typ1, i);
+ ir_entity *e1 = get_class_member(typ1, i);
for (j = 0; j < get_class_n_members(typ2); j++) {
- entity *e2 = get_class_member(typ2, j);
+ ir_entity *e2 = get_class_member(typ2, j);
if (get_entity_name(e1) == get_entity_name(e2))
m[i] = e2;
}
return 0;
}
/** Compare the supertypes **/
- t = alloca(sizeof(entity *) * get_class_n_supertypes(typ1));
- memset(t, 0, sizeof(entity *) * get_class_n_supertypes(typ1));
+ t = alloca(sizeof(ir_entity *) * get_class_n_supertypes(typ1));
+ memset(t, 0, sizeof(ir_entity *) * get_class_n_supertypes(typ1));
/* First sort the supertypes of typ2 */
for (i = 0; i < get_class_n_supertypes(typ1); i++) {
ir_type *t1 = get_class_supertype(typ1, i);
} break;
case tpo_struct: {
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));
+ m = alloca(sizeof(ir_entity *) * get_struct_n_members(typ1));
+ memset(m, 0, sizeof(ir_entity *) * get_struct_n_members(typ1));
/* First sort the members of lt */
for (i = 0; i < get_struct_n_members(typ1); i++) {
- entity *e1 = get_struct_member(typ1, i);
+ ir_entity *e1 = get_struct_member(typ1, i);
for (j = 0; j < get_struct_n_members(typ2); j++) {
- entity *e2 = get_struct_member(typ2, j);
+ ir_entity *e2 = get_struct_member(typ2, j);
if (get_entity_name(e1) == get_entity_name(e2))
m[i] = e2;
}
} break;
case tpo_union: {
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));
+ m = alloca(sizeof(ir_entity *) * get_union_n_members(typ1));
+ memset(m, 0, sizeof(ir_entity *) * get_union_n_members(typ1));
/* First sort the members of lt */
for (i = 0; i < get_union_n_members(typ1); i++) {
- entity *e1 = get_union_member(typ1, i);
+ ir_entity *e1 = get_union_member(typ1, i);
for (j = 0; j < get_union_n_members(typ2); j++) {
- entity *e2 = get_union_member(typ2, j);
+ ir_entity *e2 = get_union_member(typ2, j);
if (get_entity_name(e1) == get_entity_name(e2))
m[i] = e2;
}
/* Checks whether two types are structural comparable. */
int smaller_type (ir_type *st, ir_type *lt) {
- entity **m;
+ ir_entity **m;
int i, j;
if (st == lt) return 1;
} break;
case tpo_struct: {
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));
+ m = alloca(sizeof(ir_entity *) * get_struct_n_members(st));
+ memset(m, 0, sizeof(ir_entity *) * get_struct_n_members(st));
/* First sort the members of lt */
for (i = 0; i < get_struct_n_members(st); i++) {
- entity *se = get_struct_member(st, i);
+ ir_entity *se = get_struct_member(st, i);
for (j = 0; j < get_struct_n_members(lt); j++) {
- entity *le = get_struct_member(lt, j);
+ ir_entity *le = get_struct_member(lt, j);
if (get_entity_name(le) == get_entity_name(se))
m[i] = le;
}
} break;
case tpo_union: {
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));
+ m = alloca(sizeof(ir_entity *) * get_union_n_members(st));
+ memset(m, 0, sizeof(ir_entity *) * get_union_n_members(st));
/* First sort the members of lt */
for (i = 0; i < get_union_n_members(st); i++) {
- entity *se = get_union_member(st, i);
+ ir_entity *se = get_union_member(st, i);
for (j = 0; j < get_union_n_members(lt); j++) {
- entity *le = get_union_member(lt, j);
+ ir_entity *le = get_union_member(lt, j);
if (get_entity_name(le) == get_entity_name(se))
m[i] = le;
}
res = new_type(type_class, NULL, name, db);
- res->attr.ca.members = NEW_ARR_F (entity *, 0);
+ res->attr.ca.members = NEW_ARR_F (ir_entity *, 0);
res->attr.ca.subtypes = NEW_ARR_F (ir_type *, 0);
res->attr.ca.supertypes = NEW_ARR_F (ir_type *, 0);
res->attr.ca.peculiarity = peculiarity_existent;
}
/* manipulate private fields of class type */
-void add_class_member (ir_type *clss, entity *member) {
+void add_class_member (ir_type *clss, ir_entity *member) {
assert(clss && (clss->type_op == type_class));
assert(clss != get_entity_type(member) && "recursive type");
- ARR_APP1 (entity *, clss->attr.ca.members, member);
+ ARR_APP1 (ir_entity *, clss->attr.ca.members, member);
}
int (get_class_n_members) (const ir_type *clss) {
return _get_class_n_members(clss);
}
-int get_class_member_index(const ir_type *clss, entity *mem) {
+int get_class_member_index(const ir_type *clss, ir_entity *mem) {
int i, n;
assert(clss && (clss->type_op == type_class));
for (i = 0, n = get_class_n_members(clss); i < n; ++i)
return -1;
}
-entity *(get_class_member) (const ir_type *clss, int pos) {
+ir_entity *(get_class_member) (const ir_type *clss, int pos) {
return _get_class_member(clss, pos);
}
-entity *get_class_member_by_name(ir_type *clss, ident *name) {
+ir_entity *get_class_member_by_name(ir_type *clss, ident *name) {
int i, n_mem;
assert(clss && (clss->type_op == type_class));
n_mem = get_class_n_members(clss);
for (i = 0; i < n_mem; ++i) {
- entity *mem = get_class_member(clss, i);
+ ir_entity *mem = get_class_member(clss, i);
if (get_entity_ident(mem) == name) return mem;
}
return NULL;
}
-void set_class_member (ir_type *clss, entity *member, int pos) {
+void set_class_member (ir_type *clss, ir_entity *member, int pos) {
assert(clss && (clss->type_op == type_class));
assert(pos >= 0 && pos < get_class_n_members(clss));
clss->attr.ca.members[pos] = member;
}
-void set_class_members (ir_type *clss, entity **members, int arity) {
+void set_class_members (ir_type *clss, ir_entity **members, int arity) {
int i;
assert(clss && (clss->type_op == type_class));
DEL_ARR_F(clss->attr.ca.members);
- clss->attr.ca.members = NEW_ARR_F (entity *, 0);
+ clss->attr.ca.members = NEW_ARR_F (ir_entity *, 0);
for (i = 0; i < arity; i++) {
set_entity_owner(members[i], clss);
- ARR_APP1 (entity *, clss->attr.ca.members, members[i]);
+ ARR_APP1 (ir_entity *, clss->attr.ca.members, members[i]);
}
}
-void remove_class_member(ir_type *clss, entity *member) {
+void remove_class_member(ir_type *clss, ir_entity *member) {
int i;
assert(clss && (clss->type_op == type_class));
for (i = 0; i < (ARR_LEN (clss->attr.ca.members)); i++) {
if (clss->attr.ca.members[i] == member) {
for (; i < (ARR_LEN (clss->attr.ca.members)) - 1; i++)
clss->attr.ca.members[i] = clss->attr.ca.members[i + 1];
- ARR_SETLEN(entity*, clss->attr.ca.members, ARR_LEN(clss->attr.ca.members) - 1);
+ ARR_SETLEN(ir_entity*, clss->attr.ca.members, ARR_LEN(clss->attr.ca.members) - 1);
break;
}
}
if (clss->attr.ca.subtypes[i] == subtype) {
for (; i < (ARR_LEN (clss->attr.ca.subtypes))-1; i++)
clss->attr.ca.subtypes[i] = clss->attr.ca.subtypes[i+1];
- ARR_SETLEN(entity*, clss->attr.ca.subtypes, ARR_LEN(clss->attr.ca.subtypes) - 1);
+ ARR_SETLEN(ir_entity*, clss->attr.ca.subtypes, ARR_LEN(clss->attr.ca.subtypes) - 1);
break;
}
}
if (clss->attr.ca.supertypes[i] == supertype) {
for(; i < (ARR_LEN (clss->attr.ca.supertypes))-1; i++)
clss->attr.ca.supertypes[i] = clss->attr.ca.supertypes[i+1];
- ARR_SETLEN(entity*, clss->attr.ca.supertypes, ARR_LEN(clss->attr.ca.supertypes) - 1);
+ ARR_SETLEN(ir_entity*, clss->attr.ca.supertypes, ARR_LEN(clss->attr.ca.supertypes) - 1);
break;
}
}
-entity *get_class_type_info(const ir_type *clss) {
+ir_entity *get_class_type_info(const ir_type *clss) {
return clss->attr.ca.type_info;
}
-void set_class_type_info(ir_type *clss, entity *ent) {
+void set_class_type_info(ir_type *clss, ir_entity *ent) {
clss->attr.ca.type_info = ent;
+ if (ent)
+ ent->repr_class = clss;
}
-const char *get_peculiarity_string(peculiarity p) {
+const char *get_peculiarity_name(ir_peculiarity p) {
#define X(a) case a: return #a
switch (p) {
X(peculiarity_description);
return "invalid peculiarity";
}
-peculiarity get_class_peculiarity (const ir_type *clss) {
+ir_peculiarity get_class_peculiarity (const ir_type *clss) {
assert(clss && (clss->type_op == type_class));
return clss->attr.ca.peculiarity;
}
-void set_class_peculiarity (ir_type *clss, peculiarity pec) {
+void set_class_peculiarity (ir_type *clss, ir_peculiarity pec) {
assert(clss && (clss->type_op == type_class));
assert(pec != peculiarity_inherited); /* There is no inheritance of types in libFirm. */
clss->attr.ca.peculiarity = pec;
ir_type *new_d_type_struct(ident *name, dbg_info *db) {
ir_type *res = new_type(type_struct, NULL, name, db);
- res->attr.sa.members = NEW_ARR_F(entity *, 0);
+ res->attr.sa.members = NEW_ARR_F(ir_entity *, 0);
hook_new_type(res);
return res;
}
return (ARR_LEN (strct->attr.sa.members));
}
-void add_struct_member (ir_type *strct, entity *member) {
+void add_struct_member (ir_type *strct, ir_entity *member) {
assert(strct && (strct->type_op == type_struct));
assert(get_type_tpop(get_entity_type(member)) != type_method);
/* @@@ lowerfirm geht nicht durch */
assert(strct != get_entity_type(member) && "recursive type");
- ARR_APP1 (entity *, strct->attr.sa.members, member);
+ ARR_APP1 (ir_entity *, strct->attr.sa.members, member);
}
-entity *get_struct_member (const ir_type *strct, int pos) {
+ir_entity *get_struct_member (const ir_type *strct, int pos) {
assert(strct && (strct->type_op == type_struct));
assert(pos >= 0 && pos < get_struct_n_members(strct));
return strct->attr.sa.members[pos];
}
-int get_struct_member_index(const ir_type *strct, entity *mem) {
+int get_struct_member_index(const ir_type *strct, ir_entity *mem) {
int i, n;
assert(strct && (strct->type_op == type_struct));
for (i = 0, n = get_struct_n_members(strct); i < n; ++i)
return -1;
}
-void set_struct_member (ir_type *strct, int pos, entity *member) {
+void set_struct_member (ir_type *strct, int pos, ir_entity *member) {
assert(strct && (strct->type_op == type_struct));
assert(pos >= 0 && pos < get_struct_n_members(strct));
assert(get_entity_type(member)->type_op != type_method);/* @@@ lowerfirm !!*/
strct->attr.sa.members[pos] = member;
}
-void remove_struct_member(ir_type *strct, entity *member) {
+void remove_struct_member(ir_type *strct, ir_entity *member) {
int i;
assert(strct && (strct->type_op == type_struct));
for (i = 0; i < (ARR_LEN (strct->attr.sa.members)); i++)
if (strct->attr.sa.members[i] == member) {
for(; i < (ARR_LEN (strct->attr.sa.members))-1; i++)
strct->attr.sa.members[i] = strct->attr.sa.members[i+1];
- ARR_SETLEN(entity*, strct->attr.sa.members, ARR_LEN(strct->attr.sa.members) - 1);
+ ARR_SETLEN(ir_entity*, strct->attr.sa.members, ARR_LEN(strct->attr.sa.members) - 1);
break;
}
}
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++) {
+ ident *id = tps[i].param_name;
+
/* use res as default if corresponding type is not yet set. */
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);
+ /* use the parameter name if specified */
+ if (! id)
+ id = mangle_u(name, get_type_ident(elt_type));
+ tps[i].ent = new_entity(res, id, elt_type);
+ set_entity_allocation(tps[i].ent, allocation_parameter);
}
return res;
}
res->flags |= tf_layout_fixed;
res->size = get_mode_size_bits(mode_P_code);
res->attr.ma.n_params = n_param;
- res->attr.ma.param_type = xcalloc(n_param, sizeof(res->attr.ma.param_type[0]));
+ res->attr.ma.params = xcalloc(n_param, sizeof(res->attr.ma.params[0]));
res->attr.ma.value_params = NULL;
res->attr.ma.n_res = n_res;
res->attr.ma.res_type = xcalloc(n_res, sizeof(res->attr.ma.res_type[0]));
/* Attention: also frees entities in value parameter subtypes! */
void free_method_attrs(ir_type *method) {
assert(method && (method->type_op == type_method));
- free(method->attr.ma.param_type);
+ free(method->attr.ma.params);
free(method->attr.ma.res_type);
if (method->attr.ma.value_params) {
free_type_entities(method->attr.ma.value_params);
return _get_method_n_params(method);
}
+/* Returns the type of the parameter at position pos of a method. */
ir_type *get_method_param_type(ir_type *method, int pos) {
ir_type *res;
assert(method && (method->type_op == type_method));
assert(pos >= 0 && pos < get_method_n_params(method));
- res = method->attr.ma.param_type[pos].tp;
+ res = method->attr.ma.params[pos].tp;
assert(res != NULL && "empty method param type");
- return method->attr.ma.param_type[pos].tp = skip_tid(res);
+ return method->attr.ma.params[pos].tp = skip_tid(res);
}
void set_method_param_type(ir_type *method, int pos, ir_type *tp) {
assert(method && (method->type_op == type_method));
assert(pos >= 0 && pos < get_method_n_params(method));
- method->attr.ma.param_type[pos].tp = tp;
+ method->attr.ma.params[pos].tp = tp;
/* If information constructed set pass-by-value representation. */
if (method->attr.ma.value_params) {
assert(get_method_n_params(method) == get_struct_n_members(method->attr.ma.value_params));
}
}
+/* Returns an ident representing the parameters name. Returns NULL if not set.
+ For debug support only. */
+ident *get_method_param_ident(ir_type *method, int pos) {
+ assert(method && (method->type_op == type_method));
+ assert(pos >= 0 && pos < get_method_n_params(method));
+ return method->attr.ma.params[pos].param_name;
+}
+
+/* Returns a string representing the parameters name. Returns NULL if not set.
+ For debug support only. */
+const char *get_method_param_name(ir_type *method, int pos) {
+ ident *id = get_method_param_ident(method, pos);
+ return id ? get_id_str(id) : NULL;
+}
+
+/* Sets an ident representing the parameters name. For debug support only. */
+void set_method_param_ident(ir_type *method, int pos, ident *id) {
+ assert(method && (method->type_op == type_method));
+ assert(pos >= 0 && pos < get_method_n_params(method));
+ method->attr.ma.params[pos].param_name = id;
+}
+
/* Returns an entity that represents the copied value argument. Only necessary
for compounds passed by value. */
-entity *get_method_value_param_ent(ir_type *method, int pos) {
+ir_entity *get_method_value_param_ent(ir_type *method, int pos) {
assert(method && (method->type_op == type_method));
assert(pos >= 0 && pos < get_method_n_params(method));
/* parameter value type not created yet, build */
method->attr.ma.value_params
= build_value_type(mangle_u(get_type_ident(method), value_params_suffix),
- get_method_n_params(method), method->attr.ma.param_type);
+ get_method_n_params(method), method->attr.ma.params);
}
/*
* build_value_type() sets the method->attr.ma.value_params type as default if
* no type is set!
*/
- assert((get_entity_type(method->attr.ma.param_type[pos].ent) != method->attr.ma.value_params)
+ assert((get_entity_type(method->attr.ma.params[pos].ent) != method->attr.ma.value_params)
&& "param type not yet set");
- return method->attr.ma.param_type[pos].ent;
+ return method->attr.ma.params[pos].ent;
}
/*
/* Returns an entity that represents the copied value result. Only necessary
for compounds passed by value. */
-entity *get_method_value_res_ent(ir_type *method, int pos) {
+ir_entity *get_method_value_res_ent(ir_type *method, int pos) {
assert(method && (method->type_op == type_method));
assert(pos >= 0 && pos < get_method_n_ress(method));
ir_type *new_d_type_union(ident *name, dbg_info *db) {
ir_type *res = new_type(type_union, NULL, name, db);
- res->attr.ua.members = NEW_ARR_F(entity *, 0);
+ res->attr.ua.members = NEW_ARR_F(ir_entity *, 0);
hook_new_type(res);
return res;
}
assert(uni && (uni->type_op == type_union));
return (ARR_LEN (uni->attr.ua.members));
}
-void add_union_member (ir_type *uni, entity *member) {
+void add_union_member (ir_type *uni, ir_entity *member) {
assert(uni && (uni->type_op == type_union));
assert(uni != get_entity_type(member) && "recursive type");
- ARR_APP1 (entity *, uni->attr.ua.members, member);
+ ARR_APP1 (ir_entity *, uni->attr.ua.members, member);
}
-entity *get_union_member (const ir_type *uni, int pos) {
+ir_entity *get_union_member (const ir_type *uni, int pos) {
assert(uni && (uni->type_op == type_union));
assert(pos >= 0 && pos < get_union_n_members(uni));
return uni->attr.ua.members[pos];
}
-int get_union_member_index(const ir_type *uni, entity *mem) {
+int get_union_member_index(const ir_type *uni, ir_entity *mem) {
int i, n;
assert(uni && (uni->type_op == type_union));
for (i = 0, n = get_union_n_members(uni); i < n; ++i)
return i;
return -1;
}
-void set_union_member (ir_type *uni, int pos, entity *member) {
+void set_union_member (ir_type *uni, int pos, ir_entity *member) {
assert(uni && (uni->type_op == type_union));
assert(pos >= 0 && pos < get_union_n_members(uni));
uni->attr.ua.members[pos] = member;
}
-void remove_union_member(ir_type *uni, entity *member) {
+void remove_union_member(ir_type *uni, ir_entity *member) {
int i;
assert(uni && (uni->type_op == type_union));
for (i = 0; i < (ARR_LEN (uni->attr.ua.members)); i++)
if (uni->attr.ua.members[i] == member) {
for(; i < (ARR_LEN (uni->attr.ua.members))-1; i++)
uni->attr.ua.members[i] = uni->attr.ua.members[i+1];
- ARR_SETLEN(entity*, uni->attr.ua.members, ARR_LEN(uni->attr.ua.members) - 1);
+ ARR_SETLEN(ir_entity*, uni->attr.ua.members, ARR_LEN(uni->attr.ua.members) - 1);
break;
}
}
return array->attr.aa.element_type = skip_tid(array->attr.aa.element_type);
}
-void set_array_element_entity (ir_type *array, entity *ent) {
+void set_array_element_entity (ir_type *array, ir_entity *ent) {
assert(array && (array->type_op == type_array));
assert((get_entity_type(ent)->type_op != type_method));
array->attr.aa.element_ent = ent;
array->attr.aa.element_type = get_entity_type(ent);
}
-entity *get_array_element_entity (const ir_type *array) {
+ir_entity *get_array_element_entity (const ir_type *array) {
assert(array && (array->type_op == type_array));
return array->attr.aa.element_ent;
}
/* create a new type enumeration -- set the enumerators independently */
ir_type *new_d_type_enumeration(ident *name, int n_enums, dbg_info *db) {
- ir_type *res = new_type(type_enumeration, NULL, name, db);
+ ir_type *res;
- 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);
hook_new_type(res);
return res;
}
}
void free_enumeration_attrs(ir_type *enumeration) {
assert(enumeration && (enumeration->type_op == type_enumeration));
- free(enumeration->attr.ea.enumer);
- free(enumeration->attr.ea.enum_nameid);
+ DEL_ARR_F(enumeration->attr.ea.enumer);
}
/* manipulate fields of enumeration type. */
-int get_enumeration_n_enums (const ir_type *enumeration) {
+int get_enumeration_n_enums(const ir_type *enumeration) {
assert(enumeration && (enumeration->type_op == type_enumeration));
- return enumeration->attr.ea.n_enums;
+ return ARR_LEN(enumeration->attr.ea.enumer);
}
-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;
}
-tarval *get_enumeration_enum (const ir_type *enumeration, int pos) {
+
+ir_enum_const *get_enumeration_const(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.enumer[pos];
+ return &enumeration->attr.ea.enumer[pos];
}
-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);
}
/* typecheck */
/*
* Gets the member of a firm compound type at position pos.
*/
-entity *get_compound_member(const ir_type *tp, int pos)
+ir_entity *get_compound_member(const ir_type *tp, int pos)
{
const tp_op *op = get_type_tpop(tp);
- entity *res = NULL;
+ ir_entity *res = NULL;
if (op->ops.get_member)
res = op->ops.get_member(tp, pos);
}
/* Returns index of member in tp, -1 if not contained. */
-int get_compound_member_index(const ir_type *tp, entity *member)
+int get_compound_member_index(const ir_type *tp, ir_entity *member)
{
const tp_op *op = get_type_tpop(tp);
int index = -1;
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;
}
/* Remove type from type list. Must be treated differently than other types. */
remove_irp_type(res);
+ /* It is not possible to derive from the frame type. Set the final flag. */
+ set_class_final(res, 1);
+
return res;
}
* 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)
+ir_entity *frame_alloc_area(ir_type *frame_type, int size, int alignment, int at_start)
{
- entity *area;
+ ir_entity *area;
ir_type *tp;
ident *name;
char buf[32];
assert(is_frame_type(frame_type));
assert(get_type_state(frame_type) == layout_fixed);
+ assert(get_type_alignment_bytes(frame_type) > 0);
if (! a_byte)
a_byte = new_type_primitive(new_id_from_chars("byte", 4), mode_Bu);
if (at_start) {
/* fix all offsets so far */
for (i = get_class_n_members(frame_type) - 1; i >= 0; --i) {
- entity *ent = get_class_member(frame_type, i);
+ ir_entity *ent = get_class_member(frame_type, i);
- set_entity_offset_bytes(ent, get_entity_offset_bytes(ent) + size);
+ set_entity_offset(ent, get_entity_offset(ent) + size);
}
/* calculate offset and new type size */
offset = 0;
}
area = new_entity(frame_type, name, tp);
- set_entity_offset_bytes(area, offset);
+ set_entity_offset(area, offset);
set_type_size_bytes(frame_type, frame_size);
+ /* mark this entity as compiler generated */
+ set_entity_compiler_generated(area, 1);
return area;
}