static int group_net_to_field(type_t type, netid_t nid)
{
int count = 0;
if (type_is_record(type)) {
const int nfields = type_fields(type);
netid_t first = 0;
for (int i = 0; i < nfields; i++) {
tree_t field = type_field(type, i);
type_t ftype = tree_type(field);
const netid_t next = first + type_width(tree_type(field));
if (nid >= first && nid < next) {
if (type_is_array(ftype) || type_is_record(ftype))
return count + group_net_to_field(ftype, nid - first);
else
return count;
}
first = next;
count += type_width(ftype);
}
fatal_trace("group_net_to_field failed to find field for nid=%d type=%s",
nid, type_pp(type));
}
else if (type_is_array(type)) {
type_t elem = type_elem(type);
const int width = type_width(elem);
if (type_is_record(elem))
return (nid / width) * width + group_net_to_field(elem, nid % width);
else
return group_net_to_field(elem, nid % width);
}
else
return 0;
}
unsigned type_fields(type_t t)
{
if (t->kind == T_SUBTYPE)
return type_fields(type_base(t));
else
return lookup_item(t, I_FIELDS)->tree_array.count;
}
void type_replace(type_t t, type_t a)
{
assert(t != NULL);
assert(IS(t, T_INCOMPLETE));
t->kind = a->kind;
t->ident = a->ident;
const imask_t has = has_map[t->kind];
if (has & I_DIMS) {
const int ndims = type_dims(a);
for (int i = 0; i < ndims; i++)
type_add_dim(t, type_dim(a, i));
}
switch (a->kind) {
case T_UARRAY:
for (unsigned i = 0; i < type_index_constrs(a); i++)
type_add_index_constr(t, type_index_constr(a, i));
// Fall-through
case T_CARRAY:
type_set_elem(t, type_elem(a));
break;
case T_SUBTYPE:
type_set_base(t, type_base(a));
break;
case T_FUNC:
type_set_result(t, type_result(a));
break;
case T_INTEGER:
case T_REAL:
break;
case T_ENUM:
for (unsigned i = 0; i < type_enum_literals(a); i++)
type_enum_add_literal(t, type_enum_literal(a, i));
break;
case T_RECORD:
for (unsigned i = 0; i < type_fields(a); i++)
type_add_field(t, type_field(a, i));
break;
default:
assert(false);
}
}
tree_t find_record_field(tree_t rref)
{
ident_t fname = tree_ident(rref);
type_t value_type = tree_type(tree_value(rref));
const int nfields = type_fields(value_type);
for (int i = 0; i < nfields; i++) {
tree_t field = type_field(value_type, i);
if (tree_ident(field) == fname)
return field;
}
return NULL;
}
int record_field_to_net(type_t type, ident_t name)
{
int offset = 0;
const int nfields = type_fields(type);
for (int i = 0; i < nfields; i++) {
tree_t field = type_field(type, i);
if (tree_ident(field) == name)
return offset;
else
offset += type_width(tree_type(field));
}
assert(false);
}
unsigned type_width(type_t type)
{
if (type_is_array(type)) {
const unsigned elem_w = type_width(type_elem(type));
unsigned w = 1;
const int ndims = type_dims(type);
for (int i = 0; i < ndims; i++) {
int64_t low, high;
range_bounds(type_dim(type, i), &low, &high);
w *= MAX(high - low + 1, 0) * elem_w;
}
return w;
}
else if (type_is_record(type)) {
type_t base = type_base_recur(type);
unsigned w = 0;
const int nfields = type_fields(base);
for (int i = 0; i < nfields; i++)
w += type_width(tree_type(type_field(base, i)));
return w;
}
else
return 1;
}
tree_t make_default_value(type_t type, const loc_t *loc)
{
type_t base = type_base_recur(type);
switch (type_kind(base)) {
case T_UARRAY:
assert(type_kind(type) == T_SUBTYPE);
// Fall-through
case T_CARRAY:
{
tree_t def = NULL;
const int ndims = type_dims(type);
for (int i = ndims - 1; i >= 0; i--) {
tree_t val = (def ? def : make_default_value(type_elem(base), loc));
def = tree_new(T_AGGREGATE);
tree_set_type(def, array_aggregate_type(type, i));
tree_t a = tree_new(T_ASSOC);
tree_set_subkind(a, A_OTHERS);
tree_set_value(a, val);
tree_add_assoc(def, a);
}
tree_set_type(def, type);
tree_set_loc(def, loc);
return def;
}
case T_INTEGER:
case T_PHYSICAL:
case T_REAL:
return type_dim(type, 0).left;
case T_ENUM:
{
int64_t val = 0;
const bool folded = folded_int(type_dim(type, 0).left, &val);
if (folded)
return make_ref(type_enum_literal(base, (unsigned) val));
else
return type_dim(type, 0).left;
}
case T_RECORD:
{
tree_t def = tree_new(T_AGGREGATE);
tree_set_loc(def, loc);
const int nfields = type_fields(base);
for (int i = 0; i < nfields; i++) {
tree_t field = type_field(base, i);
tree_t a = tree_new(T_ASSOC);
tree_set_subkind(a, A_POS);
tree_set_value(a, make_default_value(tree_type(field),
tree_loc(field)));
tree_add_assoc(def, a);
}
tree_set_type(def, type);
return def;
}
case T_ACCESS:
{
tree_t null = tree_new(T_LITERAL);
tree_set_loc(null, loc);
tree_set_subkind(null, L_NULL);
tree_set_type(null, type);
return null;
}
case T_UNRESOLVED:
return NULL;
default:
fatal_trace("cannot handle type %s in %s",
type_kind_str(type_kind(base)), __func__);
}
}
tree_t make_default_value(type_t type, const loc_t *loc)
{
type_t base = type_base_recur(type);
switch (type_kind(base)) {
case T_UARRAY:
assert(type_kind(type) == T_SUBTYPE);
// Fall-through
case T_CARRAY:
{
tree_t def = NULL;
const int ndims = type_dims(type);
for (int i = ndims - 1; i >= 0; i--) {
tree_t val = (def ? def : make_default_value(type_elem(base), loc));
def = tree_new(T_AGGREGATE);
tree_set_type(def, array_aggregate_type(type, i));
tree_t a = tree_new(T_ASSOC);
tree_set_subkind(a, A_OTHERS);
tree_set_value(a, val);
tree_add_assoc(def, a);
}
tree_set_type(def, type);
tree_set_loc(def, loc);
return def;
}
case T_INTEGER:
case T_PHYSICAL:
case T_REAL:
return type_dim(type, 0).left;
case T_ENUM:
return make_ref(type_enum_literal(base, 0));
case T_RECORD:
{
tree_t def = tree_new(T_AGGREGATE);
tree_set_loc(def, loc);
const int nfields = type_fields(base);
for (int i = 0; i < nfields; i++) {
tree_t field = type_field(base, i);
tree_t a = tree_new(T_ASSOC);
tree_set_subkind(a, A_POS);
tree_set_value(a, make_default_value(tree_type(field),
tree_loc(field)));
tree_add_assoc(def, a);
}
tree_set_type(def, type);
return def;
}
case T_ACCESS:
{
tree_t null = tree_new(T_LITERAL);
tree_set_loc(null, loc);
tree_set_subkind(null, L_NULL);
tree_set_type(null, type);
return null;
}
default:
assert(false);
}
}
