[mirror_qemu.git] / accel / tcg / perf.c

/*
 * Linux perf perf-<pid>.map and jit-<pid>.dump integration.
 *
 * The jitdump spec can be found at [1].
 *
 * [1] https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/plain/tools/perf/Documentation/jitdump-specification.txt
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

#include "qemu/osdep.h"
#include "elf.h"
#include "exec/exec-all.h"
#include "qemu/timer.h"
#include "tcg/tcg.h"

#include "debuginfo.h"
#include "perf.h"

static FILE *safe_fopen_w(const char *path)
{
    int saved_errno;
    FILE *f;
    int fd;

    /* Delete the old file, if any. */
    unlink(path);

    /* Avoid symlink attacks by using O_CREAT | O_EXCL. */
    fd = open(path, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
    if (fd == -1) {
        return NULL;
    }

    /* Convert fd to FILE*. */
    f = fdopen(fd, "w");
    if (f == NULL) {
        saved_errno = errno;
        close(fd);
        errno = saved_errno;
        return NULL;
    }

    return f;
}

static FILE *perfmap;

void perf_enable_perfmap(void)
{
    char map_file[32];

    snprintf(map_file, sizeof(map_file), "/tmp/perf-%d.map", getpid());
    perfmap = safe_fopen_w(map_file);
    if (perfmap == NULL) {
        warn_report("Could not open %s: %s, proceeding without perfmap",
                    map_file, strerror(errno));
    }
}

/* Get PC and size of code JITed for guest instruction #INSN. */
static void get_host_pc_size(uintptr_t *host_pc, uint16_t *host_size,
                             const void *start, size_t insn)
{
    uint16_t start_off = insn ? tcg_ctx->gen_insn_end_off[insn - 1] : 0;

    if (host_pc) {
        *host_pc = (uintptr_t)start + start_off;
    }
    if (host_size) {
        *host_size = tcg_ctx->gen_insn_end_off[insn] - start_off;
    }
}

static const char *pretty_symbol(const struct debuginfo_query *q, size_t *len)
{
    static __thread char buf[64];
    int tmp;

    if (!q->symbol) {
        tmp = snprintf(buf, sizeof(buf), "guest-0x%"PRIx64, q->address);
        if (len) {
            *len = MIN(tmp + 1, sizeof(buf));
        }
        return buf;
    }

    if (!q->offset) {
        if (len) {
            *len = strlen(q->symbol) + 1;
        }
        return q->symbol;
    }

    tmp = snprintf(buf, sizeof(buf), "%s+0x%"PRIx64, q->symbol, q->offset);
    if (len) {
        *len = MIN(tmp + 1, sizeof(buf));
    }
    return buf;
}

static void write_perfmap_entry(const void *start, size_t insn,
                                const struct debuginfo_query *q)
{
    uint16_t host_size;
    uintptr_t host_pc;

    get_host_pc_size(&host_pc, &host_size, start, insn);
    fprintf(perfmap, "%"PRIxPTR" %"PRIx16" %s\n",
            host_pc, host_size, pretty_symbol(q, NULL));
}

static FILE *jitdump;
static size_t perf_marker_size;
static void *perf_marker = MAP_FAILED;

#define JITHEADER_MAGIC 0x4A695444
#define JITHEADER_VERSION 1

struct jitheader {
    uint32_t magic;
    uint32_t version;
    uint32_t total_size;
    uint32_t elf_mach;
    uint32_t pad1;
    uint32_t pid;
    uint64_t timestamp;
    uint64_t flags;
};

enum jit_record_type {
    JIT_CODE_LOAD = 0,
    JIT_CODE_DEBUG_INFO = 2,
};

struct jr_prefix {
    uint32_t id;
    uint32_t total_size;
    uint64_t timestamp;
};

struct jr_code_load {
    struct jr_prefix p;

    uint32_t pid;
    uint32_t tid;
    uint64_t vma;
    uint64_t code_addr;
    uint64_t code_size;
    uint64_t code_index;
};

struct debug_entry {
    uint64_t addr;
    int lineno;
    int discrim;
    const char name[];
};

struct jr_code_debug_info {
    struct jr_prefix p;

    uint64_t code_addr;
    uint64_t nr_entry;
    struct debug_entry entries[];
};

