rdwarf 0.0.1

data/ext/rdwarf/libdwarf/pro_weaks.c

@@ -0,0 +1,51 @@
+/*
+
+  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 weak name to the
+    list of weak names for the given Dwarf_P_Debug.
+    It returns 0 on error, and 1 otherwise.
+*/
+Dwarf_Unsigned
+dwarf_add_weakname(Dwarf_P_Debug dbg,
+    Dwarf_P_Die die,
+    char *weak_name, Dwarf_Error * error)
+{
+    return
+        _dwarf_add_simple_name_entry(dbg, die, weak_name,
+            dwarf_snk_weakname, error);
+}

data/ext/rdwarf/rdwarf.c

@@ -0,0 +1,765 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*-
+ *
+ * rdwarf  -  a ruby module to read DWARF debugging information
+ * https://github.com/kubo/rdwarf
+ *
+ * Copyright (C) 2015 Kubo Takehiro <kubo@jiubao.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation
+ * are those of the authors and should not be interpreted as representing
+ * official policies, either expressed or implied, of the authors.
+ */
+#include "rdwarf.h"
+#include <ruby/encoding.h>
+#include <libelf.h>
+#include <fcntl.h>
+
+static VALUE cRDwarf;     /* RDwarf */
+static VALUE rd_eError;     /* RDwarf:Error */
+static VALUE rd_mDie;       /* RDwarf::Die */
+static VALUE rd_cDieBase;   /* RDwarf::Die:Base */
+static VALUE rd_mAttr;      /* RDwarf::Attribute */
+static VALUE rd_cAttrBase;  /* RDwarf::Attribute::Base */
+static VALUE rd_cLocList;   /* RDwarf::LocationList */
+static VALUE rd_cLocDesc;   /* RDwarf::LocationDescriptor */
+
+static VALUE sym_unsupported_type;
+static ID id_at_top;
+static ID id_at_cu;
+
+typedef struct {
+    Elf *elf;
+    Dwarf_Debug dbg;
+    size_t refcnt;
+    VALUE off2die;
+} rd_shared_data_t;
+
+typedef struct {
+    rd_shared_data_t *shared_data;
+    VALUE compile_units;
+} rdwarf_t;
+
+typedef struct {
+    rd_shared_data_t *shared_data;
+    Dwarf_Die die;
+    VALUE children;
+    VALUE attributes;
+    VALUE srcfiles;
+} rd_die_t;
+
+typedef struct {
+    rd_shared_data_t *shared_data;
+    Dwarf_Attribute attr;
+    Dwarf_Half attr_type;
+} rd_attr_t;
+
+#define rd_shared_data_ref(sd) (++(sd)->refcnt, (sd))
+#define rd_shared_data_unref(sd) ((--(sd)->refcnt) == 0 ? rd_shared_data_free(sd) : 0)
+
+#define GetRDwarf(obj) (rdwarf_t*)rb_check_typeddata((obj), &rdwarf_data_type)
+#define GetDie(obj) (rd_die_t*)rb_check_typeddata((obj), &rd_die_data_type)
+#define GetAttr(obj) (rd_attr_t*)rb_check_typeddata((obj), &rd_attr_data_type)
+
+static VALUE rd_die_new(rd_shared_data_t *sd, VALUE top, VALUE cu, Dwarf_Die die);
+static VALUE rd_attr_new(rd_shared_data_t *sd, VALUE top, VALUE cu, Dwarf_Attribute attr);
+static VALUE rd_attr_loc_list(VALUE self);
+
+static rd_shared_data_t *rd_shared_data_alloc(Elf *elf, Dwarf_Debug dbg, VALUE obj)
+{
+    rd_shared_data_t *sd = xmalloc(sizeof(rd_shared_data_t));
+    sd->elf = elf;
+    sd->dbg = dbg;
+    sd->refcnt = 1;
+    sd->off2die = rb_hash_new();
+    return sd;
+}
+
+static void rd_shared_data_mark(rd_shared_data_t *sd)
+{
+    if (sd != NULL) {
+        rb_gc_mark(sd->off2die);
+    }
+}
+
+static void rd_shared_data_free(rd_shared_data_t *sd)
+{
+    Dwarf_Error err;
+
+    dwarf_finish(sd->dbg, &err);
+    elf_end(sd->elf);
+    xfree(sd);
+}
+
+static void chkerr1(int ret, Dwarf_Error *err, VALUE obj)
+{
+    VALUE exc = Qnil;
+    switch (ret) {
+    case DW_DLV_NO_ENTRY:
+        exc = rb_exc_new_cstr(rd_eError, "No Entry");
+    case DW_DLV_ERROR:
+        if (err != NULL) {
+	    exc = rb_exc_new_cstr(rd_eError, dwarf_errmsg(*err));
+        } else {
+            exc = rb_exc_new_cstr(rd_eError, "Unknown Error");
+        }
+    }
+    if (!NIL_P(exc)) {
+        rb_iv_set(exc, "@obj", obj);
+        rb_exc_raise(exc);
+    }
+}
+
+static int chkerr2(int ret, Dwarf_Error *err)
+{
+    if (ret == DW_DLV_ERROR) {
+        if (err != NULL) {
+            rb_raise(rd_eError, "%s", dwarf_errmsg(*err));
+        } else {
+            rb_raise(rd_eError, "Unknown Error");
+        }
+    }
+    return ret == DW_DLV_OK;
+}
+
+/*******************************************
+ *  class definitins
+ *******************************************/
+
+/* RDwarf */
+
+static void rdwarf_dmark(void *ptr)
+{
+    rdwarf_t *rd = (rdwarf_t *)ptr;
+    rd_shared_data_mark(rd->shared_data);
+    rb_gc_mark(rd->compile_units);
+}
+
+static void rdwarf_dfree(void *ptr)
+{
+    rdwarf_t *rd = (rdwarf_t *)ptr;
+
+    if (rd->shared_data != NULL) {
+        rd_shared_data_unref(rd->shared_data);
+    }
+    xfree(rd);
+}
+
+static size_t rdwarf_dsize(const void *ptr)
+{
+    return sizeof(rdwarf_t);
+}
+
+static const rb_data_type_t rdwarf_data_type = {
+    "RDwarf",
+    {rdwarf_dmark, rdwarf_dfree, rdwarf_dsize,},
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
+#endif
+};
+
+/* RDwarf::DIE:Base */
+
+static void rd_die_dmark(void *ptr)
+{
+    rd_die_t *die = (rd_die_t *)ptr;
+    rd_shared_data_mark(die->shared_data);
+    rb_gc_mark(die->children);
+    rb_gc_mark(die->attributes);
+    rb_gc_mark(die->srcfiles);
+}
+
+static void rd_die_dfree(void *ptr)
+{
+    rd_die_t *die = (rd_die_t *)ptr;
+    if (die->shared_data != NULL) {
+        if (die->die != NULL) {
+            dwarf_dealloc(die->shared_data->dbg, die->die, DW_DLA_DIE);
+        }
+        rd_shared_data_unref(die->shared_data);
+    }
+    xfree(die);
+}
+
+static size_t rd_die_dsize(const void *ptr)
+{
+    return sizeof(rd_die_t);
+}
+
+static const rb_data_type_t rd_die_data_type = {
+    "RDwarf::Die:Base",
+    {rd_die_dmark, rd_die_dfree, rd_die_dsize,},
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
+#endif
+};
+
+/* RDwarf::Attribute:Base */
+
+static void rd_attr_dmark(void *ptr)
+{
+    rd_attr_t *attr = (rd_attr_t *)ptr;
+    rd_shared_data_mark(attr->shared_data);
+}
+
+static void rd_attr_dfree(void *ptr)
+{
+    rd_attr_t *attr = (rd_attr_t *)ptr;
+    if (attr->shared_data != NULL) {
+        if (attr->attr != NULL) {
+            dwarf_dealloc(attr->shared_data->dbg, attr->attr, DW_DLA_ATTR);
+        }
+        rd_shared_data_unref(attr->shared_data);
+    }
+    xfree(attr);
+}
+
+static size_t rd_attr_dsize(const void *ptr)
+{
+    return sizeof(rd_attr_t);
+}
+
+static const rb_data_type_t rd_attr_data_type = {
+    "RDwarf::Attribute:Base",
+    {rd_attr_dmark, rd_attr_dfree, rd_attr_dsize,},
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
+#endif
+};
+
+/*******************************************
+ *  method definitins
+ *******************************************/
+
+/* RDwarf */
+
+static VALUE rdwarf_s_alloc(VALUE klass)
+{
+    VALUE obj;
+    rdwarf_t *rd;
+
+    obj = TypedData_Make_Struct(klass, rdwarf_t, &rdwarf_data_type, rd);
+    rd->compile_units = Qfalse;
+    return obj;
+}
+
+static VALUE rdwarf_initialize(VALUE self, VALUE filename)
+{
+    rdwarf_t *rd = GetRDwarf(self);
+    Elf *elf;
+    Dwarf_Debug dbg;
+    Dwarf_Error err;
+    int fd;
+    int ret;
+
+    SafeStringValue(filename);
+    filename = rb_str_export_to_enc(filename, rb_filesystem_encoding());
+
+    fd = rb_cloexec_open(StringValueCStr(filename), O_RDONLY, 0);
+    if (fd < 0) {
+        rb_sys_fail("open");
+    }
+    elf = elf_begin(fd, ELF_C_READ, (Elf*)0);
+    ret = dwarf_elf_init(elf, DW_DLC_READ, NULL, NULL, &dbg, &err);
+    if (ret == DW_DLV_NO_ENTRY) {
+        elf_end(elf);
+        rb_raise(rd_eError, "%s", dwarf_errmsg(err));
+    }
+    rd->shared_data = rd_shared_data_alloc(elf, dbg, self);
+    return self;
+}
+
+static VALUE rdwarf_compile_units(VALUE self)
+{
+    rdwarf_t *rd = GetRDwarf(self);
+    Dwarf_Unsigned cu_header_length = 0;
+    Dwarf_Unsigned abbrev_offset = 0;
+    Dwarf_Half version_stamp = 0;
+    Dwarf_Half address_size = 0;
+    Dwarf_Unsigned next_cu_offset = 0;
+    Dwarf_Error err;
+    Dwarf_Die die;
+    VALUE ary;
+
+    if (rd->compile_units != Qfalse) {
+      return rd->compile_units;
+    }
+    ary = rb_ary_new();
+
+    while (dwarf_next_cu_header(rd->shared_data->dbg, &cu_header_length, &version_stamp, &abbrev_offset,
+                                &address_size, &next_cu_offset, &err) == DW_DLV_OK) {
+        if (!chkerr2(dwarf_siblingof(rd->shared_data->dbg, NULL, &die, &err), &err)) {
+            continue;
+        }
+        rb_ary_push(ary, rd_die_new(rd->shared_data, self, Qnil, die));
+    }
+    rd->compile_units = ary;
+    return ary;
+}
+
+static VALUE rdwarf_die_at(VALUE self, VALUE offset)
+{
+    rdwarf_t *rd = GetRDwarf(self);
+    Dwarf_Die die;
+    Dwarf_Off cu_off;
+    Dwarf_Error err;
+    VALUE cu;
+
+    chkerr1(dwarf_offdie(rd->shared_data->dbg, NUM2LL(offset), &die, &err), &err, self);
+    chkerr1(dwarf_CU_dieoffset_given_die(die, &cu_off, &err), &err, self);
+
+    rdwarf_compile_units(self);
+    cu = rb_hash_aref(rd->shared_data->off2die, LL2NUM(cu_off));
+    if (NIL_P(cu)) {
+        rb_raise(rd_eError, "Cannot find CU");
+    }
+    return rd_die_new(rd->shared_data, self, cu, die);
+}
+
+/* RDwarf::DIE */
+
+static VALUE rd_die_s_alloc(VALUE klass)
+{
+    VALUE obj;
+    rd_die_t *die;
+
+    obj = TypedData_Make_Struct(klass, rd_die_t, &rd_die_data_type, die);
+    die->children = Qfalse;
+    die->attributes = Qfalse;
+    die->srcfiles = Qfalse;
+    return obj;
+}
+
+static VALUE rd_die_new(rd_shared_data_t *sd, VALUE top, VALUE cu, Dwarf_Die die)
+{
+    rd_die_t *rd_die;
+    Dwarf_Off off;
+    Dwarf_Half tag;
+    Dwarf_Error err;
+    VALUE obj;
+    VALUE klass;
+
+    chkerr1(dwarf_dieoffset(die, &off, &err), &err, Qnil);
+    obj = rb_hash_aref(sd->off2die, LL2NUM(off));
+    if (!NIL_P(obj)) {
+        return obj;
+    }
+
+    chkerr1(dwarf_tag(die, &tag, &err), &err, Qnil);
+    klass = rb_hash_aref(rdwarf_tag2class, INT2FIX(tag));
+    if (NIL_P(klass)) {
+        rb_raise(rb_eRuntimeError, "unknown tag %d\n", tag);
+    }
+    obj = rd_die_s_alloc(klass);
+    rd_die = GetDie(obj);
+    rd_die->shared_data = rd_shared_data_ref(sd);
+    rd_die->die = die;
+    rb_ivar_set(obj, id_at_top, top);
+    rb_ivar_set(obj, id_at_cu, NIL_P(cu) ? obj : cu);
+    rb_hash_aset(sd->off2die, LL2NUM(off), obj);
+    return obj;
+}
+
+static VALUE rd_die_name(VALUE self)
+{
+    rd_die_t *die = GetDie(self);
+    char *name;
+    Dwarf_Error err;
+
+    if (chkerr2(dwarf_diename(die->die, &name, &err), &err)) {
+        return rb_enc_str_new_cstr(name, rb_usascii_encoding());
+    } else {
+        return Qnil;
+    }
+}
+
+static VALUE rd_die_tag_name(VALUE self)
+{
+    rd_die_t *die = GetDie(self);
+    Dwarf_Half tag = 0;
+    Dwarf_Error err;
+
+    chkerr1(dwarf_tag(die->die, &tag, &err), &err, self);
+    return rb_hash_aref(rdwarf_tag2name, INT2FIX(tag));
+}
+
+static VALUE rd_die_die_offset(VALUE self)
+{
+    rd_die_t *die = GetDie(self);
+    Dwarf_Off off;
+    Dwarf_Error err;
+
+    chkerr1(dwarf_dieoffset(die->die, &off, &err), &err, self);
+    return LL2NUM(off);
+}
+
+static VALUE rd_die_die_cu_offset(VALUE self)
+{
+    rd_die_t *die = GetDie(self);
+    Dwarf_Off off;
+    Dwarf_Error err;
+
+    chkerr1(dwarf_die_CU_offset(die->die, &off, &err), &err, self);
+    return LL2NUM(off);
+}
+
+static VALUE rd_die_children(VALUE self)
+{
+    rd_die_t *die = GetDie(self);
+    VALUE top;
+    VALUE cu;
+    VALUE ary;
+    Dwarf_Die child;
+    Dwarf_Error err;
+
+    if (die->children != Qfalse) {
+        return die->children;
+    }
+
+    top = rb_ivar_get(self, id_at_top);
+    cu = rb_ivar_get(self, id_at_cu);
+    ary = rb_ary_new();
+    if (chkerr2(dwarf_child(die->die, &child, &err), &err)) {
+        do {
+            rb_ary_push(ary, rd_die_new(die->shared_data, top, cu, child));
+        } while (chkerr2(dwarf_siblingof(die->shared_data->dbg, child, &child, &err), &err));
+    }
+    die->children = ary;
+    return ary;
+}
+
+static VALUE rd_die_attributes(VALUE self)
+{
+    rd_die_t *die = GetDie(self);
+    Dwarf_Attribute *list;
+    Dwarf_Signed count;
+    Dwarf_Error err;
+    Dwarf_Signed idx;
+    VALUE top;
+    VALUE cu;
+    VALUE ary;
+
+    if (die->attributes != Qfalse) {
+        return die->attributes;
+    }
+
+    top = rb_ivar_get(self, id_at_top);
+    cu = rb_ivar_get(self, id_at_cu);
+    if (chkerr2(dwarf_attrlist(die->die, &list, &count, &err), &err)) {
+        ary = rb_ary_new_capa(count);
+        for (idx = 0; idx < count; idx++) {
+            rb_ary_store(ary, idx, rd_attr_new(die->shared_data, top, cu, list[idx]));
+        }
+    } else {
+        ary = rb_ary_new();
+    }
+    die->attributes = ary;
+    return ary;
+}
+
+static VALUE rd_die_source_files(VALUE self)
+{
+    rd_die_t *die = GetDie(self);
+    Dwarf_Signed cnt = 0;
+    char **srcfiles = 0;
+    Dwarf_Error err;
+    VALUE files = Qnil;
+
+    if (die->srcfiles != Qfalse) {
+        return die->srcfiles;
+    }
+
+    if (chkerr2(dwarf_srcfiles(die->die, &srcfiles, &cnt, &err), &err)) {
+        int i;
+
+        files = rb_ary_new_capa(cnt);
+        for (i = 0; i < cnt; i++) {
+            VALUE file = rb_str_new_cstr(srcfiles[i]);
+            OBJ_FREEZE(file);
+            rb_ary_store(files, i, file);
+            dwarf_dealloc(die->shared_data->dbg, srcfiles[i], DW_DLA_STRING);
+        }
+        dwarf_dealloc(die->shared_data->dbg, srcfiles, DW_DLA_LIST);
+    }
+    die->srcfiles = files;
+    return files;
+}
+
+static VALUE rd_die_inspect(VALUE self)
+{
+    rd_die_t *die = GetDie(self);
+    char *name;
+    Dwarf_Off dieoff = 0;
+    Dwarf_Error err;
+
+    dwarf_dieoffset(die->die, &dieoff, &err);
+
+    switch (dwarf_diename(die->die, &name, &err)) {
+    case DW_DLV_OK:
+        return rb_sprintf("#<%s:(%llu) '%s'>", rb_obj_classname(self), dieoff, name);
+    default:
+        return rb_sprintf("#<%s:(%llu)>", rb_obj_classname(self), dieoff);
+    }
+}
+
+/* RDwarf::Attribute */
+
+static VALUE rd_attr_s_alloc(VALUE klass)
+{
+    VALUE obj;
+    rd_attr_t *attr;
+
+    obj = TypedData_Make_Struct(klass, rd_attr_t, &rd_attr_data_type, attr);
+    return obj;
+}
+
+static VALUE rd_attr_new(rd_shared_data_t *sd, VALUE top, VALUE cu, Dwarf_Attribute attr)
+{
+    rd_attr_t *rd_attr;
+    Dwarf_Error err;
+    VALUE obj;
+    VALUE klass;
+    Dwarf_Half attr_type = 0;
+
+    chkerr1(dwarf_whatattr(attr, &attr_type, &err), &err, Qnil);
+    klass = rb_hash_aref(rdwarf_at2class, INT2FIX(attr_type));
+    if (NIL_P(klass)) {
+        rb_raise(rb_eRuntimeError, "unknown attribute %d\n", attr_type);
+    }
+    obj = rd_attr_s_alloc(klass);
+    rd_attr = GetAttr(obj);
+    rd_attr->shared_data = rd_shared_data_ref(sd);
+    rd_attr->attr = attr;
+    rd_attr->attr_type = attr_type;
+    rb_ivar_set(obj, id_at_top, top);
+    rb_ivar_set(obj, id_at_cu, cu);
+    return obj;
+}
+
+static VALUE rd_attr_type(VALUE self)
+{
+    rd_attr_t *attr = GetAttr(self);
+    return rb_hash_aref(rdwarf_at2name, INT2FIX(attr->attr_type));
+}
+
+static VALUE rd_attr_form(VALUE self)
+{
+    rd_attr_t *attr = GetAttr(self);
+    Dwarf_Half form_type;
+    Dwarf_Error err;
+
+    chkerr1(dwarf_whatform(attr->attr, &form_type, &err), &err, self);
+    return rb_hash_aref(rdwarf_form2name, INT2FIX(form_type));
+}
+
+static VALUE rd_attr_raw_value(VALUE self)
+{
+    rd_attr_t *attr = GetAttr(self);
+    Dwarf_Half form;
+    Dwarf_Error err;
+    union {
+        Dwarf_Addr addr;
+        Dwarf_Off off;
+        Dwarf_Unsigned udata;
+        Dwarf_Signed sdata;
+        Dwarf_Bool bool;
+        char *str;
+    } val;
+    VALUE top;
+
+    chkerr1(dwarf_whatform(attr->attr, &form, &err), &err, self);
+    switch (form) {
+    case DW_FORM_addr:
+        chkerr1(dwarf_formaddr(attr->attr, &val.addr, &err), &err, self);
+        return ULL2NUM(val.addr);
+    case DW_FORM_ref1:
+    case DW_FORM_ref2:
+    case DW_FORM_ref4:
+    case DW_FORM_ref8:
+    case DW_FORM_ref_udata:
+        chkerr1(dwarf_global_formref(attr->attr, &val.off, &err), &err, self);
+	top = rb_ivar_get(self, id_at_top);
+        return rdwarf_die_at(top, LL2NUM(val.off));
+    case DW_FORM_data1:
+    case DW_FORM_data2:
+    case DW_FORM_data4:
+    case DW_FORM_data8:
+    case DW_FORM_udata:
+        chkerr1(dwarf_formudata(attr->attr, &val.udata, &err), &err, self);
+        return ULL2NUM(val.udata);
+    case DW_FORM_sdata:
+        chkerr1(dwarf_formsdata(attr->attr, &val.sdata, &err), &err, self);
+        return LL2NUM(val.sdata);
+    case DW_FORM_flag:
+        chkerr1(dwarf_formflag(attr->attr, &val.bool, &err), &err, self);
+        return val.bool ? Qtrue : Qfalse;
+    case DW_FORM_strp:
+    case DW_FORM_string:
+        chkerr1(dwarf_formstring(attr->attr, &val.str, &err), &err, self);
+        return rb_str_new_cstr(val.str);
+    }
+    return sym_unsupported_type;
+}
+
+static VALUE rd_attr_inspect(VALUE self)
+{
+    rd_attr_t *attr = GetAttr(self);
+    Dwarf_Half form;
+    Dwarf_Error err;
+    const char *form_name = "?";
+
+    if (dwarf_whatform(attr->attr, &form, &err) == DW_DLV_OK) {
+      dwarf_get_FORM_name(form, &form_name);
+    }
+    return rb_sprintf("#<%s: %s>", rb_obj_classname(self), form_name);
+}
+
+static VALUE rd_attr_loc_list(VALUE self)
+{
+    rd_attr_t *attr = GetAttr(self);
+    Dwarf_Error err;
+    Dwarf_Loc_Head_c loc_head;
+    Dwarf_Unsigned count;
+    VALUE lhead;
+    Dwarf_Unsigned idx;
+
+    chkerr1(dwarf_get_loclist_c(attr->attr, &loc_head, &count, &err), &err, self);
+    lhead = rb_ary_new_capa(count);
+    for (idx = 0; idx < count; idx++) {
+        Dwarf_Small lle;
+	Dwarf_Addr lowpc;
+	Dwarf_Addr hipc;
+	Dwarf_Unsigned loclist_count;
+	Dwarf_Locdesc_c locentry;
+	Dwarf_Small source;
+	Dwarf_Unsigned expression_offset;
+	Dwarf_Unsigned locdesc_offset;
+        ID id_lle;
+	ID id_lowpc;
+	ID id_hipc;
+	ID id_source;
+	ID id_expression_offset;
+	ID id_locdesc_offset;
+	VALUE llist;
+	int idx2;
+
+	CONST_ID(id_lle, "@lle");
+	CONST_ID(id_lowpc, "@lowpc");
+	CONST_ID(id_hipc, "@hipc");
+	CONST_ID(id_source, "@source");
+	CONST_ID(id_expression_offset, "@expression_offset");
+	CONST_ID(id_locdesc_offset, "@locdesc_offset");
+
+	chkerr1(dwarf_get_locdesc_entry_c(loc_head, idx, &lle, &lowpc, &hipc,
+					  &loclist_count, &locentry, &source,
+					  &expression_offset, &locdesc_offset, &err),
+		&err, self);
+	llist = rb_class_new_instance(0, NULL, rd_cLocList);
+	rb_ivar_set(llist, id_lle, rb_hash_aref(rdwarf_lle2name, INT2FIX(lle)));
+	rb_ivar_set(llist, id_lowpc, ULL2NUM(lowpc));
+	rb_ivar_set(llist, id_hipc, ULL2NUM(hipc));
+	rb_ivar_set(llist, id_source, INT2FIX(source));
+	rb_ivar_set(llist, id_expression_offset, ULL2NUM(expression_offset));
+	rb_ivar_set(llist, id_locdesc_offset, ULL2NUM(locdesc_offset));
+	for (idx2 = 0; idx2 < loclist_count; idx2++) {
+	    Dwarf_Small atom;
+	    Dwarf_Unsigned operand1;
+	    Dwarf_Unsigned operand2;
+	    Dwarf_Unsigned operand3;
+	    Dwarf_Unsigned offset_for_branch;
+	    ID id_atom;
+	    ID id_operand1;
+	    ID id_operand2;
+	    ID id_operand3;
+	    ID id_offset_for_branch;
+	    VALUE ldesc;
+
+	    CONST_ID(id_atom, "@atom");
+	    CONST_ID(id_operand1, "@operand1");
+	    CONST_ID(id_operand2, "@operand2");
+	    CONST_ID(id_operand3, "@operand3");
+	    CONST_ID(id_offset_for_branch, "@offset_for_branch");
+
+	    chkerr1(dwarf_get_location_op_value_c(locentry, idx2, &atom, &operand1, &operand2, &operand3, &offset_for_branch, &err),
+		    &err, self);
+	    ldesc = rb_class_new_instance(0, NULL, rd_cLocDesc);
+	    rb_ivar_set(ldesc, id_atom, rb_hash_aref(rdwarf_op2name, INT2FIX(atom)));
+	    rb_ivar_set(ldesc, id_operand1, ULL2NUM(operand1));
+	    rb_ivar_set(ldesc, id_operand2, ULL2NUM(operand2));
+	    rb_ivar_set(ldesc, id_operand3, ULL2NUM(operand3));
+	    rb_ivar_set(ldesc, id_offset_for_branch, ULL2NUM(offset_for_branch));
+	    rb_ary_store(llist, idx2, ldesc);
+	}
+	rb_ary_store(lhead, idx, llist);
+    }
+    dwarf_loc_head_c_dealloc(loc_head);
+    return lhead;
+}
+
+void Init_rdwarf(void)
+{
+    elf_version(EV_CURRENT);
+
+    sym_unsupported_type = ID2SYM(rb_intern("unsupported_type"));
+    id_at_top = rb_intern("@top");
+    id_at_cu = rb_intern("@cu");
+
+    cRDwarf = rb_define_class("RDwarf", rb_cObject);
+    rb_define_alloc_func(cRDwarf, rdwarf_s_alloc);
+    rb_define_method(cRDwarf, "initialize", rdwarf_initialize, 1);
+    rb_define_method(cRDwarf, "compile_units", rdwarf_compile_units, 0);
+    rb_define_method(cRDwarf, "die_at", rdwarf_die_at, 1);
+
+    rd_mDie = rb_define_module_under(cRDwarf, "DIE");
+    rd_cDieBase = rb_define_class_under(rd_mDie, "Base", rb_cObject);
+    rb_define_alloc_func(rd_cDieBase, rd_die_s_alloc);
+    rb_define_method(rd_cDieBase, "name", rd_die_name, 0);
+    rb_define_method(rd_cDieBase, "tag_name", rd_die_tag_name, 0);
+    rb_define_method(rd_cDieBase, "die_offset", rd_die_die_offset, 0);
+    rb_define_method(rd_cDieBase, "die_cu_offset", rd_die_die_cu_offset, 0);
+    rb_define_method(rd_cDieBase, "children", rd_die_children, 0);
+    rb_define_method(rd_cDieBase, "attributes", rd_die_attributes, 0);
+    rb_define_method(rd_cDieBase, "source_files", rd_die_source_files, 0);
+    rb_define_method(rd_cDieBase, "to_s", rd_die_inspect, 0);
+    rb_define_method(rd_cDieBase, "inspect", rd_die_inspect, 0);
+
+    rd_mAttr = rb_define_module_under(cRDwarf, "Attribute");
+    rd_cAttrBase = rb_define_class_under(rd_mAttr, "Base", rb_cObject);
+    rb_define_method(rd_cAttrBase, "type", rd_attr_type, 0);
+    rb_define_method(rd_cAttrBase, "form", rd_attr_form, 0);
+    rb_define_method(rd_cAttrBase, "raw_value", rd_attr_raw_value, 0);
+    rb_define_method(rd_cAttrBase, "value", rd_attr_raw_value, 0);
+    rb_define_method(rd_cAttrBase, "to_s", rd_attr_inspect, 0);
+    rb_define_method(rd_cAttrBase, "inspect", rd_attr_inspect, 0);
+    rb_define_private_method(rd_cAttrBase, "loc_list", rd_attr_loc_list, 0);
+
+    rd_cLocList = rb_define_class_under(cRDwarf, "LocationList", rb_cArray);
+
+    rd_cLocDesc = rb_define_class_under(cRDwarf, "LocationDescriptor", rb_cObject);
+
+    rd_eError = rb_define_class_under(cRDwarf, "Error", rb_eStandardError);
+
+    Init_rdwarf_names(cRDwarf, rd_mDie, rd_cDieBase, rd_mAttr, rd_cAttrBase);
+}