@@ -295,7 +295,7 @@ int main(int argc, char *argv[])

     if (optget(opts, "force-interpreter")->enabled) {

 	bcs.engine = NULL;

     } else {

-	rc = cli_bytecode_init(&bcs, BYTECODE_ENGINE_MASK);

+	rc = cli_bytecode_init(&bcs);

 	if (rc != CL_SUCCESS) {

 	    fprintf(stderr,"Unable to init bytecode engine: %s\n", cl_strerror(rc));

 	    optfree(opts);

@@ -339,7 +339,7 @@ int main(int argc, char *argv[])

 	    optfree(opts);

 	    exit(4);

 	}

-	rc = cli_bytecode_prepare(&bcs, BYTECODE_ENGINE_MASK);

+	rc = cli_bytecode_prepare(engine, &bcs, BYTECODE_ENGINE_MASK);

 	if (rc != CL_SUCCESS) {

 	    fprintf(stderr,"Unable to prepare bytecode: %s\n", cl_strerror(rc));

 	    optfree(opts);

@@ -1768,7 +1768,7 @@ static int updatedb(const char *dbname, const char *hostname, char *ip, int *sig

 	    cl_engine_free(engine);

 	    return 55;

 	}

-	if((ret = cli_bytecode_prepare(&engine->bcs, engine->dconf->bytecode/*FIXME: dconf has no sense here*/))) {

+	if((ret = cli_bytecode_prepare(engine, &engine->bcs, engine->dconf->bytecode/*FIXME: dconf has no sense here*/))) {

 	    logg("!Failed to compile/load bytecode: %s\n", cl_strerror(ret));

 	    unlink(newfile);

 	    free(newfile);

@@ -2090,7 +2090,7 @@ static int selfcheck(int jit, struct cli_bcengine *engine)

     return rc;

 }

-int cli_bytecode_prepare(struct cli_all_bc *bcs, unsigned dconfmask)

+int cli_bytecode_prepare(struct cl_engine *engine, struct cli_all_bc *bcs, unsigned dconfmask)

 {

     unsigned i, interp = 0;

     int rc1, rc2, rc;

@@ -2125,10 +2125,15 @@ int cli_bytecode_prepare(struct cli_all_bc *bcs, unsigned dconfmask)

     return CL_SUCCESS;

 }

-int cli_bytecode_init(struct cli_all_bc *allbc, unsigned dconfmask)

+int cli_bytecode_init(struct cli_all_bc *allbc)

 {

+    int ret;

     memset(allbc, 0, sizeof(*allbc));

-    return cli_bytecode_init_jit(allbc, dconfmask);

+    ret = cli_bytecode_init_jit(allbc, 0/*XXX*/);

+    cli_dbgmsg("Bytecode initialized in %s mode\n",

+	       allbc->engine ? "JIT" : "interpreter");

+    allbc->inited = 1;

+    return ret;

 }

 int cli_bytecode_done(struct cli_all_bc *allbc)

@@ -25,6 +25,7 @@

 #include "clambc.h"

 #include <stdio.h>

 #include "fmap.h"

+#include "bytecode_detect.h"

 struct cli_dbio;

 struct cli_bc_ctx;

@@ -41,7 +42,8 @@ enum bc_state {

     bc_skip,

     bc_loaded,

     bc_jit,

-    bc_interp

+    bc_interp,

+    bc_disabled

 };

 struct cli_bc {

@@ -74,6 +76,8 @@ struct cli_all_bc {

     struct cli_bc *all_bcs;

     unsigned count;

     struct cli_bcengine *engine;

+    struct cli_environment env;

+    int    inited;

 };

 struct cli_pe_hook_data;

@@ -100,9 +104,9 @@ extern int have_clamjit;

 #ifdef __cplusplus

 }

 #endif

-int cli_bytecode_init(struct cli_all_bc *allbc, unsigned dconfmask);

+int cli_bytecode_init(struct cli_all_bc *allbc);

 int cli_bytecode_load(struct cli_bc *bc, FILE *f, struct cli_dbio *dbio, int security);

-int cli_bytecode_prepare(struct cli_all_bc *allbc, unsigned dconfmask);

+int cli_bytecode_prepare(struct cl_engine *engine, struct cli_all_bc *allbc, unsigned dconfmask);

 int cli_bytecode_run(const struct cli_all_bc *bcs, const struct cli_bc *bc, struct cli_bc_ctx *ctx);

 void cli_bytecode_destroy(struct cli_bc *bc);

 int cli_bytecode_done(struct cli_all_bc *allbc);

@@ -66,8 +66,8 @@ typedef enum {

     CL_EMAXSIZE,

     CL_EMAXFILES,

     CL_EFORMAT,

-    CL_EBYTECODE,

-

+    CL_EBYTECODE,/* may be reported in testmode */

+    CL_EBYTECODE_TESTFAIL, /* may be reported in testmode */

     /* no error codes below this line please */

     CL_ELAST_ERROR

@@ -147,8 +147,9 @@ enum cl_engine_field {

     CL_ENGINE_AC_MAXDEPTH,	    /* uint32_t */

     CL_ENGINE_TMPDIR,		    /* (char *) */

     CL_ENGINE_KEEPTMP,		    /* uint32_t */

-    CL_ENGINE_BYTECODE_SECURITY,     /* uint32_t */

-    CL_ENGINE_BYTECODE_TIMEOUT       /* uint32_t */

+    CL_ENGINE_BYTECODE_SECURITY,    /* uint32_t */

+    CL_ENGINE_BYTECODE_TIMEOUT,     /* uint32_t */

+    CL_ENGINE_BYTECODE_MODE         /* uint32_t */

 };

 enum bytecode_security {

@@ -157,6 +158,15 @@ enum bytecode_security {

     CL_BYTECODE_TRUST_NOTHING /* paranoid setting */

 };

+enum bytecode_mode {

+    CL_BYTECODE_MODE_AUTO=0, /* JIT if possible, fallback to interpreter */

+    CL_BYTECODE_MODE_JIT, /* force JIT */

+    CL_BYTECODE_MODE_INTERPRETER, /* force interpreter */

+    CL_BYTECODE_MODE_TEST, /* both JIT and interpreter, compare results,

+			      all failures are fatal */

+    CL_BYTECODE_MODE_OFF /* for query only, not settable */

+};

+

 extern int cl_engine_set_num(struct cl_engine *engine, enum cl_engine_field field, long long num);

 extern long long cl_engine_get_num(const struct cl_engine *engine, enum cl_engine_field field, int *err);

@@ -248,6 +248,8 @@ const char *cl_strerror(int clerror)

 	    return "CL_EFORMAT: Bad format or broken data";

 	case CL_EBYTECODE:

 	    return "CL_EBYTECODE: error during bytecode execution";

+	case CL_EBYTECODE_TESTFAIL:

+	    return "CL_EBYTECODE_TESTFAIL: failure in bytecode testmode";

 	default:

 	    return "Unknown error code";

     }

@@ -301,6 +303,7 @@ struct cl_engine *cl_engine_new(void)

     new->bytecode_security = CL_BYTECODE_TRUST_SIGNED;

     /* 5 seconds timeout */

     new->bytecode_timeout = 60000;

+    new->bytecode_mode = CL_BYTECODE_MODE_AUTO;

     new->refcount = 1;

     new->ac_only = 0;

     new->ac_mindepth = CLI_DEFAULT_AC_MINDEPTH;

@@ -394,11 +397,25 @@ int cl_engine_set_num(struct cl_engine *engine, enum cl_engine_field field, long

 		return CL_EARG;

 	    }

 #endif

+	    if (engine->dboptions & CL_DB_COMPILED) {

+		cli_errmsg("cl_engine_set_num: CL_ENGINE_BYTECODE_SECURITY cannot be set after engine was compiled\n");

+		return CL_EARG;

+	    }

 	    engine->bytecode_security = num;

 	    break;

 	case CL_ENGINE_BYTECODE_TIMEOUT:

 	    engine->bytecode_timeout = num;

 	    break;

+	case CL_ENGINE_BYTECODE_MODE:

+	    if (engine->dboptions & CL_DB_COMPILED) {

+		cli_errmsg("cl_engine_set_num: CL_ENGINE_BYTECODE_MODE cannot be set after engine was compiled\n");

+		return CL_EARG;

+	    }

+	    if (num == CL_BYTECODE_MODE_OFF) {

+		cli_errmsg("cl_engine_set_num: CL_BYTECODE_MODE_OFF is not settable, use dboptions to turn off!\n");

+	    }

+	    engine->bytecode_mode = num;

+	    break;

 	default:

 	    cli_errmsg("cl_engine_set_num: Incorrect field number\n");

 	    return CL_EARG;

@@ -446,6 +463,12 @@ long long cl_engine_get_num(const struct cl_engine *engine, enum cl_engine_field

 	    return engine->ac_maxdepth;

 	case CL_ENGINE_KEEPTMP:

 	    return engine->keeptmp;

+	case CL_ENGINE_BYTECODE_SECURITY:

+	    return engine->bytecode_security;

+	case CL_ENGINE_BYTECODE_TIMEOUT:

+	    return engine->bytecode_timeout;

+	case CL_ENGINE_BYTECODE_MODE:

+	    return engine->bytecode_mode;

 	default:

 	    cli_errmsg("cl_engine_get: Incorrect field number\n");

 	    if(err)

@@ -263,6 +263,7 @@ struct cl_engine {

     unsigned hook_lsig_ids;

     enum bytecode_security bytecode_security;

     uint32_t bytecode_timeout;

+    enum bytecode_mode bytecode_mode;

 };

 struct cl_settings {

@@ -2636,8 +2636,8 @@ int cl_load(const char *path, struct cl_engine *engine, unsigned int *signo, uns

 	if((ret = phishing_init(engine)))

 	    return ret;

-    if((dboptions & CL_DB_BYTECODE) && !engine->bcs.engine && (engine->dconf->bytecode & BYTECODE_ENGINE_MASK)) {

-	if((ret = cli_bytecode_init(&engine->bcs, engine->dconf->bytecode)))

+    if((dboptions & CL_DB_BYTECODE) && !engine->bcs.inited) {

+	if((ret = cli_bytecode_init(&engine->bcs)))

 	    return ret;

     } else {

 	cli_dbgmsg("Bytecode engine disabled\n");

@@ -3078,7 +3078,7 @@ int cl_engine_compile(struct cl_engine *engine)

     mpool_flush(engine->mempool);

     /* Compile bytecode */

-    if((ret = cli_bytecode_prepare(&engine->bcs, engine->dconf->bytecode))) {

+    if((ret = cli_bytecode_prepare(engine, &engine->bcs, engine->dconf->bytecode))) {

 	cli_errmsg("Unable to compile/load bytecode: %s\n", cl_strerror(ret));

 	return ret;

     }

@@ -70,7 +70,7 @@ static void runtest(const char *file, uint64_t expected, int fail, int nojit,

     cl_debug();

     if (!nojit) {

-	rc = cli_bytecode_init(&bcs, BYTECODE_ENGINE_MASK);

+	rc = cli_bytecode_init(&bcs);

 	fail_unless(rc == CL_SUCCESS, "cli_bytecode_init failed");

     } else {

 	bcs.engine = NULL;

@@ -83,7 +83,10 @@ static void runtest(const char *file, uint64_t expected, int fail, int nojit,

     fail_unless(rc == CL_SUCCESS, "cli_bytecode_load failed");

     fclose(f);

-    rc = cli_bytecode_prepare(&bcs, BYTECODE_ENGINE_MASK);

+    if (testmode)

+	engine->bytecode_mode = CL_BYTECODE_MODE_TEST;

+

+    rc = cli_bytecode_prepare(engine, &bcs, BYTECODE_ENGINE_MASK);

     fail_unless(rc == CL_SUCCESS, "cli_bytecode_prepare failed");

     if (have_clamjit && !nojit && nojit != -1) {