static uint32_t get_e_machine(void)
{
    Elf64_Ehdr elf_header;
    FILE *exe;
    size_t n;

    QEMU_BUILD_BUG_ON(offsetof(Elf32_Ehdr, e_machine) !=
                      offsetof(Elf64_Ehdr, e_machine));

    exe = fopen("/proc/self/exe", "r");
    if (exe == NULL) {
        return EM_NONE;
    }

    n = fread(&elf_header, sizeof(elf_header), 1, exe);
    fclose(exe);
    if (n != 1) {
        return EM_NONE;
    }

    return elf_header.e_machine;
}

void perf_enable_jitdump(void)
{
    struct jitheader header;
    char jitdump_file[32];

    if (!use_rt_clock) {
        warn_report("CLOCK_MONOTONIC is not available, proceeding without jitdump");
        return;
    }

    snprintf(jitdump_file, sizeof(jitdump_file), "jit-%d.dump", getpid());
    jitdump = safe_fopen_w(jitdump_file);
    if (jitdump == NULL) {
        warn_report("Could not open %s: %s, proceeding without jitdump",
                    jitdump_file, strerror(errno));
        return;
    }

    /*
     * `perf inject` will see that the mapped file name in the corresponding
     * PERF_RECORD_MMAP or PERF_RECORD_MMAP2 event is of the form jit-%d.dump
     * and will process it as a jitdump file.
     */
    perf_marker_size = qemu_real_host_page_size();
    perf_marker = mmap(NULL, perf_marker_size, PROT_READ | PROT_EXEC,
                       MAP_PRIVATE, fileno(jitdump), 0);
    if (perf_marker == MAP_FAILED) {
        warn_report("Could not map %s: %s, proceeding without jitdump",
                    jitdump_file, strerror(errno));
        fclose(jitdump);
        jitdump = NULL;
        return;
    }

    header.magic = JITHEADER_MAGIC;
    header.version = JITHEADER_VERSION;
    header.total_size = sizeof(header);
    header.elf_mach = get_e_machine();
    header.pad1 = 0;
    header.pid = getpid();
    header.timestamp = get_clock();
    header.flags = 0;
    fwrite(&header, sizeof(header), 1, jitdump);
}

void perf_report_prologue(const void *start, size_t size)
{
    if (perfmap) {
        fprintf(perfmap, "%"PRIxPTR" %zx tcg-prologue-buffer\n",
                (uintptr_t)start, size);
    }
}

/* Write a JIT_CODE_DEBUG_INFO jitdump entry. */
static void write_jr_code_debug_info(const void *start,
                                     const struct debuginfo_query *q,
                                     size_t icount)
{
    struct jr_code_debug_info rec;
    struct debug_entry ent;
    uintptr_t host_pc;
    int insn;

    /* Write the header. */
    rec.p.id = JIT_CODE_DEBUG_INFO;
    rec.p.total_size = sizeof(rec) + sizeof(ent) + 1;
    rec.p.timestamp = get_clock();
    rec.code_addr = (uintptr_t)start;
    rec.nr_entry = 1;
    for (insn = 0; insn < icount; insn++) {
        if (q[insn].file) {
            rec.p.total_size += sizeof(ent) + strlen(q[insn].file) + 1;
            rec.nr_entry++;
        }
    }
    fwrite(&rec, sizeof(rec), 1, jitdump);

    /* Write the main debug entries. */
    for (insn = 0; insn < icount; insn++) {
        if (q[insn].file) {
            get_host_pc_size(&host_pc, NULL, start, insn);
            ent.addr = host_pc;
            ent.lineno = q[insn].line;
            ent.discrim = 0;
            fwrite(&ent, sizeof(ent), 1, jitdump);
            fwrite(q[insn].file, strlen(q[insn].file) + 1, 1, jitdump);
        }
    }

    /* Write the trailing debug_entry. */
    ent.addr = (uintptr_t)start + tcg_ctx->gen_insn_end_off[icount - 1];
    ent.lineno = 0;
    ent.discrim = 0;
    fwrite(&ent, sizeof(ent), 1, jitdump);
    fwrite("", 1, 1, jitdump);
}

