rdwarf 0.0.1

data/ext/rdwarf/libdwarf/dwarf_abbrev.c

@@ -0,0 +1,291 @@
+/*
+
+  Copyright (C) 2000-2005 Silicon Graphics, Inc.  All Rights Reserved.
+  Portions Copyright (C) 2009-2011 David Anderson. All Rights Reserved.
+
+  This program is free software; you can redistribute it and/or modify it
+  under the terms of version 2.1 of the GNU Lesser General Public License
+  as published by the Free Software Foundation.
+
+  This program is distributed in the hope that it would be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+  Further, this software is distributed without any warranty that it is
+  free of the rightful claim of any third person regarding infringement
+  or the like.  Any license provided herein, whether implied or
+  otherwise, applies only to this software file.  Patent licenses, if
+  any, provided herein do not apply to combinations of this program with
+  other software, or any other product whatsoever.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this program; if not, write the Free Software
+  Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston MA 02110-1301,
+  USA.
+
+*/
+
+#include "config.h"
+#include "dwarf_incl.h"
+#include <stdio.h>
+#include "dwarf_abbrev.h"
+
+/*  This is used to print a .debug_abbrev section without
+    knowing about the DIEs that use the abbrevs.
+
+    When we have a simple .o
+    there is at least a hope of iterating through
+    the abbrevs meaningfully without knowing
+    a CU context.
+
+    This often fails or gets incorrect info
+    because there is no guarantee the .debug_abbrev
+    section is free of garbage bytes.
+
+    In an object with multiple CU/TUs the
+    output is difficult/impossible to usefully interpret.
+
+    In a dwp (Package File)  it is really impossible
+    to associate abbrevs with a CU.
+
+*/
+
+int
+dwarf_get_abbrev(Dwarf_Debug dbg,
+    Dwarf_Unsigned offset,
+    Dwarf_Abbrev * returned_abbrev,
+    Dwarf_Unsigned * length,
+    Dwarf_Unsigned * abbr_count, Dwarf_Error * error)
+{
+    Dwarf_Small *abbrev_ptr = 0;
+    Dwarf_Small *abbrev_section_end = 0;
+    Dwarf_Half attr = 0;
+    Dwarf_Half attr_form = 0;
+    Dwarf_Abbrev ret_abbrev = 0;
+    Dwarf_Unsigned labbr_count = 0;
+    Dwarf_Unsigned utmp = 0;
+
+    if (dbg == NULL) {
+        _dwarf_error(NULL, error, DW_DLE_DBG_NULL);
+        return (DW_DLV_ERROR);
+    }
+    if (dbg->de_debug_abbrev.dss_data == 0) {
+        /*  Loads abbrev section (and .debug_info as we do those
+            together). */
+        int res = _dwarf_load_debug_info(dbg, error);
+
+        if (res != DW_DLV_OK) {
+            return res;
+        }
+    }
+
+    if (offset >= dbg->de_debug_abbrev.dss_size) {
+        return (DW_DLV_NO_ENTRY);
+    }
+
+    ret_abbrev = (Dwarf_Abbrev) _dwarf_get_alloc(dbg, DW_DLA_ABBREV, 1);
+    if (ret_abbrev == NULL) {
+        _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+        return (DW_DLV_ERROR);
+    }
+    ret_abbrev->ab_dbg = dbg;
+    if (returned_abbrev == 0 || abbr_count == 0) {
+        dwarf_dealloc(dbg, ret_abbrev, DW_DLA_ABBREV);
+        _dwarf_error(dbg, error, DW_DLE_DWARF_ABBREV_NULL);
+        return (DW_DLV_ERROR);
+    }
+
+
+    *abbr_count = 0;
+    if (length != NULL)
+        *length = 1;
+
+
+    abbrev_ptr = dbg->de_debug_abbrev.dss_data + offset;
+    abbrev_section_end =
+        dbg->de_debug_abbrev.dss_data + dbg->de_debug_abbrev.dss_size;
+
+    DECODE_LEB128_UWORD(abbrev_ptr, utmp);
+    ret_abbrev->ab_code = (Dwarf_Word) utmp;
+    if (ret_abbrev->ab_code == 0) {
+        *returned_abbrev = ret_abbrev;
+        *abbr_count = 0;
+        if (length) {
+            *length = 1;
+        }
+        return (DW_DLV_OK);
+    }
+
+    DECODE_LEB128_UWORD(abbrev_ptr, utmp);
+    ret_abbrev->ab_tag = utmp;
+    ret_abbrev->ab_has_child = *(abbrev_ptr++);
+    ret_abbrev->ab_abbrev_ptr = abbrev_ptr;
+
+    do {
+        Dwarf_Unsigned utmp2;
+
+        DECODE_LEB128_UWORD(abbrev_ptr, utmp2);
+        attr = (Dwarf_Half) utmp2;
+        DECODE_LEB128_UWORD(abbrev_ptr, utmp2);
+        attr_form = (Dwarf_Half) utmp2;
+
+        if (attr != 0)
+            (labbr_count)++;
+
+    } while (abbrev_ptr < abbrev_section_end &&
+        (attr != 0 || attr_form != 0));
+
+    if (abbrev_ptr > abbrev_section_end) {
+        dwarf_dealloc(dbg, ret_abbrev, DW_DLA_ABBREV);
+        _dwarf_error(dbg, error, DW_DLE_ABBREV_DECODE_ERROR);
+        return (DW_DLV_ERROR);
+    }
+
+    if (length != NULL)
+        *length = abbrev_ptr - dbg->de_debug_abbrev.dss_data - offset;
+
+    *returned_abbrev = ret_abbrev;
+    *abbr_count = labbr_count;
+    return (DW_DLV_OK);
+}
+
+int
+dwarf_get_abbrev_code(Dwarf_Abbrev abbrev,
+    Dwarf_Unsigned * returned_code,
+    Dwarf_Error * error)
+{
+    if (abbrev == NULL) {
+        _dwarf_error(NULL, error, DW_DLE_DWARF_ABBREV_NULL);
+        return (DW_DLV_ERROR);
+    }
+
+    *returned_code = abbrev->ab_code;
+    return (DW_DLV_OK);
+}
+
+/*  DWARF defines DW_TAG_hi_user as 0xffff so no tag should be
+    over 16 bits.  */
+int
+dwarf_get_abbrev_tag(Dwarf_Abbrev abbrev,
+    Dwarf_Half * returned_tag, Dwarf_Error * error)
+{
+    if (abbrev == NULL) {
+        _dwarf_error(NULL, error, DW_DLE_DWARF_ABBREV_NULL);
+        return (DW_DLV_ERROR);
+    }
+
+    *returned_tag = abbrev->ab_tag;
+    return (DW_DLV_OK);
+}
+
+
+int
+dwarf_get_abbrev_children_flag(Dwarf_Abbrev abbrev,
+    Dwarf_Signed * returned_flag,
+    Dwarf_Error * error)
+{
+    if (abbrev == NULL) {
+        _dwarf_error(NULL, error, DW_DLE_DWARF_ABBREV_NULL);
+        return (DW_DLV_ERROR);
+    }
+
+    *returned_flag = abbrev->ab_has_child;
+    return (DW_DLV_OK);
+}
+
+
+int
+dwarf_get_abbrev_entry(Dwarf_Abbrev abbrev,
+    Dwarf_Signed indx,
+    Dwarf_Half * returned_attr_num,
+    Dwarf_Signed * form,
+    Dwarf_Off * offset, Dwarf_Error * error)
+{
+    Dwarf_Byte_Ptr abbrev_ptr = 0;
+    Dwarf_Byte_Ptr abbrev_end = 0;
+    Dwarf_Byte_Ptr mark_abbrev_ptr = 0;
+    Dwarf_Half attr = 0;
+    Dwarf_Half attr_form = 0;
+
+    if (indx < 0)
+        return (DW_DLV_NO_ENTRY);
+
+    if (abbrev == NULL) {
+        _dwarf_error(NULL, error, DW_DLE_DWARF_ABBREV_NULL);
+        return (DW_DLV_ERROR);
+    }
+
+    if (abbrev->ab_code == 0) {
+        return (DW_DLV_NO_ENTRY);
+    }
+
+    if (abbrev->ab_dbg == NULL) {
+        _dwarf_error(NULL, error, DW_DLE_DBG_NULL);
+        return (DW_DLV_ERROR);
+    }
+
+    abbrev_ptr = abbrev->ab_abbrev_ptr;
+    abbrev_end =
+        abbrev->ab_dbg->de_debug_abbrev.dss_data +
+        abbrev->ab_dbg->de_debug_abbrev.dss_size;
+
+    for (attr = 1, attr_form = 1;
+        indx >= 0 && abbrev_ptr < abbrev_end && (attr != 0 ||
+            attr_form != 0);
+        indx--) {
+        Dwarf_Unsigned utmp4;
+
+        mark_abbrev_ptr = abbrev_ptr;
+        DECODE_LEB128_UWORD(abbrev_ptr, utmp4);
+        attr = (Dwarf_Half) utmp4;
+        DECODE_LEB128_UWORD(abbrev_ptr, utmp4);
+        attr_form = (Dwarf_Half) utmp4;
+    }
+
+    if (abbrev_ptr >= abbrev_end) {
+        _dwarf_error(abbrev->ab_dbg, error, DW_DLE_ABBREV_DECODE_ERROR);
+        return (DW_DLV_ERROR);
+    }
+
+    if (indx >= 0) {
+        return (DW_DLV_NO_ENTRY);
+    }
+
+    if (form != NULL)
+        *form = attr_form;
+    if (offset != NULL)
+        *offset = mark_abbrev_ptr - abbrev->ab_dbg->de_debug_abbrev.dss_data;
+
+    *returned_attr_num = (attr);
+    return DW_DLV_OK;
+}
+
+/*  This function is not entirely safe to call.
+    The problem is that the DWARF[234] specification does not insist
+    that bytes in .debug_abbrev that are not referenced by .debug_info
+    or .debug_types need to be initialized to anything specific.
+    Any garbage bytes may cause trouble.  Not all compilers/linkers
+    leave unreferenced garbage bytes in .debug_abbrev, so this may
+    work for most objects. */
+int
+dwarf_get_abbrev_count(Dwarf_Debug dbg)
+{
+    Dwarf_Abbrev ab;
+    Dwarf_Unsigned offset = 0;
+    Dwarf_Unsigned length = 0;
+    Dwarf_Unsigned attr_count = 0;
+    Dwarf_Unsigned abbrev_count = 0;
+    int abres = DW_DLV_OK;
+    Dwarf_Error err;
+
+    while ((abres = dwarf_get_abbrev(dbg, offset, &ab,
+        &length, &attr_count,
+        &err)) == DW_DLV_OK) {
+
+        ++abbrev_count;
+        offset += length;
+        dwarf_dealloc(dbg, ab, DW_DLA_ABBREV);
+    }
+    return abbrev_count;
+}
+

