@@ -56,6 +56,7 @@ static void help(void)

     printf("    --version              -V         Show version\n");

     printf("    --info                 -i         Print information about bytecode\n");

     printf("    --printsrc             -p         Print bytecode source\n");

+    printf("    --printbcir            -c         Print bytecode IR\n");

     printf("    --trace <level>                   Set bytecode trace level 0..7 (default 7)\n");

     printf("    --no-trace-showsource             Don't show source line during tracing\n");

     printf("    file                              file to test\n");

@@ -328,6 +329,10 @@ int main(int argc, char *argv[])

 	cli_bytecode_describe(bc);

     } else if (optget(opts, "printsrc")->enabled) {

         print_src(opts->filename[0]);

+    } else if (optget(opts, "printbcir")->enabled) {

+        cli_bytetype_describe(bc);

+        cli_bytevalue_describe(bc, 0);

+        cli_bytefunc_describe(bc, 0);

     } else {

 	cli_ctx cctx;

 	struct cl_engine *engine = cl_engine_new();

@@ -1405,7 +1405,7 @@ static int parseBB(struct cli_bc *bc, unsigned func, unsigned bb, unsigned char

 	}

 	bcfunc->dbgnodes = cli_malloc(num*sizeof(*bcfunc->dbgnodes));

 	if (!bcfunc->dbgnodes) {

-        cli_errmsg("Unable to allocate memory for dbg nodes: %s\n", num*sizeof(*bcfunc->dbgnodes));

+        cli_errmsg("Unable to allocate memory for dbg nodes: %u\n", num*sizeof(*bcfunc->dbgnodes));

 	    return CL_EMEM;

     }

 	for (i=0;i<num;i++) {

@@ -3027,3 +3027,487 @@ void cli_bytecode_describe(const struct cli_bc *bc)

     }

     printf("\n");

 }

+

+const char *bc_tystr[] = {

+    "DFunctionType",

+    "DPointerType",

+    "DStructType",

+    "DPackedStructType",

+    "DArrayType"

+};

+

+const char *bc_opstr[] = {

+    "OP_BC_NULL",

+    "OP_BC_ADD", /* =1*/

+    "OP_BC_SUB",

+    "OP_BC_MUL",

+    "OP_BC_UDIV",

+    "OP_BC_SDIV",

+    "OP_BC_UREM",

+    "OP_BC_SREM",

+    "OP_BC_SHL",

+    "OP_BC_LSHR",

+    "OP_BC_ASHR",

+    "OP_BC_AND",

+    "OP_BC_OR",

+    "OP_BC_XOR",

+

+    "OP_BC_TRUNC",

+    "OP_BC_SEXT",

+    "OP_BC_ZEXT",

+

+    "OP_BC_BRANCH",

+    "OP_BC_JMP",

+    "OP_BC_RET",

+    "OP_BC_RET_VOID",

+

+    "OP_BC_ICMP_EQ",

+    "OP_BC_ICMP_NE",

+    "OP_BC_ICMP_UGT",

+    "OP_BC_ICMP_UGE",

+    "OP_BC_ICMP_ULT",

+    "OP_BC_ICMP_ULE",

+    "OP_BC_ICMP_SGT",

+    "OP_BC_ICMP_SGE",

+    "OP_BC_ICMP_SLE",

+    "OP_BC_ICMP_SLT",

+    "OP_BC_SELECT",

+    "OP_BC_CALL_DIRECT",

+    "OP_BC_CALL_API",

+    "OP_BC_COPY",

+    "OP_BC_GEP1",

+    "OP_BC_GEPZ",

+    "OP_BC_GEPN",

+    "OP_BC_STORE",

+    "OP_BC_LOAD",

+    "OP_BC_MEMSET",

+    "OP_BC_MEMCPY",

+    "OP_BC_MEMMOVE",

+    "OP_BC_MEMCMP",

+    "OP_BC_ISBIGENDIAN",

+    "OP_BC_ABORT",

+    "OP_BC_BSWAP16",

+    "OP_BC_BSWAP32",

+    "OP_BC_BSWAP64",

+    "OP_BC_PTRDIFF32",

+    "OP_BC_PTRTOINT64",

+    "OP_BC_INVALID" /* last */

+};

+

+extern unsigned cli_numapicalls;

+static void cli_bytetype_helper(const struct cli_bc *bc, unsigned tid)

