diff options
Diffstat (limited to 'emulator/qtools/trace_reader.cpp')
| -rw-r--r-- | emulator/qtools/trace_reader.cpp | 1201 |
1 files changed, 1201 insertions, 0 deletions
diff --git a/emulator/qtools/trace_reader.cpp b/emulator/qtools/trace_reader.cpp new file mode 100644 index 0000000..b38c0b4 --- /dev/null +++ b/emulator/qtools/trace_reader.cpp @@ -0,0 +1,1201 @@ +// Copyright 2006 The Android Open Source Project + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <limits.h> +#include <inttypes.h> +#include <assert.h> +#include <unistd.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <elf.h> +#include "trace_reader.h" +#include "decoder.h" + +// A struct for creating temporary linked-lists of DexSym structs +struct DexSymList { + DexSymList *next; + DexSym sym; +}; + +// Declare static functions used in this file +static char *ExtractDexPathFromMmap(const char *mmap_path); +static void CopyDexSymbolsToArray(DexFileList *dexfile, + DexSymList *head, int num_symbols); + +// This function creates the pathname to the a specific trace file. The +// string space is allocated in this routine and must be freed by the +// caller. +static char *CreateTracePath(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 = new char[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; +} + +inline BBReader::Future *BBReader::AllocFuture() +{ + Future *future = free_; + free_ = free_->next; + return future; +} + +inline void BBReader::FreeFuture(Future *future) +{ + future->next = free_; + free_ = future; +} + +inline void BBReader::InsertFuture(Future *future) +{ + uint64_t future_time = future->bb.next_time; + Future *prev = NULL; + Future *ptr; + for (ptr = head_; ptr; prev = ptr, ptr = ptr->next) { + if (future_time <= ptr->bb.next_time) + break; + } + if (prev == NULL) { + // link it at the front + future->next = head_; + head_ = future; + } else { + // link it after "prev" + future->next = prev->next; + prev->next = future; + } +} + +// Decodes the next basic block record from the file. Returns 1 +// at end-of-file, otherwise returns 0. +inline int BBReader::DecodeNextRec() +{ + int64_t bb_diff = decoder_->Decode(true); + uint64_t time_diff = decoder_->Decode(false); + nextrec_.bb_rec.repeat = decoder_->Decode(false); + if (time_diff == 0) + return 1; + if (nextrec_.bb_rec.repeat) + nextrec_.bb_rec.time_diff = decoder_->Decode(false); + nextrec_.bb_rec.bb_num += bb_diff; + nextrec_.bb_rec.start_time += time_diff; + return 0; +} + +BBReader::BBReader(TraceReaderBase *trace) +{ + trace_ = trace; + decoder_ = new Decoder; +} + +BBReader::~BBReader() +{ + delete decoder_; +} + +void BBReader::Open(char *filename) +{ + // Initialize the class variables + memset(&nextrec_, 0, sizeof(TimeRec)); + memset(futures_, 0, sizeof(Future) * kMaxNumBasicBlocks); + head_ = NULL; + + // Link all of the futures_[] array elements on the free list. + for (int ii = 0; ii < kMaxNumBasicBlocks - 1; ++ii) { + futures_[ii].next = &futures_[ii + 1]; + } + futures_[kMaxNumBasicBlocks - 1].next = 0; + free_ = &futures_[0]; + + // Open the trace.bb file + char *fname = CreateTracePath(filename, ".bb"); + decoder_->Open(fname); + is_eof_ = DecodeNextRec(); + delete[] fname; +} + +void BBReader::Close() +{ + decoder_->Close(); +} + +// Returns true at end of file. +bool BBReader::ReadBB(BBEvent *event) +{ + if (is_eof_ && head_ == NULL) { + return true; + } + +#if 0 + if (nextrec_) { + printf("nextrec: buffer[%d], bb_num: %lld start: %d diff %d repeat %d next %u\n", + nextrec_ - &buffer_[0], + nextrec_->bb_rec.bb_num, nextrec_->bb_rec.start_time, + nextrec_->bb_rec.time_diff, nextrec_->bb_rec.repeat, + nextrec_->next_time); + } + if (head_) { + printf("head: 0x%x, bb_num: %lld start: %d diff %d repeat %d next %u\n", + head_, + head_->bb->bb_rec.bb_num, head_->bb->bb_rec.start_time, + head_->bb->bb_rec.time_diff, head_->bb->bb_rec.repeat, + head_->bb->next_time); + } +#endif + if (!is_eof_) { + if (head_) { + TimeRec *bb = &head_->bb; + if (bb->next_time < nextrec_.bb_rec.start_time) { + // The head is earlier. + event->time = bb->next_time; + event->bb_num = bb->bb_rec.bb_num; + event->bb_addr = trace_->GetBBAddr(event->bb_num); + event->insns = trace_->GetInsns(event->bb_num); + event->num_insns = trace_->FindNumInsns(event->bb_num, event->time); + event->pid = trace_->FindCurrentPid(event->time); + event->is_thumb = trace_->GetIsThumb(event->bb_num); + + // Remove the head element from the list + Future *future = head_; + head_ = head_->next; + if (bb->bb_rec.repeat > 0) { + // there are more repetitions of this bb + bb->bb_rec.repeat -= 1; + bb->next_time += bb->bb_rec.time_diff; + + // Insert this future into the sorted list + InsertFuture(future); + } else { + // Add this future to the free list + FreeFuture(future); + } + return false; + } + } + // The nextrec is earlier (or there was no head) + event->time = nextrec_.bb_rec.start_time; + event->bb_num = nextrec_.bb_rec.bb_num; + event->bb_addr = trace_->GetBBAddr(event->bb_num); + event->insns = trace_->GetInsns(event->bb_num); + event->num_insns = trace_->FindNumInsns(event->bb_num, event->time); + event->pid = trace_->FindCurrentPid(event->time); + event->is_thumb = trace_->GetIsThumb(event->bb_num); + if (nextrec_.bb_rec.repeat > 0) { + Future *future = AllocFuture(); + future->bb.bb_rec = nextrec_.bb_rec; + future->bb.bb_rec.repeat -= 1; + future->bb.next_time = nextrec_.bb_rec.start_time + nextrec_.bb_rec.time_diff; + InsertFuture(future); + } + + is_eof_ = DecodeNextRec(); + return false; + } + + //printf("using head_ 0x%x\n", head_); + assert(head_); + TimeRec *bb = &head_->bb; + event->time = bb->next_time; + event->bb_num = bb->bb_rec.bb_num; + event->bb_addr = trace_->GetBBAddr(event->bb_num); + event->insns = trace_->GetInsns(event->bb_num); + event->num_insns = trace_->FindNumInsns(event->bb_num, event->time); + event->pid = trace_->FindCurrentPid(event->time); + event->is_thumb = trace_->GetIsThumb(event->bb_num); + + // Remove the head element from the list + Future *future = head_; + head_ = head_->next; + if (bb->bb_rec.repeat > 0) { + // there are more repetitions of this bb + bb->bb_rec.repeat -= 1; + bb->next_time += bb->bb_rec.time_diff; + + // Insert this future into the sorted list + InsertFuture(future); + } else { + // Add this future to the free list + FreeFuture(future); + } + return false; +} + +InsnReader::InsnReader() +{ + decoder_ = new Decoder; +} + +InsnReader::~InsnReader() +{ + delete decoder_; +} + +void InsnReader::Open(char *filename) +{ + prev_time_ = 0; + time_diff_ = 0; + repeat_ = -1; + + // Open the trace.insn file + char *fname = CreateTracePath(filename, ".insn"); + decoder_->Open(fname); + delete[] fname; +} + +void InsnReader::Close() +{ + decoder_->Close(); +} + +uint64_t InsnReader::ReadInsnTime(uint64_t min_time) +{ + do { + if (repeat_ == -1) { + time_diff_ = decoder_->Decode(false); + repeat_ = decoder_->Decode(false); + } + prev_time_ += time_diff_; + repeat_ -= 1; + } while (prev_time_ < min_time); + return prev_time_; +} + +AddrReader::AddrReader() +{ + decoder_ = new Decoder; + opened_ = false; +} + +AddrReader::~AddrReader() +{ + delete decoder_; +} + +// Returns true if there is an error opening the file +bool AddrReader::Open(char *filename, char *suffix) +{ + struct stat stat_buf; + + prev_addr_ = 0; + prev_time_ = 0; + + // Open the trace.addr file + char *fname = CreateTracePath(filename, suffix); + int rval = stat(fname, &stat_buf); + if (rval == -1) { + // The file does not exist + delete[] fname; + return true; + } + decoder_->Open(fname); + opened_ = true; + delete[] fname; + return false; +} + +void AddrReader::Close() +{ + decoder_->Close(); +} + +// Returns true at end of file. +bool AddrReader::ReadAddr(uint64_t *time, uint32_t *addr) +{ + if (!opened_) { + fprintf(stderr, "Cannot read address trace\n"); + exit(1); + } + uint32_t addr_diff = decoder_->Decode(true); + uint64_t time_diff = decoder_->Decode(false); + if (time_diff == 0 && addr_diff == 0) { + *addr = 0; + *time = 0; + return true; + } + prev_addr_ += addr_diff; + prev_time_ += time_diff; + *addr = prev_addr_; + *time = prev_time_; + return false; +} + +ExcReader::ExcReader() +{ + decoder_ = new Decoder; +} + +ExcReader::~ExcReader() +{ + delete decoder_; +} + +void ExcReader::Open(char *filename) +{ + prev_time_ = 0; + prev_recnum_ = 0; + + // Open the trace.exc file + char *fname = CreateTracePath(filename, ".exc"); + decoder_->Open(fname); + delete[] fname; +} + +void ExcReader::Close() +{ + decoder_->Close(); +} + +// Returns true at end of file. +bool ExcReader::ReadExc(uint64_t *time, uint32_t *current_pc, uint64_t *recnum, + uint32_t *target_pc, uint64_t *bb_num, + uint64_t *bb_start_time, int *num_insns) +{ + uint64_t time_diff = decoder_->Decode(false); + uint32_t pc = decoder_->Decode(false); + if ((time_diff | pc) == 0) { + decoder_->Decode(false); + decoder_->Decode(false); + decoder_->Decode(false); + decoder_->Decode(false); + decoder_->Decode(false); + return true; + } + uint64_t recnum_diff = decoder_->Decode(false); + prev_time_ += time_diff; + prev_recnum_ += recnum_diff; + *time = prev_time_; + *current_pc = pc; + *recnum = prev_recnum_; + *target_pc = decoder_->Decode(false); + *bb_num = decoder_->Decode(false); + *bb_start_time = decoder_->Decode(false); + *num_insns = decoder_->Decode(false); + return false; +} + +PidReader::PidReader() +{ + decoder_ = new Decoder; +} + +PidReader::~PidReader() +{ + delete decoder_; +} + +void PidReader::Open(char *filename) +{ + prev_time_ = 0; + + // Open the trace.pid file + char *fname = CreateTracePath(filename, ".pid"); + decoder_->Open(fname); + delete[] fname; +} + +void PidReader::Close() +{ + decoder_->Close(); +} + +// Returns true at end of file. +bool PidReader::ReadPidEvent(PidEvent *event) +{ + uint64_t time_diff = decoder_->Decode(false); + int rec_type = decoder_->Decode(false); + prev_time_ += time_diff; + event->time = prev_time_; + event->rec_type = rec_type; + switch(rec_type) { + case kPidEndOfFile: + return true; + case kPidSwitch: + case kPidExit: + event->pid = decoder_->Decode(false); + break; + case kPidFork: + case kPidClone: + event->tgid = decoder_->Decode(false); + event->pid = decoder_->Decode(false); + break; + case kPidMmap: + { + event->vstart = decoder_->Decode(false); + event->vend = decoder_->Decode(false); + event->offset = decoder_->Decode(false); + int len = decoder_->Decode(false); + char *path = new char[len + 1]; + decoder_->Read(path, len); + path[len] = 0; + event->path = path; + event->mmap_path = path; + char *dexfile = ExtractDexPathFromMmap(path); + if (dexfile != NULL) { + delete[] event->path; + event->path = dexfile; + } + } + break; + case kPidMunmap: + { + event->vstart = decoder_->Decode(false); + event->vend = decoder_->Decode(false); + } + break; + case kPidSymbolAdd: + { + event->vstart = decoder_->Decode(false); + int len = decoder_->Decode(false); + char *path = new char[len + 1]; + decoder_->Read(path, len); + path[len] = 0; + event->path = path; + } + break; + case kPidSymbolRemove: + event->vstart = decoder_->Decode(false); + break; + case kPidExec: + { + int argc = decoder_->Decode(false); + event->argc = argc; + char **argv = new char*[argc]; + event->argv = argv; + for (int ii = 0; ii < argc; ++ii) { + int alen = decoder_->Decode(false); + argv[ii] = new char[alen + 1]; + decoder_->Read(argv[ii], alen); + argv[ii][alen] = 0; + } + } + break; + case kPidName: + case kPidKthreadName: + { + if (rec_type == kPidKthreadName) { + event->tgid = decoder_->Decode(false); + } + event->pid = decoder_->Decode(false); + int len = decoder_->Decode(false); + char *path = new char[len + 1]; + decoder_->Read(path, len); + path[len] = 0; + event->path = path; + } + break; + } + return false; +} + +// Frees the memory that might have been allocated for the given event. +void PidReader::Dispose(PidEvent *event) +{ + switch(event->rec_type) { + case kPidMmap: + case kPidSymbolAdd: + case kPidName: + case kPidKthreadName: + delete[] event->path; + event->path = NULL; + event->mmap_path = NULL; + break; + + case kPidExec: + for (int ii = 0; ii < event->argc; ++ii) { + delete[] event->argv[ii]; + } + delete[] event->argv; + event->argv = NULL; + event->argc = 0; + break; + } +} + + +MethodReader::MethodReader() +{ + decoder_ = new Decoder; + opened_ = false; +} + +MethodReader::~MethodReader() +{ + delete decoder_; +} + +bool MethodReader::Open(char *filename) +{ + struct stat stat_buf; + + prev_time_ = 0; + prev_addr_ = 0; + prev_pid_ = 0; + + // Open the trace.method file + char *fname = CreateTracePath(filename, ".method"); + int rval = stat(fname, &stat_buf); + if (rval == -1) { + // The file does not exist + delete[] fname; + return true; + } + decoder_->Open(fname); + delete[] fname; + opened_ = true; + return false; +} + +void MethodReader::Close() +{ + decoder_->Close(); +} + +// Returns true at end of file. +bool MethodReader::ReadMethod(MethodRec *method_record) +{ + if (!opened_) + return true; + uint64_t time_diff = decoder_->Decode(false); + int32_t addr_diff = decoder_->Decode(true); + if (time_diff == 0) { + method_record->time = 0; + method_record->addr = 0; + method_record->flags = 0; + return true; + } + int32_t pid_diff = decoder_->Decode(true); + prev_time_ += time_diff; + prev_addr_ += addr_diff; + prev_pid_ += pid_diff; + method_record->time = prev_time_; + method_record->addr = prev_addr_; + method_record->pid = prev_pid_; + method_record->flags = decoder_->Decode(false); + return false; +} + +TraceReaderBase::TraceReaderBase() +{ + static_filename_ = NULL; + static_fstream_ = NULL; + header_ = new TraceHeader; + bb_reader_ = new BBReader(this); + insn_reader_ = new InsnReader; + load_addr_reader_ = new AddrReader; + store_addr_reader_ = new AddrReader; + exc_reader_ = new ExcReader; + pid_reader_ = new PidReader; + method_reader_ = new MethodReader; + internal_exc_reader_ = new ExcReader; + internal_pid_reader_ = new PidReader; + internal_method_reader_ = new MethodReader; + blocks_ = NULL; + bb_recnum_ = 0; + exc_recnum_ = 0; + exc_end_ = false; + exc_bb_num_ = 0; + exc_time_ = 0; + exc_num_insns_ = 0; + current_pid_ = 0; + next_pid_ = 0; + next_pid_switch_time_ = 0; + post_processing_ = false; + dex_hash_ = NULL; + load_eof_ = false; + load_time_ = 0; + load_addr_ = 0; + store_eof_ = false; + store_time_ = 0; + store_addr_ = 0; +} + +TraceReaderBase::~TraceReaderBase() +{ + Close(); + delete bb_reader_; + delete insn_reader_; + delete load_addr_reader_; + delete store_addr_reader_; + delete exc_reader_; + delete pid_reader_; + delete method_reader_; + delete internal_exc_reader_; + delete internal_pid_reader_; + delete internal_method_reader_; + if (blocks_) { + int num_static_bb = header_->num_static_bb; + for (int ii = 0; ii < num_static_bb; ++ii) { + delete[] blocks_[ii].insns; + } + delete[] blocks_; + } + delete header_; + if (dex_hash_ != NULL) { + HashTable<DexFileList*>::entry_type *ptr; + for (ptr = dex_hash_->GetFirst(); ptr; ptr = dex_hash_->GetNext()) { + DexFileList *dexfile = ptr->value; + delete[] dexfile->path; + int nsymbols = dexfile->nsymbols; + DexSym *symbols = dexfile->symbols; + for (int ii = 0; ii < nsymbols; ii++) { + delete[] symbols[ii].name; + } + delete[] dexfile->symbols; + delete dexfile; + } + } + delete dex_hash_; + delete[] static_filename_; +} + +void TraceReaderBase::ReadTraceHeader(FILE *fstream, char *filename, + char *tracename, TraceHeader *header) +{ + int rval = fread(header, sizeof(TraceHeader), 1, fstream); + if (rval != 1) { + perror(filename); + exit(1); + } + + if (!post_processing_ && strcmp(header->ident, TRACE_IDENT) != 0) { + fprintf(stderr, "%s: missing trace header; run 'post_trace %s' first\n", + filename, tracename); + exit(1); + } + + if (header->version != TRACE_VERSION) { + fprintf(stderr, + "%s: trace header version (%d) does not match compiled tools version (%d)\n", + tracename, header->version, TRACE_VERSION); + exit(1); + } + + convert32(header->version); + convert32(header->start_sec); + convert32(header->start_usec); + convert32(header->pdate); + convert32(header->ptime); + convert64(header->num_static_bb); + convert64(header->num_static_insn); + convert64(header->num_dynamic_bb); + convert64(header->num_dynamic_insn); + convert64(header->elapsed_usecs); +} + + +void TraceReaderBase::Open(char *filename) +{ + char *fname; + FILE *fstream; + + // Open the qtrace.bb file + bb_reader_->Open(filename); + + // Open the qtrace.insn file + insn_reader_->Open(filename); + + // Open the qtrace.load file and read the first line + load_eof_ = load_addr_reader_->Open(filename, ".load"); + if (!load_eof_) + load_eof_ = load_addr_reader_->ReadAddr(&load_time_, &load_addr_); + + // Open the qtrace.store file and read the first line + store_eof_ = store_addr_reader_->Open(filename, ".store"); + if (!store_eof_) + store_eof_ = store_addr_reader_->ReadAddr(&store_time_, &store_addr_); + + // Open the qtrace.exc file + exc_reader_->Open(filename); + + // Open another file stream to the qtrace.exc file for internal reads. + // This allows the caller to also read from the qtrace.exc file. + internal_exc_reader_->Open(filename); + + // Open the qtrace.pid file + pid_reader_->Open(filename); + internal_pid_reader_->Open(filename); + + // Open the qtrace.method file + method_reader_->Open(filename); + internal_method_reader_->Open(filename); + + // Open the qtrace.static file + fname = CreateTracePath(filename, ".static"); + static_filename_ = fname; + + fstream = fopen(fname, "r"); + if (fstream == NULL) { + perror(fname); + exit(1); + } + static_fstream_ = fstream; + + // Read the header + ReadTraceHeader(fstream, fname, filename, header_); + + // Allocate space for all of the static blocks + int num_static_bb = header_->num_static_bb; + if (num_static_bb) { + blocks_ = new StaticBlock[num_static_bb]; + + // Read in all the static blocks + for (int ii = 0; ii < num_static_bb; ++ii) { + ReadStatic(&blocks_[ii].rec); + int num_insns = blocks_[ii].rec.num_insns; + if (num_insns > 0) { + blocks_[ii].insns = new uint32_t[num_insns]; + ReadStaticInsns(num_insns, blocks_[ii].insns); + } else { + blocks_[ii].insns = NULL; + } + } + fseek(static_fstream_, sizeof(TraceHeader), SEEK_SET); + } + + ParseDexList(filename); + + // If the dex_hash_ is NULL, then assign it a small hash table + // so that we can simply do a Find() operation without having + // to check for NULL first. + if (dex_hash_ == NULL) { + dex_hash_ = new HashTable<DexFileList*>(1, NULL); + } +} + +// Reads the list of pid events looking for an mmap of a dex file. +PidEvent * TraceReaderBase::FindMmapDexFileEvent() +{ + static PidEvent event; + + while (!pid_reader_->ReadPidEvent(&event)) { + if (event.rec_type == kPidMmap && event.path != event.mmap_path) { + return &event; + } + pid_reader_->Dispose(&event); + } + return NULL; +} + +static void CopyDexSymbolsToArray(DexFileList *dexfile, + DexSymList *head, int num_symbols) +{ + if (dexfile == NULL) + return; + + DexSym *symbols = NULL; + if (num_symbols > 0) { + symbols = new DexSym[num_symbols]; + } + dexfile->nsymbols = num_symbols; + dexfile->symbols = symbols; + + // Copy the linked-list to the array. + DexSymList *next_sym = NULL; + int next_index = 0; + for (DexSymList *sym = head; sym; sym = next_sym) { + next_sym = sym->next; + symbols[next_index].addr = sym->sym.addr; + symbols[next_index].len = sym->sym.len; + symbols[next_index].name = sym->sym.name; + next_index += 1; + delete sym; + } +} + +void TraceReaderBase::ParseDexList(char *filename) +{ + struct stat stat_buf; + static const int kBufSize = 4096; + char buf[kBufSize]; + char current_file[kBufSize]; + + // Find an example dex file in the list of mmaps + PidEvent *event = FindMmapDexFileEvent(); + + // Reset the pid_reader to the beginning of the file. + pid_reader_->Close(); + pid_reader_->Open(filename); + + // If there were no mmapped dex files, then there is no need to parse + // the dexlist. + if (event == NULL) + return; + char *mmap_dexfile = event->path; + + // Check if the dexlist file exists. It should have the name + // "qtrace.dexlist" + char *fname = CreateTracePath(filename, ".dexlist"); + int rval = stat(fname, &stat_buf); + if (rval == -1) { + // The file does not exist + delete[] fname; + return; + } + + // Open the qtrace.dexlist file + FILE *fstream = fopen(fname, "r"); + if (fstream == NULL) { + perror(fname); + exit(1); + } + + // First pass: read all the filenames, looking for a match for the + // example mmap dex filename. Also count the files so that we + // know how big to make the hash table. + char *match = NULL; + int num_files = 0; + while (fgets(buf, kBufSize, fstream)) { + if (buf[0] != '#') + continue; + num_files += 1; + match = strstr(buf + 1, mmap_dexfile); + + // Check that the dexlist file ends with the string mmap_dexfile. + // We add one to the length of the mmap_dexfile because buf[] + // ends with a newline. The strlen(mmap_dexfile) computation + // could be moved above the loop but it should only ever be + // executed once. + if (match != NULL && strlen(match) == strlen(mmap_dexfile) + 1) + break; + } + + // Count the rest of the files + while (fgets(buf, kBufSize, fstream)) { + if (buf[0] == '#') + num_files += 1; + } + + if (match == NULL) { + fprintf(stderr, + "Cannot find the mmapped dex file '%s' in the dexlist\n", + mmap_dexfile); + exit(1); + } + delete[] mmap_dexfile; + + // The prefix length includes the leading '#'. + int prefix_len = match - buf; + + // Allocate a hash table + dex_hash_ = new HashTable<DexFileList*>(4 * num_files, NULL); + + // Reset the file stream to the beginning + rewind(fstream); + + // Second pass: read the filenames, stripping off the common prefix. + // And read all the (address, method) mappings. When we read a new + // filename, create a new DexFileList and add it to the hash table. + // Add new symbol mappings to a linked list until we have the whole + // list and then create an array for them so that we can use binary + // search on the address to find the symbol name quickly. + + // Use a linked list for storing the symbols + DexSymList *head = NULL; + DexSymList *prev = NULL; + int num_symbols = 0; + + DexFileList *dexfile = NULL; + int linenum = 0; + while (fgets(buf, kBufSize, fstream)) { + linenum += 1; + if (buf[0] == '#') { + // Everything after the '#' is a filename. + // Ignore the common prefix. + + // First, save all the symbols from the previous file (if any). + CopyDexSymbolsToArray(dexfile, head, num_symbols); + + dexfile = new DexFileList; + // Subtract one because buf[] contains a trailing newline + int pathlen = strlen(buf) - prefix_len - 1; + char *path = new char[pathlen + 1]; + strncpy(path, buf + prefix_len, pathlen); + path[pathlen] = 0; + dexfile->path = path; + dexfile->nsymbols = 0; + dexfile->symbols = NULL; + dex_hash_->Update(path, dexfile); + num_symbols = 0; + head = NULL; + prev = NULL; + continue; + } + + uint32_t addr; + int len, line; + char clazz[kBufSize], method[kBufSize], sig[kBufSize], file[kBufSize]; + if (sscanf(buf, "0x%x %d %s %s %s %s %d", + &addr, &len, clazz, method, sig, file, &line) != 7) { + fprintf(stderr, "Cannot parse line %d of file %s:\n%s", + linenum, fname, buf); + exit(1); + } + + // Concatenate the class name, method name, and signature + // plus one for the period separating the class and method. + int nchars = strlen(clazz) + strlen(method) + strlen(sig) + 1; + char *name = new char[nchars + 1]; + strcpy(name, clazz); + strcat(name, "."); + strcat(name, method); + strcat(name, sig); + + DexSymList *symbol = new DexSymList; + symbol->sym.addr = addr; + symbol->sym.len = len; + symbol->sym.name = name; + symbol->next = NULL; + + // Keep the list in the same order as the file + if (head == NULL) + head = symbol; + if (prev != NULL) + prev->next = symbol; + prev = symbol; + num_symbols += 1; + } + fclose(fstream); + + // Copy the symbols from the last file. + CopyDexSymbolsToArray(dexfile, head, num_symbols); + delete[] fname; +} + +// Extracts the pathname to a jar file (or .apk file) from the mmap pathname. +// An example mmap pathname looks something like this: +// /data/dalvik-cache/system@app@TestHarness.apk@classes.dex +// We want to convert that to this: +// /system/app/TestHarness.apk +// If the pathname is not of the expected form, then NULL is returned. +// The space for the extracted path is allocated in this routine and should +// be freed by the caller after it is no longer needed. +static char *ExtractDexPathFromMmap(const char *mmap_path) +{ + char *end = rindex(mmap_path, '@'); + if (end == NULL) + return NULL; + char *start = rindex(mmap_path, '/'); + if (start == NULL) + return NULL; + int len = end - start; + char *path = new char[len + 1]; + strncpy(path, start, len); + path[len] = 0; + + // Replace all the occurrences of '@' with '/' + for (int ii = 0; ii < len; ii++) { + if (path[ii] == '@') + path[ii] = '/'; + } + return path; +} + +void TraceReaderBase::Close() +{ + bb_reader_->Close(); + insn_reader_->Close(); + load_addr_reader_->Close(); + store_addr_reader_->Close(); + exc_reader_->Close(); + pid_reader_->Close(); + method_reader_->Close(); + internal_exc_reader_->Close(); + internal_pid_reader_->Close(); + internal_method_reader_->Close(); + fclose(static_fstream_); + static_fstream_ = NULL; +} + +void TraceReaderBase::WriteHeader(TraceHeader *header) +{ + TraceHeader swappedHeader; + + freopen(static_filename_, "r+", static_fstream_); + fseek(static_fstream_, 0, SEEK_SET); + + memcpy(&swappedHeader, header, sizeof(TraceHeader)); + + convert32(swappedHeader.version); + convert32(swappedHeader.start_sec); + convert32(swappedHeader.start_usec); + convert32(swappedHeader.pdate); + convert32(swappedHeader.ptime); + 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, static_fstream_); +} + +// Reads the next StaticRec from the trace file (not including the list +// of instructions). On end-of-file, this function returns true. +int TraceReaderBase::ReadStatic(StaticRec *rec) +{ + int rval = fread(rec, sizeof(StaticRec), 1, static_fstream_); + if (rval != 1) { + if (feof(static_fstream_)) { + return true; + } + perror(static_filename_); + exit(1); + } + convert64(rec->bb_num); + convert32(rec->bb_addr); + convert32(rec->num_insns); + return false; +} + +// Reads "num" instructions into the array "insns" which must be large +// enough to hold the "num" instructions. +// Returns the actual number of instructions read. This will usually +// be "num" but may be less if end-of-file occurred. +int TraceReaderBase::ReadStaticInsns(int num, uint32_t *insns) +{ + if (num == 0) + return 0; + int rval = fread(insns, sizeof(uint32_t), num, static_fstream_); + + // Convert from little-endian, if necessary + for (int ii = 0; ii < num; ++ii) + convert32(insns[ii]); + + if (rval != num) { + if (feof(static_fstream_)) { + return rval; + } + perror(static_filename_); + exit(1); + } + return rval; +} + +void TraceReaderBase::TruncateLastBlock(uint32_t num_insns) +{ + uint32_t insns[kMaxInsnPerBB]; + StaticRec static_rec; + long loc = 0, prev_loc = 0; + + freopen(static_filename_, "r+", static_fstream_); + fseek(static_fstream_, sizeof(TraceHeader), SEEK_SET); + + // Find the last record + while (1) { + prev_loc = loc; + loc = ftell(static_fstream_); + + // We don't need to byte-swap static_rec here because we are just + // reading the records until we get to the last one. + int rval = fread(&static_rec, sizeof(StaticRec), 1, static_fstream_); + if (rval != 1) + break; + ReadStaticInsns(static_rec.num_insns, insns); + } + if (prev_loc != 0) { + fseek(static_fstream_, prev_loc, SEEK_SET); + static_rec.num_insns = num_insns; + + // Now we need to byte-swap, but just the field that we changed. + convert32(static_rec.num_insns); + fwrite(&static_rec, sizeof(StaticRec), 1, static_fstream_); + int fd = fileno(static_fstream_); + long len = ftell(static_fstream_); + len += num_insns * sizeof(uint32_t); + ftruncate(fd, len); + } +} + +int TraceReaderBase::FindNumInsns(uint64_t bb_num, uint64_t bb_start_time) +{ + int num_insns; + + // Read the exception trace file. "bb_recnum_" is the number of + // basic block records that have been read so far, and "exc_recnum_" + // is the record number from the exception trace. + while (!exc_end_ && exc_recnum_ < bb_recnum_) { + uint32_t current_pc, target_pc; + uint64_t time; + + exc_end_ = internal_exc_reader_->ReadExc(&time, ¤t_pc, &exc_recnum_, + &target_pc, &exc_bb_num_, + &exc_time_, &exc_num_insns_); + } + + // If an exception occurred in this basic block, then use the + // number of instructions specified in the exception record. + if (!exc_end_ && exc_recnum_ == bb_recnum_) { + num_insns = exc_num_insns_; + } else { + // Otherwise, use the number of instructions specified in the + // static basic block. + num_insns = blocks_[bb_num].rec.num_insns; + } + return num_insns; +} + +// Finds the current pid for the given time. This routine reads the pid +// trace file and assumes that the "time" parameter is monotonically +// increasing. +int TraceReaderBase::FindCurrentPid(uint64_t time) +{ + PidEvent event; + + if (time < next_pid_switch_time_) + return current_pid_; + + current_pid_ = next_pid_; + while (1) { + if (internal_pid_reader_->ReadPidEvent(&event)) { + next_pid_switch_time_ = ~0ull; + break; + } + if (event.rec_type != kPidSwitch) + continue; + if (event.time > time) { + next_pid_ = event.pid; + next_pid_switch_time_ = event.time; + break; + } + current_pid_ = event.pid; + } + return current_pid_; +} |