rdwarf 0.0.1

data/ext/rdwarf/libdwarf/dwarf_frame3.c

@@ -0,0 +1,282 @@
+/*
+
+  Copyright (C) 2000-2006 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 <stdlib.h>
+#include "dwarf_frame.h"
+#include "dwarf_arange.h" /* using Arange as a way to build a list */
+
+/*  Used by rqs (an IRIX application).
+    Not needed except for that one application.
+    Should be moved to its own source file since
+    it is so rarely needed.
+    Returns DW_DLV_OK if returns the arrays.
+    Returns DW_DLV_NO_ENTRY if no section. ?? (How do I tell?)
+    Returns DW_DLV_ERROR if there is an error.
+
+    Uses DW_FRAME_CFA_COL because IRIX is only DWARF2
+    and that is what IRIX compilers and compatible
+    compilers support on IRIX.
+*/
+int
+_dwarf_frame_address_offsets(Dwarf_Debug dbg, Dwarf_Addr ** addrlist,
+    Dwarf_Off ** offsetlist,
+    Dwarf_Signed * returncount,
+    Dwarf_Error * err)
+{
+    int retval = DW_DLV_OK;
+    int res = DW_DLV_ERROR;
+    Dwarf_Cie *cie_data = 0;
+    Dwarf_Signed cie_count = 0;
+    Dwarf_Fde *fde_data = 0;
+    Dwarf_Signed fde_count = 0;
+    Dwarf_Signed i = 0;
+    Dwarf_Unsigned u = 0;
+    Dwarf_Frame_Op *frame_inst = 0;
+    Dwarf_Fde fdep = 0;
+    Dwarf_Cie ciep = 0;
+    Dwarf_Chain curr_chain = 0;
+    Dwarf_Chain head_chain = 0;
+    Dwarf_Chain prev_chain = 0;
+    Dwarf_Arange arange = 0;
+    Dwarf_Unsigned arange_count = 0;
+    Dwarf_Addr *arange_addrs = 0;
+    Dwarf_Off *arange_offsets = 0;
+
+    res = dwarf_get_fde_list(dbg, &cie_data, &cie_count,
+        &fde_data, &fde_count, err);
+    if (res != DW_DLV_OK) {
+        return res;
+    }
+
+    res = _dwarf_load_section(dbg, &dbg->de_debug_frame, err);
+    if (res != DW_DLV_OK) {
+        return res;
+    }
+    if (!dbg->de_debug_frame.dss_size) {
+        return (DW_DLV_NO_ENTRY);
+    }
+
+    for (i = 0; i < cie_count; i++) {
+        Dwarf_Off instoff = 0;
+        Dwarf_Signed initial_instructions_length = 0;
+        Dwarf_Small *instr_end = 0;
+        Dwarf_Sword icount = 0;
+        int j = 0;
+        int dw_err;
+
+        ciep = cie_data[i];
+        instoff = ciep->ci_cie_instr_start - dbg->de_debug_frame.dss_data;
+        initial_instructions_length = ciep->ci_length +
+            ciep->ci_length_size + ciep->ci_extension_size -
+            (ciep->ci_cie_instr_start - ciep->ci_cie_start);
+        instr_end = ciep->ci_cie_instr_start +
+            initial_instructions_length;
+        res = _dwarf_exec_frame_instr( /* make_instr */ true,
+            &frame_inst,
+            /* search_pc= */ false,
+            /* search_pc_val= */ 0,
+            /* location */ 0,
+            ciep->ci_cie_instr_start,
+            instr_end,
+            /* Dwarf_frame= */ 0,
+            /* cie= */ 0,
+            dbg,
+            DW_FRAME_CFA_COL,
+            &icount, &dw_err);
+        if (res == DW_DLV_ERROR) {
+            _dwarf_error(dbg, err, dw_err);
+            return (res);
+        } else if (res == DW_DLV_NO_ENTRY) {
+            continue;
+        }
+
+        for (j = 0; j < icount; ++j) {
+            Dwarf_Frame_Op *finst = frame_inst + j;
+
+            if (finst->fp_base_op == 0 && finst->fp_extended_op == 1) {
+                /* is DW_CFA_set_loc */
+                Dwarf_Addr add = (Dwarf_Addr) finst->fp_offset;
+                Dwarf_Off off = finst->fp_instr_offset + instoff;
+
+                arange = (Dwarf_Arange)
+                    _dwarf_get_alloc(dbg, DW_DLA_ARANGE, 1);
+                if (arange == NULL) {
+                    _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);
+                    return (DW_DLV_ERROR);
+                }
+                arange->ar_address = add;
+                arange->ar_info_offset = off;
+                arange_count++;
+                curr_chain = (Dwarf_Chain)
+                    _dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);
+                if (curr_chain == NULL) {
+                    _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);
+                    return (DW_DLV_ERROR);
+                }
+                curr_chain->ch_item = arange;
+                if (head_chain == NULL)
+                    head_chain = prev_chain = curr_chain;
+                else {
+                    prev_chain->ch_next = curr_chain;
+                    prev_chain = curr_chain;
+                }
+            }
+        }
+        dwarf_dealloc(dbg, frame_inst, DW_DLA_FRAME_BLOCK);
+
+    }
+    for (i = 0; i < fde_count; i++) {
+        Dwarf_Small *instr_end = 0;
+        Dwarf_Sword icount = 0;
+        Dwarf_Signed instructions_length = 0;
+        Dwarf_Off instoff = 0;
+        Dwarf_Off off = 0;
+        Dwarf_Addr addr = 0;
+        int j = 0;
+        int dw_err;
+
+        fdep = fde_data[i];
+        off = fdep->fd_initial_loc_pos - dbg->de_debug_frame.dss_data;
+        addr = fdep->fd_initial_location;
+        arange = (Dwarf_Arange)
+            _dwarf_get_alloc(dbg, DW_DLA_ARANGE, 1);
+        if (arange == NULL) {
+            _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);
+            return (DW_DLV_ERROR);
+        }
+        arange->ar_address = addr;
+        arange->ar_info_offset = off;
+        arange_count++;
+        curr_chain = (Dwarf_Chain)
+            _dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);
+        if (curr_chain == NULL) {
+            _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);
+            return (DW_DLV_ERROR);
+        }
+        curr_chain->ch_item = arange;
+        if (head_chain == NULL)
+            head_chain = prev_chain = curr_chain;
+        else {
+            prev_chain->ch_next = curr_chain;
+            prev_chain = curr_chain;
+        }
+
+
+        instoff = fdep->fd_fde_instr_start - dbg->de_debug_frame.dss_data;
+        instructions_length = fdep->fd_length +
+            fdep->fd_length_size + fdep->fd_extension_size -
+            (fdep->fd_fde_instr_start - fdep->fd_fde_start);
+        instr_end = fdep->fd_fde_instr_start + instructions_length;
+        res = _dwarf_exec_frame_instr( /* make_instr */ true,
+            &frame_inst,
+            /* search_pc= */ false,
+            /* search_pc_val= */ 0,
+            /* location */ 0,
+            fdep->fd_fde_instr_start,
+            instr_end,
+            /* Dwarf_frame= */ 0,
+            /* cie= */ 0,
+            dbg,
+            DW_FRAME_CFA_COL,
+            &icount, &dw_err);
+        if (res == DW_DLV_ERROR) {
+            _dwarf_error(dbg, err, dw_err);
+            return (res);
+        } else if (res == DW_DLV_NO_ENTRY) {
+            continue;
+        }
+
+        for (j = 0; j < icount; ++j) {
+            Dwarf_Frame_Op *finst2 = frame_inst + j;
+
+            if (finst2->fp_base_op == 0 && finst2->fp_extended_op == 1) {
+                /* is DW_CFA_set_loc */
+                Dwarf_Addr add = (Dwarf_Addr) finst2->fp_offset;
+                Dwarf_Off off2 = finst2->fp_instr_offset + instoff;
+
+                arange = (Dwarf_Arange)
+                    _dwarf_get_alloc(dbg, DW_DLA_ARANGE, 1);
+                if (arange == NULL) {
+                    _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);
+                    return (DW_DLV_ERROR);
+                }
+                arange->ar_address = add;
+                arange->ar_info_offset = off2;
+                arange_count++;
+                curr_chain = (Dwarf_Chain)
+                    _dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);
+                if (curr_chain == NULL) {
+                    _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);
+                    return (DW_DLV_ERROR);
+                }
+                curr_chain->ch_item = arange;
+                if (head_chain == NULL)
+                    head_chain = prev_chain = curr_chain;
+                else {
+                    prev_chain->ch_next = curr_chain;
+                    prev_chain = curr_chain;
+                }
+
+            }
+        }
+        dwarf_dealloc(dbg, frame_inst, DW_DLA_FRAME_BLOCK);
+
+    }
+    dwarf_dealloc(dbg, fde_data, DW_DLA_LIST);
+    dwarf_dealloc(dbg, cie_data, DW_DLA_LIST);
+    arange_addrs = (Dwarf_Addr *)
+        _dwarf_get_alloc(dbg, DW_DLA_ADDR, arange_count);
+    if (arange_addrs == NULL) {
+        _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);
+        return (DW_DLV_ERROR);
+    }
+    arange_offsets = (Dwarf_Off *)
+        _dwarf_get_alloc(dbg, DW_DLA_ADDR, arange_count);
+    if (arange_offsets == NULL) {
+        _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);
+        return (DW_DLV_ERROR);
+    }
+
+    curr_chain = head_chain;
+    for (u = 0; u < arange_count; u++) {
+        Dwarf_Arange ar = curr_chain->ch_item;
+
+        arange_addrs[u] = ar->ar_address;
+        arange_offsets[u] = ar->ar_info_offset;
+        prev_chain = curr_chain;
+        curr_chain = curr_chain->ch_next;
+        dwarf_dealloc(dbg, ar, DW_DLA_ARANGE);
+        dwarf_dealloc(dbg, prev_chain, DW_DLA_CHAIN);
+    }
+    *returncount = arange_count;
+    *offsetlist = arange_offsets;
+    *addrlist = arange_addrs;
+    return retval;
+}

