varun-r-mallya/sysprof
1
0
Fork 0
mirror of https://github.com/varun-r-mallya/sysprof.git synced 2025-12-31 20:36:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

Updates

Browse Source 
2007-02-24  Soren Sandmann <sandmann@daimi.au.dk>

        * TODO: Updates

        * binparser.[ch]: Get rid of BIN_UINTn types; replace with single
        BIN_UINT, where the user must provide the width

        * elfparser.c: Update to new binparser API



svn path=/trunk/; revision=354
This commit is contained in:
Soren Sandmann
2007-02-24 08:49:51 +00:00
committed by Søren Sandmann Pedersen
parent bc004a104e
commit cf70d3a7ed
5 changed files with 86 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
ChangeLog
View File

@ -1,3 +1,12 @@
2007-02-24 Soren Sandmann <sandmann@daimi.au.dk>
* TODO: Updates
* binparser.[ch]: Get rid of BIN_UINTn types; replace with single
BIN_UINT, where the user must provide the width
* elfparser.c: Update to new binparser API
2007-02-24 Soren Sandman <sandmann@daimi.au.dk> 2007-02-24 Soren Sandman <sandmann@daimi.au.dk>
* binparser.[ch]: Switch to a simpler conceptual model. * binparser.[ch]: Switch to a simpler conceptual model.

7
TODO
View File

@ -110,9 +110,6 @@ Before 1.2:
- the bin_parser_seek_record (..., 1); idiom is a little dubious - the bin_parser_seek_record (..., 1); idiom is a little dubious
- maybe convert BIN_UINT32 => { BIN_UINT, 4 }
we already have the width in the struct.
- Add error checking - Add error checking
Also need to add error checking. Also need to add error checking.
@ -675,6 +672,10 @@ Later:
-=-=-=-=-=-=-=-=-=-=-=-=-=-=- ALREADY DONE -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- -=-=-=-=-=-=-=-=-=-=-=-=-=-=- ALREADY DONE -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* Missing things in binparser.[ch]
- maybe convert BIN_UINT32 => { BIN_UINT, 4 }
we already have the width in the struct.
* Rethink binparser. Maybe the default mode should be: * Rethink binparser. Maybe the default mode should be:
- there is a current offset - there is a current offset

67
binparser.c
View File

