rdwarf 0.0.1

data/ext/rdwarf/libdwarf/pro_die.h

@@ -0,0 +1,59 @@
+/*
+
+  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.
+
+*/
+
+
+
+
+/*
+    This struct holds the abbreviation table, before they are written
+    on disk. Holds a linked list of abbreviations, each consisting of
+    a bitmap for attributes and a bitmap for forms
+*/
+typedef struct Dwarf_P_Abbrev_s *Dwarf_P_Abbrev;
+
+struct Dwarf_P_Abbrev_s {
+    Dwarf_Unsigned abb_idx;   /* index of abbreviation */
+    Dwarf_Tag abb_tag; 	      /* tag of die */
+    Dwarf_Ubyte abb_children; /* if children are present */
+    Dwarf_ufixed *abb_attrs;  /* holds names of attrs */
+    Dwarf_ufixed *abb_forms;  /* forms of attributes */
+    int abb_n_attr;           /* num of attrs = # of forms */
+    Dwarf_P_Abbrev abb_next;
+};
+
+/* used in pro_section.c */
+
+int _dwarf_pro_add_AT_fde(Dwarf_P_Debug dbg, Dwarf_P_Die die,
+    Dwarf_Unsigned offset, Dwarf_Error * error);
+
+int _dwarf_pro_add_AT_stmt_list(Dwarf_P_Debug dbg,
+    Dwarf_P_Die first_die,
+    Dwarf_Error * error);
+
+int _dwarf_pro_add_AT_macro_info(Dwarf_P_Debug dbg,
+    Dwarf_P_Die first_die,
+    Dwarf_Unsigned offset,
+    Dwarf_Error * error);

data/ext/rdwarf/libdwarf/pro_encode_nm.c

@@ -0,0 +1,108 @@
+/*
+
+  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 <string.h>
+#include "pro_incl.h"
+
+#define MORE_BYTES      0x80
+#define DATA_MASK       0x7f
+#define DIGIT_WIDTH     7
+#define SIGN_BIT        0x40
+
+
+/*  Encode val as a leb128. This encodes it as an unsigned
+    number. */
+/*  Return DW_DLV_ERROR or DW_DLV_OK.
+    space to write leb number is provided by caller, with caller
+    passing length.
+    number of bytes used returned thru nbytes arg */
+int
+_dwarf_pro_encode_leb128_nm(Dwarf_Unsigned val, int *nbytes,
+    char *space, int splen)
+{
+    char *a;
+    char *end = space + splen;
+
+    a = space;
+    do {
+        unsigned char uc;
+
+        if (a >= end) {
+            return DW_DLV_ERROR;
+        }
+        uc = val & DATA_MASK;
+        val >>= DIGIT_WIDTH;
+        if (val != 0) {
+            uc |= MORE_BYTES;
+        }
+        *a = uc;
+        a++;
+    } while (val);
+    *nbytes = a - space;
+    return DW_DLV_OK;
+}
+
+/* return DW_DLV_ERROR or DW_DLV_OK.
+** space to write leb number is provided by caller, with caller
+** passing length.
+** number of bytes used returned thru nbytes arg
+** encodes a signed number.
+*/
+int
+_dwarf_pro_encode_signed_leb128_nm(Dwarf_Signed value, int *nbytes,
+    char *space, int splen)
+{
+    char *str;
+    Dwarf_Signed sign = -(value < 0);
+    int more = 1;
+    char *end = space + splen;
+
+    str = space;
+
+    do {
+        unsigned char byte = value & DATA_MASK;
+
+        value >>= DIGIT_WIDTH;
+
+        if (str >= end) {
+            return DW_DLV_ERROR;
+        }
+        /*  Remaining chunks would just contain the sign bit, and this chunk
+            has already captured at least one sign bit.  */
+        if (value == sign && ((byte & SIGN_BIT) == (sign & SIGN_BIT))) {
+            more = 0;
+        } else {
+            byte |= MORE_BYTES;
+        }
+        *str = byte;
+        str++;
+    } while (more);
+    *nbytes = str - space;
+    return DW_DLV_OK;
+}

data/ext/rdwarf/libdwarf/pro_encode_nm.h

