From 55f4e4a5ec657a017e3bf75299ad71fd1c968dd3 Mon Sep 17 00:00:00 2001 From: The Android Open Source Project Date: Tue, 21 Oct 2008 07:00:00 -0700 Subject: Initial Contribution --- trace.c | 1875 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1875 insertions(+) create mode 100644 trace.c (limited to 'trace.c') diff --git a/trace.c b/trace.c new file mode 100644 index 0000000..6cff83c --- /dev/null +++ b/trace.c @@ -0,0 +1,1875 @@ +/* Copyright (C) 2006-2007 The Android Open Source Project +** +** This software is licensed under the terms of the GNU General Public +** License version 2, as published by the Free Software Foundation, and +** may be copied, distributed, and modified under those terms. +** +** This program is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +** GNU General Public License for more details. +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "cpu.h" +#include "exec-all.h" +#include "trace.h" +#include "varint.h" +#include "android_utils.h" + +TraceBB trace_bb; +TraceInsn trace_insn; +TraceStatic trace_static; +TraceAddr trace_load; +TraceAddr trace_store; +TraceExc trace_exc; +TracePid trace_pid; +TraceMethod trace_method; +static TraceHeader header; + +// The simulation time in cpu clock cycles +uint64_t sim_time = 1; + +// The current process id +int current_pid; + +// The start and end (wall-clock) time in microseconds +uint64_t start_time, end_time; +uint64_t elapsed_usecs; + +// For debugging output +FILE *ftrace_debug; + +// The maximum number of bytes consumed by an InsnRec after compression. +// This is very conservative but needed to ensure no buffer overflows. +#define kMaxInsnCompressed 14 + +// The maximum number of bytes consumed by an BBRec after compression. +// This is very conservative but needed to ensure no buffer overflows. +#define kMaxBBCompressed 32 + +// The maximum number of bytes consumed by an AddrRec after compression. +// This is very conservative but needed to ensure no buffer overflows. +#define kMaxAddrCompressed 14 + +// The maximum number of bytes consumed by a MethodRec after compression. +// This is very conservative but needed to ensure no buffer overflows. +#define kMaxMethodCompressed 18 + +// The maximum number of bytes consumed by an exception record after +// compression. +#define kMaxExcCompressed 38 + +// The maximum number of bytes consumed by a pid record for +// kPidSwitch, or kPidExit after compression. +#define kMaxPidCompressed 15 + +// The maximum number of bytes consumed by a pid record for kPidFork, +// or kPidClone after compression. +#define kMaxPid2Compressed 20 + +// The maximum number of bytes consumed by a pid record for kPidExecArgs +// after compression, not counting the bytes for the args. +#define kMaxExecArgsCompressed 15 + +// The maximum number of bytes consumed by a pid record for kPidName +// after compression, not counting the bytes for the name. +#define kMaxNameCompressed 20 + +// The maximum number of bytes consumed by a pid record for kPidMmap +// after compression, not counting the bytes for the pathname. +#define kMaxMmapCompressed 33 + +// The maximum number of bytes consumed by a pid record for kPidMunmap, +// after compression. +#define kMaxMunmapCompressed 28 + +// The maximum number of bytes consumed by a pid record for kPidSymbol +// after compression, not counting the bytes for the symbol name. +#define kMaxSymbolCompressed 24 + +// The maximum number of bytes consumed by a pid record for kPidKthreadName +// after compression, not counting the bytes for the name. +#define kMaxKthreadNameCompressed 25 + +void trace_cleanup(); + +// Return current time in microseconds as a 64-bit integer. +uint64 Now() { + struct timeval tv; + + gettimeofday(&tv, NULL); + uint64 val = tv.tv_sec; + val = val * 1000000ull + tv.tv_usec; + return val; +} + +static void create_trace_dir(const char *dirname) +{ + int err; + + err = path_mkdir(dirname, 0755); + if (err != 0 && errno != EEXIST) { + printf("err: %d\n", err); + perror(dirname); + exit(1); + } +} + +static char *create_trace_path(const char *filename, const char *ext) +{ + char *fname; + const char *base_start, *base_end; + int ii, len, base_len, dir_len, path_len, qtrace_len; + + // Handle error cases + if (filename == NULL || *filename == 0 || strcmp(filename, "/") == 0) + return NULL; + + // Ignore a trailing slash, if any + len = strlen(filename); + if (filename[len - 1] == '/') + len -= 1; + + // Find the basename. We don't use basename(3) because there are + // different behaviors for GNU and Posix in the case where the + // last character is a slash. + base_start = base_end = &filename[len]; + for (ii = 0; ii < len; ++ii) { + base_start -= 1; + if (*base_start == '/') { + base_start += 1; + break; + } + } + base_len = base_end - base_start; + dir_len = len - base_len; + qtrace_len = strlen("/qtrace"); + + // Create space for the pathname: "/dir/basename/qtrace.ext" + // The "ext" string already contains the dot, so just add a byte + // for the terminating zero. + path_len = dir_len + base_len + qtrace_len + strlen(ext) + 1; + fname = malloc(path_len); + if (dir_len > 0) + strncpy(fname, filename, dir_len); + fname[dir_len] = 0; + strncat(fname, base_start, base_len); + strcat(fname, "/qtrace"); + strcat(fname, ext); + return fname; +} + +void convert_secs_to_date_time(time_t secs, uint32_t *pdate, uint32_t *ptime) +{ + struct tm *tm = localtime(&secs); + uint32_t year = tm->tm_year + 1900; + uint32_t thousands = year / 1000; + year -= thousands * 1000; + uint32_t hundreds = year / 100; + year -= hundreds * 100; + uint32_t tens = year / 10; + year -= tens * 10; + uint32_t ones = year; + year = (thousands << 12) | (hundreds << 8) | (tens << 4) | ones; + + uint32_t mon = tm->tm_mon + 1; + tens = mon / 10; + ones = (mon - tens * 10); + mon = (tens << 4) | ones; + + uint32_t day = tm->tm_mday; + tens = day / 10; + ones = (day - tens * 10); + day = (tens << 4) | ones; + + *pdate = (year << 16) | (mon << 8) | day; + + uint32_t hour = tm->tm_hour; + tens = hour / 10; + ones = (hour - tens * 10); + hour = (tens << 4) | ones; + + uint32_t min = tm->tm_min; + tens = min / 10; + ones = (min - tens * 10); + min = (tens << 4) | ones; + + uint32_t sec = tm->tm_sec; + tens = sec / 10; + ones = (sec - tens * 10); + sec = (tens << 4) | ones; + + *ptime = (hour << 16) | (min << 8) | sec; +} + +void write_trace_header(TraceHeader *header) +{ + TraceHeader swappedHeader; + + memcpy(&swappedHeader, header, sizeof(TraceHeader)); + + convert32(swappedHeader.version); + convert32(swappedHeader.start_sec); + convert32(swappedHeader.start_usec); + convert32(swappedHeader.pdate); + convert32(swappedHeader.ptime); + convert32(swappedHeader.num_used_pids); + convert32(swappedHeader.first_unused_pid); + convert64(swappedHeader.num_static_bb); + convert64(swappedHeader.num_static_insn); + convert64(swappedHeader.num_dynamic_bb); + convert64(swappedHeader.num_dynamic_insn); + convert64(swappedHeader.elapsed_usecs); + + fwrite(&swappedHeader, sizeof(TraceHeader), 1, trace_static.fstream); +} + +void create_trace_bb(const char *filename) +{ + char *fname = create_trace_path(filename, ".bb"); + trace_bb.filename = fname; + + FILE *fstream = fopen(fname, "wb"); + if (fstream == NULL) { + perror(fname); + exit(1); + } + trace_bb.fstream = fstream; + trace_bb.next = &trace_bb.buffer[0]; + trace_bb.flush_time = 0; + trace_bb.compressed_ptr = trace_bb.compressed; + trace_bb.high_water_ptr = &trace_bb.compressed[kCompressedSize] - kMaxBBCompressed; + trace_bb.prev_bb_num = 0; + trace_bb.prev_bb_time = 0; + trace_bb.num_insns = 0; + trace_bb.recnum = 0; +} + +void create_trace_insn(const char *filename) +{ + // Create the instruction time trace file + char *fname = create_trace_path(filename, ".insn"); + trace_insn.filename = fname; + + FILE *fstream = fopen(fname, "wb"); + if (fstream == NULL) { + perror(fname); + exit(1); + } + trace_insn.fstream = fstream; + trace_insn.current = &trace_insn.dummy; + trace_insn.dummy.time_diff = 0; + trace_insn.dummy.repeat = 0; + trace_insn.prev_time = 0; + trace_insn.compressed_ptr = trace_insn.compressed; + trace_insn.high_water_ptr = &trace_insn.compressed[kCompressedSize] - kMaxInsnCompressed; +} + +void create_trace_static(const char *filename) +{ + // Create the static basic block trace file + char *fname = create_trace_path(filename, ".static"); + trace_static.filename = fname; + + FILE *fstream = fopen(fname, "wb"); + if (fstream == NULL) { + perror(fname); + exit(1); + } + trace_static.fstream = fstream; + trace_static.next_insn = 0; + trace_static.bb_num = 1; + trace_static.bb_addr = 0; + + // Write an empty header to reserve space for it in the file. + // The header will be filled in later when post-processing the + // trace file. + memset(&header, 0, sizeof(TraceHeader)); + + // Write out the version number so that tools can detect if the trace + // file format is the same as what they expect. + header.version = TRACE_VERSION; + + // Record the start time in the header now. + struct timeval tv; + struct timezone tz; + gettimeofday(&tv, &tz); + header.start_sec = tv.tv_sec; + header.start_usec = tv.tv_usec; + convert_secs_to_date_time(header.start_sec, &header.pdate, &header.ptime); + write_trace_header(&header); + + // Write out the record for the unused basic block number 0. + uint64_t zero = 0; + fwrite(&zero, sizeof(uint64_t), 1, trace_static.fstream); // bb_num + fwrite(&zero, sizeof(uint32_t), 1, trace_static.fstream); // bb_addr + fwrite(&zero, sizeof(uint32_t), 1, trace_static.fstream); // num_insns +} + +void create_trace_addr(const char *filename) +{ + // The "qtrace.load" and "qtrace.store" files are optional + trace_load.fstream = NULL; + trace_store.fstream = NULL; + if (trace_all_addr || trace_cache_miss) { + // Create the "qtrace.load" file + char *fname = create_trace_path(filename, ".load"); + trace_load.filename = fname; + + FILE *fstream = fopen(fname, "wb"); + if (fstream == NULL) { + perror(fname); + exit(1); + } + trace_load.fstream = fstream; + trace_load.next = &trace_load.buffer[0]; + trace_load.compressed_ptr = trace_load.compressed; + trace_load.high_water_ptr = &trace_load.compressed[kCompressedSize] - kMaxAddrCompressed; + trace_load.prev_addr = 0; + trace_load.prev_time = 0; + + // Create the "qtrace.store" file + fname = create_trace_path(filename, ".store"); + trace_store.filename = fname; + + fstream = fopen(fname, "wb"); + if (fstream == NULL) { + perror(fname); + exit(1); + } + trace_store.fstream = fstream; + trace_store.next = &trace_store.buffer[0]; + trace_store.compressed_ptr = trace_store.compressed; + trace_store.high_water_ptr = &trace_store.compressed[kCompressedSize] - kMaxAddrCompressed; + trace_store.prev_addr = 0; + trace_store.prev_time = 0; + } +} + +void create_trace_exc(const char *filename) +{ + // Create the exception trace file + char *fname = create_trace_path(filename, ".exc"); + trace_exc.filename = fname; + + FILE *fstream = fopen(fname, "wb"); + if (fstream == NULL) { + perror(fname); + exit(1); + } + trace_exc.fstream = fstream; + trace_exc.compressed_ptr = trace_exc.compressed; + trace_exc.high_water_ptr = &trace_exc.compressed[kCompressedSize] - kMaxExcCompressed; + trace_exc.prev_time = 0; + trace_exc.prev_bb_recnum = 0; +} + +void create_trace_pid(const char *filename) +{ + // Create the pid trace file + char *fname = create_trace_path(filename, ".pid"); + trace_pid.filename = fname; + + FILE *fstream = fopen(fname, "wb"); + if (fstream == NULL) { + perror(fname); + exit(1); + } + trace_pid.fstream = fstream; + trace_pid.compressed_ptr = trace_pid.compressed; + trace_pid.prev_time = 0; +} + +void create_trace_method(const char *filename) +{ + // Create the method trace file + char *fname = create_trace_path(filename, ".method"); + trace_method.filename = fname; + + FILE *fstream = fopen(fname, "wb"); + if (fstream == NULL) { + perror(fname); + exit(1); + } + trace_method.fstream = fstream; + trace_method.compressed_ptr = trace_method.compressed; + trace_method.prev_time = 0; + trace_method.prev_addr = 0; + trace_method.prev_pid = 0; +} + +void trace_init(const char *filename) +{ + // Create the trace files + create_trace_dir(filename); + create_trace_bb(filename); + create_trace_insn(filename); + create_trace_static(filename); + create_trace_addr(filename); + create_trace_exc(filename); + create_trace_pid(filename); + create_trace_method(filename); + +#if 0 + char *fname = create_trace_path(filename, ".debug"); + ftrace_debug = fopen(fname, "wb"); + if (ftrace_debug == NULL) { + perror(fname); + exit(1); + } +#else + ftrace_debug = NULL; +#endif + atexit(trace_cleanup); + + // If tracing is on, then start timing the simulator + if (tracing) + start_time = Now(); +} + +/* the following array is used to deal with def-use register interlocks, which we + * can compute statically, very fortunately. + * + * the idea is that interlock_base contains the number of cycles "executed" from + * the start of a basic block. It is set to 0 in trace_bb_start, and incremented + * in each call to get_insn_ticks. + * + * interlocks[N] correspond to the value of interlock_base after which a register N + * can be used by another operation, it is set each time an instruction writes to + * the register in get_insn_ticks() + */ + +static int interlocks[16]; +static int interlock_base; + +static void +_interlock_def(int reg, int delay) +{ + if (reg >= 0) + interlocks[reg] = interlock_base + delay; +} + +static int +_interlock_use(int reg) +{ + int delay = 0; + + if (reg >= 0) + { + delay = interlocks[reg] - interlock_base; + if (delay < 0) + delay = 0; + } + return delay; +} + +void trace_bb_start(uint32_t bb_addr) +{ + int nn; + + trace_static.bb_addr = bb_addr; + trace_static.is_thumb = 0; + + interlock_base = 0; + for (nn = 0; nn < 16; nn++) + interlocks[nn] = 0; +} + +void trace_add_insn(uint32_t insn, int is_thumb) +{ + trace_static.insns[trace_static.next_insn++] = insn; + // This relies on the fact that a basic block does not contain a mix + // of ARM and Thumb instructions. If that is not true, then many + // software tools that read the trace will have to change. + trace_static.is_thumb = is_thumb; +} + +void trace_bb_end() +{ + int ii, num_insns; + uint32_t insn; + + uint64_t bb_num = hostToLE64(trace_static.bb_num); + // If these are Thumb instructions, then encode that fact by setting + // the low bit of the basic-block address to 1. + uint32_t bb_addr = trace_static.bb_addr | trace_static.is_thumb; + bb_addr = hostToLE32(bb_addr); + num_insns = hostToLE32(trace_static.next_insn); + fwrite(&bb_num, sizeof(bb_num), 1, trace_static.fstream); + fwrite(&bb_addr, sizeof(bb_addr), 1, trace_static.fstream); + fwrite(&num_insns, sizeof(num_insns), 1, trace_static.fstream); + for (ii = 0; ii < trace_static.next_insn; ++ii) { + insn = hostToLE32(trace_static.insns[ii]); + fwrite(&insn, sizeof(insn), 1, trace_static.fstream); + } + + trace_static.bb_num += 1; + trace_static.next_insn = 0; +} + +void trace_cleanup() +{ + if (tracing) { + end_time = Now(); + elapsed_usecs += end_time - start_time; + } + header.elapsed_usecs = elapsed_usecs; + double elapsed_secs = elapsed_usecs / 1000000.0; + double cycles_per_sec = 0; + if (elapsed_secs != 0) + cycles_per_sec = sim_time / elapsed_secs; + char *suffix = ""; + if (cycles_per_sec >= 1000000) { + cycles_per_sec /= 1000000.0; + suffix = "M"; + } else if (cycles_per_sec > 1000) { + cycles_per_sec /= 1000.0; + suffix = "K"; + } + printf("Elapsed seconds: %.2f, simulated cycles/sec: %.1f%s\n", + elapsed_secs, cycles_per_sec, suffix); + if (trace_bb.fstream) { + BBRec *ptr; + BBRec *next = trace_bb.next; + char *comp_ptr = trace_bb.compressed_ptr; + int64_t prev_bb_num = trace_bb.prev_bb_num; + uint64_t prev_bb_time = trace_bb.prev_bb_time; + for (ptr = trace_bb.buffer; ptr != next; ++ptr) { + if (comp_ptr >= trace_bb.high_water_ptr) { + uint32_t size = comp_ptr - trace_bb.compressed; + fwrite(trace_bb.compressed, sizeof(char), size, + trace_bb.fstream); + comp_ptr = trace_bb.compressed; + } + int64_t bb_diff = ptr->bb_num - prev_bb_num; + prev_bb_num = ptr->bb_num; + uint64_t time_diff = ptr->start_time - prev_bb_time; + prev_bb_time = ptr->start_time; + comp_ptr = varint_encode_signed(bb_diff, comp_ptr); + comp_ptr = varint_encode(time_diff, comp_ptr); + comp_ptr = varint_encode(ptr->repeat, comp_ptr); + if (ptr->repeat) + comp_ptr = varint_encode(ptr->time_diff, comp_ptr); + } + + // Add an extra record at the end containing the ending simulation + // time and a basic block number of 0. + uint64_t time_diff = sim_time - prev_bb_time; + if (time_diff > 0) { + int64_t bb_diff = -prev_bb_num; + comp_ptr = varint_encode_signed(bb_diff, comp_ptr); + comp_ptr = varint_encode(time_diff, comp_ptr); + comp_ptr = varint_encode(0, comp_ptr); + } + + uint32_t size = comp_ptr - trace_bb.compressed; + if (size) + fwrite(trace_bb.compressed, sizeof(char), size, trace_bb.fstream); + + // Terminate the file with three zeros so that we can detect + // the end of file quickly. + uint32_t zeros = 0; + fwrite(&zeros, 3, 1, trace_bb.fstream); + fclose(trace_bb.fstream); + } + + if (trace_insn.fstream) { + InsnRec *ptr; + InsnRec *current = trace_insn.current + 1; + char *comp_ptr = trace_insn.compressed_ptr; + for (ptr = trace_insn.buffer; ptr != current; ++ptr) { + if (comp_ptr >= trace_insn.high_water_ptr) { + uint32_t size = comp_ptr - trace_insn.compressed; + uint32_t rval = fwrite(trace_insn.compressed, sizeof(char), + size, trace_insn.fstream); + if (rval != size) { + fprintf(stderr, "fwrite() failed\n"); + perror(trace_insn.filename); + exit(1); + } + comp_ptr = trace_insn.compressed; + } + comp_ptr = varint_encode(ptr->time_diff, comp_ptr); + comp_ptr = varint_encode(ptr->repeat, comp_ptr); + } + + uint32_t size = comp_ptr - trace_insn.compressed; + if (size) { + uint32_t rval = fwrite(trace_insn.compressed, sizeof(char), size, + trace_insn.fstream); + if (rval != size) { + fprintf(stderr, "fwrite() failed\n"); + perror(trace_insn.filename); + exit(1); + } + } + fclose(trace_insn.fstream); + } + + if (trace_static.fstream) { + fseek(trace_static.fstream, 0, SEEK_SET); + write_trace_header(&header); + fclose(trace_static.fstream); + } + + if (trace_load.fstream) { + AddrRec *ptr; + char *comp_ptr = trace_load.compressed_ptr; + AddrRec *next = trace_load.next; + uint32_t prev_addr = trace_load.prev_addr; + uint64_t prev_time = trace_load.prev_time; + for (ptr = trace_load.buffer; ptr != next; ++ptr) { + if (comp_ptr >= trace_load.high_water_ptr) { + uint32_t size = comp_ptr - trace_load.compressed; + fwrite(trace_load.compressed, sizeof(char), size, + trace_load.fstream); + comp_ptr = trace_load.compressed; + } + + int addr_diff = ptr->addr - prev_addr; + uint64_t time_diff = ptr->time - prev_time; + prev_addr = ptr->addr; + prev_time = ptr->time; + + comp_ptr = varint_encode_signed(addr_diff, comp_ptr); + comp_ptr = varint_encode(time_diff, comp_ptr); + } + + uint32_t size = comp_ptr - trace_load.compressed; + if (size) { + fwrite(trace_load.compressed, sizeof(char), size, + trace_load.fstream); + } + + // Terminate the file with two zeros so that we can detect + // the end of file quickly. + uint32_t zeros = 0; + fwrite(&zeros, 2, 1, trace_load.fstream); + fclose(trace_load.fstream); + } + + if (trace_store.fstream) { + AddrRec *ptr; + char *comp_ptr = trace_store.compressed_ptr; + AddrRec *next = trace_store.next; + uint32_t prev_addr = trace_store.prev_addr; + uint64_t prev_time = trace_store.prev_time; + for (ptr = trace_store.buffer; ptr != next; ++ptr) { + if (comp_ptr >= trace_store.high_water_ptr) { + uint32_t size = comp_ptr - trace_store.compressed; + fwrite(trace_store.compressed, sizeof(char), size, + trace_store.fstream); + comp_ptr = trace_store.compressed; + } + + int addr_diff = ptr->addr - prev_addr; + uint64_t time_diff = ptr->time - prev_time; + prev_addr = ptr->addr; + prev_time = ptr->time; + + comp_ptr = varint_encode_signed(addr_diff, comp_ptr); + comp_ptr = varint_encode(time_diff, comp_ptr); + } + + uint32_t size = comp_ptr - trace_store.compressed; + if (size) { + fwrite(trace_store.compressed, sizeof(char), size, + trace_store.fstream); + } + + // Terminate the file with two zeros so that we can detect + // the end of file quickly. + uint32_t zeros = 0; + fwrite(&zeros, 2, 1, trace_store.fstream); + fclose(trace_store.fstream); + } + + if (trace_exc.fstream) { + uint32_t size = trace_exc.compressed_ptr - trace_exc.compressed; + if (size) { + fwrite(trace_exc.compressed, sizeof(char), size, + trace_exc.fstream); + } + + // Terminate the file with 7 zeros so that we can detect + // the end of file quickly. + uint64_t zeros = 0; + fwrite(&zeros, 7, 1, trace_exc.fstream); + fclose(trace_exc.fstream); + } + if (trace_pid.fstream) { + uint32_t size = trace_pid.compressed_ptr - trace_pid.compressed; + if (size) { + fwrite(trace_pid.compressed, sizeof(char), size, + trace_pid.fstream); + } + + // Terminate the file with 2 zeros so that we can detect + // the end of file quickly. + uint64_t zeros = 0; + fwrite(&zeros, 2, 1, trace_pid.fstream); + fclose(trace_pid.fstream); + } + if (trace_method.fstream) { + uint32_t size = trace_method.compressed_ptr - trace_method.compressed; + if (size) { + fwrite(trace_method.compressed, sizeof(char), size, + trace_method.fstream); + } + + // Terminate the file with 2 zeros so that we can detect + // the end of file quickly. + uint64_t zeros = 0; + fwrite(&zeros, 2, 1, trace_method.fstream); + fclose(trace_method.fstream); + } + if (ftrace_debug) + fclose(ftrace_debug); +} + +// Define the number of clock ticks for some instructions. Add one to these +// (in some cases) if there is an interlock. We currently do not check for +// interlocks. +#define TICKS_OTHER 1 +#define TICKS_SMULxy 1 +#define TICKS_SMLAWy 1 +#define TICKS_SMLALxy 2 +#define TICKS_MUL 2 +#define TICKS_MLA 2 +#define TICKS_MULS 4 // no interlock penalty +#define TICKS_MLAS 4 // no interlock penalty +#define TICKS_UMULL 3 +#define TICKS_UMLAL 3 +#define TICKS_SMULL 3 +#define TICKS_SMLAL 3 +#define TICKS_UMULLS 5 // no interlock penalty +#define TICKS_UMLALS 5 // no interlock penalty +#define TICKS_SMULLS 5 // no interlock penalty +#define TICKS_SMLALS 5 // no interlock penalty + +// Compute the number of cycles that this instruction will take, +// not including any I-cache or D-cache misses. This function +// is called for each instruction in a basic block when that +// block is being translated. +int get_insn_ticks(uint32_t insn) +{ +#if 1 + int result = 1; /* by default, use 1 cycle */ + + /* See Chapter 12 of the ARM920T Reference Manual for details about clock cycles */ + + /* first check for invalid condition codes */ + if ((insn >> 28) == 0xf) + { + if ((insn >> 25) == 0x7d) { /* BLX */ + result = 3; + goto Exit; + } + /* XXX: if we get there, we're either in an UNDEFINED instruction */ + /* or in co-processor related ones. For now, only return 1 cycle */ + goto Exit; + } + + /* other cases */ + switch ((insn >> 25) & 7) + { + case 0: + if ((insn & 0x00000090) == 0x00000090) /* Multiplies, extra load/store, Table 3-2 */ + { + /* XXX: TODO: Add support for multiplier operand content penalties in the translator */ + + if ((insn & 0x0fc000f0) == 0x00000090) /* 3-2: Multiply (accumulate) */ + { + int Rm = (insn & 15); + int Rs = (insn >> 8) & 15; + int Rn = (insn >> 12) & 15; + + if ((insn & 0x00200000) != 0) { /* MLA */ + result += _interlock_use(Rn); + } else { /* MLU */ + if (Rn != 0) /* UNDEFINED */ + goto Exit; + } + /* cycles=2+m, assume m=1, this should be adjusted at interpretation time */ + result += 2 + _interlock_use(Rm) + _interlock_use(Rs); + } + else if ((insn & 0x0f8000f0) == 0x00800090) /* 3-2: Multiply (accumulate) long */ + { + int Rm = (insn & 15); + int Rs = (insn >> 8) & 15; + int RdLo = (insn >> 12) & 15; + int RdHi = (insn >> 16) & 15; + + if ((insn & 0x00200000) != 0) { /* SMLAL & UMLAL */ + result += _interlock_use(RdLo) + _interlock_use(RdHi); + } + /* else SMLL and UMLL */ + + /* cucles=3+m, assume m=1, this should be adjusted at interpretation time */ + result += 3 + _interlock_use(Rm) + _interlock_use(Rs); + } + else if ((insn & 0x0fd00ff0) == 0x01000090) /* 3-2: Swap/swap byte */ + { + int Rm = (insn & 15); + int Rd = (insn >> 8) & 15; + + result = 2 + _interlock_use(Rm); + _interlock_def(Rd, result+1); + } + else if ((insn & 0x0e400ff0) == 0x00000090) /* 3-2: load/store halfword, reg offset */ + { + int Rm = (insn & 15); + int Rd = (insn >> 12) & 15; + int Rn = (insn >> 16) & 15; + + result += _interlock_use(Rn) + _interlock_use(Rm); + if ((insn & 0x00100000) != 0) /* it's a load, there's a 2-cycle interlock */ + _interlock_def(Rd, result+2); + } + else if ((insn & 0x0e400ff0) == 0x00400090) /* 3-2: load/store halfword, imm offset */ + { + int Rd = (insn >> 12) & 15; + int Rn = (insn >> 16) & 15; + + result += _interlock_use(Rn); + if ((insn & 0x00100000) != 0) /* it's a load, there's a 2-cycle interlock */ + _interlock_def(Rd, result+2); + } + else if ((insn & 0x0e500fd0) == 0x000000d0) /* 3-2: load/store two words, reg offset */ + { + /* XXX: TODO: Enhanced DSP instructions */ + } + else if ((insn & 0x0e500fd0) == 0x001000d0) /* 3-2: load/store half/byte, reg offset */ + { + int Rm = (insn & 15); + int Rd = (insn >> 12) & 15; + int Rn = (insn >> 16) & 15; + + result += _interlock_use(Rn) + _interlock_use(Rm); + if ((insn & 0x00100000) != 0) /* load, 2-cycle interlock */ + _interlock_def(Rd, result+2); + } + else if ((insn & 0x0e5000d0) == 0x004000d0) /* 3-2: load/store two words, imm offset */ + { + /* XXX: TODO: Enhanced DSP instructions */ + } + else if ((insn & 0x0e5000d0) == 0x005000d0) /* 3-2: load/store half/byte, imm offset */ + { + int Rd = (insn >> 12) & 15; + int Rn = (insn >> 16) & 15; + + result += _interlock_use(Rn); + if ((insn & 0x00100000) != 0) /* load, 2-cycle interlock */ + _interlock_def(Rd, result+2); + } + else + { + /* UNDEFINED */ + } + } + else if ((insn & 0x0f900000) == 0x01000000) /* Misc. instructions, table 3-3 */ + { + switch ((insn >> 4) & 15) + { + case 0: + if ((insn & 0x0fb0fff0) == 0x0120f000) /* move register to status register */ + { + int Rm = (insn & 15); + result += _interlock_use(Rm); + } + break; + + case 1: + if ( ((insn & 0x0ffffff0) == 0x01200010) || /* branch/exchange */ + ((insn & 0x0fff0ff0) == 0x01600010) ) /* count leading zeroes */ + { + int Rm = (insn & 15); + result += _interlock_use(Rm); + } + break; + + case 3: + if ((insn & 0x0ffffff0) == 0x01200030) /* link/exchange */ + { + int Rm = (insn & 15); + result += _interlock_use(Rm); + } + break; + + default: + /* TODO: Enhanced DSP instructions */ + ; + } + } + else /* Data processing */ + { + int Rm = (insn & 15); + int Rn = (insn >> 16) & 15; + + result += _interlock_use(Rn) + _interlock_use(Rm); + if ((insn & 0x10)) { /* register-controlled shift => 1 cycle penalty */ + int Rs = (insn >> 8) & 15; + result += 1 + _interlock_use(Rs); + } + } + break; + + case 1: + if ((insn & 0x01900000) == 0x01900000) + { + /* either UNDEFINED or move immediate to CPSR */ + } + else /* Data processing immediate */ + { + int Rn = (insn >> 12) & 15; + result += _interlock_use(Rn); + } + break; + + case 2: /* load/store immediate */ + { + int Rn = (insn >> 16) & 15; + + result += _interlock_use(Rn); + if (insn & 0x00100000) { /* LDR */ + int Rd = (insn >> 12) & 15; + + if (Rd == 15) /* loading PC */ + result = 5; + else + _interlock_def(Rd,result+1); + } + } + break; + + case 3: + if ((insn & 0x10) == 0) /* load/store register offset */ + { + int Rm = (insn & 15); + int Rn = (insn >> 16) & 15; + + result += _interlock_use(Rm) + _interlock_use(Rn); + + if (insn & 0x00100000) { /* LDR */ + int Rd = (insn >> 12) & 15; + if (Rd == 15) + result = 5; + else + _interlock_def(Rd,result+1); + } + } + /* else UNDEFINED */ + break; + + case 4: /* load/store multiple */ + { + int Rn = (insn >> 16) & 15; + uint32_t mask = (insn & 0xffff); + int count; + + for (count = 0; mask; count++) + mask &= (mask-1); + + result += _interlock_use(Rn); + + if (insn & 0x00100000) /* LDM */ + { + int nn; + + if (insn & 0x8000) { /* loading PC */ + result = count+4; + } else { /* not loading PC */ + result = (count < 2) ? 2 : count; + } + /* create defs, all registers locked until the end of the load */ + for (nn = 0; nn < 15; nn++) + if ((insn & (1U << nn)) != 0) + _interlock_def(nn,result); + } + else /* STM */ + result = (count < 2) ? 2 : count; + } + break; + + case 5: /* branch and branch+link */ + break; + + case 6: /* coprocessor load/store */ + { + int Rn = (insn >> 16) & 15; + + if (insn & 0x00100000) + result += _interlock_use(Rn); + + /* XXX: other things to do ? */ + } + break; + + default: /* i.e. 7 */ + /* XXX: TODO: co-processor related things */ + ; + } +Exit: + interlock_base += result; + return result; +#else /* old code - this seems to be completely buggy ?? */ + if ((insn & 0x0ff0f090) == 0x01600080) { + return TICKS_SMULxy; + } else if ((insn & 0x0ff00090) == 0x01200080) { + return TICKS_SMLAWy; + } else if ((insn & 0x0ff00090) == 0x01400080) { + return TICKS_SMLALxy; + } else if ((insn & 0x0f0000f0) == 0x00000090) { + // multiply + uint8_t bit23 = (insn >> 23) & 0x1; + uint8_t bit22_U = (insn >> 22) & 0x1; + uint8_t bit21_A = (insn >> 21) & 0x1; + uint8_t bit20_S = (insn >> 20) & 0x1; + + if (bit23 == 0) { + // 32-bit multiply + if (bit22_U != 0) { + // This is an unexpected bit pattern. + return TICKS_OTHER; + } + if (bit21_A == 0) { + if (bit20_S) + return TICKS_MULS; + return TICKS_MUL; + } + if (bit20_S) + return TICKS_MLAS; + return TICKS_MLA; + } + // 64-bit multiply + if (bit22_U == 0) { + // Unsigned multiply long + if (bit21_A == 0) { + if (bit20_S) + return TICKS_UMULLS; + return TICKS_UMULL; + } + if (bit20_S) + return TICKS_UMLALS; + return TICKS_UMLAL; + } + // Signed multiply long + if (bit21_A == 0) { + if (bit20_S) + return TICKS_SMULLS; + return TICKS_SMULL; + } + if (bit20_S) + return TICKS_SMLALS; + return TICKS_SMLAL; + } + return TICKS_OTHER; +#endif +} + +int get_insn_ticks_thumb(uint32_t insn) +{ +#if 1 + int result = 1; + + switch ((insn >> 11) & 31) + { + case 0: + case 1: + case 2: /* Shift by immediate */ + { + int Rm = (insn >> 3) & 7; + result += _interlock_use(Rm); + } + break; + + case 3: /* Add/Substract */ + { + int Rn = (insn >> 3) & 7; + result += _interlock_use(Rn); + + if ((insn & 0x0400) == 0) { /* register value */ + int Rm = (insn >> 6) & 7; + result += _interlock_use(Rm); + } + } + break; + + case 4: /* move immediate */ + break; + + case 5: + case 6: + case 7: /* add/substract/compare immediate */ + { + int Rd = (insn >> 8) & 7; + result += _interlock_use(Rd); + } + break; + + case 8: + { + if ((insn & 0x0400) == 0) /* data processing register */ + { + /* the registers can also be Rs and Rn in some cases */ + /* but they're always read anyway and located at the */ + /* same place, so we don't check the opcode */ + int Rm = (insn >> 3) & 7; + int Rd = (insn >> 3) & 7; + + result += _interlock_use(Rm) + _interlock_use(Rd); + } + else switch ((insn >> 8) & 3) + { + case 0: + case 1: + case 2: /* special data processing */ + { + int Rn = (insn & 7) | ((insn >> 4) & 0x8); + int Rm = ((insn >> 3) & 15); + + result += _interlock_use(Rn) + _interlock_use(Rm); + } + break; + + case 3: + if ((insn & 0xff07) == 0x4700) /* branch/exchange */ + { + int Rm = (insn >> 3) & 15; + + result = 3 + _interlock_use(Rm); + } + /* else UNDEFINED */ + break; + } + } + break; + + case 9: /* load from literal pool */ + { + int Rd = (insn >> 8) & 7; + _interlock_def(Rd,result+1); + } + break; + + case 10: + case 11: /* load/store register offset */ + { + int Rd = (insn & 7); + int Rn = (insn >> 3) & 7; + int Rm = (insn >> 6) & 7; + + result += _interlock_use(Rn) + _interlock_use(Rm); + + switch ((insn >> 9) & 7) + { + case 0: /* STR */ + case 1: /* STRH */ + case 2: /* STRB */ + result += _interlock_use(Rd); + break; + + case 3: /* LDRSB */ + case 5: /* LDRH */ + case 6: /* LDRB */ + case 7: /* LDRSH */ + _interlock_def(Rd,result+2); + break; + + case 4: /* LDR */ + _interlock_def(Rd,result+1); + } + } + break; + + case 12: /* store word immediate offset */ + case 14: /* store byte immediate offset */ + { + int Rd = (insn & 7); + int Rn = (insn >> 3) & 7; + + result += _interlock_use(Rd) + _interlock_use(Rn); + } + break; + + case 13: /* load word immediate offset */ + { + int Rd = (insn & 7); + int Rn = (insn >> 3) & 7; + + result += _interlock_use(Rn); + _interlock_def(Rd,result+1); + } + break; + + case 15: /* load byte immediate offset */ + { + int Rd = (insn & 7); + int Rn = (insn >> 3) & 7; + + result += _interlock_use(Rn); + _interlock_def(Rd,result+2); + } + break; + + case 16: /* store halfword immediate offset */ + { + int Rd = (insn & 7); + int Rn = (insn >> 3) & 7; + + result += _interlock_use(Rn) + _interlock_use(Rd); + } + break; + + case 17: /* load halfword immediate offset */ + { + int Rd = (insn & 7); + int Rn = (insn >> 3) & 7; + + result += _interlock_use(Rn); + _interlock_def(Rd,result+2); + } + break; + + case 18: /* store to stack */ + { + int Rd = (insn >> 8) & 3; + result += _interlock_use(Rd); + } + break; + + case 19: /* load from stack */ + { + int Rd = (insn >> 8) & 3; + _interlock_def(Rd,result+1); + } + break; + + case 20: /* add to PC */ + case 21: /* add to SP */ + { + int Rd = (insn >> 8) & 3; + result += _interlock_use(Rd); + } + break; + + case 22: + case 23: /* misc. instructions, table 6-2 */ + { + if ((insn & 0xff00) == 0xb000) /* adjust stack pointer */ + { + result += _interlock_use(14); + } + else if ((insn & 0x0600) == 0x0400) /* push pop register list */ + { + uint32_t mask = insn & 0x01ff; + int count, nn; + + for (count = 0; mask; count++) + mask &= (mask-1); + + result = (count < 2) ? 2 : count; + + if (insn & 0x0800) /* pop register list */ + { + for (nn = 0; nn < 9; nn++) + if (insn & (1 << nn)) + _interlock_def(nn, result); + } + else /* push register list */ + { + for (nn = 0; nn < 9; nn++) + if (insn & (1 << nn)) + result += _interlock_use(nn); + } + } + /* else software breakpoint */ + } + break; + + case 24: /* store multiple */ + { + int Rd = (insn >> 8) & 7; + uint32_t mask = insn & 255; + int count, nn; + + for (count = 0; mask; count++) + mask &= (mask-1); + + result = (count < 2) ? 2 : count; + result += _interlock_use(Rd); + + for (nn = 0; nn < 8; nn++) + if (insn & (1 << nn)) + result += _interlock_use(nn); + } + break; + + case 25: /* load multiple */ + { + int Rd = (insn >> 8) & 7; + uint32_t mask = insn & 255; + int count, nn; + + for (count = 0; mask; count++) + mask &= (mask-1); + + result = (count < 2) ? 2 : count; + result += _interlock_use(Rd); + + for (nn = 0; nn < 8; nn++) + if (insn & (1 << nn)) + _interlock_def(nn, result); + } + break; + + case 26: + case 27: /* conditional branch / undefined / software interrupt */ + switch ((insn >> 8) & 15) + { + case 14: /* UNDEFINED */ + case 15: /* SWI */ + break; + + default: /* conditional branch */ + result = 3; + } + break; + + case 28: /* unconditional branch */ + result = 3; + break; + + case 29: /* BLX suffix or undefined */ + if ((insn & 1) == 0) + result = 3; + break; + + case 30: /* BLX/BLX prefix */ + break; + + case 31: /* BL suffix */ + result = 3; + break; + } + interlock_base += result; + return result; +#else /* old code */ + if ((insn & 0xfc00) == 0x4340) /* MUL */ + return TICKS_SMULxy; + + return TICKS_OTHER; +#endif +} + +// Adds an exception trace record. +void trace_exception(uint32 target_pc) +{ + if (trace_exc.fstream == NULL) + return; + + // Sometimes we get an unexpected exception as the first record. If the + // basic block number is zero, then we know it is bogus. + if (trace_bb.current_bb_num == 0) + return; + + uint32_t current_pc = trace_bb.current_bb_addr + 4 * (trace_bb.num_insns - 1); +#if 0 + if (ftrace_debug) { + fprintf(ftrace_debug, "t%llu exc pc: 0x%x bb_addr: 0x%x num_insns: %d current_pc: 0x%x bb_num %llu bb_start_time %llu\n", + sim_time, target_pc, trace_bb.current_bb_addr, + trace_bb.num_insns, current_pc, trace_bb.current_bb_num, + trace_bb.current_bb_start_time); + } +#endif + char *comp_ptr = trace_exc.compressed_ptr; + if (comp_ptr >= trace_exc.high_water_ptr) { + uint32_t size = comp_ptr - trace_exc.compressed; + fwrite(trace_exc.compressed, sizeof(char), size, trace_exc.fstream); + comp_ptr = trace_exc.compressed; + } + uint64_t time_diff = sim_time - trace_exc.prev_time; + trace_exc.prev_time = sim_time; + uint64_t bb_recnum_diff = trace_bb.recnum - trace_exc.prev_bb_recnum; + trace_exc.prev_bb_recnum = trace_bb.recnum; + comp_ptr = varint_encode(time_diff, comp_ptr); + comp_ptr = varint_encode(current_pc, comp_ptr); + comp_ptr = varint_encode(bb_recnum_diff, comp_ptr); + comp_ptr = varint_encode(target_pc, comp_ptr); + comp_ptr = varint_encode(trace_bb.current_bb_num, comp_ptr); + comp_ptr = varint_encode(trace_bb.current_bb_start_time, comp_ptr); + comp_ptr = varint_encode(trace_bb.num_insns, comp_ptr); + trace_exc.compressed_ptr = comp_ptr; +} + +void trace_pid_1arg(int pid, int rec_type) +{ + if (trace_pid.fstream == NULL) + return; + char *comp_ptr = trace_pid.compressed_ptr; + char *max_end_ptr = comp_ptr + kMaxPidCompressed; + if (max_end_ptr >= &trace_pid.compressed[kCompressedSize]) { + uint32_t size = comp_ptr - trace_pid.compressed; + fwrite(trace_pid.compressed, sizeof(char), size, trace_pid.fstream); + comp_ptr = trace_pid.compressed; + } + uint64_t time_diff = sim_time - trace_pid.prev_time; + trace_pid.prev_time = sim_time; + comp_ptr = varint_encode(time_diff, comp_ptr); + comp_ptr = varint_encode(rec_type, comp_ptr); + comp_ptr = varint_encode(pid, comp_ptr); + trace_pid.compressed_ptr = comp_ptr; +} + +void trace_pid_2arg(int tgid, int pid, int rec_type) +{ + if (trace_pid.fstream == NULL) + return; + char *comp_ptr = trace_pid.compressed_ptr; + char *max_end_ptr = comp_ptr + kMaxPid2Compressed; + if (max_end_ptr >= &trace_pid.compressed[kCompressedSize]) { + uint32_t size = comp_ptr - trace_pid.compressed; + fwrite(trace_pid.compressed, sizeof(char), size, trace_pid.fstream); + comp_ptr = trace_pid.compressed; + } + uint64_t time_diff = sim_time - trace_pid.prev_time; + trace_pid.prev_time = sim_time; + comp_ptr = varint_encode(time_diff, comp_ptr); + comp_ptr = varint_encode(rec_type, comp_ptr); + comp_ptr = varint_encode(tgid, comp_ptr); + comp_ptr = varint_encode(pid, comp_ptr); + trace_pid.compressed_ptr = comp_ptr; +} + +void trace_switch(int pid) +{ +#if 0 + if (ftrace_debug && trace_pid.fstream) + fprintf(ftrace_debug, "t%lld switch %d\n", sim_time, pid); +#endif + trace_pid_1arg(pid, kPidSwitch); + current_pid = pid; +} + +void trace_fork(int tgid, int pid) +{ +#if 0 + if (ftrace_debug && trace_pid.fstream) + fprintf(ftrace_debug, "t%lld fork %d\n", sim_time, pid); +#endif + trace_pid_2arg(tgid, pid, kPidFork); +} + +void trace_clone(int tgid, int pid) +{ +#if 0 + if (ftrace_debug && trace_pid.fstream) + fprintf(ftrace_debug, "t%lld clone %d\n", sim_time, pid); +#endif + trace_pid_2arg(tgid, pid, kPidClone); +} + +void trace_exit(int exitcode) +{ +#if 0 + if (ftrace_debug && trace_pid.fstream) + fprintf(ftrace_debug, "t%lld exit %d\n", sim_time, exitcode); +#endif + trace_pid_1arg(exitcode, kPidExit); +} + +void trace_name(char *name) +{ +#if 0 + if (ftrace_debug && trace_pid.fstream) { + fprintf(ftrace_debug, "t%lld pid %d name %s\n", + sim_time, current_pid, name); + } +#endif + if (trace_pid.fstream == NULL) + return; + int len = strlen(name); + char *comp_ptr = trace_pid.compressed_ptr; + char *max_end_ptr = comp_ptr + len + kMaxNameCompressed; + if (max_end_ptr >= &trace_pid.compressed[kCompressedSize]) { + uint32_t size = comp_ptr - trace_pid.compressed; + fwrite(trace_pid.compressed, sizeof(char), size, trace_pid.fstream); + comp_ptr = trace_pid.compressed; + } + uint64_t time_diff = sim_time - trace_pid.prev_time; + trace_pid.prev_time = sim_time; + comp_ptr = varint_encode(time_diff, comp_ptr); + int rec_type = kPidName; + comp_ptr = varint_encode(rec_type, comp_ptr); + comp_ptr = varint_encode(current_pid, comp_ptr); + comp_ptr = varint_encode(len, comp_ptr); + strncpy(comp_ptr, name, len); + comp_ptr += len; + trace_pid.compressed_ptr = comp_ptr; +} + +void trace_execve(const char *argv, int len) +{ + int ii; + + if (trace_pid.fstream == NULL) + return; + // Count the number of args + int alen = 0; + int sum_len = 0; + int argc = 0; + const char *ptr = argv; + while (sum_len < len) { + argc += 1; + alen = strlen(ptr); + ptr += alen + 1; + sum_len += alen + 1; + } + +#if 0 + if (ftrace_debug) { + fprintf(ftrace_debug, "t%lld argc: %d\n", sim_time, argc); + alen = 0; + ptr = argv; + for (ii = 0; ii < argc; ++ii) { + fprintf(ftrace_debug, " argv[%d]: %s\n", ii, ptr); + alen = strlen(ptr); + ptr += alen + 1; + } + } +#endif + + char *comp_ptr = trace_pid.compressed_ptr; + char *max_end_ptr = comp_ptr + len + 5 * argc + kMaxExecArgsCompressed; + if (max_end_ptr >= &trace_pid.compressed[kCompressedSize]) { + uint32_t size = comp_ptr - trace_pid.compressed; + fwrite(trace_pid.compressed, sizeof(char), size, trace_pid.fstream); + comp_ptr = trace_pid.compressed; + } + uint64_t time_diff = sim_time - trace_pid.prev_time; + trace_pid.prev_time = sim_time; + comp_ptr = varint_encode(time_diff, comp_ptr); + int rec_type = kPidExec; + comp_ptr = varint_encode(rec_type, comp_ptr); + comp_ptr = varint_encode(argc, comp_ptr); + + ptr = argv; + for (ii = 0; ii < argc; ++ii) { + alen = strlen(ptr); + comp_ptr = varint_encode(alen, comp_ptr); + strncpy(comp_ptr, ptr, alen); + comp_ptr += alen; + ptr += alen + 1; + } + trace_pid.compressed_ptr = comp_ptr; +} + +void trace_mmap(unsigned long vstart, unsigned long vend, + unsigned long offset, const char *path) +{ + if (trace_pid.fstream == NULL) + return; +#if 0 + if (ftrace_debug) + fprintf(ftrace_debug, "t%lld mmap %08lx - %08lx, offset %08lx '%s'\n", + sim_time, vstart, vend, offset, path); +#endif + int len = strlen(path); + char *comp_ptr = trace_pid.compressed_ptr; + char *max_end_ptr = comp_ptr + len + kMaxMmapCompressed; + if (max_end_ptr >= &trace_pid.compressed[kCompressedSize]) { + uint32_t size = comp_ptr - trace_pid.compressed; + fwrite(trace_pid.compressed, sizeof(char), size, trace_pid.fstream); + comp_ptr = trace_pid.compressed; + } + uint64_t time_diff = sim_time - trace_pid.prev_time; + trace_pid.prev_time = sim_time; + comp_ptr = varint_encode(time_diff, comp_ptr); + int rec_type = kPidMmap; + comp_ptr = varint_encode(rec_type, comp_ptr); + comp_ptr = varint_encode(vstart, comp_ptr); + comp_ptr = varint_encode(vend, comp_ptr); + comp_ptr = varint_encode(offset, comp_ptr); + comp_ptr = varint_encode(len, comp_ptr); + strncpy(comp_ptr, path, len); + trace_pid.compressed_ptr = comp_ptr + len; +} + +void trace_munmap(unsigned long vstart, unsigned long vend) +{ + if (trace_pid.fstream == NULL) + return; +#if 0 + if (ftrace_debug) + fprintf(ftrace_debug, "t%lld munmap %08lx - %08lx\n", + sim_time, vstart, vend); +#endif + char *comp_ptr = trace_pid.compressed_ptr; + char *max_end_ptr = comp_ptr + kMaxMunmapCompressed; + if (max_end_ptr >= &trace_pid.compressed[kCompressedSize]) { + uint32_t size = comp_ptr - trace_pid.compressed; + fwrite(trace_pid.compressed, sizeof(char), size, trace_pid.fstream); + comp_ptr = trace_pid.compressed; + } + uint64_t time_diff = sim_time - trace_pid.prev_time; + trace_pid.prev_time = sim_time; + comp_ptr = varint_encode(time_diff, comp_ptr); + int rec_type = kPidMunmap; + comp_ptr = varint_encode(rec_type, comp_ptr); + comp_ptr = varint_encode(vstart, comp_ptr); + comp_ptr = varint_encode(vend, comp_ptr); + trace_pid.compressed_ptr = comp_ptr; +} + +void trace_dynamic_symbol_add(unsigned long vaddr, const char *name) +{ + if (trace_pid.fstream == NULL) + return; +#if 0 + if (ftrace_debug) + fprintf(ftrace_debug, "t%lld sym %08lx '%s'\n", sim_time, vaddr, name); +#endif + int len = strlen(name); + char *comp_ptr = trace_pid.compressed_ptr; + char *max_end_ptr = comp_ptr + len + kMaxSymbolCompressed; + if (max_end_ptr >= &trace_pid.compressed[kCompressedSize]) { + uint32_t size = comp_ptr - trace_pid.compressed; + fwrite(trace_pid.compressed, sizeof(char), size, trace_pid.fstream); + comp_ptr = trace_pid.compressed; + } + uint64_t time_diff = sim_time - trace_pid.prev_time; + trace_pid.prev_time = sim_time; + comp_ptr = varint_encode(time_diff, comp_ptr); + int rec_type = kPidSymbolAdd; + comp_ptr = varint_encode(rec_type, comp_ptr); + comp_ptr = varint_encode(vaddr, comp_ptr); + comp_ptr = varint_encode(len, comp_ptr); + strncpy(comp_ptr, name, len); + trace_pid.compressed_ptr = comp_ptr + len; +} + +void trace_dynamic_symbol_remove(unsigned long vaddr) +{ + if (trace_pid.fstream == NULL) + return; +#if 0 + if (ftrace_debug) + fprintf(ftrace_debug, "t%lld remove %08lx\n", sim_time, vaddr); +#endif + char *comp_ptr = trace_pid.compressed_ptr; + char *max_end_ptr = comp_ptr + kMaxSymbolCompressed; + if (max_end_ptr >= &trace_pid.compressed[kCompressedSize]) { + uint32_t size = comp_ptr - trace_pid.compressed; + fwrite(trace_pid.compressed, sizeof(char), size, trace_pid.fstream); + comp_ptr = trace_pid.compressed; + } + uint64_t time_diff = sim_time - trace_pid.prev_time; + trace_pid.prev_time = sim_time; + comp_ptr = varint_encode(time_diff, comp_ptr); + int rec_type = kPidSymbolRemove; + comp_ptr = varint_encode(rec_type, comp_ptr); + comp_ptr = varint_encode(vaddr, comp_ptr); + trace_pid.compressed_ptr = comp_ptr; +} + +void trace_init_name(int tgid, int pid, const char *name) +{ + if (trace_pid.fstream == NULL) + return; +#if 0 + if (ftrace_debug) + fprintf(ftrace_debug, "t%lld kthread %d %s\n", sim_time, pid, name); +#endif + int len = strlen(name); + char *comp_ptr = trace_pid.compressed_ptr; + char *max_end_ptr = comp_ptr + len + kMaxKthreadNameCompressed; + if (max_end_ptr >= &trace_pid.compressed[kCompressedSize]) { + uint32_t size = comp_ptr - trace_pid.compressed; + fwrite(trace_pid.compressed, sizeof(char), size, trace_pid.fstream); + comp_ptr = trace_pid.compressed; + } + uint64_t time_diff = sim_time - trace_pid.prev_time; + trace_pid.prev_time = sim_time; + comp_ptr = varint_encode(time_diff, comp_ptr); + int rec_type = kPidKthreadName; + comp_ptr = varint_encode(rec_type, comp_ptr); + comp_ptr = varint_encode(tgid, comp_ptr); + comp_ptr = varint_encode(pid, comp_ptr); + comp_ptr = varint_encode(len, comp_ptr); + strncpy(comp_ptr, name, len); + trace_pid.compressed_ptr = comp_ptr + len; +} + +void trace_init_exec(unsigned long start, unsigned long end, + unsigned long offset, const char *exe) +{ +} + +// This function is called by the generated code to record the basic +// block number. +void trace_bb_helper(uint64_t bb_num, TranslationBlock *tb) +{ + BBRec *bb_rec = tb->bb_rec; + uint64_t prev_time = tb->prev_time; + trace_bb.current_bb_addr = tb->pc; + trace_bb.current_bb_num = bb_num; + trace_bb.current_bb_start_time = sim_time; + trace_bb.num_insns = 0; + trace_bb.recnum += 1; + +#if 0 + if (ftrace_debug) + fprintf(ftrace_debug, "t%lld %lld\n", sim_time, bb_num); +#endif + if (bb_rec && bb_rec->bb_num == bb_num && prev_time > trace_bb.flush_time) { + uint64_t time_diff = sim_time - prev_time; + if (bb_rec->repeat == 0) { + bb_rec->repeat = 1; + bb_rec->time_diff = time_diff; + tb->prev_time = sim_time; + return; + } else if (time_diff == bb_rec->time_diff) { + bb_rec->repeat += 1; + tb->prev_time = sim_time; + return; + } + } + + BBRec *next = trace_bb.next; + if (next == &trace_bb.buffer[kMaxNumBasicBlocks]) { + BBRec *ptr; + char *comp_ptr = trace_bb.compressed_ptr; + int64_t prev_bb_num = trace_bb.prev_bb_num; + uint64_t prev_bb_time = trace_bb.prev_bb_time; + for (ptr = trace_bb.buffer; ptr != next; ++ptr) { + if (comp_ptr >= trace_bb.high_water_ptr) { + uint32_t size = comp_ptr - trace_bb.compressed; + fwrite(trace_bb.compressed, sizeof(char), size, trace_bb.fstream); + comp_ptr = trace_bb.compressed; + } + int64_t bb_diff = ptr->bb_num - prev_bb_num; + prev_bb_num = ptr->bb_num; + uint64_t time_diff = ptr->start_time - prev_bb_time; + prev_bb_time = ptr->start_time; + comp_ptr = varint_encode_signed(bb_diff, comp_ptr); + comp_ptr = varint_encode(time_diff, comp_ptr); + comp_ptr = varint_encode(ptr->repeat, comp_ptr); + if (ptr->repeat) + comp_ptr = varint_encode(ptr->time_diff, comp_ptr); + } + trace_bb.compressed_ptr = comp_ptr; + trace_bb.prev_bb_num = prev_bb_num; + trace_bb.prev_bb_time = prev_bb_time; + + next = trace_bb.buffer; + trace_bb.flush_time = sim_time; + } + tb->bb_rec = next; + next->bb_num = bb_num; + next->start_time = sim_time; + next->time_diff = 0; + next->repeat = 0; + tb->prev_time = sim_time; + next += 1; + trace_bb.next = next; +} + +// This function is called by the generated code to record the simulation +// time at the start of each instruction. +void trace_insn_helper() +{ + InsnRec *current = trace_insn.current; + uint64_t time_diff = sim_time - trace_insn.prev_time; + trace_insn.prev_time = sim_time; + + // Keep track of the number of traced instructions so far in this + // basic block in case we get an exception in the middle of the bb. + trace_bb.num_insns += 1; + +#if 0 + if (ftrace_debug) { + uint32_t current_pc = trace_bb.current_bb_addr + 4 * (trace_bb.num_insns - 1); + fprintf(ftrace_debug, "%llu %x\n", sim_time, current_pc); + } +#endif + if (time_diff == current->time_diff) { + current->repeat += 1; + if (current->repeat != 0) + return; + + // The repeat count wrapped around, so back up one and create + // a new record. + current->repeat -= 1; + } + current += 1; + + if (current == &trace_insn.buffer[kInsnBufferSize]) { + InsnRec *ptr; + char *comp_ptr = trace_insn.compressed_ptr; + for (ptr = trace_insn.buffer; ptr != current; ++ptr) { + if (comp_ptr >= trace_insn.high_water_ptr) { + uint32_t size = comp_ptr - trace_insn.compressed; + uint32_t rval = fwrite(trace_insn.compressed, sizeof(char), + size, trace_insn.fstream); + if (rval != size) { + fprintf(stderr, "fwrite() failed\n"); + perror(trace_insn.filename); + exit(1); + } + comp_ptr = trace_insn.compressed; + } + comp_ptr = varint_encode(ptr->time_diff, comp_ptr); + comp_ptr = varint_encode(ptr->repeat, comp_ptr); + } + trace_insn.compressed_ptr = comp_ptr; + current = trace_insn.buffer; + } + current->time_diff = time_diff; + current->repeat = 0; + trace_insn.current = current; +} + +// Adds an interpreted method trace record. Each trace record is a time +// stamped entry or exit to a method in a language executed by a "virtual +// machine". This allows profiling tools to show the method names instead +// of the core virtual machine interpreter. +void trace_interpreted_method(uint32_t addr, int call_type) +{ + if (trace_method.fstream == NULL) + return; +#if 0 + fprintf(stderr, "trace_method time: %llu p%d 0x%x %d\n", + sim_time, current_pid, addr, call_type); +#endif + char *comp_ptr = trace_method.compressed_ptr; + char *max_end_ptr = comp_ptr + kMaxMethodCompressed; + if (max_end_ptr >= &trace_method.compressed[kCompressedSize]) { + uint32_t size = comp_ptr - trace_method.compressed; + fwrite(trace_method.compressed, sizeof(char), size, trace_method.fstream); + comp_ptr = trace_method.compressed; + } + uint64_t time_diff = sim_time - trace_method.prev_time; + trace_method.prev_time = sim_time; + + int32_t addr_diff = addr - trace_method.prev_addr; + trace_method.prev_addr = addr; + + int32_t pid_diff = current_pid - trace_method.prev_pid; + trace_method.prev_pid = current_pid; + + comp_ptr = varint_encode(time_diff, comp_ptr); + comp_ptr = varint_encode_signed(addr_diff, comp_ptr); + comp_ptr = varint_encode_signed(pid_diff, comp_ptr); + comp_ptr = varint_encode(call_type, comp_ptr); + trace_method.compressed_ptr = comp_ptr; +} -- cgit v1.1