data/ext/rdwarf/libdwarf/dwarf_funcs.c

@@ -0,0 +1,123 @@
+/*
+
+  Copyright (C) 2000-2005 Silicon Graphics, Inc.  All Rights Reserved.
+  Portions Copyright (C) 2009-2010 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_funcs.h"
+#include "dwarf_global.h"
+
+int
+dwarf_get_funcs(Dwarf_Debug dbg,
+    Dwarf_Func ** funcs,
+    Dwarf_Signed * ret_func_count, Dwarf_Error * error)
+{
+    int res = _dwarf_load_section(dbg, &dbg->de_debug_funcnames,error);
+    if (res != DW_DLV_OK) {
+        return res;
+    }
+    if (!dbg->de_debug_funcnames.dss_size) {
+        return (DW_DLV_NO_ENTRY);
+    }
+
+
+    return _dwarf_internal_get_pubnames_like_data(dbg,
+        dbg->de_debug_funcnames.dss_data,
+        dbg->de_debug_funcnames.dss_size,
+        (Dwarf_Global **) funcs, /* Type punning for sections with identical format. */
+        ret_func_count,
+        error,
+        DW_DLA_FUNC_CONTEXT,
+        DW_DLA_FUNC,
+        DW_DLE_DEBUG_FUNCNAMES_LENGTH_BAD,
+        DW_DLE_DEBUG_FUNCNAMES_VERSION_ERROR);
+}
+
+/* Deallocating fully requires deallocating the list
+   and all entries.  But some internal data is
+   not exposed, so we need a function with internal knowledge.
+*/
+
+void
+dwarf_funcs_dealloc(Dwarf_Debug dbg, Dwarf_Func * dwgl,
+    Dwarf_Signed count)
+{
+    _dwarf_internal_globals_dealloc(dbg, (Dwarf_Global *) dwgl,
+        count,
+        DW_DLA_FUNC_CONTEXT,
+        DW_DLA_FUNC, DW_DLA_LIST);
+    return;
+}
+
+
+
+int
+dwarf_funcname(Dwarf_Func func_in, char **ret_name, Dwarf_Error * error)
+{
+    Dwarf_Global func = (Dwarf_Global) func_in;
+
+    if (func == NULL) {
+        _dwarf_error(NULL, error, DW_DLE_FUNC_NULL);
+        return (DW_DLV_ERROR);
+    }
+
+    *ret_name = (char *) (func->gl_name);
+    return DW_DLV_OK;
+}
+
+int
+dwarf_func_die_offset(Dwarf_Func func_in,
+    Dwarf_Off * return_offset, Dwarf_Error * error)
+{
+    Dwarf_Global func = (Dwarf_Global) func_in;
+
+    return dwarf_global_die_offset(func, return_offset, error);
+}
+
+
+int
+dwarf_func_cu_offset(Dwarf_Func func_in,
+    Dwarf_Off * return_offset, Dwarf_Error * error)
+{
+    Dwarf_Global func = (Dwarf_Global) func_in;
+
+    return dwarf_global_cu_offset(func, return_offset, error);
+}
+
+
+int
+dwarf_func_name_offsets(Dwarf_Func func_in,
+    char **ret_func_name,
+    Dwarf_Off * die_offset,
+    Dwarf_Off * cu_die_offset, Dwarf_Error * error)
+{
+    Dwarf_Global func = (Dwarf_Global) func_in;
+
+    return dwarf_global_name_offsets(func,
+        ret_func_name,
+        die_offset, cu_die_offset, error);
+}