data/ext/rdwarf/libdwarf/dwarf_abbrev.h

@@ -0,0 +1,45 @@
+/*
+   Copyright (C) 2000 Silicon Graphics, Inc.  All Rights Reserved.
+   Portions Copyright (C) 2008-2011  David Anderson. All Rights Reserved.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of version 2.1 of the GNU Lesser General Public License
+   as published by the Free Software Foundation.
+
+   This program is distributed in the hope that it would be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+   Further, this software is distributed without any warranty that it is
+   free of the rightful claim of any third person regarding infringement
+   or the like.  Any license provided herein, whether implied or
+   otherwise, applies only to this software file.  Patent licenses, if
+   any, provided herein do not apply to combinations of this program with
+   other software, or any other product whatsoever.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this program; if not, write the Free Software
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston MA 02110-1301,
+   USA.
+
+*/
+
+
+
+
+/*  In a given CU, one of these is (eventually) set up
+    for every abbreviation we need to find (and for all.
+    those ealier in the abbreviations for that CU).
+    So we don't want elements needlessly big.
+*/
+struct Dwarf_Abbrev_s {
+    /*  No TAG should exceed DW_TAG_hi_user, 0xffff, but
+        we do allow a larger value here. */
+    Dwarf_Word ab_tag;
+    /*  Abbreviations are numbered (normally sequentially from
+        1 and so 16 bits is not enough!  */
+    Dwarf_Word ab_code;
+    Dwarf_Small ab_has_child;
+    Dwarf_Byte_Ptr ab_abbrev_ptr;
+    Dwarf_Debug ab_dbg;
+};

