blob: 2625c7c30cd2b1e0e7f190bce92bf520b30f3df5 [file] [log] [blame] [edit]
/**
* @file parse_dump.c
* parse a jit dump file
*
* @remark Copyright 2007 OProfile authors
* @remark Read the file COPYING
*
* @author Jens Wilke
* @Modifications Maynard Johnson
* @Modifications Philippe Elie
* @Modifications Daniel Hansel
*
* Copyright IBM Corporation 2007
*
*/
#include "opjitconv.h"
#include "jitdump.h"
#include "opd_printf.h"
#include "op_libiberty.h"
#include <string.h>
#include <stdio.h>
/* parse a code load record and add the entry to the jitentry list */
static int parse_code_load(void const * ptr_arg, int size,
unsigned long long end_time)
{
struct jitentry * entry;
int rc = OP_JIT_CONV_OK;
char const * ptr = ptr_arg;
struct jr_code_load const * rec = ptr_arg;
char const * end;
size_t padding_count, rec_totalsize;
end = rec->code_addr ? ptr + size : NULL;
entry = xcalloc(1, sizeof(struct jitentry));
// jitentry constructor
entry->next = NULL;
ptr += sizeof(*rec);
/* symbol_name can be malloced so we cast away the constness. */
entry->symbol_name = (char *)ptr;
entry->sym_name_malloced = 0;
ptr += strlen(ptr) + 1;
entry->code = rec->code_addr ? ptr : NULL;
entry->vma = rec->vma;
entry->code_size = rec->code_size;
entry->section = NULL;
entry->life_start = rec->timestamp;
// if nothing else is known the symbol lives till the end of the
// sampling run, this value may be overwritten by an unload record1
// later
entry->life_end = end_time;
// build list
entry->next = jitentry_list;
jitentry_list = entry;
/* padding bytes are calculated over the complete record
* (i.e. header + symbol name + code)
*/
rec_totalsize = sizeof(*rec) + strlen(entry->symbol_name) + 1 + entry->code_size;
padding_count = PADDING_8ALIGNED(rec_totalsize);
verbprintf(debug, "record0: name=%s, vma=%llx, code_size=%i, "
"padding_count=%llu, life_start=%lli, life_end=%lli\n", entry->symbol_name,
entry->vma, entry->code_size, (unsigned long long)padding_count, entry->life_start,
entry->life_end);
/* If end == NULL, the dump does not include code, and this sanity
* check is skipped.
*/
if (end && (ptr + entry->code_size + padding_count != end)) {
verbprintf(debug, "record total size mismatch\n");
rc = OP_JIT_CONV_FAIL;
}
return rc;
}
/*
* parse a code unload record. Search for existing record with this code
* address and fill life_end field with the timestamp. linear search not very
* efficient. FIXME: inefficient
*/
static void parse_code_unload(void const * ptr, unsigned long long end_time)
{
struct jr_code_unload const * rec = ptr;
struct jitentry * entry;
verbprintf(debug,"record1: vma=%llx, life_end=%lli\n",
rec->vma, rec->timestamp);
/**
* Normally we won't get a jr_code_unload with a zero time stamp or
* a zero code address. The code address is directly provided by the JVMTI.
* The documentation of JVMTI does not say anything about the address value if
* it could be zero or not. Therefore it is only a sanity check at the moment.
*/
if (rec->timestamp > 0 && rec->vma != 0) {
for (entry = jitentry_list; entry; entry = entry->next) {
if (entry->vma == rec->vma &&
entry->life_end == end_time) {
entry->life_end = rec->timestamp;
verbprintf(debug,"matching record found\n");
break;
}
}
}
}
/*
* There is no real parsing here, we just record a pointer to the data,
* we will interpret on the fly the record when building the bfd file.
*/
static void parse_code_debug_info(void const * ptr, void const * end,
unsigned long long end_time)
{
struct jr_code_debug_info const * rec = ptr;
struct jitentry_debug_line * debug_line =
xmalloc(sizeof(struct jitentry_debug_line));
debug_line->data = rec;
debug_line->end = end;
debug_line->life_start = rec->timestamp;
debug_line->life_end = end_time;
debug_line->next = jitentry_debug_line_list;
jitentry_debug_line_list = debug_line;
}
/* parse all entries in the jit dump file and build jitentry_list.
* the code needs to check always whether there is enough
* to read remaining. this is because the file may be written to
* concurrently. */
static int parse_entries(void const * ptr, void const * end,
unsigned long long end_time)
{
int rc = OP_JIT_CONV_OK;
struct jr_prefix const * rec = ptr;
while ((void *)rec + sizeof(struct jr_prefix) < end) {
if (((void *) rec + rec->total_size) > end) {
verbprintf(debug, "record past end of file\n");
rc = OP_JIT_CONV_FAIL;
break;
}
switch (rec->id) {
case JIT_CODE_LOAD:
if (parse_code_load(rec, rec->total_size, end_time)) {
rc = OP_JIT_CONV_FAIL;
break;
}
break;
case JIT_CODE_UNLOAD:
parse_code_unload(rec, end_time);
break;
// end of VM live time, no action
case JIT_CODE_CLOSE:
break;
case JIT_CODE_DEBUG_INFO:
if (rec->total_size == 0) {
/* op_write_debug_line_info() ensures to write records with
* totalsize > 0.
*/
rc = OP_JIT_CONV_FAIL;
break;
}
parse_code_debug_info(rec, end, end_time);
break;
default:
verbprintf(debug, "unknown record type\n");
rc = OP_JIT_CONV_FAIL;
break;
}
/* advance to next record (incl. possible padding bytes) */
rec = (void *)rec + rec->total_size;
}
return rc;
}
/* parse the jit dump header information
* The ptr arg is the address of the pointer to the mmapped
* file, which we modify below.
*/
static int parse_header(char const ** ptr, char const * end)
{
int rc = OP_JIT_CONV_OK;
struct jitheader const * header;
if (*ptr + sizeof(struct jitheader) >= end) {
verbprintf(debug,
"opjitconv: EOF in jitdump file, no header\n");
rc = OP_JIT_CONV_FAIL;
goto out;
}
header = (struct jitheader *)*ptr;
if (header->magic != JITHEADER_MAGIC) {
verbprintf(debug, "opjitconv: Wrong jitdump file magic\n");
rc = OP_JIT_CONV_FAIL;
goto out;
}
if (header->version != JITHEADER_VERSION) {
verbprintf(debug, "opjitconv: Wrong jitdump file version\n");
rc = OP_JIT_CONV_FAIL;
goto out;
}
if (*ptr + header->totalsize > end) {
verbprintf(debug, "opjitconv: EOF in jitdump file, not enough "
"data for header\n");
rc = OP_JIT_CONV_FAIL;
goto out;
}
dump_bfd_arch = header->bfd_arch;
dump_bfd_mach = header->bfd_mach;
dump_bfd_target_name = header->bfd_target;
verbprintf(debug, "header: bfd-arch=%i, bfd-mach=%i,"
" bfd_target_name=%s\n", dump_bfd_arch, dump_bfd_mach,
dump_bfd_target_name);
*ptr = *ptr + header->totalsize;
out:
return rc;
}
/* Read in the memory mapped jitdump file.
* Build up jitentry structure and set global variables.
*/
int parse_all(void const * start, void const * end,
unsigned long long end_time)
{
char const * ptr = start;
if (!parse_header(&ptr, end))
return parse_entries(ptr, end, end_time);
else
return OP_JIT_CONV_FAIL;
}