@@ -0,0 +1,39 @@
+/*
+
+  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.
+
+*/
+
+
+
+/*  Bytes needed to encode a number.
+    Not a tight bound, just a reasonable bound.
+*/
+#define ENCODE_SPACE_NEEDED   (2*sizeof(Dwarf_Unsigned))
+
+
+int _dwarf_pro_encode_leb128_nm(Dwarf_Unsigned val, int *nbytes,
+    char *space, int splen);
+
+int _dwarf_pro_encode_signed_leb128_nm(Dwarf_Signed value, int *nbytes,
+    char *space, int splen);

data/ext/rdwarf/libdwarf/pro_error.c

@@ -0,0 +1,96 @@
+/*
+
+  Copyright (C) 2000,2002,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"
+#ifdef HAVE_ELF_H
+#include <elf.h>
+#endif
+
+#include <stdio.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <stdlib.h>
+#include "pro_incl.h"
+
+extern char *_dwarf_errmsgs[];
+
+/*
+    This function performs error handling as described in the
+    libdwarf consumer document section 3.  Dbg is the Dwarf_P_debug
+    structure being processed.  Error is a pointer to the pointer
+    to the error descriptor that will be returned.  Errval is an
+    error code listed in dwarf_error.h.
+
+    The error number may be retrieved from the Dwarf_Error
+    by calling dwarf_errno().
+    The error string implied by the error number may be retrieved
+    from the Dwarf_Error by calling dwarf_errmsg().
+*/
+void
+_dwarf_p_error(Dwarf_P_Debug dbg,
+    Dwarf_Error * error, Dwarf_Word errval)
+{
+    Dwarf_Error errptr;
+
+    if (errval > DW_DLE_LAST) {
+        /*  We do not expect to ever see such an error number,
+            DW_DLE_LO_USER is not used. */
+        /*  The 'standard' typedef for Dwarf_Word is "unsigned long". */
+        fprintf(stderr,"ERROR VALUE: %lu - %s\n",
+            (unsigned long) errval, "this error value is unknown to libdwarf.");
+    }
+    /*  Allow NULL dbg on entry, since sometimes that can happen and we
+        want to report the upper-level error, not this one. */
+    if (error != NULL) {
+        errptr = (Dwarf_Error)
+            _dwarf_p_get_alloc(dbg, sizeof(struct Dwarf_Error_s));
+        if (errptr == NULL) {
+            fprintf(stderr,
+                "Could not allocate Dwarf_Error structure\n");
+            abort();
+        }
+        errptr->er_errval = (Dwarf_Sword) errval;
+        *error = errptr;
+        return;
+    }
+
+    if (dbg != NULL && dbg->de_errhand != NULL) {
+        errptr = (Dwarf_Error)
+            _dwarf_p_get_alloc(dbg, sizeof(struct Dwarf_Error_s));
+        if (errptr == NULL) {
+            fprintf(stderr,
+                "Could not allocate Dwarf_Error structure\n");
+            abort();
+        }
+        errptr->er_errval = (Dwarf_Sword) errval;
+        dbg->de_errhand(errptr, dbg->de_errarg);
+        return;
+    }
+
+    abort();
+}

data/ext/rdwarf/libdwarf/pro_error.h

@@ -0,0 +1,43 @@
+/*
+
+  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.
+
+*/
+
+
+
+
+/* Handle error passing in the name of the Dwarf_P_Debug
+   User must supply {} around the macro.
+   Putting the {} here leads to macro uses that don't look like C.
+   The error argument to dwarf_error is hard coded here as 'error'
+*/
+#define DWARF_P_DBG_ERROR(dbg,errval,retval) \
+    _dwarf_p_error(dbg,error,errval); return(retval);
+
+struct Dwarf_Error_s {
+    Dwarf_Sword er_errval;
+};
+
+void _dwarf_p_error(Dwarf_P_Debug dbg, Dwarf_Error * error,
+    Dwarf_Word errval);

data/ext/rdwarf/libdwarf/pro_expr.c