+{

+    unsigned i, j;

+

+    if (tid & 0x8000) {

+        printf("alloc ");

+        tid &= 0x7fff;

+    }

+

+    if (tid < 65) {

+        printf("i%d", tid);

+        return;

+    }

+

+    i = tid - 65;

+    const struct cli_bc_type *ty = &bc->types[i];

+

+    switch (ty->kind) {

+    case DFunctionType:

+        cli_bytetype_helper(bc, ty->containedTypes[0]);

+        printf(" func ( ");

+        for (j = 1; j < ty->numElements; ++j) {

+            cli_bytetype_helper(bc, ty->containedTypes[0]);

+            printf(" ");

+        }

+        printf(")");

+        break;

+    case DPointerType:

+        cli_bytetype_helper(bc, ty->containedTypes[0]);

+        printf("*");

+        break;

+    case DStructType:

+    case DPackedStructType:

+        printf("{ ");

+        for (j = 0; j < ty->numElements; ++j) {

+            cli_bytetype_helper(bc, ty->containedTypes[0]);

+            printf(" ");

+        }

+        printf("}");

+        break;

+    case DArrayType:

+        printf("[");

+        printf("%d x ", ty->numElements);

+        cli_bytetype_helper(bc, ty->containedTypes[0]);

+        printf("]");

+        break;

+    default:

+        printf("unhandled type kind %d, cannot parse", ty->kind);

+        break;

+    }

+

+}

+

+void cli_bytetype_describe(const struct cli_bc *bc)

+{

+    unsigned i, tid;

+

+    printf("found %d extra types of %d total, starting at tid %d\n", 

+           bc->num_types, 64+bc->num_types, bc->start_tid);

+

+    printf("TID  KIND                INTERNAL\n");

+    printf("------------------------------------------------------------------------\n");

+    for (i = 0, tid = 65; i < bc->num_types-1; ++i, ++tid) {

+        printf("%3d: %-20s", tid, bc_tystr[bc->types[i].kind]);

+        cli_bytetype_helper(bc, tid);

+        printf("\n");

+    }

+    printf("------------------------------------------------------------------------\n");

+}

+

+void cli_bytevalue_describe(const struct cli_bc *bc, unsigned funcid)

+{

+    unsigned i, j, total = 0;

+    const struct cli_bc_func *func;

+

+    if (funcid >= bc->num_func) {

+        printf("bytecode diagnostic: funcid [%u] outside byecode numfuncs [%u]\n",

+               funcid, bc->num_func);

+        return;

+    }

+    // globals

+    printf("found a total of %d globals\n", bc->num_globals);

+    printf("GID  ID    VALUE\n");

+    printf("------------------------------------------------------------------------\n");

+    for (i = 0; i < bc->num_globals; ++i) {

+        printf("%3u [%3u]: ", i, i);

+        cli_bytetype_helper(bc, bc->globaltys[i]);

+        printf(" unknown\n");

+    }

+    printf("------------------------------------------------------------------------\n");

+

+    // arguments and local values

+    func = &bc->funcs[funcid];

+    printf("found %d values with %d arguments and %d locals\n",

+           func->numValues, func->numArgs, func->numLocals);

+    printf("VID  ID    VALUE\n");

+    printf("------------------------------------------------------------------------\n");

+    for (i = 0; i < func->numValues; ++i) {

+        printf("%3u [%3u]: ", i, total++);

+        cli_bytetype_helper(bc, func->types[i]);

+        if (i < func->numArgs)

+            printf("argument");

+        printf("\n");

+    }

+    printf("------------------------------------------------------------------------\n");

+    

+    // constants

+    printf("found a total of %d constants\n", func->numConstants);

+    printf("CID  ID    VALUE\n");

+    printf("------------------------------------------------------------------------\n");

+    for (i = 0; i < func->numConstants; ++i) {

+        printf("%3u [%3u]: %llu(0x%llx)\n", i, total++, func->constants[i], func->constants[i]);

+    }

+    printf("------------------------------------------------------------------------\n");

+    printf("found a total of %u total values\n", total);

+    printf("------------------------------------------------------------------------\n");

+    return;

+}

+

+void cli_byteinst_describe(const struct cli_bc_inst *inst, unsigned *bbnum)

