static void ungroup_proc_params(tree_t t, group_nets_ctx_t *ctx) { // Ungroup any signal that is passed to a procedure as in general we // cannot guarantee anything about the procedure's behaviour const int nparams = tree_params(t); for (int i = 0; i < nparams; i++) { tree_t value = tree_value(tree_param(t, i)); tree_kind_t kind = tree_kind(value); while (kind == T_ARRAY_REF || kind == T_ARRAY_SLICE) { value = tree_value(value); kind = tree_kind(value); } if (kind != T_REF) continue; tree_t decl = tree_ref(value); if (tree_kind(decl) != T_SIGNAL_DECL) continue; const int nnets = tree_nets(decl); for (int i = 0; i < nnets; i++) group_add(ctx, tree_net(decl, i), 1); } }
static void opt_elide_array_ref_bounds(tree_t t) { tree_t value = tree_value(t); if (tree_kind(value) != T_REF) return; tree_t decl = tree_ref(value); const int nparams = tree_params(t); for (int i = 0; i < nparams; i++) { tree_t index = tree_value(tree_param(t, i)); if (tree_kind(index) != T_REF) return; tree_t index_decl = tree_ref(index); tree_t range_var = tree_attr_tree(index_decl, range_var_i); if (range_var == NULL) return; if (range_var != decl) return; } tree_add_attr_int(t, elide_bounds_i, 1); }
static void opt_tag_last_value_fcall(tree_t t) { tree_t decl = tree_ref(t); if (tree_attr_str(decl, builtin_i) != NULL) return; // A regular subprogram call may pass parameters as class signal which // could access 'LAST_VALUE in the body const int nports = tree_ports(decl); for (int i = 0; i < nports; i++) { tree_t port = tree_port(decl, i); if (tree_class(port) != C_SIGNAL) continue; tree_t value = tree_value(tree_param(t, i)); tree_kind_t kind; while ((kind = tree_kind(value)) != T_REF) { assert((kind == T_ARRAY_REF) || (kind == T_ARRAY_SLICE)); value = tree_value(value); } tree_add_attr_int(tree_ref(value), last_value_i, 1); } }
static tree_t elab_port_to_signal(tree_t arch, tree_t port, tree_t actual) { assert(tree_kind(port) == T_PORT_DECL); ident_t name = tree_ident(port); const int ndecls = tree_decls(arch); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(arch, i); if (tree_ident(d) == name) return d; } type_t port_type = tree_type(port); type_t actual_type = tree_type(actual); type_t type = (type_is_unconstrained(port_type)) ? actual_type : port_type; port_mode_t mode = tree_subkind(port); tree_t s = tree_new(T_SIGNAL_DECL); tree_set_ident(s, tree_ident(port)); tree_set_type(s, type); tree_add_attr_int(s, fst_dir_i, mode); tree_set_loc(s, tree_loc(port)); tree_set_flag(s, tree_flags(port) & TREE_F_LAST_VALUE); if ((mode == PORT_OUT) || (mode == PORT_INOUT) || (mode == PORT_BUFFER)) { if (tree_has_value(port)) tree_add_attr_tree(s, driver_init_i, tree_value(port)); } tree_add_decl(arch, s); return s; }
class_t class_of(tree_t t) { switch (tree_kind(t)) { case T_VAR_DECL: return C_VARIABLE; case T_SIGNAL_DECL: return C_SIGNAL; case T_CONST_DECL: return C_CONSTANT; case T_PORT_DECL: return tree_class(t); case T_ENUM_LIT: case T_GENVAR: case T_ALIAS: case T_FIELD_DECL: return C_DEFAULT; case T_UNIT_DECL: return C_UNITS; case T_ARCH: return C_ARCHITECTURE; case T_FUNC_DECL: case T_FUNC_BODY: return C_FUNCTION; case T_PROC_DECL: case T_PROC_BODY: return C_PROCEDURE; case T_ENTITY: return C_ENTITY; case T_TYPE_DECL: return C_TYPE; case T_FILE_DECL: return C_FILE; case T_PROCESS: case T_BLOCK: case T_FOR: return C_LABEL; case T_COMPONENT: return C_COMPONENT; case T_REF: return class_of(tree_ref(t)); case T_ARRAY_REF: case T_ARRAY_SLICE: case T_RECORD_REF: return class_of(tree_value(t)); case T_PACKAGE: return C_PACKAGE; case T_LIBRARY: return C_LIBRARY; case T_ELAB: return C_ELAB; default: fatal("missing class_of for %s", tree_kind_str(tree_kind(t))); } }
END_TEST START_TEST(test_issue19) { input_from_file(TESTDIR "/elab/issue19.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); tree_t tmp = NULL; const int ndecls = tree_decls(e); for (int i = 0; (i < ndecls) && (tmp == NULL); i++) { tree_t t = tree_decl(e, i); if (icmp(tree_ident(t), ":comp6:c1:tmp")) tmp = t; } fail_if(tmp == NULL); tree_t value = tree_value(tmp); fail_unless(tree_kind(value) == T_LITERAL); fail_unless(tree_ival(value) == 32); for (int i = 0; (i < ndecls) && (tmp == NULL); i++) { tree_t t = tree_decl(e, i); if (icmp(tree_ident(t), ":comp6:c1:tmp3")) tmp = t; } fail_if(tmp == NULL); value = tree_value(tmp); fail_unless(tree_kind(value) == T_LITERAL); fail_unless(tree_ival(value) == 32); }
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; }
static fst_unit_t *fst_make_unit_map(type_t type) { type_t base = type_base_recur(type); const int nunits = type_units(base); fst_unit_t *map = xmalloc(nunits * sizeof(fst_unit_t)); for (int i = 0; i < nunits; i++) { tree_t unit = type_unit(base, nunits - 1 - i); map[i].mult = assume_int(tree_value(unit)); map[i].name = strdup(istr(tree_ident(unit))); } return map; }
static void group_ref(tree_t target, group_nets_ctx_t *ctx, int start, int n) { assert(tree_kind(target) == T_REF); tree_t decl = tree_ref(target); switch (tree_kind(decl)) { case T_SIGNAL_DECL: group_decl(decl, ctx, start, n); break; case T_ALIAS: group_target(tree_value(decl), ctx); break; default: break; } }
static void ungroup_name(tree_t name, group_nets_ctx_t *ctx) { switch (tree_kind(name)) { case T_ARRAY_REF: case T_ARRAY_SLICE: case T_RECORD_REF: ungroup_name(tree_value(name), ctx); break; case T_REF: ungroup_ref(name, ctx); break; default: fatal_trace("cannot handle tree type %s in ungroup_name", tree_kind_str(tree_kind(name))); } }
static tree_t rewrite_refs(tree_t t, void *context) { rewrite_params_t *params = context; if (tree_kind(t) != T_REF) return t; tree_t decl = tree_ref(t); for (int i = 0; i < params->count; i++) { if (decl != params->formals[i]) continue; // Do not rewrite references if they appear as formal names if (tree_attr_int(t, formal_i, 0)) continue; // Skip assignments to OPEN ports if (params->actuals[i] == NULL) continue; switch (tree_kind(params->actuals[i])) { case T_SIGNAL_DECL: case T_ENUM_LIT: tree_set_ref(t, params->actuals[i]); tree_set_type(t, tree_type(params->actuals[i])); return t; case T_LITERAL: case T_AGGREGATE: case T_REF: case T_ARRAY_SLICE: case T_ARRAY_REF: case T_FCALL: case T_CONCAT: return params->actuals[i]; case T_TYPE_CONV: // XXX: this only works in trivial cases return tree_value(tree_param(params->actuals[i], 0)); default: fatal_at(tree_loc(params->actuals[i]), "cannot handle tree kind %s " "in rewrite_refs", tree_kind_str(tree_kind(params->actuals[i]))); } } return t; }
static ident_t elab_formal_name(tree_t t) { tree_kind_t kind; while ((kind = tree_kind(t)) != T_REF) { switch (kind) { case T_ARRAY_REF: case T_ARRAY_SLICE: t = tree_value(t); break; default: fatal_at(tree_loc(t), "sorry, this kind of formal is not supported %s", tree_kind_str(kind)); } } return tree_ident(t); }
static void group_target(tree_t t, group_nets_ctx_t *ctx) { switch (tree_kind(t)) { case T_REF: group_ref(t, ctx, 0, -1); break; case T_ARRAY_REF: case T_ARRAY_SLICE: case T_RECORD_REF: { type_t type = tree_type(t); if (!type_known_width(type)) ungroup_name(t, ctx); else if (!group_name(t, ctx, 0, type_width(type))) ungroup_name(t, ctx); } break; case T_LITERAL: case T_OPEN: // Constant folding can cause this to appear break; case T_AGGREGATE: { const int nassocs = tree_assocs(t); for (int i = 0; i < nassocs; i++) group_target(tree_value(tree_assoc(t, i)), ctx); } break; default: fmt_loc(stdout, tree_loc(t)); fatal_trace("Cannot handle tree kind %s in group_target", tree_kind_str(tree_kind(t))); } }
END_TEST START_TEST(test_lib_save) { { tree_t ent = tree_new(T_ENTITY); tree_set_ident(ent, ident_new("name")); tree_add_attr_str(ent, ident_new("attr"), ident_new("test string")); type_t e = type_new(T_ENUM); type_set_ident(e, ident_new("myenum")); tree_t a = tree_new(T_ENUM_LIT); tree_set_ident(a, ident_new("a")); tree_set_type(a, e); tree_set_pos(a, 55); type_enum_add_literal(e, a); tree_t b = tree_new(T_ENUM_LIT); tree_set_ident(b, ident_new("b")); tree_set_type(b, e); type_enum_add_literal(e, b); tree_t p1 = tree_new(T_PORT_DECL); tree_set_ident(p1, ident_new("foo")); tree_set_subkind(p1, PORT_OUT); tree_set_type(p1, type_universal_int()); tree_add_port(ent, p1); tree_t p2 = tree_new(T_PORT_DECL); tree_set_ident(p2, ident_new("bar")); tree_set_subkind(p2, PORT_IN); tree_set_type(p2, e); tree_add_port(ent, p2); tree_t ar = tree_new(T_ARCH); tree_set_ident(ar, ident_new("arch")); tree_set_ident2(ar, ident_new("foo")); tree_t pr = tree_new(T_PROCESS); tree_set_ident(pr, ident_new("proc")); tree_add_stmt(ar, pr); tree_t v1 = tree_new(T_VAR_DECL); tree_set_ident(v1, ident_new("v1")); tree_set_type(v1, e); tree_t r = tree_new(T_REF); tree_set_ident(r, ident_new("v1")); tree_set_ref(r, v1); tree_t s = tree_new(T_VAR_ASSIGN); tree_set_ident(s, ident_new("var_assign")); tree_set_target(s, r); tree_set_value(s, r); tree_add_stmt(pr, s); tree_t c = tree_new(T_LITERAL); tree_set_subkind(c, L_INT); tree_set_ival(c, 53); tree_t s2 = tree_new(T_VAR_ASSIGN); tree_set_ident(s2, ident_new("var_assign")); tree_set_target(s2, r); tree_set_value(s2, c); tree_add_stmt(pr, s2); tree_t s3 = tree_new(T_VAR_ASSIGN); tree_set_ident(s3, ident_new("var_assign")); tree_set_target(s3, r); tree_set_value(s3, str_to_agg("foobar", NULL)); tree_add_stmt(pr, s3); tree_t s4 = tree_new(T_ASSERT); tree_set_ident(s4, ident_new("assert")); tree_set_value(s4, c); tree_set_severity(s4, c); tree_set_message(s4, str_to_agg("message", NULL)); tree_add_stmt(pr, s4); lib_put(work, ar); lib_put(work, ent); } tree_gc(); lib_save(work); lib_free(work); lib_add_search_path("/tmp"); work = lib_find(ident_new("test_lib"), false); fail_if(work == NULL); { tree_t ent = lib_get(work, ident_new("name")); fail_if(ent == NULL); fail_unless(tree_kind(ent) == T_ENTITY); fail_unless(tree_ident(ent) == ident_new("name")); fail_unless(tree_ports(ent) == 2); ident_t attr = tree_attr_str(ent, ident_new("attr")); fail_if(attr == NULL); fail_unless(icmp(attr, "test string")); tree_t p1 = tree_port(ent, 0); fail_unless(tree_kind(p1) == T_PORT_DECL); fail_unless(tree_subkind(p1) == PORT_OUT); fail_unless(type_kind(tree_type(p1)) == T_INTEGER); tree_t p2 = tree_port(ent, 1); fail_unless(tree_kind(p2) == T_PORT_DECL); fail_unless(tree_subkind(p2) == PORT_IN); type_t e = tree_type(p2); fail_unless(type_kind(e) == T_ENUM); fail_unless(type_enum_literals(e) == 2); tree_t a = type_enum_literal(e, 0); fail_unless(tree_kind(a) == T_ENUM_LIT); fail_unless(tree_ident(a) == ident_new("a")); fail_unless(tree_type(a) == e); fail_unless(tree_pos(a) == 55); tree_t b = type_enum_literal(e, 1); fail_unless(tree_kind(b) == T_ENUM_LIT); fail_unless(tree_ident(b) == ident_new("b")); fail_unless(tree_type(b) == e); tree_t ar = lib_get(work, ident_new("arch")); fail_if(ar == NULL); fail_unless(tree_ident(ar) == ident_new("arch")); fail_unless(tree_ident2(ar) == ident_new("foo")); tree_t pr = tree_stmt(ar, 0); fail_unless(tree_kind(pr) == T_PROCESS); fail_unless(tree_ident(pr) == ident_new("proc")); tree_t s = tree_stmt(pr, 0); fail_unless(tree_kind(s) == T_VAR_ASSIGN); tree_t r = tree_target(s); fail_unless(tree_kind(r) == T_REF); fail_unless(tree_value(s) == r); tree_t s2 = tree_stmt(pr, 1); fail_unless(tree_kind(s2) == T_VAR_ASSIGN); fail_unless(tree_target(s2) == r); tree_t s3 = tree_stmt(pr, 2); fail_unless(tree_kind(s3) == T_VAR_ASSIGN); fail_unless(tree_target(s3) == r); fail_unless(tree_kind(tree_value(s3)) == T_AGGREGATE); tree_t s4 = tree_stmt(pr, 3); fail_unless(tree_kind(s4) == T_ASSERT); fail_unless(tree_ident(s4) == ident_new("assert")); tree_t c = tree_value(s2); fail_unless(tree_kind(c) == T_LITERAL); fail_unless(tree_subkind(c) == L_INT); fail_unless(tree_ival(c) == 53); // Type declaration and reference written to different units // so two copies of the type declaration will be read back // hence can't check for pointer equality here fail_unless(type_eq(tree_type(tree_ref(r)), e)); } }
static tree_t elab_signal_port(tree_t arch, tree_t formal, tree_t param, map_list_t **maps) { assert(tree_kind(param) == T_PARAM); tree_t actual = tree_value(param); // NULL name means associate the whole port tree_t name = NULL; if (tree_subkind(param) == P_NAMED) { tree_t n = tree_name(param); if (tree_kind(n) != T_REF) name = n; } const bool partial_map = name != NULL; switch (tree_kind(actual)) { case T_REF: case T_ARRAY_REF: case T_ARRAY_SLICE: case T_RECORD_REF: { // Replace the formal port with a signal and connect its nets to // those of the actual tree_t ref = actual; tree_kind_t ref_kind; while ((ref_kind = tree_kind(ref)) != T_REF) { if ((ref_kind == T_AGGREGATE) || (ref_kind == T_LITERAL)) return actual; else ref = tree_value(ref); } tree_t decl = tree_ref(ref); tree_kind_t decl_kind = tree_kind(decl); if (decl_kind == T_SIGNAL_DECL) { tree_t s = elab_port_to_signal(arch, formal, actual); if (partial_map) tree_add_attr_int(s, partial_map_i, 1); map_list_t *m = xmalloc(sizeof(map_list_t)); m->next = *maps; m->formal = formal; m->actual = actual; m->signal = s; m->name = name; *maps = m; return s; } else if (decl_kind == T_PORT_DECL) return NULL; // Port was OPEN at a higher level else return actual; } case T_LITERAL: case T_AGGREGATE: { type_t formal_type = tree_type(formal); if (!type_is_unconstrained(formal_type)) tree_set_type(actual, formal_type); return actual; } case T_OPEN: return NULL; case T_TYPE_CONV: // Only allow simple array type conversions for now { type_t to_type = tree_type(actual); type_t from_type = tree_type(tree_value(tree_param(actual, 0))); if (type_is_array(to_type) && type_is_array(from_type)) return actual; else fatal_at(tree_loc(actual), "sorry, this form of type conversion " "is not supported as an actual"); } default: fatal_at(tree_loc(actual), "tree %s not supported as actual", tree_kind_str(tree_kind(actual))); } }
static map_list_t *elab_map(tree_t t, tree_t arch, tree_formals_t tree_Fs, tree_formal_t tree_F, tree_actuals_t tree_As, tree_actual_t tree_A) { tree_t unit = tree_ref(arch); assert(tree_kind(unit) == T_ENTITY); const int nformals = tree_Fs(unit); const int nactuals = (tree_As != NULL) ? tree_As(t) : 0; bool *have_formals = xmalloc(sizeof(bool) * nformals); for (int i = 0; i < nformals; i++) have_formals[i] = false; const int maxr = nformals + nactuals; tree_t *rformals = xmalloc(sizeof(tree_t) * maxr); tree_t *ractuals = xmalloc(sizeof(tree_t) * maxr); int count = 0; map_list_t *maps = NULL; for (int i = 0; i < nactuals; i++) { tree_t p = tree_A(t, i); tree_t formal = NULL; switch (tree_subkind(p)) { case P_POS: { const int pos = tree_pos(p); formal = tree_F(unit, pos); have_formals[pos] = true; } break; case P_NAMED: { ident_t name = elab_formal_name(tree_name(p)); for (int j = 0; j < nformals; j++) { tree_t port = tree_F(unit, j); if (tree_ident(port) == name) { formal = port; have_formals[j] = true; break; } } } break; default: assert(false); } assert(formal != NULL); switch (tree_class(formal)) { case C_SIGNAL: ractuals[count] = elab_signal_port(arch, formal, p, &maps); break; case C_CONSTANT: ractuals[count] = tree_value(p); break; default: assert(false); } rformals[count] = formal; count++; } // Assign default values for (unsigned i = 0; i < nformals; i++) { if (!have_formals[i]) { tree_t f = tree_F(unit, i); if (tree_has_value(f)) { rformals[count] = f; ractuals[count] = tree_value(f); count++; } } } assert(count <= maxr); if (count > 0) { rewrite_params_t params = { .formals = rformals, .actuals = ractuals, .count = count }; tree_rewrite(arch, rewrite_refs, ¶ms); tree_t ent = tree_ref(arch); if (tree_stmts(ent) > 0 || tree_decls(ent) > 0) tree_rewrite(ent, rewrite_refs, ¶ms); }
static bool group_name(tree_t target, group_nets_ctx_t *ctx, int start, int n) { switch (tree_kind(target)) { case T_REF: group_ref(target, ctx, start, n); return true; case T_ARRAY_REF: { tree_t value = tree_value(target); type_t type = tree_type(value); if (type_is_unconstrained(type)) return false; int offset = 0; const int nparams = tree_params(target); for (int i = 0; i < nparams; i++) { tree_t index = tree_value(tree_param(target, i)); const int stride = type_width(type_elem(type)); if (tree_kind(index) != T_LITERAL) { if (i > 0) return false; const int twidth = type_width(type); for (int j = 0; j < twidth; j += stride) group_name(value, ctx, start + j, n); return true; } else { if (i > 0) { range_t type_r = range_of(type, i); int64_t low, high; range_bounds(type_r, &low, &high); offset *= high - low + 1; } offset += stride * rebase_index(type, i, assume_int(index)); } } return group_name(value, ctx, start + offset, n); } case T_ARRAY_SLICE: { tree_t value = tree_value(target); type_t type = tree_type(value); if (type_is_unconstrained(type)) return false; // Only in procedure range_t slice = tree_range(target, 0 ); if (tree_kind(slice.left) != T_LITERAL || tree_kind(slice.right) != T_LITERAL) return false; int64_t low, high; range_bounds(slice, &low, &high); const int64_t low0 = rebase_index(type, 0, assume_int(slice.left)); const int stride = type_width(type_elem(type)); return group_name(value, ctx, start + low0 * stride, n); } case T_RECORD_REF: { tree_t value = tree_value(target); type_t rec = tree_type(value); const int offset = record_field_to_net(rec, tree_ident(target)); return group_name(value, ctx, start + offset, n); } case T_AGGREGATE: case T_LITERAL: // This can appear due to assignments to open ports with a // default value return true; default: fatal_at(tree_loc(target), "tree kind %s not yet supported for offset " "calculation", tree_kind_str(tree_kind(target))); } }