data/ext/rdwarf/libdwarf/dwarf_addr_finder.c

@@ -0,0 +1,676 @@
+/*
+
+  Copyright (C) 2000-2004 Silicon Graphics, Inc.  All Rights Reserved.
+  Portions Copyright 2011 David Anderson. All Rights Reserved.
+
+  This program is free software; you can redistribute it and/or modify it
+  under the terms of version 2.1 of the GNU Lesser General Public License
+  as published by the Free Software Foundation.
+
+  This program is distributed in the hope that it would be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+  Further, this software is distributed without any warranty that it is
+  free of the rightful claim of any third person regarding infringement
+  or the like.  Any license provided herein, whether implied or
+  otherwise, applies only to this software file.  Patent licenses, if
+  any, provided herein do not apply to combinations of this program with
+  other software, or any other product whatsoever.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this program; if not, write the Free Software
+  Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston MA 02110-1301,
+  USA.
+
+*/
+/*  This code used by SGI-IRIX rqs processing, not needed by
+    any other system or application.
+    The 'We need' and 'FIX' here are left in for historical
+    interest, the code is not really used in the public libdwarf
+    or applications.
+*/
+
+#include "config.h"
+#include "libdwarfdefs.h"
+#ifdef HAVE_ELF_H
+#include <elf.h>
+#endif
+#include <dwarf.h>
+#include <libdwarf.h>
+#include "dwarf_base_types.h"
+#include "dwarf_alloc.h"
+#include "dwarf_opaque.h"
+#include "dwarf_arange.h"
+#include "dwarf_line.h"
+#include "dwarf_frame.h"
+#include <cmplrs/dwarf_addr_finder.h>
+#include "dwarf_error.h"
+
+typedef unsigned long long ull;
+
+static int do_this_die_and_dealloc(Dwarf_Debug dbg, Dwarf_Die die,
+    int *errval);
+static int handle_debug_info(Dwarf_Debug dbg, int *errval);
+static int handle_debug_frame(Dwarf_Debug dbg,
+    Dwarf_addr_callback_func cb_func, int *errval);
+static int handle_debug_aranges(Dwarf_Debug dbg,
+    Dwarf_addr_callback_func cb_func, int *errval);
+static int handle_debug_line(Dwarf_Debug dbg,
+    Dwarf_Die cu_die, Dwarf_addr_callback_func cb_func, int *errval);
+static int handle_debug_loc(void);
+
+
+/*  A static variable is not thread-safe, but this is only
+    used by SGI-internal software which is single-threaded
+    so the static variable is safe.
+*/
+static Dwarf_addr_callback_func send_addr_note;
+
+/*  A function which should probably not be used outside
+    of SGI.   Intended to be used by executable and
+    shared-library post-processor software.
+*/
+int
+_dwarf_addr_finder(dwarf_elf_handle elf_file_ptr,
+    Dwarf_addr_callback_func cb_func, int *dwerr)
+{
+
+    Dwarf_Error err = 0;
+    Dwarf_Debug dbg = 0;
+    int res = 0;
+    int errval = 0;
+    int sections_found = 0;
+
+    res = dwarf_elf_init(elf_file_ptr, DW_DLC_READ, /* errhand */ 0,
+        /* errarg */ 0, &dbg, &err);
+    if (res == DW_DLV_ERROR) {
+        int errv = (int) dwarf_errno(err);
+        return errv;
+    }
+    if (res == DW_DLV_NO_ENTRY) {
+        return res;
+    }
+    send_addr_note = cb_func;
+    res = handle_debug_info(dbg, &errval);
+    switch (res) {
+    case DW_DLV_OK:
+        ++sections_found;
+        break;
+    case DW_DLV_NO_ENTRY:
+
+        break;
+    default:
+    case DW_DLV_ERROR:
+        dwarf_finish(dbg, &err);
+        *dwerr = errval;
+        return res;
+    }
+
+    res = handle_debug_aranges(dbg, cb_func, &errval);
+    switch (res) {
+    case DW_DLV_OK:
+        ++sections_found;
+        break;
+    case DW_DLV_NO_ENTRY:
+        break;
+    default:
+    case DW_DLV_ERROR:
+        dwarf_finish(dbg, &err);
+        *dwerr = errval;
+        return res;
+    }
+    res = handle_debug_frame(dbg, cb_func, &errval);
+    switch (res) {
+    case DW_DLV_OK:
+        ++sections_found;
+        break;
+    case DW_DLV_NO_ENTRY:
+        break;
+    default:
+    case DW_DLV_ERROR:
+        dwarf_finish(dbg, &err);
+        *dwerr = errval;
+        return res;
+    }
+
+    res = handle_debug_loc();   /* does nothing */
+    switch (res) {
+    case DW_DLV_OK:
+        ++sections_found;
+        break;
+    case DW_DLV_NO_ENTRY:
+        break;
+    default:
+    case DW_DLV_ERROR:
+        /* IMPOSSIBLE : handle_debug_loc cannot return this */
+        dwarf_finish(dbg, &err);
+        *dwerr = errval;
+        return res;
+    }
+
+
+
+    *dwerr = 0;
+    res = dwarf_finish(dbg, &err);
+    if (res == DW_DLV_ERROR) {
+        *dwerr = (int) dwarf_errno(err);
+        return DW_DLV_ERROR;
+    }
+    if (sections_found == 0) {
+        return DW_DLV_NO_ENTRY;
+    }
+    return DW_DLV_OK;
+
+}
+
+/*  Return DW_DLV_OK, ERROR, or NO_ENTRY.  */
+static int
+handle_debug_info(Dwarf_Debug dbg, int *errval)
+{
+    Dwarf_Unsigned nxtoff = 1;
+    Dwarf_Unsigned hdr_length;
+    Dwarf_Half version_stamp;
+    Dwarf_Unsigned abbrev_offset;
+    Dwarf_Half addr_size;
+    Dwarf_Error err;
+    int terminate_now = 0;
+    int res = 0;
+    Dwarf_Die sibdie;
+    int sibres;
+    int nres = DW_DLV_OK;
+
+
+    for (nres = dwarf_next_cu_header(dbg, &hdr_length, &version_stamp,
+        &abbrev_offset,
+        &addr_size, &nxtoff, &err);
+        terminate_now == 0 && nres == DW_DLV_OK;
+        nres = dwarf_next_cu_header(dbg, &hdr_length, &version_stamp,
+            &abbrev_offset,
+            &addr_size, &nxtoff, &err)) {
+
+        Dwarf_Die curdie = 0;
+
+        /* Try to get the compilation unit die */
+        sibres = dwarf_siblingof(dbg, curdie, &sibdie, &err);
+        if (sibres == DW_DLV_OK) {
+            res = do_this_die_and_dealloc(dbg, sibdie, errval);
+            switch (res) {
+            case DW_DLV_OK:
+                break;
+            case DW_DLV_NO_ENTRY:
+                break;
+            default:
+            case DW_DLV_ERROR:
+                return DW_DLV_ERROR;
+            }
+        } else if (sibres == DW_DLV_ERROR) {
+            *errval = (int) dwarf_errno(err);
+            return DW_DLV_ERROR;
+        } else {
+            /* NO ENTRY! */
+            /* impossible? */
+        }
+
+    }
+    if (nres == DW_DLV_ERROR) {
+        int localerr = (int) dwarf_errno(err);
+
+        *errval = localerr;
+        return DW_DLV_ERROR;
+    }
+    return DW_DLV_OK;
+}
+
+static const int
+  might_have_addr[] = {
+    DW_AT_high_pc,
+    DW_AT_low_pc,
+};
+static  const int might_have_locdesc[] = {
+    DW_AT_segment,
+    DW_AT_return_addr,
+    DW_AT_frame_base,
+    DW_AT_static_link,
+    DW_AT_data_member_location,
+    DW_AT_string_length,
+    DW_AT_location,
+    DW_AT_use_location,
+    DW_AT_vtable_elem_location,
+};
+
+/*  Return DW_DLV_OK if handling this went ok.
+    For any FORM except DW_FORM_addr we do nothing
+    and return DW_DLV_OK.
+    For DW_FORM_ref_addr (the offset in .debug_info
+    of an address) we don't need to do anything
+    as the offsets in .debug_info do not change.
+*/
+static int
+handle_attr_addr(Dwarf_Debug dbg, Dwarf_Die die, Dwarf_Half attrnum,
+    Dwarf_Error * perr)
+{
+    int res = DW_DLV_OK;
+    Dwarf_Off offset;
+    Dwarf_Addr addr;
+    Dwarf_Half form;
+    int ares;
+
+    Dwarf_Attribute attr;
+
+    ares = dwarf_attr(die, attrnum, &attr, perr);
+    if (ares == DW_DLV_OK) {
+        int formres = dwarf_whatform(attr, &form, perr);
+
+        switch (formres) {
+        case DW_DLV_OK:
+            break;
+        case DW_DLV_ERROR:
+        case DW_DLV_NO_ENTRY:   /* impossible. */
+            return formres;
+
+        }
+
+        switch (form) {
+        case DW_FORM_addr:
+            res = dwarf_attr_offset(die, attr, &offset, perr);
+            if (res == DW_DLV_OK) {
+                ares = dwarf_formaddr(attr, &addr, perr);
+                if (ares == DW_DLV_OK) {
+                    send_addr_note(DW_SECTION_INFO, offset, addr);
+                } else if (ares == DW_DLV_ERROR) {
+                    return ares;
+                }
+                /* no entry: ok. */
+            } else {
+                /* NO_ENTRY is impossible. */
+                res = DW_DLV_ERROR;
+            }
+            break;
+
+        default:
+            /* Surprising FORM. An error? */
+            /* Do nothing */
+            ;
+        }
+        dwarf_dealloc(dbg, attr, DW_DLA_ATTR);
+    } else {
+        res = ares;
+    }
+    return res;
+}
+
+/* Return DW_DLV_OK if handling this went ok.  */
+static int
+handle_attr_locdesc(Dwarf_Debug dbg, Dwarf_Die die, Dwarf_Half attrnum,
+    Dwarf_Error * perr)
+{
+    int retval = DW_DLV_OK;
+    Dwarf_Attribute attr;
+    Dwarf_Locdesc *llbuf;
+    Dwarf_Signed i;
+    Dwarf_Off offset;
+    Dwarf_Loc *locp;
+    unsigned int entindx;
+    int res;
+    int ares;
+
+
+    ares = dwarf_attr(die, attrnum, &attr, perr);
+    if (ares == DW_DLV_OK) {
+        Dwarf_Half form;
+        int fres = dwarf_whatform(attr, &form, perr);
+
+        if (fres == DW_DLV_OK) {
+            switch (form) {
+            case DW_FORM_block1:
+            case DW_FORM_block2:
+            case DW_FORM_block4:
+                /* must be location description */
+                res = dwarf_attr_offset(die, attr, &offset, perr);
+                llbuf = 0;
+                if (res == DW_DLV_OK) {
+                    Dwarf_Signed count;
+                    int lres = dwarf_loclist(attr, &llbuf, &count, perr);
+                    if (lres != DW_DLV_OK) {
+                        return lres;
+                    }
+                    if (count != 1) {
+                        /* this cannot happen! */
+                        /* perr? */
+                        _dwarf_error(dbg, perr,
+                            DW_DLE_LOCDESC_COUNT_WRONG);
+                        retval = DW_DLV_ERROR;
+                        return retval;
+                    }
+                    for (i = 0; i < count; ++i) {
+                        unsigned int ents = llbuf[i].ld_cents;
+
+                        locp = llbuf[i].ld_s;
+                        for (entindx = 0; entindx < ents; entindx++) {
+                            Dwarf_Loc *llocp;
+
+                            llocp = locp + entindx;
+                            if (llocp->lr_atom == DW_OP_addr) {
+                                send_addr_note(DW_SECTION_INFO, offset +
+                                    llocp->lr_offset + 1
+                                    /*  The offset is the
+                                        offset of the atom,
+                                        ** and we know the
+                                        addr is 1 past it. */
+                                        , llocp->lr_number);
+                            }
+                        }
+                    }
+
+
+                    if (count > 0) {
+                        for (i = 0; i < count; ++i) {
+                            dwarf_dealloc(dbg, llbuf[i].ld_s,
+                                DW_DLA_LOC_BLOCK);
+                        }
+                        dwarf_dealloc(dbg, llbuf, DW_DLA_LOCDESC);
+                    }
+                } else {
+                    retval = res;
+                }
+                break;
+
+            default:
+                /* must be a const offset in debug_loc */
+                ; /* do nothing */
+            }
+            dwarf_dealloc(dbg, attr, DW_DLA_ATTR);
+        }   /* else error or no entry */
+        retval = fres;
+    } else {
+        retval = ares;
+    }
+    return retval;
+}
+
+/*  Return DW_DLV_OK, or DW_DLV_ERROR
+
+    Handle the addrs in a single die.  */
+static int
+process_this_die_attrs(Dwarf_Debug dbg, Dwarf_Die newdie, int *errval)
+{
+    Dwarf_Error err;
+    Dwarf_Half i;
+    Dwarf_Half newattrnum;
+    int res;
+    int tres;
+    Dwarf_Half ltag;
+
+    Dwarf_Off doff;
+    int doffres = dwarf_dieoffset(newdie, &doff, &err);
+
+    if (doffres != DW_DLV_OK) {
+        if (doffres == DW_DLV_ERROR) {
+            *errval = (int) dwarf_errno(err);
+        }
+        return doffres;
+    }
+    tres = dwarf_tag(newdie, &ltag, &err);
+    if (tres != DW_DLV_OK) {
+        return tres;
+    }
+    if (DW_TAG_compile_unit == ltag) {
+        /*  Because of the way the dwarf_line code works, we do lines
+            only per compile unit. This may turn out to be wrong if
+            we have lines left unconnected to a CU. of course such
+            lines will not, at present, be used by gnome. This is
+            not ideal as coded due to the dwarf_line.c issue. */
+        int lres = handle_debug_line(dbg, newdie, send_addr_note, errval);
+        if (lres == DW_DLV_ERROR) {
+            return lres;
+        }
+    }
+
+    for (i = 0; i < sizeof(might_have_addr) / sizeof(int); i++) {
+        int resattr;
+        Dwarf_Bool hasattr;
+
+        newattrnum = might_have_addr[i];
+        err = 0;
+        resattr = dwarf_hasattr(newdie, newattrnum, &hasattr, &err);
+        if (DW_DLV_OK == resattr) {
+            if (hasattr) {
+                res = handle_attr_addr(dbg, newdie, newattrnum, &err);
+                if (res != DW_DLV_OK) {
+                    *errval = (int) dwarf_errno(err);
+                    return DW_DLV_ERROR;
+                }
+            }
+        } else {
+            if (resattr == DW_DLV_ERROR) {
+                *errval = (int) dwarf_errno(err);
+                return resattr;
+            }
+        }
+    }
+    for (i = 0; i < sizeof(might_have_locdesc) / sizeof(int); i++) {
+        int resattr;
+        Dwarf_Bool hasattr;
+
+        newattrnum = might_have_locdesc[i];
+        err = 0;
+        resattr = dwarf_hasattr(newdie, newattrnum, &hasattr, &err);
+        if (DW_DLV_OK == resattr) {
+            if (hasattr) {
+                res =
+                    handle_attr_locdesc(dbg, newdie, newattrnum, &err);
+                if (res != DW_DLV_OK) {
+                    *errval = (int) dwarf_errno(err);
+                    return DW_DLV_ERROR;
+                }
+            }
+        } else {
+            if (resattr == DW_DLV_ERROR) {
+                *errval = (int) dwarf_errno(err);
+                return resattr;
+            }
+        }
+    }
+
+    return DW_DLV_OK;
+}
+
+/*  Handle siblings as a list,
+    Do children by recursing.
+    Effectively this is walking the tree preorder.
+
+    This dealloc's any die passed to it, so the
+    caller should not do that dealloc.
+    It seems more logical to have the one causing
+    the alloc to do the dealloc, but that way this
+    routine became a mess.
+*/
+static int
+do_this_die_and_dealloc(Dwarf_Debug dbg, Dwarf_Die die, int *errval)
+{
+
+    Dwarf_Die prevdie = 0;
+    Dwarf_Die newdie = die;
+    Dwarf_Error err = 0;
+    int res = 0;
+    int sibres = DW_DLV_OK;
+    int tres = DW_DLV_OK;
+    Dwarf_Die sibdie;
+
+    while (sibres == DW_DLV_OK) {
+        Dwarf_Die ch_die;
+
+
+        res = process_this_die_attrs(dbg, newdie, errval);
+        switch (res) {
+        case DW_DLV_OK:
+            break;
+        case DW_DLV_NO_ENTRY:
+            break;
+        default:
+        case DW_DLV_ERROR:
+            if (prevdie) {
+                dwarf_dealloc(dbg, prevdie, DW_DLA_DIE);
+                prevdie = 0;
+            }
+            return DW_DLV_ERROR;
+        }
+
+        tres = dwarf_child(newdie, &ch_die, &err);
+
+        if (tres == DW_DLV_OK) {
+            res = do_this_die_and_dealloc(dbg, ch_die, errval);
+            switch (res) {
+            case DW_DLV_OK:
+                break;
+            case DW_DLV_NO_ENTRY:
+                break;
+            default:
+            case DW_DLV_ERROR:
+                if (prevdie) {
+                    dwarf_dealloc(dbg, prevdie, DW_DLA_DIE);
+                    prevdie = 0;
+                }
+                return DW_DLV_ERROR;
+            }
+        } else if (tres == DW_DLV_ERROR) {
+            /* An error! */
+            *errval = (int) dwarf_errno(err);
+            if (prevdie) {
+                dwarf_dealloc(dbg, prevdie, DW_DLA_DIE);
+                prevdie = 0;
+            }
+            dwarf_dealloc(dbg, err, DW_DLA_ERROR);
+            return DW_DLV_ERROR;
+        }  /* else was NO ENTRY */
+        prevdie = newdie;
+        sibdie = 0;
+        sibres = dwarf_siblingof(dbg, newdie, &sibdie, &err);
+        if (prevdie) {
+            dwarf_dealloc(dbg, prevdie, DW_DLA_DIE);
+            prevdie = 0;
+        }
+        newdie = sibdie;
+
+    }
+    if (sibres == DW_DLV_NO_ENTRY) {
+        return DW_DLV_OK;
+    }
+    /* error. */
+    *errval = (int) dwarf_errno(err);
+    if (prevdie) {
+        dwarf_dealloc(dbg, prevdie, DW_DLA_DIE);
+        prevdie = 0;
+    }
+    dwarf_dealloc(dbg, err, DW_DLA_ERROR);
+    return DW_DLV_ERROR;
+
+}
+
+
+static int
+handle_debug_frame(Dwarf_Debug dbg, Dwarf_addr_callback_func cb_func,
+    int *errval)
+{
+    int retval = DW_DLV_OK;
+    int res;
+    Dwarf_Error err;
+    Dwarf_Addr *addrlist;
+    Dwarf_Off *offsetlist;
+    Dwarf_Signed count;
+    int i;
+
+    res =
+        _dwarf_frame_address_offsets(dbg, &addrlist, &offsetlist,
+            &count, &err);
+    if (res == DW_DLV_OK) {
+        for (i = 0; i < count; i++) {
+            cb_func(DW_SECTION_FRAME, offsetlist[i], addrlist[i]);
+        }
+        dwarf_dealloc(dbg, offsetlist, DW_DLA_ADDR);
+        dwarf_dealloc(dbg, addrlist, DW_DLA_ADDR);
+    } else if (res == DW_DLV_NO_ENTRY) {
+        retval = res;
+    } else {
+        *errval = (int) dwarf_errno(err);
+        retval = DW_DLV_ERROR;
+    }
+    return retval;
+
+}
+static int
+handle_debug_aranges(Dwarf_Debug dbg, Dwarf_addr_callback_func cb_func,
+    int *errval)
+{
+    int retval = DW_DLV_OK;
+    Dwarf_Error err;
+    Dwarf_Addr *aranges;
+    Dwarf_Signed count;
+    int indx;
+    Dwarf_Off *offsets;
+
+    retval =
+        _dwarf_get_aranges_addr_offsets(dbg, &aranges, &offsets, &count,
+            &err);
+    if (retval == DW_DLV_OK) {
+        if (count == 0) {
+            retval = DW_DLV_NO_ENTRY;
+        } else {
+            for (indx = 0; indx < count; indx++) {
+                cb_func(DW_SECTION_ARANGES, offsets[indx],
+                    aranges[indx]);
+            }
+        }
+        dwarf_dealloc(dbg, aranges, DW_DLA_ADDR);
+        dwarf_dealloc(dbg, offsets, DW_DLA_ADDR);
+    } else if (retval == DW_DLV_NO_ENTRY) {
+        ; /* do nothing */
+    } else {
+        *errval = (int) dwarf_errno(err);
+        retval = DW_DLV_ERROR;
+    }
+    return retval;
+}
+static int
+handle_debug_line(Dwarf_Debug dbg, Dwarf_Die cu_die,
+    Dwarf_addr_callback_func cb_func, int *errval)
+{
+    int retval = DW_DLV_OK;
+    int res;
+    Dwarf_Error err;
+    Dwarf_Addr *addrlist;
+    Dwarf_Off *offsetlist;
+    Dwarf_Unsigned count;
+    Dwarf_Unsigned i;
+
+    res =
+        _dwarf_line_address_offsets(dbg, cu_die, &addrlist, &offsetlist,
+            &count, &err);
+    if (res == DW_DLV_OK) {
+        for (i = 0; i < count; i++) {
+            cb_func(DW_SECTION_LINE, offsetlist[i], addrlist[i]);
+
+        }
+        dwarf_dealloc(dbg, offsetlist, DW_DLA_ADDR);
+        dwarf_dealloc(dbg, addrlist, DW_DLA_ADDR);
+    } else if (res == DW_DLV_NO_ENTRY) {
+        retval = res;
+    } else {
+        *errval = (int) dwarf_errno(err);
+        retval = DW_DLV_ERROR;
+    }
+    return retval;
+}
+
+/*  We need to add support for this. Currently we do not
+    generate this section.
+    FIX!
+*/
+static int
+handle_debug_loc(void)
+{
+    int retval = DW_DLV_NO_ENTRY;
+
+    return retval;
+}