@@ -0,0 +1,575 @@
+/*
+  Copyright (C) 2000,2004,2006 Silicon Graphics, Inc.  All Rights Reserved.
+  Portions Copyright 2007-2010 Sun Microsystems, 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>
+#include "pro_incl.h"
+#include "pro_expr.h"
+
+/*
+    This function creates a new expression
+    struct that can be used to build up a
+    location expression.
+*/
+Dwarf_P_Expr
+dwarf_new_expr(Dwarf_P_Debug dbg, Dwarf_Error * error)
+{
+    Dwarf_P_Expr ret_expr;
+
+    if (dbg == NULL) {
+        _dwarf_p_error(NULL, error, DW_DLE_DBG_NULL);
+        return (NULL);
+    }
+
+    ret_expr = (Dwarf_P_Expr)
+        _dwarf_p_get_alloc(dbg, sizeof(struct Dwarf_P_Expr_s));
+    if (ret_expr == NULL) {
+        _dwarf_p_error(dbg, error, DW_DLE_ALLOC_FAIL);
+        return (NULL);
+    }
+
+    ret_expr->ex_dbg = dbg;
+
+    return (ret_expr);
+}
+
+
+Dwarf_Unsigned
+dwarf_add_expr_gen(Dwarf_P_Expr expr,
+    Dwarf_Small opcode,
+    Dwarf_Unsigned val1,
+    Dwarf_Unsigned val2, Dwarf_Error * error)
+{
+    /* 2* since used to concatenate 2 leb's below */
+    char encode_buffer[2 * ENCODE_SPACE_NEEDED];
+
+    char encode_buffer2[ENCODE_SPACE_NEEDED];
+    int res = 0;
+    Dwarf_P_Debug dbg = 0;
+
+    /*  Give the buffer where the operands are first going to be
+        assembled the largest alignment. */
+    Dwarf_Unsigned operand_buffer[10];
+
+    /* Size of the byte stream buffer that needs to be memcpy-ed. */
+    int operand_size = 0;
+
+    /*  Points to the byte stream for the first operand, and finally to
+        the buffer that is memcp-ed into the Dwarf_P_Expr_s struct. */
+    Dwarf_Small *operand = 0;
+
+    /*  Size of the byte stream for second operand. */
+    int operand2_size = 0;
+
+    /*  Points to next byte to be written in Dwarf_P_Expr_s struct. */
+    Dwarf_Small *next_byte_ptr = 0;
+
+    /*  Offset past the last byte written into Dwarf_P_Expr_s. */
+    int next_byte_offset = 0;
+
+    /* ***** BEGIN CODE ***** */
+
+    if (expr == NULL) {
+        _dwarf_p_error(NULL, error, DW_DLE_EXPR_NULL);
+        return (DW_DLV_NOCOUNT);
+    }
+    dbg = expr->ex_dbg;
+
+    if (expr->ex_dbg == NULL) {
+        _dwarf_p_error(NULL, error, DW_DLE_DBG_NULL);
+        return (DW_DLV_NOCOUNT);
+    }
+
+    operand = NULL;
+    operand_size = 0;
+
+    switch (opcode) {
+    case DW_OP_reg0:
+    case DW_OP_reg1:
+    case DW_OP_reg2:
+    case DW_OP_reg3:
+    case DW_OP_reg4:
+    case DW_OP_reg5:
+    case DW_OP_reg6:
+    case DW_OP_reg7:
+    case DW_OP_reg8:
+    case DW_OP_reg9:
+    case DW_OP_reg10:
+    case DW_OP_reg11:
+    case DW_OP_reg12:
+    case DW_OP_reg13:
+    case DW_OP_reg14:
+    case DW_OP_reg15:
+    case DW_OP_reg16:
+    case DW_OP_reg17:
+    case DW_OP_reg18:
+    case DW_OP_reg19:
+    case DW_OP_reg20:
+    case DW_OP_reg21:
+    case DW_OP_reg22:
+    case DW_OP_reg23:
+    case DW_OP_reg24:
+    case DW_OP_reg25:
+    case DW_OP_reg26:
+    case DW_OP_reg27:
+    case DW_OP_reg28:
+    case DW_OP_reg29:
+    case DW_OP_reg30:
+    case DW_OP_reg31:
+        break;
+
+    case DW_OP_breg0:
+    case DW_OP_breg1:
+    case DW_OP_breg2:
+    case DW_OP_breg3:
+    case DW_OP_breg4:
+    case DW_OP_breg5:
+    case DW_OP_breg6:
+    case DW_OP_breg7:
+    case DW_OP_breg8:
+    case DW_OP_breg9:
+    case DW_OP_breg10:
+    case DW_OP_breg11:
+    case DW_OP_breg12:
+    case DW_OP_breg13:
+    case DW_OP_breg14:
+    case DW_OP_breg15:
+    case DW_OP_breg16:
+    case DW_OP_breg17:
+    case DW_OP_breg18:
+    case DW_OP_breg19:
+    case DW_OP_breg20:
+    case DW_OP_breg21:
+    case DW_OP_breg22:
+    case DW_OP_breg23:
+    case DW_OP_breg24:
+    case DW_OP_breg25:
+    case DW_OP_breg26:
+    case DW_OP_breg27:
+    case DW_OP_breg28:
+    case DW_OP_breg29:
+    case DW_OP_breg30:
+    case DW_OP_breg31:
+        res = _dwarf_pro_encode_signed_leb128_nm(val1,
+            &operand_size, encode_buffer, sizeof(encode_buffer));
+        if (res != DW_DLV_OK) {
+            _dwarf_p_error(expr->ex_dbg, error, DW_DLE_EXPR_LENGTH_BAD);
+            return (DW_DLV_NOCOUNT);
+        }
+        operand = (Dwarf_Small *) encode_buffer;
+        break;
+
+    case DW_OP_regx:
+        res = _dwarf_pro_encode_leb128_nm(val1, &operand_size,
+            encode_buffer, sizeof(encode_buffer));
+        if (res != DW_DLV_OK) {
+            _dwarf_p_error(expr->ex_dbg, error, DW_DLE_EXPR_LENGTH_BAD);
+            return (DW_DLV_NOCOUNT);
+        }
+        operand = (Dwarf_Small *) encode_buffer;
+        break;
+
+    case DW_OP_lit0:
+    case DW_OP_lit1:
+    case DW_OP_lit2:
+    case DW_OP_lit3:
+    case DW_OP_lit4:
+    case DW_OP_lit5:
+    case DW_OP_lit6:
+    case DW_OP_lit7:
+    case DW_OP_lit8:
+    case DW_OP_lit9:
+    case DW_OP_lit10:
+    case DW_OP_lit11:
+    case DW_OP_lit12:
+    case DW_OP_lit13:
+    case DW_OP_lit14:
+    case DW_OP_lit15:
+    case DW_OP_lit16:
+    case DW_OP_lit17:
+    case DW_OP_lit18:
+    case DW_OP_lit19:
+    case DW_OP_lit20:
+    case DW_OP_lit21:
+    case DW_OP_lit22:
+    case DW_OP_lit23:
+    case DW_OP_lit24:
+    case DW_OP_lit25:
+    case DW_OP_lit26:
+    case DW_OP_lit27:
+    case DW_OP_lit28:
+    case DW_OP_lit29:
+    case DW_OP_lit30:
+    case DW_OP_lit31:
+        break;
+
+    case DW_OP_addr:
+        _dwarf_p_error(expr->ex_dbg, error, DW_DLE_BAD_EXPR_OPCODE);
+        return (DW_DLV_NOCOUNT);
+
+    case DW_OP_const1u:
+    case DW_OP_const1s:
+        operand = (Dwarf_Small *) & operand_buffer[0];
+        WRITE_UNALIGNED(dbg, operand, &val1, sizeof(val1), 1);
+        operand_size = 1;
+        break;
+
+    case DW_OP_const2u:
+    case DW_OP_const2s:
+        operand = (Dwarf_Small *) & operand_buffer[0];
+        WRITE_UNALIGNED(dbg, operand, &val1, sizeof(val1), 2);
+        operand_size = 2;
+        break;
+
+    case DW_OP_const4u:
+    case DW_OP_const4s:
+        operand = (Dwarf_Small *) & operand_buffer[0];
+        WRITE_UNALIGNED(dbg, operand, &val1, sizeof(val1), 4);
+        operand_size = 4;
+        break;
+
+    case DW_OP_const8u:
+    case DW_OP_const8s:
+        operand = (Dwarf_Small *) & operand_buffer[0];
+        WRITE_UNALIGNED(dbg, operand, &val1, sizeof(val1), 8);
+        operand_size = 8;
+        break;
+
+    case DW_OP_constu:
+        res = _dwarf_pro_encode_leb128_nm(val1,
+            &operand_size, encode_buffer, sizeof(encode_buffer));
+        if (res != DW_DLV_OK) {
+            _dwarf_p_error(expr->ex_dbg, error, DW_DLE_EXPR_LENGTH_BAD);
+            return (DW_DLV_NOCOUNT);
+        }
+        operand = (Dwarf_Small *) encode_buffer;
+        break;
+
+    case DW_OP_consts:
+        res = _dwarf_pro_encode_signed_leb128_nm(val1,
+            &operand_size,
+            encode_buffer,
+            sizeof(encode_buffer));
+        if (res != DW_DLV_OK) {
+            _dwarf_p_error(expr->ex_dbg, error, DW_DLE_EXPR_LENGTH_BAD);
+            return (DW_DLV_NOCOUNT);
+        }
+        operand = (Dwarf_Small *) encode_buffer;
+        break;
+
+    case DW_OP_fbreg:
+        res = _dwarf_pro_encode_signed_leb128_nm(val1,
+            &operand_size,
+            encode_buffer,
+            sizeof(encode_buffer));
+        if (res != DW_DLV_OK) {
+            _dwarf_p_error(expr->ex_dbg, error, DW_DLE_EXPR_LENGTH_BAD);
+            return (DW_DLV_NOCOUNT);
+        }
+        operand = (Dwarf_Small *) encode_buffer;
+        break;
+
+    case DW_OP_bregx:
+        res = _dwarf_pro_encode_leb128_nm(val1, &operand_size,
+            encode_buffer,
+            sizeof(encode_buffer));
+        if (res != DW_DLV_OK) {
+            _dwarf_p_error(expr->ex_dbg, error, DW_DLE_EXPR_LENGTH_BAD);
+            return (DW_DLV_NOCOUNT);
+        }
+        operand = (Dwarf_Small *) encode_buffer;
+        /* put this one directly into 'operand' at tail of prev value */
+        res = _dwarf_pro_encode_signed_leb128_nm(val2, &operand2_size,
+            ((char *) operand) +
+            operand_size,
+            sizeof(encode_buffer2));
+        if (res != DW_DLV_OK) {
+            _dwarf_p_error(expr->ex_dbg, error, DW_DLE_EXPR_LENGTH_BAD);
+            return (DW_DLV_NOCOUNT);
+        }
+        operand_size += operand2_size;
+
+    case DW_OP_dup:
+    case DW_OP_drop:
+        break;
+
+    case DW_OP_pick:
+        operand = (Dwarf_Small *) & operand_buffer[0];
+        WRITE_UNALIGNED(dbg, operand, (const void *) &val1,
+            sizeof(val1), 1);
+        operand_size = 1;
+        break;
+
+    case DW_OP_over:
+    case DW_OP_swap:
+    case DW_OP_rot:
+    case DW_OP_deref:
+    case DW_OP_xderef:
+        break;
+
+    case DW_OP_deref_size:
+    case DW_OP_xderef_size:
+        operand = (Dwarf_Small *) & operand_buffer[0];
+        WRITE_UNALIGNED(dbg, operand, (const void *) &val1,
+            sizeof(val1), 1);
+        operand_size = 1;
+        break;
+
+    case DW_OP_abs:
+    case DW_OP_and:
+    case DW_OP_div:
+    case DW_OP_minus:
+    case DW_OP_mod:
+    case DW_OP_mul:
+    case DW_OP_neg:
+    case DW_OP_not:
+    case DW_OP_or:
+    case DW_OP_plus:
+        break;
+
+    case DW_OP_plus_uconst:
+        res = _dwarf_pro_encode_leb128_nm(val1, &operand_size,
+            encode_buffer,
+            sizeof(encode_buffer));
+        if (res != DW_DLV_OK) {
+            _dwarf_p_error(expr->ex_dbg, error, DW_DLE_EXPR_LENGTH_BAD);
+            return (DW_DLV_NOCOUNT);
+        }
+        operand = (Dwarf_Small *) encode_buffer;
+        break;
+
+    case DW_OP_shl:
+    case DW_OP_shr:
+    case DW_OP_shra:
+    case DW_OP_xor:
+        break;
+
+    case DW_OP_le:
+    case DW_OP_ge:
+    case DW_OP_eq:
+    case DW_OP_lt:
+    case DW_OP_gt:
+    case DW_OP_ne:
+        break;
+
+    case DW_OP_skip:
+    case DW_OP_bra:
+        /* FIX: unhandled! OP_bra, OP_skip! */
+        _dwarf_p_error(expr->ex_dbg, error, DW_DLE_BAD_EXPR_OPCODE);
+        return (DW_DLV_NOCOUNT);
+
+    case DW_OP_piece:
+        res = _dwarf_pro_encode_leb128_nm(val1, &operand_size,
+            encode_buffer,
+            sizeof(encode_buffer));
+        if (res != DW_DLV_OK) {
+            _dwarf_p_error(expr->ex_dbg, error, DW_DLE_EXPR_LENGTH_BAD);
+            return (DW_DLV_NOCOUNT);
+        }
+        operand = (Dwarf_Small *) encode_buffer;
+        break;
+
+    case DW_OP_nop:
+        break;
+    case DW_OP_push_object_address:     /* DWARF3 */
+        break;
+    case DW_OP_call2:           /* DWARF3 */
+        operand = (Dwarf_Small *) & operand_buffer[0];
+        WRITE_UNALIGNED(dbg, operand, &val1, sizeof(val1), 2);
+        operand_size = 2;
+        break;
+
+    case DW_OP_call4:           /* DWARF3 */
+        operand = (Dwarf_Small *) & operand_buffer[0];
+        WRITE_UNALIGNED(dbg, operand, &val1, sizeof(val1), 4);
+        operand_size = 4;
+        break;
+
+    case DW_OP_call_ref:        /* DWARF3 */
+        operand = (Dwarf_Small *) & operand_buffer[0];
+        WRITE_UNALIGNED(dbg, operand, &val1, sizeof(val1),
+            dbg->de_offset_size);
+        operand_size = dbg->de_offset_size;
+        break;
+    case DW_OP_form_tls_address:        /* DWARF3f */
+        break;
+    case DW_OP_call_frame_cfa:  /* DWARF3f */
+        break;
+    case DW_OP_bit_piece:       /* DWARF3f */
+        res = _dwarf_pro_encode_leb128_nm(val1, &operand_size,
+            encode_buffer,
+            sizeof(encode_buffer));
+        if (res != DW_DLV_OK) {
+            _dwarf_p_error(expr->ex_dbg, error, DW_DLE_EXPR_LENGTH_BAD);
+            return (DW_DLV_NOCOUNT);
+        }
+        operand = (Dwarf_Small *) encode_buffer;
+        /* put this one directly into 'operand' at tail of prev value */
+        res = _dwarf_pro_encode_leb128_nm(val2, &operand2_size,
+            ((char *) operand) +
+            operand_size,
+            sizeof(encode_buffer2));
+        if (res != DW_DLV_OK) {
+            _dwarf_p_error(expr->ex_dbg, error, DW_DLE_EXPR_LENGTH_BAD);
+            return (DW_DLV_NOCOUNT);
+        }
+        operand_size += operand2_size;
+
+
+    default:
+        _dwarf_p_error(expr->ex_dbg, error, DW_DLE_BAD_EXPR_OPCODE);
+        return (DW_DLV_NOCOUNT);
+    }
+
+    next_byte_offset = expr->ex_next_byte_offset + operand_size + 1;
+
+    if (next_byte_offset > MAXIMUM_LOC_EXPR_LENGTH) {
+        _dwarf_p_error(expr->ex_dbg, error, DW_DLE_EXPR_LENGTH_BAD);
+        return (DW_DLV_NOCOUNT);
+    }
+
+    next_byte_ptr =
+        &(expr->ex_byte_stream[0]) + expr->ex_next_byte_offset;
+
+    *next_byte_ptr = opcode;
+    next_byte_ptr++;
+    memcpy(next_byte_ptr, operand, operand_size);
+
+    expr->ex_next_byte_offset = next_byte_offset;
+    return (next_byte_offset);
+}
+
+Dwarf_Unsigned
+dwarf_add_expr_addr_b(Dwarf_P_Expr expr,
+    Dwarf_Unsigned addr,
+    Dwarf_Unsigned sym_index, Dwarf_Error * error)
+{
+    Dwarf_P_Debug dbg;
+    Dwarf_Small *next_byte_ptr;
+    Dwarf_Unsigned next_byte_offset;
+    int upointer_size;
+
+    if (expr == NULL) {
+        _dwarf_p_error(NULL, error, DW_DLE_EXPR_NULL);
+        return (DW_DLV_NOCOUNT);
+    }
+
+    dbg = expr->ex_dbg;
+    if (dbg == NULL) {
+        _dwarf_p_error(NULL, error, DW_DLE_DBG_NULL);
+        return (DW_DLV_NOCOUNT);
+    }
+
+    upointer_size = dbg->de_pointer_size;
+    next_byte_offset = expr->ex_next_byte_offset + upointer_size + 1;
+    if (next_byte_offset > MAXIMUM_LOC_EXPR_LENGTH) {
+        _dwarf_p_error(dbg, error, DW_DLE_EXPR_LENGTH_BAD);
+        return (DW_DLV_NOCOUNT);
+    }
+
+    next_byte_ptr =
+        &(expr->ex_byte_stream[0]) + expr->ex_next_byte_offset;
+
+    *next_byte_ptr = DW_OP_addr;
+    next_byte_ptr++;
+    WRITE_UNALIGNED(dbg, next_byte_ptr, (const void *) &addr,
+        sizeof(addr), upointer_size);
+
+    if (expr->ex_reloc_offset != 0) {
+        _dwarf_p_error(dbg, error, DW_DLE_MULTIPLE_RELOC_IN_EXPR);
+        return (DW_DLV_NOCOUNT);
+    }
+
+    expr->ex_reloc_sym_index = sym_index;
+    expr->ex_reloc_offset = expr->ex_next_byte_offset + 1;
+
+    expr->ex_next_byte_offset = next_byte_offset;
+    return (next_byte_offset);
+}
+
+Dwarf_Unsigned
+dwarf_add_expr_addr(Dwarf_P_Expr expr,
+    Dwarf_Unsigned addr,
+    Dwarf_Signed sym_index, Dwarf_Error * error)
+{
+    return
+        dwarf_add_expr_addr_b(expr, addr, (Dwarf_Unsigned) sym_index,
+            error);
+}
+
+
+Dwarf_Unsigned
+dwarf_expr_current_offset(Dwarf_P_Expr expr, Dwarf_Error * error)
+{
+    if (expr == NULL) {
+        _dwarf_p_error(NULL, error, DW_DLE_EXPR_NULL);
+        return (DW_DLV_NOCOUNT);
+    }
+
+    if (expr->ex_dbg == NULL) {
+        _dwarf_p_error(NULL, error, DW_DLE_DBG_NULL);
+        return (DW_DLV_NOCOUNT);
+    }
+
+    return (expr->ex_next_byte_offset);
+}
+
+void
+dwarf_expr_reset(Dwarf_P_Expr expr, Dwarf_Error * error)
+{
+    if (expr == NULL) {
+        _dwarf_p_error(NULL, error, DW_DLE_EXPR_NULL);
+        return;
+    }
+    expr->ex_next_byte_offset=0;
+}
+
+
+Dwarf_Addr
+dwarf_expr_into_block(Dwarf_P_Expr expr,
+    Dwarf_Unsigned * length, Dwarf_Error * error)
+{
+    if (expr == NULL) {
+        _dwarf_p_error(NULL, error, DW_DLE_EXPR_NULL);
+        return (DW_DLV_BADADDR);
+    }
+
+    if (expr->ex_dbg == NULL) {
+        _dwarf_p_error(NULL, error, DW_DLE_DBG_NULL);
+        return (DW_DLV_BADADDR);
+    }
+
+    if (length != NULL)
+        *length = expr->ex_next_byte_offset;
+    /*  The following cast from pointer to integer is ok as long as
+        Dwarf_Addr is at least as large as a pointer. Which is a
+        requirement of libdwarf so must be satisfied (some compilers
+        emit a warning about the following line). */
+    return ((Dwarf_Addr) & (expr->ex_byte_stream[0]));
+}