+{

+    unsigned j;

+    char inst_str[256];

+

+    if (inst->opcode > OP_BC_INVALID) {

+        printf("opcode %u[%u] of type %u is not implemented yet!",

+               inst->opcode, inst->interp_op/5, inst->interp_op%5);

+        return;

+    }

+

+    snprintf(inst_str, 256, "%-20s[%-3d/%3d/%3d]", bc_opstr[inst->opcode], 

+             inst->opcode, inst->interp_op, inst->interp_op%inst->opcode);

+    printf("%-35s", inst_str);

+    switch (inst->opcode) {

+        // binary operations

+    case OP_BC_ADD:

+        printf("%d = %d + %d", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_SUB:

+        printf("%d = %d - %d", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_MUL:

+        printf("%d = %d * %d", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_UDIV:

+        printf("%d = %d / %d", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_SDIV:

+        printf("%d = %d / %d", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_UREM:

+        printf("%d = %d %% %d", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_SREM:

+        printf("%d = %d %% %d", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_SHL:

+        printf("%d = %d << %d", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_LSHR:

+        printf("%d = %d >> %d", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_ASHR:

+        printf("%d = %d >> %d", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_AND:

+        printf("%d = %d & %d", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_OR:

+        printf("%d = %d | %d", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_XOR:

+        printf("%d = %d ^ %d", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+

+        // casting operations

+    case OP_BC_TRUNC:

+        printf("%d = %d trunc %llx", inst->dest, inst->u.cast.source, inst->u.cast.mask);

+        break;

+    case OP_BC_SEXT:

+        printf("%d = %d sext %llx", inst->dest, inst->u.cast.source, inst->u.cast.mask);

+        break;

+    case OP_BC_ZEXT:

+        printf("%d = %d zext %llx", inst->dest, inst->u.cast.source, inst->u.cast.mask);

+        break;

+        

+        // control operations (termination instructions)

+    case OP_BC_BRANCH:

+        printf("br %d ? bb.%d : bb.%d", inst->u.branch.condition,

+               inst->u.branch.br_true, inst->u.branch.br_false);

+        (*bbnum)++;

+        break;

+    case OP_BC_JMP:

+        printf("jmp bb.%d", inst->u.jump);

+        (*bbnum)++;

+        break;

+    case OP_BC_RET:

+        printf("ret %d", inst->u.unaryop);

+        (*bbnum)++;

+        break;

+    case OP_BC_RET_VOID:

+        printf("ret void");

+        (*bbnum)++;

+        break;

+

+        // comparison operations

+    case OP_BC_ICMP_EQ:

+        printf("%d = (%d == %d)", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_ICMP_NE:

+        printf("%d = (%d != %d)", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_ICMP_UGT:

+        printf("%d = (%d > %d)", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_ICMP_UGE:

+        printf("%d = (%d >= %d)", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_ICMP_ULT:

+        printf("%d = (%d > %d)", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_ICMP_ULE:

+        printf("%d = (%d >= %d)", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_ICMP_SGT:

+        printf("%d = (%d > %d)", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_ICMP_SGE:

+        printf("%d = (%d >= %d)", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_ICMP_SLE:

+        printf("%d = (%d <= %d)", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_ICMP_SLT:

+        printf("%d = (%d < %d)", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_SELECT:

+        printf("%d = %d ? %d : %d)", inst->dest, inst->u.three[0], 

+               inst->u.three[1], inst->u.three[2]);

+        break;

+

+        // function calling

+    case OP_BC_CALL_DIRECT:

+        printf("%d = call F.%d (", inst->dest, inst->u.ops.funcid);

+        for (j = 0; j < inst->u.ops.numOps; ++j) {

+            if (j == inst->u.ops.numOps-1) {

+                printf("%d", inst->u.ops.ops[j]);

+            }

+            else {

+                printf("%d, ", inst->u.ops.ops[j]);

+            }

+        }

+        printf(")");

+        break;

+    case OP_BC_CALL_API:

+        {

+            if (inst->u.ops.funcid > cli_numapicalls) {

+                printf("apicall FID %d not yet implemented!\n", inst->u.ops.funcid);

+                break;

+            }

+            const struct cli_apicall *api = &cli_apicalls[inst->u.ops.funcid];

+            switch (api->kind) {

+            case 0:

+                printf("%d = %s[%d] (%d, %d)", inst->dest, api->name,

+                       inst->u.ops.funcid, inst->u.ops.ops[0], inst->u.ops.ops[1]);

+                break;

+            case 1:

+                printf("%d = %s[%d] (p.%d, %d)", inst->dest, api->name,

+                       inst->u.ops.funcid, inst->u.ops.ops[0], inst->u.ops.ops[1]);

+                break;

+            case 2:

+                printf("%d = %s[%d] (%d)", inst->dest, api->name,

+                       inst->u.ops.funcid, inst->u.ops.ops[0]);

+                break;

+            case 3:

+                printf("p.%d = %s[%d] (%d)", inst->dest, api->name,

+                       inst->u.ops.funcid, inst->u.ops.ops[0]);

+                break;

+            case 4:

+                printf("%d = %s[%d] (p.%d, %d, %d, %d, %d)", inst->dest, api->name,

+                       inst->u.ops.funcid, inst->u.ops.ops[0], inst->u.ops.ops[1],

+                       inst->u.ops.ops[2], inst->u.ops.ops[3], inst->u.ops.ops[4]);

+                break;

+            case 5:

+                printf("%d = %s[%d] ()", inst->dest, api->name,

+                       inst->u.ops.funcid);

+                break;

+            case 6:

+                printf("p.%d = %s[%d] (%d, %d)", inst->dest, api->name,

+                       inst->u.ops.funcid, inst->u.ops.ops[0], inst->u.ops.ops[1]);

+                break;

+            case 7:

+                printf("%d = %s[%d] (%d, %d, %d)", inst->dest, api->name,

+                       inst->u.ops.funcid, inst->u.ops.ops[0], inst->u.ops.ops[1],

+                       inst->u.ops.ops[2]);

+                break;

+            case 8:

+                printf("%d = %s[%d] (p.%d, %d, p.%d, %d)", inst->dest, api->name,

+                       inst->u.ops.funcid, inst->u.ops.ops[0], inst->u.ops.ops[1],

+                       inst->u.ops.ops[2], inst->u.ops.ops[3]);

+                break;

+            case 9:

+                printf("%d = %s[%d] (p.%d, %d, %d)", inst->dest, api->name,

+                       inst->u.ops.funcid, inst->u.ops.ops[0], inst->u.ops.ops[1],

+                       inst->u.ops.ops[2]);

+                break;

+            default:

+                printf("type %u apicalls not yet implemented!\n", api->kind);

+                break;

+            }

+        }

+        break;

+

+        // memory operations

+    case OP_BC_COPY:

+        printf("cp %d -> %d", inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_GEP1:

+        printf("%d = gep1 p.%d + (%d * %d)", inst->dest, inst->u.three[1],

+               inst->u.three[2], inst->u.three[0]);

+        break;

+    case OP_BC_GEPZ:

+        printf("%d = gepz p.%d + (%d)", inst->dest, 

+               inst->u.three[1], inst->u.three[2]);

+        break;

+    case OP_BC_GEPN:

+        printf("illegal opcode, impossible");

+        break;

+    case OP_BC_STORE:

+        printf("store %d -> p.%d", inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_LOAD:

+        printf("load  %d <- p.%d", inst->dest, inst->u.unaryop);

+        break;

+

+        // llvm instrinsics

+    case OP_BC_MEMSET:

+        printf("%d = memset (p.%d, %d, %d)", inst->dest, inst->u.three[0],

+               inst->u.three[1], inst->u.three[2]);

+        break;

+    case OP_BC_MEMCPY:

+        printf("%d = memcpy (p.%d, p.%d, %d)", inst->dest, inst->u.three[0],

+               inst->u.three[1], inst->u.three[2]);

+        break;

+    case OP_BC_MEMMOVE:

+        printf("%d = memmove (p.%d, p.%d, %d)", inst->dest, inst->u.three[0],

+               inst->u.three[1], inst->u.three[2]);

+        break;

+    case OP_BC_MEMCMP:

+        printf("%d = memcmp (p.%d, p.%d, %d)", inst->dest, inst->u.three[0],

+               inst->u.three[1], inst->u.three[2]);

+        break;

+

+        // utility operations

+    case OP_BC_ISBIGENDIAN:

+        printf("%d = isbigendian()", inst->dest);

+        break;

+    case OP_BC_ABORT:

+        printf("ABORT!!");

+        break;

+    case OP_BC_BSWAP16:

+        printf("%d = bswap16 %d", inst->dest, inst->u.unaryop);

+        break;

+    case OP_BC_BSWAP32:

+        printf("%d = bswap32 %d", inst->dest, inst->u.unaryop);

+        break;

+    case OP_BC_BSWAP64:

+        printf("%d = bswap64 %d", inst->dest, inst->u.unaryop);

+        break;

+    case OP_BC_PTRDIFF32:

+        printf("%d = ptrdiff32 p.%d p.%d", inst->dest, inst->u.binop[0], inst->u.binop[1]);

+        break;

+    case OP_BC_PTRTOINT64:

+        printf("%d = ptrtoint64 p.%d", inst->dest, inst->u.unaryop);

+        break;

+    case OP_BC_INVALID:  /* last */

+        printf("INVALID!!");

+        break;

+

+    default:

+        // redundant check

+        printf("opcode %u[%u] of type %u is not implemented yet!",

+               inst->opcode, inst->interp_op/5, inst->interp_op%5);

+        break;

+    }

+}

+

+void cli_bytefunc_describe(const struct cli_bc *bc, unsigned funcid)

+{

+    unsigned i, bbnum, bbpre;

+    const struct cli_bc_func *func;

+

+    if (funcid >= bc->num_func) {

+        printf("bytecode diagnostic: funcid [%u] outside byecode numfuncs [%u]\n",

+               funcid, bc->num_func);

+        return;

+    }

+

+    func = &bc->funcs[funcid];

+

+    printf("FUNCTION ID: F.%d -> NUMINSTS %d\n", funcid, func->numInsts);

+    printf("BB   IDX  OPCODE              [ID /IID/MOD]  INST\n");

+    printf("------------------------------------------------------------------------\n");

+    bbpre = 0; bbnum = 0;

+    for (i = 0; i < func->numInsts; ++i) {

+        if (bbpre != bbnum) {

+            printf("\n");

+            bbpre = bbnum;

+        }

+

+        printf("%3d  %3d  ", bbnum, i);

+        cli_byteinst_describe(&func->allinsts[i], &bbnum);

+        printf("\n");

+    }

+    printf("------------------------------------------------------------------------\n");

+}

@@ -114,7 +114,14 @@ int cli_bytecode_prepare2(struct cl_engine *engine, struct cli_all_bc *allbc, un

 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);

+

+/* Bytecode IR descriptions */

 void cli_bytecode_describe(const struct cli_bc *bc);

+void cli_bytetype_describe(const struct cli_bc *bc);

+void cli_bytevalue_describe(const struct cli_bc *bc, unsigned funcid);

+void cli_byteinst_describe(const struct cli_bc_inst *inst, unsigned *bbnum);

+void cli_bytefunc_describe(const struct cli_bc *bc, unsigned funcid);

+

 /* Hooks */

 struct cli_exe_info;

@@ -214,8 +214,8 @@ const struct cli_bc_type cli_apicall_types[]={

 	{DArrayType, cli_tmp29, 3, 0, 0},

 	{DArrayType, cli_tmp30, 10, 0, 0}

 };

-

 const unsigned cli_apicall_maxtypes=sizeof(cli_apicall_types)/sizeof(cli_apicall_types[0]);

+

 const struct cli_apicall cli_apicalls[]={

 /* Bytecode APIcalls BEGIN */

 	{"test1", 10, 0, 0},

@@ -320,6 +320,8 @@ const struct cli_apicall cli_apicalls[]={

 	{"json_get_int", 8, 33, 2}

 /* Bytecode APIcalls END */

 };

+const unsigned cli_numapicalls=sizeof(cli_apicalls)/sizeof(cli_apicalls[0]);

+

 const cli_apicall_int2 cli_apicalls0[] = {

 	(cli_apicall_int2)cli_bcapi_test1,

 	(cli_apicall_int2)cli_bcapi_seek,

@@ -199,6 +199,10 @@ CLAMAV_PRIVATE {

     cli_bytecode_debug_printsrc;

     cli_bytecode_printversion;

     cli_bytecode_describe;

+    cli_bytetype_describe;

+    cli_bytevalue_describe;

+    cli_byteinst_describe;

+    cli_bytefunc_describe;

     cli_printcxxver;

     cli_detect_environment;

     cli_disasm_one;

@@ -141,6 +141,7 @@ const struct clam_option __clam_options[] = {

     { NULL, "trust-bytecode", 't', CLOPT_TYPE_BOOL, MATCH_BOOL, 1, NULL, 0, OPT_CLAMBC, "Trust loaded bytecode (default yes)", ""},

     { NULL, "info", 'i', CLOPT_TYPE_BOOL, MATCH_BOOL, 0, NULL, 0, OPT_CLAMBC, "Load and print bytecode information without executing", ""},

     { NULL, "printsrc", 'p', CLOPT_TYPE_BOOL, MATCH_BOOL, 0, NULL, 0, OPT_CLAMBC, "Print source code of bytecode", ""},

+    { NULL, "printbcir", 'c', CLOPT_TYPE_BOOL, MATCH_BOOL, 0, NULL, 0, OPT_CLAMBC, "Print bytecode representation of bytecode signature", ""},

     { NULL, "input", 'r', CLOPT_TYPE_STRING, NULL, -1, NULL, 0, OPT_CLAMBC, "Input file to run the bytecode n", ""},

     { NULL, "trace", 't', CLOPT_TYPE_NUMBER, MATCH_NUMBER, 7, NULL, 0, OPT_CLAMBC, "bytecode trace level",""},

     { NULL, "no-trace-showsource", 's', CLOPT_TYPE_BOOL, MATCH_BOOL, 0, NULL, 0, OPT_CLAMBC, "Don't show source line during tracing",""},