/* Write a JIT_CODE_LOAD jitdump entry. */
static void write_jr_code_load(const void *start, uint16_t host_size,
                               const struct debuginfo_query *q)
{
    static uint64_t code_index;
    struct jr_code_load rec;
    const char *symbol;
    size_t symbol_size;

    symbol = pretty_symbol(q, &symbol_size);
    rec.p.id = JIT_CODE_LOAD;
    rec.p.total_size = sizeof(rec) + symbol_size + host_size;
    rec.p.timestamp = get_clock();
    rec.pid = getpid();
    rec.tid = qemu_get_thread_id();
    rec.vma = (uintptr_t)start;
    rec.code_addr = (uintptr_t)start;
    rec.code_size = host_size;
    rec.code_index = code_index++;
    fwrite(&rec, sizeof(rec), 1, jitdump);
    fwrite(symbol, symbol_size, 1, jitdump);
    fwrite(start, host_size, 1, jitdump);
}

void perf_report_code(uint64_t guest_pc, TranslationBlock *tb,
                      const void *start)
{
    struct debuginfo_query *q;
    size_t insn, start_words;
    uint64_t *gen_insn_data;

    if (!perfmap && !jitdump) {
        return;
    }

    q = g_try_malloc0_n(tb->icount, sizeof(*q));
    if (!q) {
        return;
    }

    debuginfo_lock();

    /* Query debuginfo for each guest instruction. */
    gen_insn_data = tcg_ctx->gen_insn_data;
    start_words = tcg_ctx->insn_start_words;

    for (insn = 0; insn < tb->icount; insn++) {
        /* FIXME: This replicates the restore_state_to_opc() logic. */
        q[insn].address = gen_insn_data[insn * start_words + 0];
        if (tb_cflags(tb) & CF_PCREL) {
            q[insn].address |= (guest_pc & TARGET_PAGE_MASK);
        } else {
#if defined(TARGET_I386)
            q[insn].address -= tb->cs_base;
#endif
        }
        q[insn].flags = DEBUGINFO_SYMBOL | (jitdump ? DEBUGINFO_LINE : 0);
    }
    debuginfo_query(q, tb->icount);

    /* Emit perfmap entries if needed. */
    if (perfmap) {
        flockfile(perfmap);
        for (insn = 0; insn < tb->icount; insn++) {
            write_perfmap_entry(start, insn, &q[insn]);
        }
        funlockfile(perfmap);
    }

    /* Emit jitdump entries if needed. */
    if (jitdump) {
        flockfile(jitdump);
        write_jr_code_debug_info(start, q, tb->icount);
        write_jr_code_load(start, tcg_ctx->gen_insn_end_off[tb->icount - 1],
                           q);
        funlockfile(jitdump);
    }

    debuginfo_unlock();
    g_free(q);
}

