rdwarf 0.0.1

data/ext/rdwarf/libdwarf/pro_pubnames.c

@@ -0,0 +1,60 @@
+/*
+
+  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.
+
+*/
+
+#include "config.h"
+#include "libdwarfdefs.h"
+#include <stdio.h>
+#include <string.h>
+#ifdef HAVE_ELFACCESS_H
+#include <elfaccess.h>
+#endif
+#include "pro_incl.h"
+#include "pro_section.h"
+
+
+/*  This function adds another public name to the
+    list of public names for the given Dwarf_P_Debug.
+    It returns 0 on error, and 1 otherwise.  */
+
+Dwarf_Unsigned
+dwarf_add_pubname(Dwarf_P_Debug dbg,
+    Dwarf_P_Die die,
+    char *pubname_name, Dwarf_Error * error)
+{
+    return
+        _dwarf_add_simple_name_entry(dbg, die, pubname_name,
+            dwarf_snk_pubname, error);
+}
+Dwarf_Unsigned
+dwarf_add_pubtype(Dwarf_P_Debug dbg,
+    Dwarf_P_Die die,
+    char *pubtype_name, Dwarf_Error * error)
+{
+    return
+        _dwarf_add_simple_name_entry(dbg, die, pubtype_name,
+            dwarf_snk_pubtype, error);
+}

data/ext/rdwarf/libdwarf/pro_reloc.c

