Remove final bits of binparser
authorSøren Sandmann Pedersen <ssp@redhat.com>
Thu, 8 Oct 2009 23:25:54 +0000 (19:25 -0400)
committerSøren Sandmann Pedersen <ssp@redhat.com>
Thu, 8 Oct 2009 23:26:44 +0000 (19:26 -0400)
Makefile.am
binparser.c [deleted file]
binparser.h [deleted file]
elfparser.c
unwind.c

index 1624fc4..11327b7 100644 (file)
@@ -10,8 +10,6 @@ endif
 SYSPROF_CORE =                                 \
        binfile.h                               \
        binfile.c                               \
-       binparser.h                             \
-       binparser.c                             \
        collector.c                             \
        collector.h                             \
        demangle.c                              \
@@ -108,8 +106,6 @@ testunwind_SOURCES =        \
        demangle.c      \
        elfparser.c     \
        elfparser.h     \
-       binparser.c     \
-       binparser.h     \
        unwind.c        \
        unwind.h
 testunwind_CPPFLAGS = $(CORE_DEP_CFLAGS)
@@ -120,8 +116,7 @@ testelf_SOURCES =   \
        testelf.c       \
        demangle.c      \
        elfparser.c     \
-       elfparser.h     \
-       binparser.c     \
-       binparser.h
+       elfparser.h
+
 testelf_CPPFLAGS = $(CORE_DEP_CFLAGS)
 testelf_LDADD = $(CORE_DEP_LIBS)
