--- a/src/dwarf2-abbrev.c	Mon Aug 02 00:24:56 2010 +0200
+++ b/src/dwarf2-abbrev.c	Mon Aug 02 01:02:34 2010 +0200
@@ -201,18 +201,17 @@
                  */
                 goto error;
         }
-        decl->offset = abbrev_offset;
         reader_seek (reader, abbrev_offset);
         decl->abbr_code = reader_read_uleb128 (reader);
         decl->tag = reader_read_uleb128 (reader);
         decl->children = reader_read_u8 (reader);
+        decl->offset = reader_get_offset (reader);
 
         assert (decl->abbr_code == abbr_code);
 
         return;
  error:
         assert (false);
-        reader->status = -1;
 }
 
 void 
@@ -221,17 +220,7 @@
                                uint32_t *new_offset,
                                struct reader *reader)
 {
-        uint64_t code, tag;
-        uint8_t children;
         reader_seek (reader, decl->offset);
-
-        code = reader_read_uleb128 (reader);
-        tag = reader_read_uleb128 (reader);
-        children = reader_read_u8 (reader);
-        assert (decl->abbr_code == code);
-        assert (decl->tag == tag);
-        assert (decl->children == children);
-
         attr->name = reader_read_uleb128 (reader);
         attr->form = reader_read_uleb128 (reader);
         *new_offset = reader_get_offset (reader);

--- a/src/dwarf2-abbrev.h	Mon Aug 02 00:24:56 2010 +0200
+++ b/src/dwarf2-abbrev.h	Mon Aug 02 01:02:34 2010 +0200
@@ -69,14 +69,14 @@
                                   uint32_t offset /* offset from start of file */);
 
 void dwarf2_abbrev_decl_read (struct dwarf2_abbrev_cu *abbrev_cu,
-                                 struct dwarf2_abbrev_decl *decl,
-                                 uint64_t code,
-                                 struct reader *reader);
+                              struct dwarf2_abbrev_decl *decl,
+                              uint64_t code,
+                              struct reader *reader);
 
 void dwarf2_abbrev_attr_read_first (struct dwarf2_abbrev_decl *decl,
-                                         struct dwarf2_abbrev_attr *attr,
-                                         uint32_t *new_offset,
-                                         struct reader *reader);
+                                    struct dwarf2_abbrev_attr *attr,
+                                    uint32_t *new_offset,
+                                    struct reader *reader);
 void dwarf2_abbrev_attr_read (uint32_t cur_offset,
                               struct dwarf2_abbrev_attr *attr,
                               uint32_t *new_offset,

--- a/src/reader.h	Mon Aug 02 00:24:56 2010 +0200
+++ b/src/reader.h	Mon Aug 02 01:02:34 2010 +0200
@@ -28,11 +28,9 @@
 #endif
 
 struct reader {
-        /* status < 0 in case of error. */
-        int status;
-        uint8_t *buffer;
-        uint32_t size;
-        uint32_t current;
+        uint8_t *start;
+        uint8_t *end;
+        uint8_t *current;
         bool lsb;
 };
 
@@ -45,7 +43,7 @@
 int8_t   reader_read_s8      (struct reader *reader);
 int16_t  reader_read_s16     (struct reader *reader);
 int32_t  reader_read_s32     (struct reader *reader);
-uint32_t reader_read_u       (struct reader *reader, uint8_t length);
+uint64_t reader_read_u       (struct reader *reader, uint8_t length);
 static inline uint64_t reader_read_uleb128 (struct reader *reader);
 int64_t  reader_read_sleb128 (struct reader *reader);
 uint8_t  reader_read_u8bcd   (struct reader *reader);
@@ -53,9 +51,9 @@
 int      reader_read_str_len (struct reader *reader);
 void     reader_read_buffer  (struct reader *reader, uint8_t *buffer, uint32_t size);
 
-uint32_t reader_get_offset   (struct reader *reader);
+static inline uint32_t reader_get_offset   (struct reader *reader);
 /* absolute offset. */
-void     reader_seek         (struct reader *reader, uint32_t offset);
+static inline void     reader_seek         (struct reader *reader, uint32_t offset);
 /* relative offset. */
 void     reader_skip         (struct reader *reader, uint32_t offset);
 void     reader_skip64       (struct reader *reader, uint64_t offset);
@@ -63,20 +61,12 @@
 
 void     reader_initialize   (struct reader *reader, uint8_t *buffer, uint32_t size);
 
-uint64_t reader_read_uleb128_slow (struct reader *reader);
-
 static inline uint8_t  reader_read_u8  (struct reader *reader)
 {
         uint8_t retval;
-        if (reader->size < reader->current + 1) {
-                goto error;
-        }
-        retval = reader->buffer[reader->current];
+        retval = *reader->current;
         reader->current++;
         return retval;
- error:
-        reader->status = -1;
-        return 0xff;
 }
 
 static inline uint64_t 
@@ -85,58 +75,48 @@
         uint64_t result;
         uint8_t byte;
         uint8_t shift;
-        uint8_t *buffer;
-        if (reader->size < reader->current + 9) {
-                return reader_read_uleb128_slow (reader);
-        }
+        uint8_t *current;
         result = 0;
         shift = 0;
-        buffer = &reader->buffer[reader->current];
+        current = reader->current;
         do {
-                byte = *buffer;
-                buffer++;
+                byte = *current;
+                current++;
                 result |= (byte & (~0x80))<<shift;
                 shift += 7;
-        } while (byte & 0x80 && 
-                 /* a LEB128 unsigned number is at most 9 bytes long. */
-                 shift < (7*9)); 
-        if (byte & 0x80) {
-                /* This means the LEB128 number was not valid.
-                 * ie: the last (9th) byte did not have the high-order bit zeroed.
-                 */
-                reader->status = -1;
-        }
-        reader->current += shift / 7;
+        } while (byte & 0x80); 
+        reader->current = current;
         return result;
 }
 
 static inline void reader_skip_uleb128 (struct reader *reader)
 {
         uint8_t byte;
-        uint8_t shift;
-        uint8_t *buffer;
-        if (reader->size < reader->current + 9) {
-                reader_read_uleb128_slow (reader);
-                return;
-        }
-        shift = 0;
-        buffer = &reader->buffer[reader->current];
+        uint8_t *current;
+        current = reader->current;
         do {
-                byte = *buffer;
-                buffer++;
-                shift += 7;
-        } while (byte & 0x80 && 
-                 /* a LEB128 unsigned number is at most 9 bytes long. */
-                 shift < (7*9)); 
-        if (byte & 0x80) {
-                /* This means the LEB128 number was not valid.
-                 * ie: the last (9th) byte did not have the high-order bit zeroed.
-                 */
-                reader->status = -1;
-        }
-        reader->current += shift / 7;
+                byte = *current;
+                current++;
+        } while (byte & 0x80); 
+        reader->current = current;
+}
+
+static inline uint32_t
+reader_get_offset (struct reader *reader)
+{
+        return reader->current - reader->start;
 }
 
+static inline void
+reader_seek (struct reader *reader, uint32_t offset)
+{
+        reader->current = &reader->start[offset];
+        return;
+}
+
+
+
+
 
 #ifdef __cplusplus
 }