void
verify_bottom_code (gcc_jit_context *ctxt, gcc_jit_result *result)
{
typedef int (*fn_type) (double a, double b, double c,
double *r1, double *r2);
CHECK_NON_NULL (result);
fn_type test_quadratic =
(fn_type)gcc_jit_result_get_code (result, "test_quadratic");
CHECK_NON_NULL (test_quadratic);
/* Verify that the code correctly solves quadratic equations. */
double r1, r2;
/* This one has two solutions: */
CHECK_VALUE (test_quadratic (1, 3, -4, &r1, &r2), 2);
CHECK_VALUE (r1, 1);
CHECK_VALUE (r2, -4);
/* This one has one solution: */
CHECK_VALUE (test_quadratic (4, 4, 1, &r1, &r2), 1);
CHECK_VALUE (r1, -0.5);
/* This one has no real solutions: */
CHECK_VALUE (test_quadratic (4, 1, 1, &r1, &r2), 0);
}
static void
verify_test_of_builtin_trig (gcc_jit_context *ctxt, gcc_jit_result *result)
{
typedef double (*fn_type) (double);
CHECK_NON_NULL (result);
fn_type test_of_builtin_trig =
(fn_type)gcc_jit_result_get_code (result, "test_of_builtin_trig");
CHECK_NON_NULL (test_of_builtin_trig);
/* Verify that it correctly computes
sin (2 * theta)
(perhaps calling sin and cos). */
CHECK_DOUBLE_VALUE (test_of_builtin_trig (0.0 ), 0.0);
CHECK_DOUBLE_VALUE (test_of_builtin_trig (M_PI_4 ), 1.0);
CHECK_DOUBLE_VALUE (test_of_builtin_trig (M_PI_2 ), 0.0);
CHECK_DOUBLE_VALUE (test_of_builtin_trig (M_PI_4 * 3.0), -1.0);
CHECK_DOUBLE_VALUE (test_of_builtin_trig (M_PI ), 0.0);
/* PR jit/64020:
The "sincos" pass merges sin/cos calls into the cexpi builtin.
Verify that a dump of the "sincos" pass was provided, and that it
shows a call to the cexpi builtin on a SSA name of "theta". */
CHECK_NON_NULL (trig_sincos_dump);
CHECK_STRING_CONTAINS (trig_sincos_dump, " = __builtin_cexpi (theta_");
free (trig_sincos_dump);
/* Similarly, verify that the statistics dump was provided, and that
it shows the sincos optimization. */
CHECK_NON_NULL (trig_statistics_dump);
CHECK_STRING_CONTAINS (
trig_statistics_dump,
"sincos \"sincos statements inserted\" \"test_of_builtin_trig\" 1");
free (trig_statistics_dump);
}
extern void
verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
{
typedef void (*fn_type) (const char *);
CHECK_NON_NULL (result);
fn_type hello_world =
(fn_type)gcc_jit_result_get_code (result, "hello_world");
CHECK_NON_NULL (hello_world);
hello_world ("world");
fflush (stdout);
}
void
verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
{
CHECK_NON_NULL (result);
typedef int (*my_fn_type) (void);
CHECK_NON_NULL (result);
my_fn_type my_fn =
(my_fn_type)gcc_jit_result_get_code (result, long_names.fn_name);
CHECK_NON_NULL (my_fn);
int val = my_fn ();
CHECK_VALUE (val, 42);
}
static void
verify_void_return (gcc_jit_context *ctxt, gcc_jit_result *result)
{
typedef void (*fn_type) (int *);
CHECK_NON_NULL (result);
fn_type test_of_void_return =
(fn_type)gcc_jit_result_get_code (result, "test_of_void_return");
CHECK_NON_NULL (test_of_void_return);
int i;
test_of_void_return (&i);
CHECK_VALUE (i, 1); /* ensure correct value was written back */
}
static void
verify_test_of_builtin_strcmp (gcc_jit_context *ctxt, gcc_jit_result *result)
{
typedef int (*fn_type) (const char *, const char *);
CHECK_NON_NULL (result);
fn_type test_of_builtin_strcmp =
(fn_type)gcc_jit_result_get_code (result, "test_of_builtin_strcmp");
CHECK_NON_NULL (test_of_builtin_strcmp);
/* Verify that it correctly called strcmp. */
CHECK_VALUE (test_of_builtin_strcmp ("foo", "foo"), 0);
CHECK (test_of_builtin_strcmp ("foo", "bar") > 0);
CHECK (test_of_builtin_strcmp ("bar", "foo") < 0);
}
Z3_bool Z3_API Z3_fpa_get_numeral_sign(Z3_context c, Z3_ast t, int * sgn) {
Z3_TRY;
LOG_Z3_fpa_get_numeral_sign(c, t, sgn);
RESET_ERROR_CODE();
CHECK_NON_NULL(t, 0);
CHECK_VALID_AST(t, 0);
if (sgn == nullptr) {
SET_ERROR_CODE(Z3_INVALID_ARG);
return 0;
}
ast_manager & m = mk_c(c)->m();
mpf_manager & mpfm = mk_c(c)->fpautil().fm();
family_id fid = mk_c(c)->get_fpa_fid();
fpa_decl_plugin * plugin = (fpa_decl_plugin*)m.get_plugin(fid);
expr * e = to_expr(t);
if (!is_app(e) || is_app_of(e, fid, OP_FPA_NAN) || !is_fp(c, t)) {
SET_ERROR_CODE(Z3_INVALID_ARG);
return 0;
}
scoped_mpf val(mpfm);
bool r = plugin->is_numeral(to_expr(t), val);
if (!r || mpfm.is_nan(val)) {
SET_ERROR_CODE(Z3_INVALID_ARG);
return 0;
}
*sgn = mpfm.sgn(val);
return r;
Z3_CATCH_RETURN(0);
}
Z3_ast Z3_API Z3_get_model_func_entry_value(Z3_context c,
Z3_model m,
unsigned i,
unsigned j) {
Z3_TRY;
LOG_Z3_get_model_func_entry_value(c, m, i, j);
RESET_ERROR_CODE();
CHECK_NON_NULL(m, 0);
if (j >= get_model_func_num_entries_core(c, m, i)) {
SET_ERROR_CODE(Z3_IOB);
RETURN_Z3(0);
}
Z3_func_decl d = get_model_func_decl_core(c, m, i);
if (d) {
model * _m = to_model_ref(m);
func_interp * g = _m->get_func_interp(to_func_decl(d));
if (g && j < g->num_entries()) {
func_entry const* e = g->get_entry(j);
expr* a = e->get_result();
mk_c(c)->save_ast_trail(a);
RETURN_Z3(of_ast(a));
}
SET_ERROR_CODE(Z3_IOB);
RETURN_Z3(0);
}
RETURN_Z3(0);
Z3_CATCH_RETURN(0);
}
Z3_ast Z3_API Z3_fpa_get_numeral_sign_bv(Z3_context c, Z3_ast t) {
Z3_TRY;
LOG_Z3_fpa_get_numeral_sign_bv(c, t);
RESET_ERROR_CODE();
CHECK_NON_NULL(t, nullptr);
CHECK_VALID_AST(t, nullptr);
ast_manager & m = mk_c(c)->m();
mpf_manager & mpfm = mk_c(c)->fpautil().fm();
family_id fid = mk_c(c)->get_fpa_fid();
fpa_decl_plugin * plugin = (fpa_decl_plugin*)m.get_plugin(fid);
api::context * ctx = mk_c(c);
expr * e = to_expr(t);
if (!is_app(e) || is_app_of(e, fid, OP_FPA_NAN) || !is_fp(c, t)) {
SET_ERROR_CODE(Z3_INVALID_ARG);
RETURN_Z3(nullptr);
}
scoped_mpf val(mpfm);
bool r = plugin->is_numeral(to_expr(t), val);
if (!r || mpfm.is_nan(val)) {
SET_ERROR_CODE(Z3_INVALID_ARG);
return nullptr;
}
app * a;
if (mpfm.is_pos(val))
a = ctx->bvutil().mk_numeral(0, 1);
else
a = ctx->bvutil().mk_numeral(1, 1);
mk_c(c)->save_ast_trail(a);
RETURN_Z3(of_expr(a));
Z3_CATCH_RETURN(nullptr);
}
Z3_ast Z3_API Z3_fpa_get_numeral_significand_bv(Z3_context c, Z3_ast t) {
Z3_TRY;
LOG_Z3_fpa_get_numeral_significand_bv(c, t);
RESET_ERROR_CODE();
CHECK_NON_NULL(t, nullptr);
CHECK_VALID_AST(t, nullptr);
ast_manager & m = mk_c(c)->m();
mpf_manager & mpfm = mk_c(c)->fpautil().fm();
unsynch_mpq_manager & mpqm = mpfm.mpq_manager();
family_id fid = mk_c(c)->get_fpa_fid();
fpa_decl_plugin * plugin = (fpa_decl_plugin*)m.get_plugin(fid);
SASSERT(plugin != 0);
expr * e = to_expr(t);
if (!is_app(e) || is_app_of(e, fid, OP_FPA_NAN) || !is_fp(c, t)) {
SET_ERROR_CODE(Z3_INVALID_ARG);
RETURN_Z3(nullptr);
}
scoped_mpf val(mpfm);
bool r = plugin->is_numeral(e, val);
if (!r || !(mpfm.is_normal(val) || mpfm.is_denormal(val) || mpfm.is_zero(val) || mpfm.is_inf(val))) {
SET_ERROR_CODE(Z3_INVALID_ARG);
RETURN_Z3(nullptr);
}
unsigned sbits = val.get().get_sbits();
scoped_mpq q(mpqm);
mpqm.set(q, mpfm.sig(val));
if (mpfm.is_inf(val)) mpqm.set(q, 0);
app * a = mk_c(c)->bvutil().mk_numeral(q.get(), sbits-1);
mk_c(c)->save_ast_trail(a);
RETURN_Z3(of_expr(a));
Z3_CATCH_RETURN(nullptr);
}
bool Z3_API Z3_model_has_interp(Z3_context c, Z3_model m, Z3_func_decl a) {
Z3_TRY;
LOG_Z3_model_has_interp(c, m, a);
CHECK_NON_NULL(m, 0);
return to_model_ref(m)->has_interpretation(to_func_decl(a));
Z3_CATCH_RETURN(false);
}
Z3_string Z3_API Z3_fpa_get_numeral_significand_string(Z3_context c, Z3_ast t) {
Z3_TRY;
LOG_Z3_fpa_get_numeral_significand_string(c, t);
RESET_ERROR_CODE();
CHECK_NON_NULL(t, nullptr);
CHECK_VALID_AST(t, nullptr);
ast_manager & m = mk_c(c)->m();
mpf_manager & mpfm = mk_c(c)->fpautil().fm();
unsynch_mpq_manager & mpqm = mpfm.mpq_manager();
family_id fid = mk_c(c)->get_fpa_fid();
fpa_decl_plugin * plugin = (fpa_decl_plugin*)m.get_plugin(fid);
SASSERT(plugin != 0);
expr * e = to_expr(t);
if (!is_app(e) || is_app_of(e, fid, OP_FPA_NAN) || !is_fp(c, t)) {
SET_ERROR_CODE(Z3_INVALID_ARG);
return "";
}
scoped_mpf val(mpfm);
bool r = plugin->is_numeral(e, val);
if (!r || !(mpfm.is_normal(val) || mpfm.is_denormal(val) || mpfm.is_zero(val) || mpfm.is_inf(val))) {
SET_ERROR_CODE(Z3_INVALID_ARG);
return "";
}
unsigned sbits = val.get().get_sbits();
scoped_mpq q(mpqm);
mpqm.set(q, mpfm.sig(val));
if (!mpfm.is_denormal(val)) mpqm.add(q, mpfm.m_powers2(sbits - 1), q);
mpqm.div(q, mpfm.m_powers2(sbits - 1), q);
if (mpfm.is_inf(val)) mpqm.set(q, 0);
std::stringstream ss;
mpqm.display_decimal(ss, q, sbits);
return mk_c(c)->mk_external_string(ss.str());
Z3_CATCH_RETURN("");
}
void
verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
{
typedef double (*test_nested_loops_fn_type) (int n, double *a, double *b);
CHECK_NON_NULL (result);
test_nested_loops_fn_type test_nested_loops =
(test_nested_loops_fn_type)gcc_jit_result_get_code (result,
"test_nested_loops");
CHECK_NON_NULL (test_nested_loops);
double test_a[] = {1., 2., 3., 4., 5., 6., 7., 8., 9., 10.};
double test_b[] = {5., 6., 7., 8., 9., 10., 1., 2., 3., 4.};
double val = test_nested_loops (10, test_a, test_b);
note ("test_nested_loops returned: %f", val);
CHECK_VALUE (val, 3025.0);
}
void
verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
{
CHECK_NON_NULL (result);
/* We don't actually build any functions above;
nothing more to verify. */
}
unsigned Z3_API Z3_model_get_num_funcs(Z3_context c, Z3_model m) {
Z3_TRY;
LOG_Z3_model_get_num_funcs(c, m);
RESET_ERROR_CODE();
CHECK_NON_NULL(m, 0);
return to_model_ref(m)->get_num_functions();
Z3_CATCH_RETURN(0);
}
unsigned Z3_API Z3_func_interp_get_arity(Z3_context c, Z3_func_interp f) {
Z3_TRY;
LOG_Z3_func_interp_get_arity(c, f);
RESET_ERROR_CODE();
CHECK_NON_NULL(f, 0);
return to_func_interp_ref(f)->get_arity();
Z3_CATCH_RETURN(0);
}
Z3_ast Z3_API Z3_func_interp_get_else(Z3_context c, Z3_func_interp f) {
Z3_TRY;
LOG_Z3_func_interp_get_else(c, f);
RESET_ERROR_CODE();
CHECK_NON_NULL(f, 0);
expr * e = to_func_interp_ref(f)->get_else();
RETURN_Z3(of_expr(e));
Z3_CATCH_RETURN(0);
}
void
verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
{
typedef float (*fn_type) (int i);
CHECK_NON_NULL (result);
fn_type test_union =
(fn_type)gcc_jit_result_get_code (result, "test_union");
CHECK_NON_NULL (test_union);
/* Call the JIT-generated function. */
float f_result = test_union (42);
union int_or_float u;
u.as_float = f_result;
CHECK_VALUE (u.as_int, 42);
}
Z3_func_decl get_model_func_decl_core(Z3_context c, Z3_model m, unsigned i) {
CHECK_NON_NULL(m, nullptr);
model * _m = to_model_ref(m);
if (i >= _m->get_num_functions()) {
SET_ERROR_CODE(Z3_IOB, nullptr);
return nullptr;
}
return of_func_decl(_m->get_function(i));
}
Z3_bool Z3_API Z3_model_has_interp(Z3_context c, Z3_model m, Z3_func_decl a) {
Z3_TRY;
LOG_Z3_model_has_interp(c, m, a);
CHECK_NON_NULL(m, 0);
if (to_model_ref(m)->has_interpretation(to_func_decl(a))) {
return Z3_TRUE;
} else {
return Z3_FALSE;
}
Z3_CATCH_RETURN(Z3_FALSE);
}
void
verify_uint_overflow_fn (gcc_jit_result *jit_result,
const char *funcname,
unsigned int x, unsigned int y,
unsigned int expected_result,
int expected_ovf)
{
CHECK_NON_NULL (jit_result);
typedef unsigned int (*overflow_fn_type) (unsigned int, unsigned int, int *);
overflow_fn_type fn =
(overflow_fn_type)gcc_jit_result_get_code (jit_result, funcname);
CHECK_NON_NULL (fn);
/* Call the function: */
int actual_ovf = 0;
unsigned int actual_result = fn (x, y, &actual_ovf);
note ("%s (%d, %d) returned: %d with ovf: %d",
funcname, x, y, actual_result, actual_ovf);
CHECK_VALUE (actual_result, expected_result);
CHECK_VALUE (actual_ovf, expected_ovf);
}
static void
verify_hidden_functions (gcc_jit_context *ctxt, gcc_jit_result *result)
{
CHECK_NON_NULL (result);
/* GCC_JIT_FUNCTION_INTERNAL and GCC_JIT_FUNCTION_ALWAYS_INLINE
functions should not be accessible in the result. */
CHECK_VALUE (NULL, gcc_jit_result_get_code (result, "my_internal_mult"));
CHECK_VALUE (NULL, gcc_jit_result_get_code (result, "my_always_inline_mult"));
typedef double (*fn_type) (double);
fn_type my_square_with_internal =
(fn_type)gcc_jit_result_get_code (result, "my_square_with_internal");
CHECK_NON_NULL (my_square_with_internal);
CHECK_VALUE (my_square_with_internal (5.0), 25.0);
fn_type my_square_with_always_inline =
(fn_type)gcc_jit_result_get_code (result, "my_square_with_always_inline");
CHECK_NON_NULL (my_square_with_always_inline);
CHECK_VALUE (my_square_with_always_inline (5.0), 25.0);
}
Z3_ast Z3_API Z3_func_interp_get_else(Z3_context c, Z3_func_interp f) {
Z3_TRY;
LOG_Z3_func_interp_get_else(c, f);
RESET_ERROR_CODE();
CHECK_NON_NULL(f, nullptr);
expr * e = to_func_interp_ref(f)->get_else();
if (e) {
mk_c(c)->save_ast_trail(e);
}
RETURN_Z3(of_expr(e));
Z3_CATCH_RETURN(nullptr);
}
void
verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
{
typedef void (*fn_type) (int);
CHECK_NON_NULL (result);
fn_type test_caller =
(fn_type)gcc_jit_result_get_code (result, "test_caller");
CHECK_NON_NULL (test_caller);
called_with[0] = 0;
called_with[1] = 0;
called_with[2] = 0;
/* Call the JIT-generated function. */
test_caller (5);
/* Verify that it correctly called "called_function". */
CHECK_VALUE (called_with[0], 15);
CHECK_VALUE (called_with[1], 20);
CHECK_VALUE (called_with[2], 25);
}
unsigned Z3_API Z3_fpa_get_sbits(Z3_context c, Z3_sort s) {
Z3_TRY;
LOG_Z3_fpa_get_sbits(c, s);
RESET_ERROR_CODE();
CHECK_NON_NULL(s, 0);
CHECK_VALID_AST(s, 0);
if (!is_fp_sort(c, s)) {
SET_ERROR_CODE(Z3_INVALID_ARG);
RETURN_Z3(0);
}
return mk_c(c)->fpautil().get_sbits(to_sort(s));
Z3_CATCH_RETURN(0);
}
Z3_ast Z3_API Z3_model_get_const_interp(Z3_context c, Z3_model m, Z3_func_decl a) {
Z3_TRY;
LOG_Z3_model_get_const_interp(c, m, a);
RESET_ERROR_CODE();
CHECK_NON_NULL(m, 0);
expr * r = to_model_ref(m)->get_const_interp(to_func_decl(a));
if (!r) {
SET_ERROR_CODE(Z3_INVALID_ARG);
RETURN_Z3(0);
}
RETURN_Z3(of_expr(r));
Z3_CATCH_RETURN(0);
}
Z3_ast_opt Z3_API Z3_model_get_const_interp(Z3_context c, Z3_model m, Z3_func_decl a) {
Z3_TRY;
LOG_Z3_model_get_const_interp(c, m, a);
RESET_ERROR_CODE();
CHECK_NON_NULL(m, nullptr);
expr * r = to_model_ref(m)->get_const_interp(to_func_decl(a));
if (!r) {
RETURN_Z3(nullptr);
}
mk_c(c)->save_ast_trail(r);
RETURN_Z3(of_expr(r));
Z3_CATCH_RETURN(nullptr);
}
static void
test_script (const char *scripts_dir, const char *script_name, int input,
int expected_result)
{
char *script_path;
toyvm_function *fn;
int interpreted_result;
toyvm_compiled_function *compiled_fn;
toyvm_compiled_code code;
int compiled_result;
snprintf (test, sizeof (test), "toyvm.c: %s", script_name);
script_path = (char *)malloc (strlen (scripts_dir)
+ strlen (script_name) + 1);
CHECK_NON_NULL (script_path);
sprintf (script_path, "%s%s", scripts_dir, script_name);
fn = toyvm_function_parse (script_path, script_name);
CHECK_NON_NULL (fn);
interpreted_result = toyvm_function_interpret (fn, input, NULL);
CHECK_VALUE (interpreted_result, expected_result);
compiled_fn = toyvm_function_compile (fn);
CHECK_NON_NULL (compiled_fn);
code = (toyvm_compiled_code)compiled_fn->cf_code;
CHECK_NON_NULL (code);
compiled_result = code (input);
CHECK_VALUE (compiled_result, expected_result);
gcc_jit_result_release (compiled_fn->cf_jit_result);
free (compiled_fn);
free (fn);
free (script_path);
}
Z3_bool Z3_API Z3_is_array_value(Z3_context c, Z3_model _m, Z3_ast _v, unsigned* size) {
Z3_TRY;
LOG_Z3_is_array_value(c, _m, _v, size);
RESET_ERROR_CODE();
CHECK_NON_NULL(_v, Z3_FALSE);
CHECK_NON_NULL(_m, Z3_FALSE);
model * m = to_model_ref(_m);
expr * v = to_expr(_v);
ast_manager& mgr = mk_c(c)->m();
family_id afid = mk_c(c)->get_array_fid();
unsigned sz = 0;
array_util pl(mgr);
if (pl.is_as_array(v)) {
func_decl* f = pl.get_as_array_func_decl(to_app(v));
func_interp* g = m->get_func_interp(f);
sz = g->num_entries();
if (sz > 0 && g->get_arity() != 1) {
return Z3_FALSE;
}
}
else {
while (pl.is_store(v)) {
if (to_app(v)->get_num_args() != 3) {
return Z3_FALSE;
}
v = to_app(v)->get_arg(0);
++sz;
}
if (!is_app_of(v, afid, OP_CONST_ARRAY)) {
return Z3_FALSE;
}
}
if (size) {
*size = sz;
}
return Z3_TRUE;
Z3_CATCH_RETURN(Z3_FALSE);
}
Z3_bool Z3_API Z3_model_eval(Z3_context c, Z3_model m, Z3_ast t, Z3_bool model_completion, Z3_ast * v) {
Z3_TRY;
LOG_Z3_model_eval(c, m, t, model_completion, v);
if (v) *v = 0;
RESET_ERROR_CODE();
CHECK_NON_NULL(m, Z3_FALSE);
model * _m = to_model_ref(m);
expr_ref result(mk_c(c)->m());
_m->eval(to_expr(t), result, model_completion == Z3_TRUE);
mk_c(c)->save_ast_trail(result.get());
*v = of_ast(result.get());
RETURN_Z3_model_eval Z3_TRUE;
Z3_CATCH_RETURN(0);
}