diff --git a/binparser.c b/binparser.c
deleted file mode 100644 (file)
index 152315f..0000000
+++ /dev/null
@@ -1,384 +0,0 @@
-/* Sysprof -- Sampling, systemwide CPU profiler
- * Copyright 2006, 2007, Soeren Sandmann
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 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.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- */
-#include <string.h>
-
-#include "binparser.h"
-
-typedef struct Field Field;
-
-struct BinParser
-{
-    const guchar *     data;
-    gsize              length;
-
-    gsize              offset;
-    const char *       error_msg;
-    GList *            records;
-    BinEndian          endian;
-
-    gsize              saved_offset;
-};
-
-struct Field
-{
-    char       name[BIN_MAX_NAME];
-    guint      offset;                 /* from beginning of struct */
-    guint      width;
-    BinType    type;
-};
-
-struct BinRecord
-{
-    int                        n_fields;
-    Field              fields[1];
-};
-
-BinParser *
-bin_parser_new (const guchar *data,
-               gsize         length)
-{
-    BinParser *parser = g_new0 (BinParser, 1);
-    
-    parser->data = data;
-    parser->length = length;
-    parser->offset = 0;
-    parser->error_msg = NULL;
-    parser->records = NULL;
-    parser->endian = BIN_NATIVE_ENDIAN;
-    
-    return parser;
-}
-
-void
-bin_parser_free (BinParser *parser)
-{
-    GList *list;
-
-    for (list = parser->records; list != NULL; list = list->next)
-    {
-       BinRecord *record = list->data;
-       
-       g_free (record);
-    }
-
-    g_list_free (parser->records);
-    
-    g_free (parser);
-}
-
-const guchar *
-bin_parser_get_data (BinParser *parser)
-{
-    return parser->data;
-}
-
-gsize
-bin_parser_get_length (BinParser *parser)
-{
-    return parser->length;
-}
-
-static guint64
-align (guint64 offset, int alignment)
-{
-    /* Note that we can speed this up by assuming alignment'
-     * is a power of two, since
-     *
-     *     offset % alignment == offset & (alignemnt - 1)
-     *
-     */
-    
-    if (offset % alignment != 0)
-       offset += (alignment - (offset % alignment));
-    
-    return offset;
-}
-
-static int
-get_align (const BinField *field)
-{
-    if (field->type == BIN_UNINTERPRETED)
-       return 1;
-    else
-       return field->n_bytes;
-}
-
-BinRecord *
-bin_parser_create_record (BinParser      *parser,
-                         const BinField *fields)
-{
-    BinRecord *record;
-    int i, n_fields;
-    guint offset;
-       
-    n_fields = 0;
-    while (fields[n_fields].name[0] != '\0')
-    {
-       n_fields++;
-#if 0
-       g_print ("type: %d\n", fields[n_fields].type);
-#endif
-    }
-
-    record = g_malloc0 (sizeof (BinRecord) +
-                       (n_fields - 1) * sizeof (Field));
-
-    offset = 0;
-    record->n_fields = n_fields;
-    for (i = 0; i < n_fields; ++i)
-    {
-       const BinField *bin_field = &(fields[i]);
-       Field *field = &(record->fields[i]);
-       
-       offset = align (offset, get_align (bin_field));
-       
-       strncpy (field->name, bin_field->name, BIN_MAX_NAME - 1);
-       field->offset = offset;
-       field->type = bin_field->type;
-       field->width = bin_field->n_bytes;
-
-       offset += record->fields[i].width;
-    }
-
-    parser->records = g_list_prepend (parser->records, record);
-    
-    return record;
-}
-
-gboolean
-bin_parser_error (BinParser *parser)
-{
-    return parser->error_msg != NULL;
-}
-
-void
-bin_parser_clear_error (BinParser *parser)
-{
-    parser->error_msg = NULL;
-}
-
-const gchar *
-bin_parser_get_error_msg (BinParser *parser)
-{
-    return parser->error_msg;
-}
-
-void
-bin_parser_set_endian (BinParser *parser,
-                      BinEndian  endian)
-{
-    parser->endian = endian;
-}
-
-/* Move current offset */
-gsize
-bin_parser_get_offset  (BinParser  *parser)
-{
-    return parser->offset;
-}
-
-void
-bin_parser_set_offset  (BinParser  *parser,
-                       gsize       offset)
-{
-    parser->offset = offset;
-}
-
-void
-bin_parser_align       (BinParser  *parser,
-                       gsize       byte_width)
-{
-    parser->offset = align (parser->offset, byte_width);
-}
-
-gsize
-bin_record_get_size (BinRecord *record)
-{
-    Field *last_field = &(record->fields[record->n_fields - 1]);
-    Field *first_field = &(record->fields[0]);
-
-    /* align to first field, since that's the alignment of the record
-     * following this one
-     */
-    
-    return align (last_field->offset + last_field->width, first_field->width);
-}
-
-void
-bin_parser_seek_record (BinParser  *parser,
-                       BinRecord  *record,
-                       int       n_records)
-{
-    gsize record_size = bin_record_get_size (record);
-
-    parser->offset += record_size * n_records;
-}
-
-void
-bin_parser_save (BinParser *parser)
-{
-    parser->saved_offset = parser->offset;
-}
-
-void
-bin_parser_restore (BinParser *parser)
-{
-    parser->offset = parser->saved_offset;
-}
-
-/* retrieve data */
-static guint64
-convert_uint (const guchar *data,
-             BinEndian     endian,
-             int           width)
-{
-    guint8 r8;
-    guint16 r16;
-    guint32 r32;
-    guint64 r64;
-
-#if 0
-    if (width == 4)
-       g_print ("converting at %p  %d %d %d %d\n", data, data[0], data[1], data[2], data[3]);
-#endif
-
-    /* FIXME: check that we are within the file */
-    
-    switch (width)
-    {
-    case 1:
-       r8 = *(guint8 *)data;
-       return r8;
-       
-    case 2:
-       r16 = *(guint16 *)data;
-       
-       if (endian == BIN_BIG_ENDIAN)
-           r16 = GUINT16_FROM_BE (r16);
-       else if (endian == BIN_LITTLE_ENDIAN)
-           r16 = GUINT16_FROM_LE (r16);
-       
-       return r16;
-       
-    case 4:
-       r32 = *(guint32 *)data;
-       
-       if (endian == BIN_BIG_ENDIAN)
-           r32 = GUINT32_FROM_BE (r32);
-       else if (endian == BIN_LITTLE_ENDIAN)
-           r32 = GUINT32_FROM_LE (r32);
-       
-       return r32;
-       
-    case 8:
-       r64 = *(guint64 *)data;
-       
-       if (endian == BIN_BIG_ENDIAN)
-           r64 = GUINT64_FROM_BE (r64);
-       else if (endian == BIN_LITTLE_ENDIAN)
-           r64 = GUINT64_FROM_LE (r64);
-       
-       return r64;
-
-    default:
-       g_assert_not_reached();
-       return 0;
-    }
-}
-
-guint64
-bin_parser_get_uint (BinParser *parser,
-                    int        width)
-{
-    guint64 r = convert_uint (parser->data + parser->offset, parser->endian, width);
-
-    parser->offset += width;
-
-    return r;
-}
-
-const char *
-bin_parser_get_string (BinParser *parser)
-{
-    const char *result;
-    
-    /* FIXME: check that the string is within the file */
-    
-    result = (const char *)parser->data + parser->offset;
-
-    parser->offset += strlen (result) + 1;
-
-    return result;
-}
-
-static const Field *
-get_field (BinRecord *format,
-          const gchar *name)
-{
-    int i;
-    
-    for (i = 0; i < format->n_fields; ++i)
-    {
-       Field *field = &(format->fields[i]);
-
-       if (strcmp (field->name, name) == 0)
-       {
-#if 0
-           g_print ("found field: %s  (offset: %d, type %d)\n", field->name, field->offset, field->type);
-#endif
-           
-       
-           return field;
-       }
-    }
-    
-    return NULL;
-}
-
-guint64
-bin_parser_get_uint_field (BinParser *parser,
-                          BinRecord *record,
-                          const char *name)
-{
-    const Field *field = get_field (record, name);
-    const guchar *pos;
-
-#if 0
-    g_print ("moving to %d (%d + %d)\n", parser->offset + field->offset, parser->offset, field->offset);
-#endif
-    
-    pos = parser->data + parser->offset + field->offset;
-
-#if 0
-    g_print ("   record offset: %d\n", record->offset);
-    g_print ("   record index: %d\n", record->index);
-    g_print ("   field offset %d\n", field->offset);
-#endif
-    
-    if (pos > parser->data + parser->length)
-    {
-       /* FIXME: generate error */
-       return 0;
-    }
-
-#if 0
-    g_print ("    uint %d at %p    =>   %d\n", field->width, pos, convert_uint (pos, record->format->big_endian, field->width));
-#endif
-    
-    return convert_uint (pos, parser->endian, field->width);
-}
diff --git a/binparser.h b/binparser.h
deleted file mode 100644 (file)
index de34be5..0000000
+++ /dev/null
@@ -1,110 +0,0 @@
-/* Sysprof -- Sampling, systemwide CPU profiler
- * Copyright 2006, 2007, Soeren Sandmann
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 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.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- */
-#include <glib.h>
-
-typedef struct BinParser BinParser;
-typedef struct BinRecord BinRecord;
-typedef struct BinField  BinField;
-
-/* The model is:
- *
- *    BinParser has an offset associated with it. This offset can be
- *    manipulated with methods
- *
- *             goto            - go to absolute position from file start
- *             goto_rel        - go to relative position
- *             goto_record_rel - skip the given number of records 
- *             align           - move forward until aligned to given width
- *             save/restore    - save/restore the current offset (stack)
- *
- *   and queried with
- *
- *             get_offset      - return current offset in bytes from start
- *
- *   data can be retrieved with
- *
- *             get_uint         - return a uint of given width, and skip
- *             get_string       - return a null terminated stringm, and skip
- *             get_pstring      - return a 'pascal' string with given length
- *
- *             get_uint_field   - return the named field
- *
- *   formats should probably be definable as static data.
- *
- *   A bin parser also has an associated "status" with it. This can be
- *   OK, or error. It is ok to use a parser with an error status, but
- *   the data returned will not be meaningfull.
- *
- *   
- */
-
-#define BIN_MAX_NAME           52
-
-typedef enum
-{
-    BIN_LITTLE_ENDIAN,
-    BIN_BIG_ENDIAN,
-    BIN_NATIVE_ENDIAN
-} BinEndian;
-
-typedef enum
-{
-    /* More types can (and probably will) be added in the future */
-    BIN_UINT,
-    BIN_UNINTERPRETED
-} BinType;
-
-struct BinField {
-    const char         name[BIN_MAX_NAME];
-    char               type;
-    char               n_bytes;        /* number of bytes in the type */
-};
-
-BinParser *   bin_parser_new        (const guchar *data,
-                                    gsize         length);
-void          bin_parser_free       (BinParser    *parser);
-const guchar *bin_parser_get_data   (BinParser    *parser);
-gsize         bin_parser_get_length (BinParser    *parser);
-void         bin_parser_set_endian    (BinParser *parser,
-                                       BinEndian  endian);
-gboolean      bin_parser_error        (BinParser *parser); 
-void         bin_parser_clear_error   (BinParser *parser);
-const gchar * bin_parser_get_error_msg (BinParser *parser);
-BinRecord *   bin_parser_create_record (BinParser      *parser,
-                                       const BinField *fields);
-gsize        bin_record_get_size      (BinRecord *record);
-guint64              bin_parser_get_uint_field (BinParser *parser,
-                                        BinRecord *record,
-                                        const char *field);
-
-/* Move current offset */
-gsize        bin_parser_get_offset  (BinParser  *parser);
-void          bin_parser_set_offset  (BinParser  *parser,
-                                     gsize       offset);
-void          bin_parser_align       (BinParser  *parser,
-                                     gsize       byte_width);
-void         bin_parser_seek_record (BinParser  *parser,
-                                     BinRecord  *record,
-                                     int         n_records);
-void         bin_parser_save       (BinParser    *parser);
-void         bin_parser_restore    (BinParser    *parser);
-
-/* retrieve data */
-guint64              bin_parser_get_uint   (BinParser    *parser,
-                                    int           width);
-const char *  bin_parser_get_string (BinParser    *parser);
index 9513c63..09f08f5 100644 (file)
@@ -19,7 +19,6 @@
 #include <string.h>
 #include <elf.h>
 #include <sys/mman.h>