void perf_exit(void)
{
    if (perfmap) {
        fclose(perfmap);
        perfmap = NULL;
    }

    if (perf_marker != MAP_FAILED) {
        munmap(perf_marker, perf_marker_size);
        perf_marker = MAP_FAILED;
    }

    if (jitdump) {
        fclose(jitdump);
        jitdump = NULL;
    }
}
Commit	Line	Data
5584e2db IL	1	/*
	2	* Linux perf perf-<pid>.map and jit-<pid>.dump integration.
	3	*
	4	* The jitdump spec can be found at [1].
	5	*
	6	* [1] https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/plain/tools/perf/Documentation/jitdump-specification.txt
	7	*
	8	* SPDX-License-Identifier: GPL-2.0-or-later
	9	*/
	10
	11	#include "qemu/osdep.h"
	12	#include "elf.h"
	13	#include "exec/exec-all.h"
	14	#include "qemu/timer.h"
	15	#include "tcg/tcg.h"
	16
	17	#include "debuginfo.h"
	18	#include "perf.h"
	19
	20	static FILE safe_fopen_w(const char path)
	21	{
	22	int saved_errno;
	23	FILE *f;
	24	int fd;
	25
	26	/* Delete the old file, if any. */
	27	unlink(path);
	28
	29	/* Avoid symlink attacks by using O_CREAT \| O_EXCL. */
	30	fd = open(path, O_RDWR \| O_CREAT \| O_EXCL, S_IRUSR \| S_IWUSR);
	31	if (fd == -1) {
	32	return NULL;
	33	}
	34
	35	/* Convert fd to FILE. /
	36	f = fdopen(fd, "w");
	37	if (f == NULL) {
	38	saved_errno = errno;
	39	close(fd);
	40	errno = saved_errno;
	41	return NULL;
	42	}
	43
	44	return f;
	45	}
	46
	47	static FILE *perfmap;
	48
	49	void perf_enable_perfmap(void)
	50	{
	51	char map_file[32];
	52
	53	snprintf(map_file, sizeof(map_file), "/tmp/perf-%d.map", getpid());
	54	perfmap = safe_fopen_w(map_file);
	55	if (perfmap == NULL) {
	56	warn_report("Could not open %s: %s, proceeding without perfmap",
	57	map_file, strerror(errno));
	58	}
	59	}
	60
	61	/* Get PC and size of code JITed for guest instruction #INSN. */
	62	static void get_host_pc_size(uintptr_t host_pc, uint16_t host_size,
	63	const void *start, size_t insn)
	64	{
65	uint16_t start_off = insn ? tcg_ctx->gen_insn_end_off[insn - 1] : 0;
66
67	if (host_pc) {
68	*host_pc = (uintptr_t)start + start_off;
69	}
70	if (host_size) {
71	*host_size = tcg_ctx->gen_insn_end_off[insn] - start_off;
72	}
73	}
74
75	static const char pretty_symbol(const struct debuginfo_query q, size_t *len)
76	{
77	static __thread char buf[64];
78	int tmp;
79
80	if (!q->symbol) {
81	tmp = snprintf(buf, sizeof(buf), "guest-0x%"PRIx64, q->address);
82	if (len) {
83	*len = MIN(tmp + 1, sizeof(buf));
84	}
85	return buf;
86	}
87
88	if (!q->offset) {
89	if (len) {
90	*len = strlen(q->symbol) + 1;
91	}
92	return q->symbol;
93	}
94
95	tmp = snprintf(buf, sizeof(buf), "%s+0x%"PRIx64, q->symbol, q->offset);
96	if (len) {
97	*len = MIN(tmp + 1, sizeof(buf));
98	}
99	return buf;
100	}
101
102	static void write_perfmap_entry(const void *start, size_t insn,
103	const struct debuginfo_query *q)
104	{
105	uint16_t host_size;
106	uintptr_t host_pc;
107
108	get_host_pc_size(&host_pc, &host_size, start, insn);
109	fprintf(perfmap, "%"PRIxPTR" %"PRIx16" %s\n",
110	host_pc, host_size, pretty_symbol(q, NULL));
111	}
112
113	static FILE *jitdump;
e7cd7a39 IL	114	static size_t perf_marker_size;
e7cd7a39 IL	115	static void *perf_marker = MAP_FAILED;
5584e2db IL	116
	117	#define JITHEADER_MAGIC 0x4A695444
	118	#define JITHEADER_VERSION 1
	119
	120	struct jitheader {
	121	uint32_t magic;
	122	uint32_t version;
	123	uint32_t total_size;
	124	uint32_t elf_mach;
	125	uint32_t pad1;
	126	uint32_t pid;
	127	uint64_t timestamp;
	128	uint64_t flags;
	129	};
	130
	131	enum jit_record_type {
	132	JIT_CODE_LOAD = 0,
	133	JIT_CODE_DEBUG_INFO = 2,
	134	};
	135
	136	struct jr_prefix {
	137	uint32_t id;
	138	uint32_t total_size;
	139	uint64_t timestamp;
	140	};
	141
	142	struct jr_code_load {
	143	struct jr_prefix p;
	144
	145	uint32_t pid;
	146	uint32_t tid;
	147	uint64_t vma;
	148	uint64_t code_addr;
	149	uint64_t code_size;
	150	uint64_t code_index;
	151	};
	152
	153	struct debug_entry {
	154	uint64_t addr;
	155	int lineno;
	156	int discrim;
	157	const char name[];
	158	};
	159
	160	struct jr_code_debug_info {
	161	struct jr_prefix p;
	162
	163	uint64_t code_addr;
	164	uint64_t nr_entry;
	165	struct debug_entry entries[];
	166	};
	167
	168	static uint32_t get_e_machine(void)
	169	{
	170	Elf64_Ehdr elf_header;
	171	FILE *exe;
	172	size_t n;
	173
	174	QEMU_BUILD_BUG_ON(offsetof(Elf32_Ehdr, e_machine) !=
	175	offsetof(Elf64_Ehdr, e_machine));
	176
	177	exe = fopen("/proc/self/exe", "r");
	178	if (exe == NULL) {
	179	return EM_NONE;
180	}
181
182	n = fread(&elf_header, sizeof(elf_header), 1, exe);
183	fclose(exe);
184	if (n != 1) {
185	return EM_NONE;
186	}
187
188	return elf_header.e_machine;
189	}
190
191	void perf_enable_jitdump(void)
192	{
193	struct jitheader header;
194	char jitdump_file[32];
5584e2db IL	195
	196	if (!use_rt_clock) {
	197	warn_report("CLOCK_MONOTONIC is not available, proceeding without jitdump");
	198	return;
	199	}
	200
	201	snprintf(jitdump_file, sizeof(jitdump_file), "jit-%d.dump", getpid());
	202	jitdump = safe_fopen_w(jitdump_file);
	203	if (jitdump == NULL) {
	204	warn_report("Could not open %s: %s, proceeding without jitdump",
	205	jitdump_file, strerror(errno));
	206	return;
	207	}
	208
	209	/*
	210	* `perf inject` will see that the mapped file name in the corresponding
	211	* PERF_RECORD_MMAP or PERF_RECORD_MMAP2 event is of the form jit-%d.dump
	212	* and will process it as a jitdump file.
	213	*/
e7cd7a39 IL	214	perf_marker_size = qemu_real_host_page_size();
e7cd7a39 IL	215	perf_marker = mmap(NULL, perf_marker_size, PROT_READ \| PROT_EXEC,
5584e2db IL	216	MAP_PRIVATE, fileno(jitdump), 0);
	217	if (perf_marker == MAP_FAILED) {
	218	warn_report("Could not map %s: %s, proceeding without jitdump",
	219	jitdump_file, strerror(errno));
	220	fclose(jitdump);
	221	jitdump = NULL;
	222	return;
	223	}
	224
	225	header.magic = JITHEADER_MAGIC;
	226	header.version = JITHEADER_VERSION;
	227	header.total_size = sizeof(header);
	228	header.elf_mach = get_e_machine();
	229	header.pad1 = 0;
	230	header.pid = getpid();
	231	header.timestamp = get_clock();
	232	header.flags = 0;
	233	fwrite(&header, sizeof(header), 1, jitdump);
	234	}
	235
	236	void perf_report_prologue(const void *start, size_t size)
	237	{
	238	if (perfmap) {
	239	fprintf(perfmap, "%"PRIxPTR" %zx tcg-prologue-buffer\n",
	240	(uintptr_t)start, size);
	241	}
	242	}
	243
	244	/* Write a JIT_CODE_DEBUG_INFO jitdump entry. */
	245	static void write_jr_code_debug_info(const void *start,
	246	const struct debuginfo_query *q,
	247	size_t icount)
	248	{
	249	struct jr_code_debug_info rec;
	250	struct debug_entry ent;
	251	uintptr_t host_pc;
	252	int insn;
	253
	254	/* Write the header. */
	255	rec.p.id = JIT_CODE_DEBUG_INFO;
	256	rec.p.total_size = sizeof(rec) + sizeof(ent) + 1;
	257	rec.p.timestamp = get_clock();
	258	rec.code_addr = (uintptr_t)start;
	259	rec.nr_entry = 1;
	260	for (insn = 0; insn < icount; insn++) {
	261	if (q[insn].file) {
	262	rec.p.total_size += sizeof(ent) + strlen(q[insn].file) + 1;
	263	rec.nr_entry++;
	264	}
	265	}
	266	fwrite(&rec, sizeof(rec), 1, jitdump);
	267
	268	/* Write the main debug entries. */
	269	for (insn = 0; insn < icount; insn++) {
	270	if (q[insn].file) {
	271	get_host_pc_size(&host_pc, NULL, start, insn);
	272	ent.addr = host_pc;
	273	ent.lineno = q[insn].line;
	274	ent.discrim = 0;
	275	fwrite(&ent, sizeof(ent), 1, jitdump);
	276	fwrite(q[insn].file, strlen(q[insn].file) + 1, 1, jitdump);
	277	}
	278	}
	279
280	/* Write the trailing debug_entry. */
281	ent.addr = (uintptr_t)start + tcg_ctx->gen_insn_end_off[icount - 1];
282	ent.lineno = 0;
283	ent.discrim = 0;
284	fwrite(&ent, sizeof(ent), 1, jitdump);
285	fwrite("", 1, 1, jitdump);
286	}
287
288	/* Write a JIT_CODE_LOAD jitdump entry. */
289	static void write_jr_code_load(const void *start, uint16_t host_size,
290	const struct debuginfo_query *q)
291	{
292	static uint64_t code_index;
293	struct jr_code_load rec;
294	const char *symbol;
295	size_t symbol_size;
296
297	symbol = pretty_symbol(q, &symbol_size);
298	rec.p.id = JIT_CODE_LOAD;
299	rec.p.total_size = sizeof(rec) + symbol_size + host_size;
300	rec.p.timestamp = get_clock();
301	rec.pid = getpid();
302	rec.tid = qemu_get_thread_id();
303	rec.vma = (uintptr_t)start;
304	rec.code_addr = (uintptr_t)start;
305	rec.code_size = host_size;
306	rec.code_index = code_index++;
307	fwrite(&rec, sizeof(rec), 1, jitdump);
308	fwrite(symbol, symbol_size, 1, jitdump);
309	fwrite(start, host_size, 1, jitdump);
310	}
311
312	void perf_report_code(uint64_t guest_pc, TranslationBlock *tb,
313	const void *start)
314	{
315	struct debuginfo_query *q;
747bd69d RH	316	size_t insn, start_words;
747bd69d RH	317	uint64_t *gen_insn_data;
5584e2db IL	318
	319	if (!perfmap && !jitdump) {
	320	return;
	321	}
	322
	323	q = g_try_malloc0_n(tb->icount, sizeof(*q));
	324	if (!q) {
	325	return;
	326	}
	327
	328	debuginfo_lock();
	329
	330	/* Query debuginfo for each guest instruction. */
747bd69d RH	331	gen_insn_data = tcg_ctx->gen_insn_data;
	332	start_words = tcg_ctx->insn_start_words;
	333
5584e2db IL	334	for (insn = 0; insn < tb->icount; insn++) {
5584e2db IL	335	/* FIXME: This replicates the restore_state_to_opc() logic. */
747bd69d	336	q[insn].address = gen_insn_data[insn * start_words + 0];
4be79026	337	if (tb_cflags(tb) & CF_PCREL) {
5584e2db IL	338	q[insn].address \|= (guest_pc & TARGET_PAGE_MASK);
	339	} else {
	340	#if defined(TARGET_I386)
	341	q[insn].address -= tb->cs_base;
	342	#endif
	343	}
	344	q[insn].flags = DEBUGINFO_SYMBOL \| (jitdump ? DEBUGINFO_LINE : 0);
	345	}
	346	debuginfo_query(q, tb->icount);
	347
	348	/* Emit perfmap entries if needed. */
	349	if (perfmap) {
	350	flockfile(perfmap);
	351	for (insn = 0; insn < tb->icount; insn++) {
	352	write_perfmap_entry(start, insn, &q[insn]);
	353	}
	354	funlockfile(perfmap);
	355	}
	356
	357	/* Emit jitdump entries if needed. */
	358	if (jitdump) {
	359	flockfile(jitdump);
	360	write_jr_code_debug_info(start, q, tb->icount);
	361	write_jr_code_load(start, tcg_ctx->gen_insn_end_off[tb->icount - 1],
	362	q);
	363	funlockfile(jitdump);
	364	}
	365
	366	debuginfo_unlock();
	367	g_free(q);
	368	}
	369
	370	void perf_exit(void)
	371	{
	372	if (perfmap) {
	373	fclose(perfmap);
	374	perfmap = NULL;
	375	}
	376
e7cd7a39 IL	377	if (perf_marker != MAP_FAILED) {
	378	munmap(perf_marker, perf_marker_size);
	379	perf_marker = MAP_FAILED;
	380	}
	381
5584e2db IL	382	if (jitdump) {
	383	fclose(jitdump);
	384	jitdump = NULL;
	385	}
	386	}