@ -107,34 +107,13 @@ align (guint64 offset, int alignment)
return offset; return offset;
} }
static int
get_field_width (const BinField *field)
{
switch (field->type)
{
case BIN_UINT8:
return 1;
case BIN_UINT16:
return 2;
case BIN_UINT32:
return 4;
case BIN_UINT64:
return 8;
case BIN_UNINTERPRETED:
return field->n_bytes;
}
g_assert_not_reached ();
return -1;
}
static int static int
get_align (const BinField *field) get_align (const BinField *field)
{ {
if (field->type == BIN_UNINTERPRETED) if (field->type == BIN_UNINTERPRETED)
return 1; return 1;
else else
return get_field_width (field); return field->n_bytes;
} }
BinRecord * BinRecord *
@ -169,12 +148,8 @@ bin_parser_create_record (BinParser *parser,
strncpy (field->name, bin_field->name, BIN_MAX_NAME - 1); strncpy (field->name, bin_field->name, BIN_MAX_NAME - 1);
field->offset = offset; field->offset = offset;
field->type = bin_field->type; field->type = bin_field->type;
field->width = get_field_width (bin_field); field->width = bin_field->n_bytes;
#if 0
g_print ("created field %s with type %d\n", field->name, field->type);
#endif
offset += record->fields[i].width; offset += record->fields[i].width;
} }
@ -268,7 +243,7 @@ bin_parser_restore (BinParser *parser)
static guint64 static guint64
convert_uint (const guchar *data, convert_uint (const guchar *data,
BinEndian endian, BinEndian endian,
BinType type) int width)
{ {
guint8 r8; guint8 r8;
guint16 r16; guint16 r16;
@ -282,13 +257,13 @@ convert_uint (const guchar *data,
/* FIXME: check that we are within the file */ /* FIXME: check that we are within the file */
switch (type) switch (width)
{ {
case BIN_UINT8: case 1:
r8 = *(guint8 *)data; r8 = *(guint8 *)data;
return r8; return r8;
case BIN_UINT16: case 2:
r16 = *(guint16 *)data; r16 = *(guint16 *)data;
if (endian == BIN_BIG_ENDIAN) if (endian == BIN_BIG_ENDIAN)
@ -298,7 +273,7 @@ convert_uint (const guchar *data,
return r16; return r16;
case BIN_UINT32: case 4:
r32 = *(guint32 *)data; r32 = *(guint32 *)data;
if (endian == BIN_BIG_ENDIAN) if (endian == BIN_BIG_ENDIAN)
@ -308,7 +283,7 @@ convert_uint (const guchar *data,
return r32; return r32;
case BIN_UINT64: case 8:
r64 = *(guint64 *)data; r64 = *(guint64 *)data;
if (endian == BIN_BIG_ENDIAN) if (endian == BIN_BIG_ENDIAN)
@ -324,31 +299,13 @@ convert_uint (const guchar *data,
} }
} }
static int
get_uint_width (BinType type)
{
switch (type)
{
case BIN_UINT8:
return 1;
case BIN_UINT16:
return 2;
case BIN_UINT32:
return 4;
case BIN_UINT64:
return 8;
default:
return -1;
}
}
guint64 guint64
bin_parser_get_uint (BinParser *parser, bin_parser_get_uint (BinParser *parser,
BinType type) int width)
{ {
guint64 r = convert_uint (parser->data + parser->offset, parser->endian, type); guint64 r = convert_uint (parser->data + parser->offset, parser->endian, width);
parser->offset += get_uint_width (type); parser->offset += width;
return r; return r;
} }
@ -422,5 +379,5 @@ bin_parser_get_uint_field (BinParser *parser,
g_print (" uint %d at %p => %d\n", field->width, pos, convert_uint (pos, record->format->big_endian, field->width)); g_print (" uint %d at %p => %d\n", field->width, pos, convert_uint (pos, record->format->big_endian, field->width));
#endif #endif
return convert_uint (pos, parser->endian, field->type); return convert_uint (pos, parser->endian, field->width);
} }

7
binparser.h
View File

@ -65,10 +65,7 @@ typedef enum
typedef enum typedef enum
{ {
/* More types can (and probably will) be added in the future */ /* More types can (and probably will) be added in the future */
BIN_UINT8, BIN_UINT,
BIN_UINT16,
BIN_UINT32,
BIN_UINT64,
BIN_UNINTERPRETED BIN_UNINTERPRETED
} BinType; } BinType;
@ -107,7 +104,7 @@ void bin_parser_restore (BinParser *parser);
/* retrieve data */ /* retrieve data */
guint64 bin_parser_get_uint (BinParser *parser, guint64 bin_parser_get_uint (BinParser *parser,
BinType type); int width);
const char * bin_parser_get_string (BinParser *parser); const char * bin_parser_get_string (BinParser *parser);
guint64 bin_parser_get_uint_field (BinParser *parser, guint64 bin_parser_get_uint_field (BinParser *parser,
BinRecord *record, BinRecord *record,

118
elfparser.c
View File

@ -584,7 +584,7 @@ elf_parser_get_debug_link (ElfParser *parser, guint32 *crc32)
bin_parser_align (parser->parser, 4); bin_parser_align (parser->parser, 4);
if (crc32) if (crc32)
*crc32 = bin_parser_get_uint (parser->parser, BIN_UINT32); *crc32 = bin_parser_get_uint (parser->parser, 4);
return result; return result;
} }
@ -669,85 +669,85 @@ get_formats (gboolean is_64,
{ {
static const BinField elf64_header[] = { static const BinField elf64_header[] = {
{ "e_ident", BIN_UNINTERPRETED, EI_NIDENT }, { "e_ident", BIN_UNINTERPRETED, EI_NIDENT },
{ "e_type", BIN_UINT16 }, { "e_type", BIN_UINT, 2 },
{ "e_machine", BIN_UINT16 }, { "e_machine", BIN_UINT, 2 },
{ "e_version", BIN_UINT32 }, { "e_version", BIN_UINT, 4 },
{ "e_entry", BIN_UINT64 }, { "e_entry", BIN_UINT, 8 },
{ "e_phoff", BIN_UINT64 }, { "e_phoff", BIN_UINT, 8 },
{ "e_shoff", BIN_UINT64 }, { "e_shoff", BIN_UINT, 8 },
{ "e_flags", BIN_UINT32 }, { "e_flags", BIN_UINT, 4 },
{ "e_ehsize", BIN_UINT16 }, { "e_ehsize", BIN_UINT, 2 },
{ "e_phentsize", BIN_UINT16 }, { "e_phentsize", BIN_UINT, 2 },
{ "e_phnum", BIN_UINT16 }, { "e_phnum", BIN_UINT, 2 },
{ "e_shentsize", BIN_UINT16 }, { "e_shentsize", BIN_UINT, 2 },
{ "e_shnum", BIN_UINT16 }, { "e_shnum", BIN_UINT, 2 },
{ "e_shstrndx", BIN_UINT16 }, { "e_shstrndx", BIN_UINT, 2 },
{ "" }, { "" },
}; };
static const BinField elf32_header[] = { static const BinField elf32_header[] = {
{ "e_ident", BIN_UNINTERPRETED, EI_NIDENT }, { "e_ident", BIN_UNINTERPRETED, EI_NIDENT },
{ "e_type", BIN_UINT16 }, { "e_type", BIN_UINT, 2 },
{ "e_machine", BIN_UINT16 }, { "e_machine", BIN_UINT, 2 },
{ "e_version", BIN_UINT32 }, { "e_version", BIN_UINT, 4 },
{ "e_entry", BIN_UINT32 }, { "e_entry", BIN_UINT, 4 },
{ "e_phoff", BIN_UINT32 }, { "e_phoff", BIN_UINT, 4 },
{ "e_shoff", BIN_UINT32 }, { "e_shoff", BIN_UINT, 4 },
{ "e_flags", BIN_UINT32 }, { "e_flags", BIN_UINT, 4 },
{ "e_ehsize", BIN_UINT16 }, { "e_ehsize", BIN_UINT, 2 },
{ "e_phentsize", BIN_UINT16 }, { "e_phentsize", BIN_UINT, 2 },
{ "e_phnum", BIN_UINT16 }, { "e_phnum", BIN_UINT, 2 },
{ "e_shentsize", BIN_UINT16 }, { "e_shentsize", BIN_UINT, 2 },
{ "e_shnum", BIN_UINT16 }, { "e_shnum", BIN_UINT, 2 },
{ "e_shstrndx", BIN_UINT16 }, { "e_shstrndx", BIN_UINT, 2 },
{ "" }, { "" },
}; };
static const BinField shn64_entry[] = { static const BinField shn64_entry[] = {
{ "sh_name", BIN_UINT32 }, { "sh_name", BIN_UINT, 4 },
{ "sh_type", BIN_UINT32 }, { "sh_type", BIN_UINT, 4 },
{ "sh_flags", BIN_UINT64 }, { "sh_flags", BIN_UINT, 8 },
{ "sh_addr", BIN_UINT64 }, { "sh_addr", BIN_UINT, 8 },
{ "sh_offset", BIN_UINT64 }, { "sh_offset", BIN_UINT, 8 },
{ "sh_size", BIN_UINT64 }, { "sh_size", BIN_UINT, 8 },
{ "sh_link", BIN_UINT32 }, { "sh_link", BIN_UINT, 4 },
{ "sh_info", BIN_UINT32 }, { "sh_info", BIN_UINT, 4 },
{ "sh_addralign", BIN_UINT64 }, { "sh_addralign", BIN_UINT, 8 },
{ "sh_entsize", BIN_UINT64 }, { "sh_entsize", BIN_UINT, 8 },
{ "" } { "" }
}; };
static const BinField shn32_entry[] = { static const BinField shn32_entry[] = {
{ "sh_name", BIN_UINT32 }, { "sh_name", BIN_UINT, 4 },
{ "sh_type", BIN_UINT32 }, { "sh_type", BIN_UINT, 4 },
{ "sh_flags", BIN_UINT32 }, { "sh_flags", BIN_UINT, 4 },
{ "sh_addr", BIN_UINT32 }, { "sh_addr", BIN_UINT, 4 },
{ "sh_offset", BIN_UINT32 }, { "sh_offset", BIN_UINT, 4 },
{ "sh_size", BIN_UINT32 }, { "sh_size", BIN_UINT, 4 },
{ "sh_link", BIN_UINT32 }, { "sh_link", BIN_UINT, 4 },
{ "sh_info", BIN_UINT32 }, { "sh_info", BIN_UINT, 4 },
{ "sh_addralign", BIN_UINT32 }, { "sh_addralign", BIN_UINT, 4 },
{ "sh_entsize", BIN_UINT32 }, { "sh_entsize", BIN_UINT, 4 },
{ "" } { "" }
}; };
static const BinField sym64_format[] = { static const BinField sym64_format[] = {
{ "st_name", BIN_UINT32 }, { "st_name", BIN_UINT, 4 },
{ "st_info", BIN_UINT8 }, { "st_info", BIN_UINT, 1 },
{ "st_other", BIN_UINT8 }, { "st_other", BIN_UINT, 1 },
{ "st_shndx", BIN_UINT16 }, { "st_shndx", BIN_UINT, 2 },
{ "st_value", BIN_UINT64 }, { "st_value", BIN_UINT, 8 },
{ "st_size", BIN_UINT64 }, { "st_size", BIN_UINT, 8 },
{ "" } { "" }
}; };
static const BinField sym32_format[] = { static const BinField sym32_format[] = {
{ "st_name", BIN_UINT32 }, { "st_name", BIN_UINT, 4 },
{ "st_value", BIN_UINT32 }, { "st_value", BIN_UINT, 4 },
{ "st_size", BIN_UINT32 }, { "st_size", BIN_UINT, 4 },
{ "st_info", BIN_UINT8 }, { "st_info", BIN_UINT, 1 },
{ "st_other", BIN_UINT8 }, { "st_other", BIN_UINT, 1 },
{ "st_shndx", BIN_UINT16 }, { "st_shndx", BIN_UINT, 2 },
{ "" }, { "" },
}; };