-#include "binparser.h"
 #include "elfparser.h"
 
 typedef struct Section Section;
@@ -43,16 +42,8 @@ struct Section
 
 struct ElfParser
 {
-    BinParser *                parser;
-    
-    BinRecord *                header;
-    BinRecord *                strtab_format;
-    BinRecord *                shn_entry;
-    BinRecord *                sym_format;
-    BinRecord *                note_format;
-
     gboolean           is_64;
-    const char *       data;
+    const guchar *     data;
     gsize              length;
     
     int                        n_sections;
@@ -72,10 +63,6 @@ struct ElfParser
     const Section *    text_section;
 };
 
-static gboolean parse_elf_signature (const guchar *data, gsize length,
-                                    gboolean *is_64, gboolean *is_be);
-static void     make_formats        (ElfParser *parser, gboolean is_64);
-
 /* FIXME: All of these should in principle do endian swapping,
  * but sysprof never has to deal with binaries of a different
  * endianness than sysprof itself
@@ -99,17 +86,7 @@ static void     make_formats        (ElfParser *parser, gboolean is_64);
        return GET_FIELD (parser, 0, Ehdr, 0, field_name);              \
     }
 
-MAKE_ELF_UINT_ACCESSOR (e_type)
-MAKE_ELF_UINT_ACCESSOR (e_machine)
-MAKE_ELF_UINT_ACCESSOR (e_version)
-MAKE_ELF_UINT_ACCESSOR (e_entry)
-MAKE_ELF_UINT_ACCESSOR (e_phoff)
 MAKE_ELF_UINT_ACCESSOR (e_shoff)
-MAKE_ELF_UINT_ACCESSOR (e_flags)
-MAKE_ELF_UINT_ACCESSOR (e_ehsize)
-MAKE_ELF_UINT_ACCESSOR (e_phentsize)
-MAKE_ELF_UINT_ACCESSOR (e_phnum)
-MAKE_ELF_UINT_ACCESSOR (e_shentsize)
 MAKE_ELF_UINT_ACCESSOR (e_shnum)
 MAKE_ELF_UINT_ACCESSOR (e_shstrndx)
 
@@ -127,10 +104,6 @@ MAKE_SECTION_HEADER_ACCESSOR (sh_flags);
 MAKE_SECTION_HEADER_ACCESSOR (sh_addr);
 MAKE_SECTION_HEADER_ACCESSOR (sh_offset);
 MAKE_SECTION_HEADER_ACCESSOR (sh_size);
-MAKE_SECTION_HEADER_ACCESSOR (sh_link);
-MAKE_SECTION_HEADER_ACCESSOR (sh_info);
-MAKE_SECTION_HEADER_ACCESSOR (sh_addralign);
-MAKE_SECTION_HEADER_ACCESSOR (sh_entsize);
 
 #define MAKE_SYMBOL_ACCESSOR(field_name)                               \
     static uint64_t field_name (ElfParser *parser, gulong offset, gulong nth)  \
@@ -142,7 +115,6 @@ MAKE_SYMBOL_ACCESSOR(st_name);
 MAKE_SYMBOL_ACCESSOR(st_info);
 MAKE_SYMBOL_ACCESSOR(st_value);
 MAKE_SYMBOL_ACCESSOR(st_size);
-MAKE_SYMBOL_ACCESSOR(st_other);
 MAKE_SYMBOL_ACCESSOR(st_shndx);
 
 static void
@@ -169,6 +141,42 @@ find_section (ElfParser *parser,
     return NULL;
 }
 
+static gboolean
+parse_elf_signature (const guchar *data,
+                    gsize         length,
+                    gboolean     *is_64,
+                    gboolean     *is_be)
+{
+    /* FIXME: this function should be able to return an error */
+    if (length < EI_NIDENT)
+    {
+       /* FIXME set error */
+       return FALSE;
+    }
+    
+    if (data[EI_CLASS] != ELFCLASS32 &&
+       data[EI_CLASS] != ELFCLASS64)
+    {
+       /* FIXME set error */
+       return FALSE;
+    }
+    
+    if (data[EI_DATA] != ELFDATA2LSB &&
+       data[EI_DATA] != ELFDATA2MSB)
+    {
+       /* FIXME set error */
+       return FALSE;
+    }
+    
+    if (is_64)
+       *is_64 = (data[EI_CLASS] == ELFCLASS64);
+    
+    if (is_be)
+       *is_be = (data[EI_DATA] == ELFDATA2MSB);
+    
+    return TRUE;
+}
+
 ElfParser *
 elf_parser_new_from_data (const guchar *data,
                          gsize length)