@@ -0,0 +1,253 @@
+/*
+
+  Copyright (C) 2000,2004 Silicon Graphics, Inc.  All Rights Reserved.
+  Portions Copyright 2008-2011 David Anderson, 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.
+
+*/
+
+#include "config.h"
+#include "libdwarfdefs.h"
+#include <stdio.h>
+#include <string.h>
+/*#include <elfaccess.h> */
+#include "pro_incl.h"
+#include "pro_reloc.h"
+
+
+/*  Do initial alloc of newslots slots.
+    Fails only if malloc fails.
+
+    Supposed to be called before any relocs allocated.
+    Ignored if after any allocated.
+
+    Part of an optimization, so that for a known 'newslots'
+    relocations count we can preallocate the right size block.
+    Called from just 2 places.
+
+    returns DW_DLV_OK or  DW_DLV_ERROR
+*/
+int
+_dwarf_pro_pre_alloc_n_reloc_slots(Dwarf_P_Debug dbg,
+    int rel_sec_index,
+    Dwarf_Unsigned newslots)
+{
+    unsigned long len = 0;
+    struct Dwarf_P_Relocation_Block_s *data = 0;
+    Dwarf_P_Per_Reloc_Sect prel = &dbg->de_reloc_sect[rel_sec_index];
+    unsigned long slots_in_blk = (unsigned long) newslots;
+    unsigned long rel_rec_size = dbg->de_relocation_record_size;
+
+    if (prel->pr_first_block)
+        return DW_DLV_OK;       /* do nothing */
+
+    len = sizeof(struct Dwarf_P_Relocation_Block_s) +
+        slots_in_blk * rel_rec_size;
+
+
+    data = (struct Dwarf_P_Relocation_Block_s *)
+        _dwarf_p_get_alloc(dbg, len);
+    if (!data) {
+        return DW_DLV_ERROR;
+    }
+    data->rb_slots_in_block = slots_in_blk;     /* could use default
+        here, as fallback in case our origininal
+        estimate wrong. When we call this we
+        presumably know what we are doing, so
+        keep this count for now */
+    data->rb_next_slot_to_use = 0;
+    data->rb_where_to_add_next =
+        ((char *) data) + sizeof(struct Dwarf_P_Relocation_Block_s);
+    data->rb_data = data->rb_where_to_add_next;
+
+    prel->pr_first_block = data;
+    prel->pr_last_block = data;
+    prel->pr_block_count = 1;
+
+
+    return DW_DLV_OK;
+}
+
+
+/*Do alloc of slots.
+  Fails only if malloc fails.
+
+  Only allocator used.
+
+  returns DW_DLV_OK or  DW_DLV_ERROR
+*/
+int
+_dwarf_pro_alloc_reloc_slots(Dwarf_P_Debug dbg, int rel_sec_index)
+{
+    unsigned long len = 0;
+    struct Dwarf_P_Relocation_Block_s *data = 0;
+    Dwarf_P_Per_Reloc_Sect prel = &dbg->de_reloc_sect[rel_sec_index];
+    unsigned long slots_in_blk = prel->pr_slots_per_block_to_alloc;
+    unsigned long rel_rec_size = dbg->de_relocation_record_size;
+
+    len = sizeof(struct Dwarf_P_Relocation_Block_s) +
+        slots_in_blk * rel_rec_size;
+
+    data = (struct Dwarf_P_Relocation_Block_s *)
+        _dwarf_p_get_alloc(dbg, len);
+    if (!data) {
+        return DW_DLV_ERROR;
+    }
+
+    if (prel->pr_first_block) {
+        prel->pr_last_block->rb_next = data;
+        prel->pr_last_block = data;
+        prel->pr_block_count += 1;
+
+    } else {
+
+        prel->pr_first_block = data;
+        prel->pr_last_block = data;
+        prel->pr_block_count = 1;
+    }
+
+    data->rb_slots_in_block = slots_in_blk;
+    data->rb_next_slot_to_use = 0;
+    data->rb_where_to_add_next =
+        ((char *) data) + sizeof(struct Dwarf_P_Relocation_Block_s);
+    data->rb_data = data->rb_where_to_add_next;
+
+    return DW_DLV_OK;
+
+}
+
+/*  Reserve a slot. return DW_DLV_OK if succeeds.
+
+    Return DW_DLV_ERROR if fails (malloc error).
+
+    Use the relrec_to_fill to pass back a pointer to
+    a slot space to use.  */
+int
+_dwarf_pro_reloc_get_a_slot(Dwarf_P_Debug dbg,
+    int base_sec_index, void **relrec_to_fill)
+{
+    struct Dwarf_P_Relocation_Block_s *data = 0;
+    Dwarf_P_Per_Reloc_Sect prel = &dbg->de_reloc_sect[base_sec_index];
+    unsigned long rel_rec_size = dbg->de_relocation_record_size;
+
+    char *ret_addr = 0;
+
+    data = prel->pr_last_block;
+    if ((data == 0) ||
+        (data->rb_next_slot_to_use >= data->rb_slots_in_block)) {
+        int res;
+
+        res = _dwarf_pro_alloc_reloc_slots(dbg, base_sec_index);
+        if (res != DW_DLV_OK) {
+            return res;
+        }
+    }
+
+    data = prel->pr_last_block;
+    /* now we have an empty slot */
+    ret_addr = data->rb_where_to_add_next;
+
+    data->rb_where_to_add_next += rel_rec_size;
+    data->rb_next_slot_to_use += 1;
+
+    prel->pr_reloc_total_count += 1;
+
+    *relrec_to_fill = (void *) ret_addr;
+
+    return DW_DLV_OK;
+
+}
+
+/*
+   On success  returns count of
+   .rel.* sections that are symbolic
+   thru count_of_relocation_sections.
+
+   On success, returns DW_DLV_OK.
+
+   If this is not a 'symbolic' run, returns
+    DW_DLV_NO_ENTRY.
+
+   No errors are possible.
+
+
+
+
+*/
+
+/*ARGSUSED*/ int
+dwarf_get_relocation_info_count(Dwarf_P_Debug dbg,
+    Dwarf_Unsigned *
+    count_of_relocation_sections,
+    int *drd_buffer_version,
+    Dwarf_Error * error)
+{
+    if (dbg->de_flags & DW_DLC_SYMBOLIC_RELOCATIONS) {
+        int i;
+        unsigned int count = 0;
+
+        for (i = 0; i < NUM_DEBUG_SECTIONS; ++i) {
+            if (dbg->de_reloc_sect[i].pr_reloc_total_count > 0) {
+                ++count;
+            }
+        }
+        *count_of_relocation_sections = (Dwarf_Unsigned) count;
+        *drd_buffer_version = DWARF_DRD_BUFFER_VERSION;
+        return DW_DLV_OK;
+    }
+    return DW_DLV_NO_ENTRY;
+}
+
+int
+dwarf_get_relocation_info(Dwarf_P_Debug dbg,
+    Dwarf_Signed * elf_section_index,
+    Dwarf_Signed * elf_section_index_link,
+    Dwarf_Unsigned * relocation_buffer_count,
+    Dwarf_Relocation_Data * reldata_buffer,
+    Dwarf_Error * error)
+{
+    int next = dbg->de_reloc_next_to_return;
+
+    if (dbg->de_flags & DW_DLC_SYMBOLIC_RELOCATIONS) {
+        int i;
+
+        for (i = next; i < NUM_DEBUG_SECTIONS; ++i) {
+            Dwarf_P_Per_Reloc_Sect prel = &dbg->de_reloc_sect[i];
+
+            if (prel->pr_reloc_total_count > 0) {
+                dbg->de_reloc_next_to_return = i + 1;
+
+
+                /* ASSERT: prel->.pr_block_count == 1 */
+
+                *elf_section_index = prel->pr_sect_num_of_reloc_sect;
+                *elf_section_index_link = dbg->de_elf_sects[i];
+                *relocation_buffer_count = prel->pr_reloc_total_count;
+                *reldata_buffer = (Dwarf_Relocation_Data)
+                    (prel->pr_first_block->rb_data);
+                return DW_DLV_OK;
+            }
+        }
+        DWARF_P_DBG_ERROR(dbg, DW_DLE_REL_ALLOC, DW_DLV_ERROR);
+    }
+    return DW_DLV_NO_ENTRY;
+}

