bool folded_enum(tree_t t, unsigned *pos) { if (tree_kind(t) == T_REF) { tree_t decl = tree_ref(t); if (tree_kind(decl) == T_ENUM_LIT) { *pos = tree_pos(decl); return true; } } return false; }
bool folded_bool(tree_t t, bool *b) { if (tree_kind(t) == T_REF) { tree_t decl = tree_ref(t); if (tree_kind(decl) == T_ENUM_LIT && type_ident(tree_type(decl)) == std_bool_i) { *b = (tree_pos(decl) == 1); return true; } } return false; }
bool folded_bool(tree_t t, bool *b) { ident_t std_bool_i = ident_new("STD.STANDARD.BOOLEAN"); if (tree_kind(t) == T_REF) { tree_t decl = tree_ref(t); if (tree_kind(decl) == T_ENUM_LIT && type_ident(tree_type(decl)) == std_bool_i) { *b = (tree_pos(decl) == 1); return true; } } return false; }
int64_t assume_int(tree_t t) { switch (tree_kind(t)) { case T_LITERAL: assert(tree_subkind(t) == L_INT); return tree_ival(t); case T_REF: { tree_t ref = tree_ref(t); assert(tree_kind(ref) == T_ENUM_LIT); return tree_pos(ref); } default: fatal_at(tree_loc(t), "expression cannot be folded to " "an integer constant"); } }
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 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); }