@@ -176,7 +184,7 @@ elf_parser_new_from_data (const guchar *data,
     ElfParser *parser;
     gboolean is_64, is_big_endian;
     int section_names_idx;
-    const char *section_names;
+    const guchar *section_names;
     gsize section_headers;
     int i;
     
@@ -189,47 +197,24 @@ elf_parser_new_from_data (const guchar *data,
     parser = g_new0 (ElfParser, 1);
 
     parser->is_64 = is_64;
-    parser->data = (const char *)data;
+    parser->data = data;
     parser->length = length;
     
 #if 0
     g_print ("  new parser : %p\n", parser);
 #endif
     
-    parser->parser = bin_parser_new (data, length);
-    
-    if (is_big_endian)
-       bin_parser_set_endian (parser->parser, BIN_BIG_ENDIAN);
-    else
-       bin_parser_set_endian (parser->parser, BIN_LITTLE_ENDIAN);
-    
-    make_formats (parser, is_64);
-    
-    
     /* Read ELF header */
     
-    bin_parser_set_offset (parser->parser, 0);
-    
     parser->n_sections = e_shnum (parser);
     section_names_idx = e_shstrndx (parser);
     section_headers = e_shoff (parser);
     
     /* Read section headers */
     parser->sections = g_new0 (Section *, parser->n_sections);
-
-    
-    
-    bin_parser_set_offset (parser->parser, section_headers);
-    
-    bin_parser_save (parser->parser);
     
-    bin_parser_seek_record (parser->parser, parser->shn_entry,
-                           section_names_idx);
-
     section_names = parser->data + sh_offset (parser, section_names_idx);
 
-    bin_parser_restore (parser->parser);
-    
     for (i = 0; i < parser->n_sections; ++i)
     {
        Section *section = g_new (Section, 1);
@@ -400,8 +385,6 @@ elf_parser_free (ElfParser *parser)
     
     g_free (parser->symbols);
     
-    bin_parser_free (parser->parser);
-
     if (parser->filename)
        g_free (parser->filename);
 
@@ -464,7 +447,7 @@ read_table (ElfParser *parser,
            const Section *sym_table,
            const Section *str_table)
 {
-    int sym_size = bin_record_get_size (parser->sym_format);
+    int sym_size = GET_SIZE (parser, Sym);
     int i, n_symbols;
 
 #if 0
@@ -683,7 +666,7 @@ elf_parser_get_text_offset (ElfParser *parser)
 }
 
 static gchar *
-make_hex_string (const gchar *data, int n_bytes)
+make_hex_string (const guchar *data, int n_bytes)
 {
     static const char hex_digits[] = {
        '0', '1', '2', '3', '4', '5', '6', '7',
@@ -729,12 +712,12 @@ elf_parser_get_build_id (ElfParser *parser)
 
        offset += GET_SIZE (parser, Nhdr);
 
-       name = parser->data + offset;
+       name = (char *)(parser->data + offset);
        
        if (strncmp (name, ELF_NOTE_GNU, name_size) != 0 || type != NT_GNU_BUILD_ID)
            return NULL;
 
-       offset += strlen (parser->data + offset);
+       offset += strlen (name);
 
        offset = (offset + 3) & (~0x3);
 
@@ -757,7 +740,7 @@ elf_parser_get_debug_link (ElfParser *parser, guint32 *crc32)
 
     offset = debug_link->offset;
     
-    result = parser->data + offset;
+    result = (char *)(parser->data + offset);
 
     if (crc32)
     {
@@ -828,165 +811,3 @@ elf_parser_get_sym_address (ElfParser *parser,
 /*
  * Utility functions
  */
-static gboolean
-parse_elf_signature (const guchar *data,
-                    gsize         length,
-                    gboolean     *is_64,
-                    gboolean     *is_be)
-{
-    /* FIXME: this function should be able to return an error */
-    if (length < EI_NIDENT)
-    {
-       /* FIXME set error */
-       return FALSE;
-    }
-    
-    if (data[EI_CLASS] != ELFCLASS32 &&
-       data[EI_CLASS] != ELFCLASS64)
-    {
-       /* FIXME set error */
-       return FALSE;
-    }
-    
-    if (data[EI_DATA] != ELFDATA2LSB &&
-       data[EI_DATA] != ELFDATA2MSB)
-    {
-       /* FIXME set error */
-       return FALSE;
-    }
-    
-    if (is_64)
-       *is_64 = (data[EI_CLASS] == ELFCLASS64);
-    
-    if (is_be)
-       *is_be = (data[EI_DATA] == ELFDATA2MSB);
-    
-    return TRUE;
-}
-
-static void
-get_formats (gboolean is_64,
-            const BinField **elf_header,
-            const BinField **shn_entry,
-            const BinField **sym_format,
-            const BinField **note_format_out)
-{
-    static const BinField elf64_header[] = {
-       { "e_ident",            BIN_UNINTERPRETED, EI_NIDENT },
-       { "e_type",             BIN_UINT,       2 },
-       { "e_machine",          BIN_UINT,       2 }, 
-       { "e_version",          BIN_UINT,       4 },
-       { "e_entry",            BIN_UINT,       8 },
-       { "e_phoff",            BIN_UINT,       8 },
-       { "e_shoff",            BIN_UINT,       8 },
-       { "e_flags",            BIN_UINT,       4 },
-       { "e_ehsize",           BIN_UINT,       2 },
-       { "e_phentsize",        BIN_UINT,       2 },
-       { "e_phnum",            BIN_UINT,       2 },
-       { "e_shentsize",        BIN_UINT,       2 },
-       { "e_shnum",            BIN_UINT,       2 },
-       { "e_shstrndx",         BIN_UINT,       2 },
-       { "" },
-    };
-    
-    static const BinField elf32_header[] = {
-       { "e_ident",            BIN_UNINTERPRETED, EI_NIDENT },
-       { "e_type",             BIN_UINT,       2 },
-       { "e_machine",          BIN_UINT,       2 }, 
-       { "e_version",          BIN_UINT,       4 },
-       { "e_entry",            BIN_UINT,       4 },
-       { "e_phoff",            BIN_UINT,       4 },
-       { "e_shoff",            BIN_UINT,       4 },
-       { "e_flags",            BIN_UINT,       4 },
-       { "e_ehsize",           BIN_UINT,       2 },
-       { "e_phentsize",        BIN_UINT,       2 },
-       { "e_phnum",            BIN_UINT,       2 },
-       { "e_shentsize",        BIN_UINT,       2 },
-       { "e_shnum",            BIN_UINT,       2 },
-       { "e_shstrndx",         BIN_UINT,       2 },
-       { "" },
-    };
-    
-    static const BinField shn64_entry[] = {
-       { "sh_name",            BIN_UINT,       4 },
-       { "sh_type",            BIN_UINT,       4 },
-       { "sh_flags",           BIN_UINT,       8 },
-       { "sh_addr",            BIN_UINT,       8 },
-       { "sh_offset",          BIN_UINT,       8 },
-       { "sh_size",            BIN_UINT,       8 },
-       { "sh_link",            BIN_UINT,       4 },
-       { "sh_info",            BIN_UINT,       4 },
-       { "sh_addralign",       BIN_UINT,       8 },
-       { "sh_entsize",         BIN_UINT,       8 },
-       { "" }
-    };
-    
-    static const BinField shn32_entry[] = {
-       { "sh_name",            BIN_UINT,       4 },
-       { "sh_type",            BIN_UINT,       4 },
-       { "sh_flags",           BIN_UINT,       4 },
-       { "sh_addr",            BIN_UINT,       4 },
-       { "sh_offset",          BIN_UINT,       4 },
-       { "sh_size",            BIN_UINT,       4 },
-       { "sh_link",            BIN_UINT,       4 },
-       { "sh_info",            BIN_UINT,       4 },
-       { "sh_addralign",       BIN_UINT,       4 },
-       { "sh_entsize",         BIN_UINT,       4 },
-       { "" }
-    };
-    
-    static const BinField sym64_format[] = {
-       { "st_name",            BIN_UINT,       4 },
-       { "st_info",            BIN_UINT,       1 },
-       { "st_other",           BIN_UINT,       1 },
-       { "st_shndx",           BIN_UINT,       2 },
-       { "st_value",           BIN_UINT,       8 },
-       { "st_size",            BIN_UINT,       8 },
-       { "" }
-    };
-
-    static const BinField sym32_format[] = {
-       { "st_name",            BIN_UINT,       4 },
-       { "st_value",           BIN_UINT,       4 },
-       { "st_size",            BIN_UINT,       4 },
-       { "st_info",            BIN_UINT,       1 },
-       { "st_other",           BIN_UINT,       1 },
-       { "st_shndx",           BIN_UINT,       2 },
-       { "" },
-    };
-
-    static const BinField note_format[] = {
-       { "name_size",          BIN_UINT,       4 },
-       { "desc_size",          BIN_UINT,       4 },
-       { "type",               BIN_UINT,       4 },
-    };
-
-    if (is_64)
-    {
-       *elf_header = elf64_header;
-       *shn_entry  = shn64_entry;
-       *sym_format = sym64_format;
-    }
-    else
-    {
-       *elf_header = elf32_header;
-       *shn_entry  = shn32_entry;
-       *sym_format = sym32_format;
-    }
-
-    *note_format_out = note_format;
-}
-
-static void
-make_formats (ElfParser *parser, gboolean is_64)
-{
-    const BinField *elf_header, *shn_entry, *sym_format, *note_format;
-
-    get_formats (is_64, &elf_header, &shn_entry, &sym_format, &note_format);
-
-    parser->header = bin_parser_create_record (parser->parser, elf_header);
-    parser->shn_entry = bin_parser_create_record (parser->parser, shn_entry);
-    parser->sym_format = bin_parser_create_record (parser->parser, sym_format);
-    parser->note_format = bin_parser_create_record (parser->parser, note_format);
-}
-
index 3631c75..2184158 100644 (file)
--- a/unwind.c
+++ b/unwind.c
@@ -1,5 +1,4 @@
 #include "elfparser.h"
-#include "binparser.h"
 #include <string.h>
 
 /* Pointer encodings, from dwarf2.h.  */