data/ext/rdwarf/libdwarf/pro_reloc.h

@@ -0,0 +1,38 @@
+/*
+
+  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.
+
+*/
+
+
+
+
+int _dwarf_pro_pre_alloc_n_reloc_slots(Dwarf_P_Debug dbg,
+    int rel_sec_index,
+    Dwarf_Unsigned newslots);
+
+int _dwarf_pro_alloc_reloc_slots(Dwarf_P_Debug dbg, int rel_sec_index);
+
+int _dwarf_pro_reloc_get_a_slot(Dwarf_P_Debug dbg,
+    int base_sec_index,
+    void **relrec_to_fill);

data/ext/rdwarf/libdwarf/pro_reloc_stream.c

@@ -0,0 +1,256 @@
+/*
+
+  Copyright (C) 2000,2001,2004 Silicon Graphics, Inc.  All Rights Reserved.
+  Portions Copyright 2002-2010 Sun Microsystems, Inc. All rights reserved.
+  Portions Copyright 2008-2011 David Anderson, 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.
+
+*/
+
+#include "config.h"
+#include "libdwarfdefs.h"
+#include <stdio.h>
+#include <string.h>
+#ifdef HAVE_ELFACCESS_H
+#include <elfaccess.h>
+#else
+/* Set r_info  as defined by ELF generic ABI */
+#define Set_REL32_info(r,s,t) ((r).r_info = ELF32_R_INFO(s,t))
+#define Set_REL64_info(r,s,t) ((r).r_info = ELF64_R_INFO(s,t))
+#endif
+#include "pro_incl.h"
+#include "pro_section.h"
+#include "pro_reloc.h"
+#include "pro_reloc_stream.h"
+
+/*  Return DW_DLV_ERROR on malloc error or reltarget_length error.
+    Return DW_DLV_OK otherwise */
+/*ARGSUSED*/ int
+_dwarf_pro_reloc_name_stream64(Dwarf_P_Debug dbg,
+    int base_sec_index,
+    Dwarf_Unsigned offset,      /* r_offset of reloc */
+    Dwarf_Unsigned symidx,
+    enum Dwarf_Rel_Type type,
+    int reltarget_length)
+{
+#if HAVE_ELF64_GETEHDR
+    REL64 *elf64_reloc = 0;
+    void *relrec_to_fill = 0;
+    int res = 0;
+    int rel_type = 0;
+
+    res = _dwarf_pro_reloc_get_a_slot(dbg, base_sec_index,
+        &relrec_to_fill);
+    if (res != DW_DLV_OK)
+        return res;
+
+
+    if (type == dwarf_drt_data_reloc) {
+        if (reltarget_length == dbg->de_offset_size) {
+            rel_type = dbg->de_offset_reloc;
+        } else if (reltarget_length == dbg->de_pointer_size) {
+            rel_type = dbg->de_ptr_reloc;
+        } else {
+            return DW_DLV_ERROR;
+        }
+    } else if (type == dwarf_drt_segment_rel) {
+        rel_type = dbg->de_exc_reloc;
+    } else {
+        /*  We are in trouble: improper use of stream relocations.
+            Someone else will diagnose */
+        rel_type = 0;
+    }
+
+    elf64_reloc = (REL64 *)relrec_to_fill;
+    elf64_reloc->r_offset = offset;
+    Set_REL64_info(*elf64_reloc, symidx, rel_type);
+    return DW_DLV_OK;
+#else /* !HAVE_ELF64_GETEHDR */
+    return DW_DLV_ERROR;
+#endif /* #if HAVE_ELF64_GETEHDR */
+}
+
+/*  Return DW_DLV_ERROR on malloc error or reltarget_length error.
+    Return DW_DLV_OK otherwise
+    a binary reloc: 32bit ABI */ int
+_dwarf_pro_reloc_name_stream32(Dwarf_P_Debug dbg, int base_sec_index,
+    Dwarf_Unsigned offset,      /* r_offset of reloc */
+    Dwarf_Unsigned symidx,
+    enum Dwarf_Rel_Type type,
+    int reltarget_length)
+{
+    REL32 *elf32_reloc = 0;
+    void *relrec_to_fill = 0;
+    int res = 0;
+    int rel_type = 0;
+
+    res = _dwarf_pro_reloc_get_a_slot(dbg, base_sec_index,
+        &relrec_to_fill);
+    if (res != DW_DLV_OK)
+        return res;
+    if (type == dwarf_drt_data_reloc) {
+        if (reltarget_length == dbg->de_offset_size) {
+            rel_type = dbg->de_offset_reloc;
+        } else if (reltarget_length == dbg->de_pointer_size) {
+            rel_type = dbg->de_ptr_reloc;
+        } else {
+            return DW_DLV_ERROR;
+        }
+    } else if (type == dwarf_drt_segment_rel) {
+        rel_type = dbg->de_exc_reloc;
+    } else {
+        /*  We are in trouble: improper use of stream relocations.
+            Someone else will diagnose */
+        rel_type = 0;
+    }
+
+    elf32_reloc = (REL32*)relrec_to_fill;
+    elf32_reloc->r_offset = (Elf32_Addr) offset;
+    Set_REL32_info(*elf32_reloc, (Dwarf_Word) symidx, rel_type);
+    return DW_DLV_OK;
+
+    /* get a slot, fill in the slot entry */
+}
+
+
+
+/*  Return DW_DLV_OK.
+    Never can really do anything: lengths cannot
+    be represented as end-start in a stream.  */
+/*ARGSUSED*/ int
+_dwarf_pro_reloc_length_stream(Dwarf_P_Debug dbg,
+    int base_sec_index,
+    Dwarf_Unsigned offset,    /* r_offset of reloc */
+    Dwarf_Unsigned start_symidx,
+    Dwarf_Unsigned end_symidx,
+    enum Dwarf_Rel_Type type,
+    int reltarget_length)
+{
+    /* get a slot, fill in the slot entry */
+    return DW_DLV_OK;
+}
+
+
+/*  Ensure each stream is a single buffer and
+    add that single buffer to the set of stream buffers.
+
+    By creating a new buffer and copying if necessary.
+
+    Free the input set of buffers if we consolidate.
+    Return -1 on error (malloc failure)
+
+    Return DW_DLV_OK on success. Any other return indicates
+    malloc failed.  */
+int
+_dwarf_stream_relocs_to_disk(Dwarf_P_Debug dbg,
+    Dwarf_Signed * new_sec_count)
+{
+    unsigned long total_size = 0;
+    Dwarf_Small *data = 0;
+    int sec_index = 0;
+    unsigned long i = 0;
+    Dwarf_Error erre = 0;
+    Dwarf_Error *error = &erre;
+
+    Dwarf_Signed sec_count = 0;
+
+    Dwarf_P_Per_Reloc_Sect p_reloc = &dbg->de_reloc_sect[0];
+
+    for (i = 0; i < NUM_DEBUG_SECTIONS; ++i, ++p_reloc) {
+        unsigned long ct = p_reloc->pr_reloc_total_count;
+        unsigned len = 0;
+        struct Dwarf_P_Relocation_Block_s *p_blk = 0;
+        struct Dwarf_P_Relocation_Block_s *p_blk_last = 0;
+        Dwarf_P_Per_Reloc_Sect prb = 0;
+
+        if (ct == 0) {
+            continue;
+        }
+        prb = &dbg->de_reloc_sect[i];
+        len = dbg->de_relocation_record_size;
+        ++sec_count;
+
+        total_size = ct * len;
+        sec_index = prb->pr_sect_num_of_reloc_sect;
+        if (sec_index == 0) {
+            /*  Call de_callback_func or de_callback_func_b or _c, getting
+                section number of reloc section. */
+            int rel_section_index = 0;
+            Dwarf_Unsigned name_idx = 0;
+            int erri = 0;
+
+            if (dbg->de_callback_func) {
+                rel_section_index =
+                    dbg->de_callback_func(_dwarf_rel_section_names[i],
+                        /* size */ dbg->de_relocation_record_size,
+                        /* type */ SHT_REL,
+                        /* flags */ 0,
+                        /* link to symtab, which we cannot
+                            know */ 0,
+                        /* info == link to sec rels apply to */
+                            dbg->de_elf_sects[i],
+                        &name_idx,
+                        dbg->de_user_data,
+                        &erri);
+            }
+            if (rel_section_index == -1) {
+                {
+                    _dwarf_p_error(dbg, error, DW_DLE_ELF_SECT_ERR);
+                    return (DW_DLV_ERROR);
+                }
+
+            }
+            prb->pr_sect_num_of_reloc_sect = rel_section_index;
+            sec_index = rel_section_index;
+        }
+        GET_CHUNK(dbg, sec_index, data, total_size, &erri);
+        p_blk = p_reloc->pr_first_block;
+
+        /*  Following loop executes at least once. Effects the
+            consolidation to a single block or, if already a single
+            block, simply copies to the output buffer. And frees the
+            input block. The new block is in the de_debug_sects list. */
+        while (p_blk) {
+
+            unsigned long lenk =
+                p_blk->rb_where_to_add_next - p_blk->rb_data;
+
+            memcpy(data, p_blk->rb_data, lenk);
+
+            data += lenk;
+
+            p_blk_last = p_blk;
+            p_blk = p_blk->rb_next;
+
+            _dwarf_p_dealloc(dbg, (Dwarf_Small *) p_blk_last);
+        }
+        /* ASSERT: sum of len copied == total_size */
+
+        /*  We have copied the input, now drop the pointers to it. For
+            debugging, leave the other data untouched. */
+        p_reloc->pr_first_block = 0;
+        p_reloc->pr_last_block = 0;
+    }
+
+    *new_sec_count = sec_count;
+    return DW_DLV_OK;
+}