data/ext/rdwarf/libdwarf/dwarf_funcs.h

@@ -0,0 +1,33 @@
+/*
+
+  Copyright (C) 2000, 2004 Silicon Graphics, Inc.  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.
+
+*/
+
+
+
+
+typedef struct Dwarf_Func_Context_s *Dwarf_Func_Context;
+
+
+/* struct  never completed: see dwarf_global.h */

data/ext/rdwarf/libdwarf/dwarf_gdbindex.c

@@ -0,0 +1,520 @@
+/*
+
+  Copyright (C) 2014-2014 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 <stdlib.h>
+#include "dwarf_gdbindex.h"
+
+#define TRUE 1
+#define FALSE 0
+
+/*  The dwarf_util macro READ_UNALIGNED
+    cannot be directly used because
+    gdb defines the section contents of
+    .gdb_index as little-endian always.
+*/
+
+#if WORDS_BIGENDIAN   /* meaning on this host */
+#define READ_GDBINDEX(dest,desttype, source, length)                     \
+    do {                                                                 \
+        BIGGEST_UINT _ltmp = 0;                                          \
+        _dwarf_memcpy_swap_bytes((((char *)(&_ltmp)) + sizeof(_ltmp) - length), \
+            source, length) ;                                            \
+        dest = (desttype)_ltmp;                                          \
+    } while (0)
+#else /* little-endian on this host */
+#define READ_GDBINDEX(dest,desttype, source, length)                     \
+    do {                                                                 \
+        BIGGEST_UINT _ltmp = 0;                                          \
+        memcpy(((char *)(&_ltmp)) ,            \
+            source, length) ;                                            \
+        dest = (desttype)_ltmp;                                          \
+    } while (0)
+
+#endif
+
+
+struct gi_fileheader_s {
+    gdbindex_offset_type headerval[6];
+};
+
+struct dwarf_64bitpair {
+    gdbindex_64 offset;
+    gdbindex_64 length;
+};
+
+static int
+set_base(Dwarf_Debug dbg,
+    struct Dwarf_Gdbindex_array_instance_s * hdr,
+    Dwarf_Small *start,
+    Dwarf_Small *end,
+    /* entrylen is the length of a single struct as seen in the object. */
+    Dwarf_Unsigned entrylen,
+    /* The size of each field in the struct in the object. */
+    Dwarf_Unsigned fieldlen,
+    enum gdbindex_type_e type,
+    Dwarf_Error * err)
+{
+
+    if (type == git_std || type == git_cuvec) {
+        /*  cuvec is sort of a fake as a simple
+            section, but a useful one. */
+        Dwarf_Unsigned count = 0;
+        if( end < start) {
+            _dwarf_error(dbg, err,DW_DLE_GDB_INDEX_COUNT_ERROR);
+            return DW_DLV_ERROR;
+        }
+        count = end - start;
+        count = count / entrylen;
+        hdr->dg_type = type;
+        hdr->dg_base = start;
+        hdr->dg_count = count;
+        hdr->dg_entry_length = entrylen;
+        hdr->dg_fieldlen = fieldlen;
+    } else {
+        /* address area. */
+        /* 64bit, 64bit, offset. Then 32bit pad. */
+        Dwarf_Unsigned count = 0;
+        hdr->dg_base = start;
+        if( end < start) {
+            _dwarf_error(dbg, err,DW_DLE_GDB_INDEX_COUNT_ADDR_ERROR);
+            return DW_DLV_ERROR;
+        }
+        /* entry length includes pad. */
+        hdr->dg_entry_length = 2*sizeof(gdbindex_64) +
+            sizeof(gdbindex_offset_type);
+        count = end - start;
+        count = count / hdr->dg_entry_length;
+        hdr->dg_count = count;
+        /*  The dg_fieldlen is a fake, the fields are not
+            all the same length. */
+        hdr->dg_fieldlen = sizeof(gdbindex_offset_type);
+        hdr->dg_type = type;
+    }
+    return DW_DLV_OK;
+}
+
+int
+dwarf_gdbindex_header(Dwarf_Debug dbg,
+    Dwarf_Gdbindex * gdbindexptr,
+    Dwarf_Unsigned * version,
+    Dwarf_Unsigned * cu_list_offset,
+    Dwarf_Unsigned * types_cu_list_offset,
+    Dwarf_Unsigned * address_area_offset,
+    Dwarf_Unsigned * symbol_table_offset,
+    Dwarf_Unsigned * constant_pool_offset,
+    Dwarf_Unsigned * section_size,
+    Dwarf_Unsigned * unused_reserved,
+    const char    ** section_name,
+    Dwarf_Error    * error)
+{
+
+    struct gi_fileheader_s header;
+    Dwarf_Gdbindex indexptr = 0;
+    int res = DW_DLV_ERROR;
+
+    if (!dbg->de_debug_gdbindex.dss_size) {
+        return DW_DLV_NO_ENTRY;
+    }
+    if (!dbg->de_debug_gdbindex.dss_data) {
+        res = _dwarf_load_section(dbg, &dbg->de_debug_gdbindex,error);
+        if (res != DW_DLV_OK) {
+            return res;
+        }
+    }
+
+    if (dbg->de_debug_gdbindex.dss_size < sizeof(struct gi_fileheader_s) ) {
+        _dwarf_error(dbg, error, DW_DLE_ERRONEOUS_GDB_INDEX_SECTION);
+        return (DW_DLV_ERROR);
+    }
+    memcpy(&header,dbg->de_debug_gdbindex.dss_data,
+        sizeof(struct gi_fileheader_s));
+    indexptr = (Dwarf_Gdbindex)_dwarf_get_alloc(dbg,DW_DLA_GDBINDEX,1);
+    if (indexptr == NULL) {
+        _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+        return (DW_DLV_ERROR);
+    }
+
+    indexptr->gi_dbg = dbg;
+    indexptr->gi_section_data = dbg->de_debug_gdbindex.dss_data;
+    indexptr->gi_section_length = dbg->de_debug_gdbindex.dss_size;
+    READ_GDBINDEX(indexptr->gi_version ,Dwarf_Unsigned,
+        dbg->de_debug_gdbindex.dss_data,
+        sizeof(gdbindex_offset_type));
+    READ_GDBINDEX(indexptr->gi_cu_list_offset ,Dwarf_Unsigned,
+        dbg->de_debug_gdbindex.dss_data + sizeof(gdbindex_offset_type),
+        sizeof(gdbindex_offset_type));
+    READ_GDBINDEX(indexptr->gi_types_cu_list_offset ,Dwarf_Unsigned,
+        dbg->de_debug_gdbindex.dss_data + 2*sizeof(gdbindex_offset_type),
+        sizeof(gdbindex_offset_type));
+    READ_GDBINDEX(indexptr->gi_address_area_offset ,Dwarf_Unsigned,
+        dbg->de_debug_gdbindex.dss_data + 3*sizeof(gdbindex_offset_type),
+        sizeof(gdbindex_offset_type));
+    READ_GDBINDEX(indexptr->gi_symbol_table_offset ,Dwarf_Unsigned,
+        dbg->de_debug_gdbindex.dss_data + 4*sizeof(gdbindex_offset_type),
+        sizeof(gdbindex_offset_type));
+    READ_GDBINDEX(indexptr->gi_constant_pool_offset ,Dwarf_Unsigned,
+        dbg->de_debug_gdbindex.dss_data + 5*sizeof(gdbindex_offset_type),
+        sizeof(gdbindex_offset_type));
+
+    res = set_base(dbg,&indexptr->gi_culisthdr,
+        dbg->de_debug_gdbindex.dss_data + indexptr->gi_cu_list_offset,
+        dbg->de_debug_gdbindex.dss_data + indexptr->gi_types_cu_list_offset,
+        2*sizeof(gdbindex_64),
+        sizeof(gdbindex_64),
+        git_std,error);
+    res = set_base(dbg,&indexptr->gi_typesculisthdr,
+        dbg->de_debug_gdbindex.dss_data + indexptr->gi_types_cu_list_offset,
+        dbg->de_debug_gdbindex.dss_data + indexptr->gi_address_area_offset,
+        3*sizeof(gdbindex_64),
+        sizeof(gdbindex_64),
+        git_std,error);
+    res = set_base(dbg,&indexptr->gi_addressareahdr,
+        dbg->de_debug_gdbindex.dss_data + indexptr->gi_address_area_offset,
+        dbg->de_debug_gdbindex.dss_data + indexptr->gi_symbol_table_offset,
+        3*sizeof(gdbindex_64),
+        sizeof(gdbindex_64),
+        git_address,error);
+    res = set_base(dbg,&indexptr->gi_symboltablehdr,
+        dbg->de_debug_gdbindex.dss_data + indexptr->gi_symbol_table_offset,
+        dbg->de_debug_gdbindex.dss_data + indexptr->gi_constant_pool_offset,
+        2*sizeof(gdbindex_offset_type),
+        sizeof(gdbindex_offset_type),
+        git_std,error);
+    res = set_base(dbg,&indexptr->gi_cuvectorhdr,
+        dbg->de_debug_gdbindex.dss_data + indexptr->gi_constant_pool_offset,
+        /*  There is no real single vector size.
+            but we'll use the entire rest as if there was. */
+        dbg->de_debug_gdbindex.dss_data + indexptr->gi_section_length,
+        sizeof(gdbindex_offset_type),
+        sizeof(gdbindex_offset_type),
+        git_cuvec,error);
+
+    /* Really just pointing to constant pool area. */
+    indexptr->gi_string_pool = dbg->de_debug_gdbindex.dss_data +
+        indexptr->gi_constant_pool_offset;
+
+    *gdbindexptr          = indexptr;
+    *version              = indexptr->gi_version;
+    *cu_list_offset       = indexptr->gi_cu_list_offset;
+    *types_cu_list_offset = indexptr->gi_types_cu_list_offset;
+    *address_area_offset  = indexptr->gi_address_area_offset;
+    *symbol_table_offset  = indexptr->gi_symbol_table_offset;
+    *constant_pool_offset = indexptr->gi_constant_pool_offset;
+    *section_size         = indexptr->gi_section_length;
+    *unused_reserved = 0;
+    *section_name  =        dbg->de_debug_gdbindex.dss_name;
+
+    return DW_DLV_OK;
+
+
+}
+
+
+int
+dwarf_gdbindex_culist_array(Dwarf_Gdbindex gdbindexptr,
+    Dwarf_Unsigned       * list_length,
+    Dwarf_Error          * error)
+{
+    *list_length = gdbindexptr->gi_culisthdr.dg_count;
+    return DW_DLV_OK;
+}
+
+/*  entryindex: 0 to list_length-1 */
+int
+dwarf_gdbindex_culist_entry(Dwarf_Gdbindex gdbindexptr,
+    Dwarf_Unsigned   entryindex,
+    Dwarf_Unsigned * cu_offset,
+    Dwarf_Unsigned * cu_length,
+    Dwarf_Error    * error)
+{
+    Dwarf_Unsigned max =  gdbindexptr->gi_culisthdr.dg_count;
+    Dwarf_Small * base = 0;
+    Dwarf_Unsigned offset = 0;
+    Dwarf_Unsigned length = 0;
+    unsigned fieldlen = gdbindexptr->gi_culisthdr.dg_fieldlen;
+
+    if (entryindex >= max) {
+        _dwarf_error(gdbindexptr->gi_dbg, error,DW_DLE_GDB_INDEX_INDEX_ERROR);
+        return DW_DLV_ERROR;
+    }
+    base = gdbindexptr->gi_culisthdr.dg_base;
+    base += entryindex*gdbindexptr->gi_culisthdr.dg_entry_length;
+
+    READ_GDBINDEX(offset ,Dwarf_Unsigned,
+        base,
+        fieldlen);
+    READ_GDBINDEX(length ,Dwarf_Unsigned,
+        base+ fieldlen,
+        fieldlen);
+    *cu_offset = offset;
+    *cu_length = length;
+    return DW_DLV_OK;
+}
+
+int
+dwarf_gdbindex_types_culist_array(Dwarf_Gdbindex gdbindexptr,
+    Dwarf_Unsigned       * list_length,
+    Dwarf_Error          * error)
+{
+    *list_length = gdbindexptr->gi_typesculisthdr.dg_count;
+    return DW_DLV_OK;
+}
+
+/*  entryindex: 0 to list_length-1 */
+int
+dwarf_gdbindex_types_culist_entry(Dwarf_Gdbindex gdbindexptr,
+    Dwarf_Unsigned   entryindex,
+    Dwarf_Unsigned * t_offset,
+    Dwarf_Unsigned * t_length,
+    Dwarf_Unsigned * t_signature,
+    Dwarf_Error    * error)
+{
+    Dwarf_Unsigned max =  gdbindexptr->gi_typesculisthdr.dg_count;
+    Dwarf_Small * base = 0;
+    Dwarf_Unsigned offset = 0;
+    Dwarf_Unsigned length = 0;
+    Dwarf_Unsigned signature = 0;
+    unsigned fieldlen = gdbindexptr->gi_typesculisthdr.dg_fieldlen;
+
+    if (entryindex >= max) {
+        _dwarf_error(gdbindexptr->gi_dbg, error,DW_DLE_GDB_INDEX_INDEX_ERROR);
+        return DW_DLV_ERROR;
+    }
+    base = gdbindexptr->gi_typesculisthdr.dg_base;
+    base += entryindex*gdbindexptr->gi_typesculisthdr.dg_entry_length;
+
+    READ_GDBINDEX(offset ,Dwarf_Unsigned,
+        base,
+        fieldlen);
+    READ_GDBINDEX(length ,Dwarf_Unsigned,
+        base+ (1*fieldlen),
+        fieldlen);
+    READ_GDBINDEX(signature ,Dwarf_Unsigned,
+        base+ (2*fieldlen),
+        fieldlen);
+    *t_offset = offset;
+    *t_length = length;
+    *t_signature = signature;
+    return DW_DLV_OK;
+}
+
+int
+dwarf_gdbindex_addressarea(Dwarf_Gdbindex gdbindexptr,
+    Dwarf_Unsigned            * list_length,
+    Dwarf_Error               * error)
+{
+    *list_length = gdbindexptr->gi_addressareahdr.dg_count;
+    return DW_DLV_OK;
+}
+
+/*    entryindex: 0 to addressarea_list_length-1 */
+int
+dwarf_gdbindex_addressarea_entry(
+    Dwarf_Gdbindex   gdbindexptr,
+    Dwarf_Unsigned   entryindex,
+    Dwarf_Unsigned * low_address,
+    Dwarf_Unsigned * high_address,
+    Dwarf_Unsigned * cu_index,
+    Dwarf_Error    * error)
+{
+    Dwarf_Unsigned max =  gdbindexptr->gi_addressareahdr.dg_count;
+    Dwarf_Small * base = 0;
+    Dwarf_Unsigned lowaddr = 0;
+    Dwarf_Unsigned highaddr = 0;
+    Dwarf_Unsigned cuindex = 0;
+
+    if (entryindex >= max) {
+        _dwarf_error(gdbindexptr->gi_dbg, error,DW_DLE_GDB_INDEX_INDEX_ERROR);
+        return DW_DLV_ERROR;
+    }
+    base = gdbindexptr->gi_addressareahdr.dg_base;
+    base += entryindex*gdbindexptr->gi_addressareahdr.dg_entry_length;
+
+    READ_GDBINDEX(lowaddr ,Dwarf_Unsigned,
+        base,
+        sizeof(gdbindex_64));
+    READ_GDBINDEX(highaddr ,Dwarf_Unsigned,
+        base+ (1*sizeof(gdbindex_64)),
+        sizeof(gdbindex_64));
+    READ_GDBINDEX(cuindex ,Dwarf_Unsigned,
+        base+ (2*sizeof(gdbindex_64)),
+        sizeof(gdbindex_offset_type));
+    *low_address = lowaddr;
+    *high_address = highaddr;
+    *cu_index = cuindex;
+    return DW_DLV_OK;
+}
+
+int
+dwarf_gdbindex_symboltable_array(Dwarf_Gdbindex gdbindexptr,
+    Dwarf_Unsigned            * list_length,
+    Dwarf_Error               * error)
+{
+    *list_length = gdbindexptr->gi_symboltablehdr.dg_count;
+    return DW_DLV_OK;
+}
+
+/*  entryindex: 0 to symtab_list_length-1 */
+int
+dwarf_gdbindex_symboltable_entry(
+    Dwarf_Gdbindex   gdbindexptr,
+    Dwarf_Unsigned   entryindex,
+    Dwarf_Unsigned * string_offset,
+    Dwarf_Unsigned * cu_vector_offset,
+    Dwarf_Error    * error)
+{
+    Dwarf_Unsigned max =  gdbindexptr->gi_symboltablehdr.dg_count;
+    Dwarf_Small * base = 0;
+    Dwarf_Unsigned symoffset = 0;
+    Dwarf_Unsigned cuoffset = 0;
+    unsigned fieldlen = gdbindexptr->gi_symboltablehdr.dg_fieldlen;
+
+    if (entryindex >= max) {
+        _dwarf_error(gdbindexptr->gi_dbg, error,DW_DLE_GDB_INDEX_INDEX_ERROR);
+        return DW_DLV_ERROR;
+    }
+    base = gdbindexptr->gi_symboltablehdr.dg_base;
+    base += entryindex*gdbindexptr->gi_symboltablehdr.dg_entry_length;
+
+    READ_GDBINDEX(symoffset ,Dwarf_Unsigned,
+        base,
+        fieldlen);
+    READ_GDBINDEX(cuoffset ,Dwarf_Unsigned,
+        base + fieldlen,
+        fieldlen);
+    *string_offset = symoffset;
+    *cu_vector_offset = cuoffset;
+    return DW_DLV_OK;
+}
+
+int
+dwarf_gdbindex_cuvector_length(Dwarf_Gdbindex gdbindex,
+    Dwarf_Unsigned   cuvector_offset,
+    Dwarf_Unsigned * innercount,
+    Dwarf_Error    * error)
+{
+    Dwarf_Small *base = gdbindex->gi_cuvectorhdr.dg_base;
+    Dwarf_Small *end = gdbindex->gi_section_data + gdbindex->gi_section_length;
+    Dwarf_Unsigned val = 0;
+    unsigned fieldlen =  gdbindex->gi_cuvectorhdr.dg_entry_length;
+
+    base += cuvector_offset;
+    if ((base + fieldlen) >= end) {
+        _dwarf_error(gdbindex->gi_dbg, error,DW_DLE_GDB_INDEX_INDEX_ERROR);
+        return DW_DLV_ERROR;
+    }
+
+    READ_GDBINDEX(val,Dwarf_Unsigned,
+        base,
+        fieldlen);
+    *innercount = val;
+    return DW_DLV_OK;
+}
+
+int
+dwarf_gdbindex_cuvector_inner_attributes(Dwarf_Gdbindex gdbindexptr,
+    Dwarf_Unsigned   cuvector_offset,
+    Dwarf_Unsigned   innerindex,
+    /* The attr_value is a field of bits. For expanded version
+        use  dwarf_gdbindex_instance_expand_value() */
+    Dwarf_Unsigned * attributes,
+    Dwarf_Error    * error)
+{
+    Dwarf_Small *base = gdbindexptr->gi_cuvectorhdr.dg_base;
+    Dwarf_Small *end = gdbindexptr->gi_section_data +
+        gdbindexptr->gi_section_length;
+    Dwarf_Unsigned val = 0;
+    unsigned fieldlen = gdbindexptr->gi_cuvectorhdr.dg_entry_length;
+
+    base += cuvector_offset;
+    if ((base+fieldlen) >= end) {
+        _dwarf_error(gdbindexptr->gi_dbg, error,DW_DLE_GDB_INDEX_INDEX_ERROR);
+        return DW_DLV_ERROR;
+    }
+    base += fieldlen;
+    base += innerindex*fieldlen;
+
+    READ_GDBINDEX(val ,Dwarf_Unsigned,
+        base,
+        fieldlen);
+    *attributes = val;
+    return DW_DLV_OK;
+}
+
+
+int
+dwarf_gdbindex_cuvector_instance_expand_value(Dwarf_Gdbindex gdbindexptr,
+    Dwarf_Unsigned   value,
+    Dwarf_Unsigned * cu_index,
+    Dwarf_Unsigned * reserved1,
+    Dwarf_Unsigned * symbol_kind,
+    Dwarf_Unsigned * is_static,
+    Dwarf_Error    * error)
+{
+    *cu_index =    value         & 0xffffff;
+    *reserved1 =   (value >> 24) & 0xf;
+    *symbol_kind = (value >> 28) & 0x7;
+    *is_static =   (value >> 31) & 1;
+    return DW_DLV_OK;
+}
+
+
+/*  The strings in the pool follow (in memory) the cu index
+    set and are NUL terminated. */
+int
+dwarf_gdbindex_string_by_offset(Dwarf_Gdbindex gdbindexptr,
+    Dwarf_Unsigned   stringoffsetinpool,
+    const char    ** string_ptr,
+    Dwarf_Error   *  error)
+{
+    Dwarf_Small *pooldata = gdbindexptr->gi_section_data +
+        gdbindexptr->gi_constant_pool_offset;
+    Dwarf_Small *section_end = gdbindexptr->gi_section_data +
+        gdbindexptr->gi_section_length;
+
+    Dwarf_Small *stringitself = pooldata + stringoffsetinpool;
+    if (stringitself > section_end) {
+        _dwarf_error(gdbindexptr->gi_dbg, error,DW_DLE_GDB_INDEX_INDEX_ERROR);
+        return DW_DLV_ERROR;
+    }
+    *string_ptr = (const char *)stringitself;
+    return DW_DLV_OK;
+}
+
+
+
+
+void
+dwarf_gdbindex_free(Dwarf_Gdbindex indexptr)
+{
+    if(indexptr) {
+        Dwarf_Debug dbg = indexptr->gi_dbg;
+        dwarf_dealloc(dbg,indexptr,DW_DLA_GDBINDEX);
+    }
+}