Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 2 of 2.

1 files changed, 731 insertions, 731 deletions

diff --git a/contrib/libs/libunwind/src/DwarfInstructions.hpp b/contrib/libs/libunwind/src/DwarfInstructions.hpp
index 4f61bf739c..c1a241c55c 100644
--- a/contrib/libs/libunwind/src/DwarfInstructions.hpp
+++ b/contrib/libs/libunwind/src/DwarfInstructions.hpp
@@ -1,79 +1,79 @@
 //===----------------------------------------------------------------------===//
-// 
+//
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-// 
-// 
+//
+//
 //  Processor specific interpretation of DWARF unwind info.
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef __DWARF_INSTRUCTIONS_HPP__ 
-#define __DWARF_INSTRUCTIONS_HPP__ 
- 
-#include <stdint.h> 
-#include <stdio.h> 
-#include <stdlib.h> 
- 
-#include "dwarf2.h" 
-#include "Registers.hpp" 
-#include "DwarfParser.hpp" 
-#include "config.h" 
- 
- 
-namespace libunwind { 
- 
- 
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __DWARF_INSTRUCTIONS_HPP__
+#define __DWARF_INSTRUCTIONS_HPP__
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "dwarf2.h"
+#include "Registers.hpp"
+#include "DwarfParser.hpp"
+#include "config.h"
+
+
+namespace libunwind {
+
+
 /// DwarfInstructions maps abtract DWARF unwind instructions to a particular
-/// architecture 
-template <typename A, typename R> 
-class DwarfInstructions { 
-public: 
-  typedef typename A::pint_t pint_t; 
-  typedef typename A::sint_t sint_t; 
- 
-  static int stepWithDwarf(A &addressSpace, pint_t pc, pint_t fdeStart, 
+/// architecture
+template <typename A, typename R>
+class DwarfInstructions {
+public:
+  typedef typename A::pint_t pint_t;
+  typedef typename A::sint_t sint_t;
+
+  static int stepWithDwarf(A &addressSpace, pint_t pc, pint_t fdeStart,
                            R &registers, bool &isSignalFrame);
- 
-private: 
- 
-  enum { 
-    DW_X86_64_RET_ADDR = 16 
-  }; 
- 
-  enum { 
-    DW_X86_RET_ADDR = 8 
-  }; 
- 
-  typedef typename CFI_Parser<A>::RegisterLocation  RegisterLocation; 
-  typedef typename CFI_Parser<A>::PrologInfo        PrologInfo; 
-  typedef typename CFI_Parser<A>::FDE_Info          FDE_Info; 
-  typedef typename CFI_Parser<A>::CIE_Info          CIE_Info; 
- 
-  static pint_t evaluateExpression(pint_t expression, A &addressSpace, 
-                                   const R &registers, 
-                                   pint_t initialStackValue); 
-  static pint_t getSavedRegister(A &addressSpace, const R &registers, 
-                                 pint_t cfa, const RegisterLocation &savedReg); 
-  static double getSavedFloatRegister(A &addressSpace, const R &registers, 
-                                  pint_t cfa, const RegisterLocation &savedReg); 
-  static v128 getSavedVectorRegister(A &addressSpace, const R &registers, 
-                                  pint_t cfa, const RegisterLocation &savedReg); 
- 
-  static pint_t getCFA(A &addressSpace, const PrologInfo &prolog, 
-                       const R &registers) { 
+
+private:
+
+  enum {
+    DW_X86_64_RET_ADDR = 16
+  };
+
+  enum {
+    DW_X86_RET_ADDR = 8
+  };
+
+  typedef typename CFI_Parser<A>::RegisterLocation  RegisterLocation;
+  typedef typename CFI_Parser<A>::PrologInfo        PrologInfo;
+  typedef typename CFI_Parser<A>::FDE_Info          FDE_Info;
+  typedef typename CFI_Parser<A>::CIE_Info          CIE_Info;
+
+  static pint_t evaluateExpression(pint_t expression, A &addressSpace,
+                                   const R &registers,
+                                   pint_t initialStackValue);
+  static pint_t getSavedRegister(A &addressSpace, const R &registers,
+                                 pint_t cfa, const RegisterLocation &savedReg);
+  static double getSavedFloatRegister(A &addressSpace, const R &registers,
+                                  pint_t cfa, const RegisterLocation &savedReg);
+  static v128 getSavedVectorRegister(A &addressSpace, const R &registers,
+                                  pint_t cfa, const RegisterLocation &savedReg);
+
+  static pint_t getCFA(A &addressSpace, const PrologInfo &prolog,
+                       const R &registers) {
     if (prolog.cfaRegister != 0)
       return (pint_t)((sint_t)registers.getRegister((int)prolog.cfaRegister) +
-             prolog.cfaRegisterOffset); 
-    if (prolog.cfaExpression != 0) 
-      return evaluateExpression((pint_t)prolog.cfaExpression, addressSpace,  
-                                registers, 0); 
-    assert(0 && "getCFA(): unknown location"); 
-    __builtin_unreachable(); 
-  } 
-}; 
- 
+             prolog.cfaRegisterOffset);
+    if (prolog.cfaExpression != 0)
+      return evaluateExpression((pint_t)prolog.cfaExpression, addressSpace, 
+                                registers, 0);
+    assert(0 && "getCFA(): unknown location");
+    __builtin_unreachable();
+  }
+};
+
 template <typename R>
 auto getSparcWCookie(const R &r, int) -> decltype(r.getWCookie()) {
   return r.getWCookie();
@@ -81,108 +81,108 @@ auto getSparcWCookie(const R &r, int) -> decltype(r.getWCookie()) {
 template <typename R> uint64_t getSparcWCookie(const R &, long) {
   return 0;
 }
- 
-template <typename A, typename R> 
-typename A::pint_t DwarfInstructions<A, R>::getSavedRegister( 
-    A &addressSpace, const R &registers, pint_t cfa, 
-    const RegisterLocation &savedReg) { 
-  switch (savedReg.location) { 
-  case CFI_Parser<A>::kRegisterInCFA: 
+
+template <typename A, typename R>
+typename A::pint_t DwarfInstructions<A, R>::getSavedRegister(
+    A &addressSpace, const R &registers, pint_t cfa,
+    const RegisterLocation &savedReg) {
+  switch (savedReg.location) {
+  case CFI_Parser<A>::kRegisterInCFA:
     return (pint_t)addressSpace.getRegister(cfa + (pint_t)savedReg.value);
- 
+
   case CFI_Parser<A>::kRegisterInCFADecrypt: // sparc64 specific
     return addressSpace.getP(cfa + (pint_t)savedReg.value) ^
            getSparcWCookie(registers, 0);
 
-  case CFI_Parser<A>::kRegisterAtExpression: 
+  case CFI_Parser<A>::kRegisterAtExpression:
     return (pint_t)addressSpace.getRegister(evaluateExpression(
         (pint_t)savedReg.value, addressSpace, registers, cfa));
- 
-  case CFI_Parser<A>::kRegisterIsExpression: 
-    return evaluateExpression((pint_t)savedReg.value, addressSpace, 
-                              registers, cfa); 
- 
-  case CFI_Parser<A>::kRegisterInRegister: 
-    return registers.getRegister((int)savedReg.value); 
+
+  case CFI_Parser<A>::kRegisterIsExpression:
+    return evaluateExpression((pint_t)savedReg.value, addressSpace,
+                              registers, cfa);
+
+  case CFI_Parser<A>::kRegisterInRegister:
+    return registers.getRegister((int)savedReg.value);
   case CFI_Parser<A>::kRegisterUndefined:
     return 0;
-  case CFI_Parser<A>::kRegisterUnused: 
-  case CFI_Parser<A>::kRegisterOffsetFromCFA: 
-    // FIX ME 
-    break; 
-  } 
-  _LIBUNWIND_ABORT("unsupported restore location for register"); 
-} 
- 
-template <typename A, typename R> 
-double DwarfInstructions<A, R>::getSavedFloatRegister( 
-    A &addressSpace, const R &registers, pint_t cfa, 
-    const RegisterLocation &savedReg) { 
-  switch (savedReg.location) { 
-  case CFI_Parser<A>::kRegisterInCFA: 
-    return addressSpace.getDouble(cfa + (pint_t)savedReg.value); 
- 
-  case CFI_Parser<A>::kRegisterAtExpression: 
-    return addressSpace.getDouble( 
-        evaluateExpression((pint_t)savedReg.value, addressSpace, 
-                            registers, cfa)); 
+  case CFI_Parser<A>::kRegisterUnused:
+  case CFI_Parser<A>::kRegisterOffsetFromCFA:
+    // FIX ME
+    break;
+  }
+  _LIBUNWIND_ABORT("unsupported restore location for register");
+}
+
+template <typename A, typename R>
+double DwarfInstructions<A, R>::getSavedFloatRegister(
+    A &addressSpace, const R &registers, pint_t cfa,
+    const RegisterLocation &savedReg) {
+  switch (savedReg.location) {
+  case CFI_Parser<A>::kRegisterInCFA:
+    return addressSpace.getDouble(cfa + (pint_t)savedReg.value);
+
+  case CFI_Parser<A>::kRegisterAtExpression:
+    return addressSpace.getDouble(
+        evaluateExpression((pint_t)savedReg.value, addressSpace,
+                            registers, cfa));
   case CFI_Parser<A>::kRegisterUndefined:
     return 0.0;
   case CFI_Parser<A>::kRegisterInRegister:
 #ifndef _LIBUNWIND_TARGET_ARM
     return registers.getFloatRegister((int)savedReg.value);
 #endif
-  case CFI_Parser<A>::kRegisterIsExpression: 
-  case CFI_Parser<A>::kRegisterUnused: 
-  case CFI_Parser<A>::kRegisterOffsetFromCFA: 
+  case CFI_Parser<A>::kRegisterIsExpression:
+  case CFI_Parser<A>::kRegisterUnused:
+  case CFI_Parser<A>::kRegisterOffsetFromCFA:
   case CFI_Parser<A>::kRegisterInCFADecrypt:
-    // FIX ME 
-    break; 
-  } 
-  _LIBUNWIND_ABORT("unsupported restore location for float register"); 
-} 
- 
-template <typename A, typename R> 
-v128 DwarfInstructions<A, R>::getSavedVectorRegister( 
-    A &addressSpace, const R &registers, pint_t cfa, 
-    const RegisterLocation &savedReg) { 
-  switch (savedReg.location) { 
-  case CFI_Parser<A>::kRegisterInCFA: 
-    return addressSpace.getVector(cfa + (pint_t)savedReg.value); 
- 
-  case CFI_Parser<A>::kRegisterAtExpression: 
-    return addressSpace.getVector( 
-        evaluateExpression((pint_t)savedReg.value, addressSpace, 
-                            registers, cfa)); 
- 
-  case CFI_Parser<A>::kRegisterIsExpression: 
-  case CFI_Parser<A>::kRegisterUnused: 
+    // FIX ME
+    break;
+  }
+  _LIBUNWIND_ABORT("unsupported restore location for float register");
+}
+
+template <typename A, typename R>
+v128 DwarfInstructions<A, R>::getSavedVectorRegister(
+    A &addressSpace, const R &registers, pint_t cfa,
+    const RegisterLocation &savedReg) {
+  switch (savedReg.location) {
+  case CFI_Parser<A>::kRegisterInCFA:
+    return addressSpace.getVector(cfa + (pint_t)savedReg.value);
+
+  case CFI_Parser<A>::kRegisterAtExpression:
+    return addressSpace.getVector(
+        evaluateExpression((pint_t)savedReg.value, addressSpace,
+                            registers, cfa));
+
+  case CFI_Parser<A>::kRegisterIsExpression:
+  case CFI_Parser<A>::kRegisterUnused:
   case CFI_Parser<A>::kRegisterUndefined:
-  case CFI_Parser<A>::kRegisterOffsetFromCFA: 
-  case CFI_Parser<A>::kRegisterInRegister: 
+  case CFI_Parser<A>::kRegisterOffsetFromCFA:
+  case CFI_Parser<A>::kRegisterInRegister:
   case CFI_Parser<A>::kRegisterInCFADecrypt:
-    // FIX ME 
-    break; 
-  } 
-  _LIBUNWIND_ABORT("unsupported restore location for vector register"); 
-} 
- 
-template <typename A, typename R> 
-int DwarfInstructions<A, R>::stepWithDwarf(A &addressSpace, pint_t pc, 
+    // FIX ME
+    break;
+  }
+  _LIBUNWIND_ABORT("unsupported restore location for vector register");
+}
+
+template <typename A, typename R>
+int DwarfInstructions<A, R>::stepWithDwarf(A &addressSpace, pint_t pc,
                                            pint_t fdeStart, R &registers,
                                            bool &isSignalFrame) {
-  FDE_Info fdeInfo; 
-  CIE_Info cieInfo; 
-  if (CFI_Parser<A>::decodeFDE(addressSpace, fdeStart, &fdeInfo, 
-                               &cieInfo) == NULL) { 
-    PrologInfo prolog; 
-    if (CFI_Parser<A>::parseFDEInstructions(addressSpace, fdeInfo, cieInfo, pc, 
+  FDE_Info fdeInfo;
+  CIE_Info cieInfo;
+  if (CFI_Parser<A>::decodeFDE(addressSpace, fdeStart, &fdeInfo,
+                               &cieInfo) == NULL) {
+    PrologInfo prolog;
+    if (CFI_Parser<A>::parseFDEInstructions(addressSpace, fdeInfo, cieInfo, pc,
                                             R::getArch(), &prolog)) {
-      // get pointer to cfa (architecture specific) 
-      pint_t cfa = getCFA(addressSpace, prolog, registers); 
- 
+      // get pointer to cfa (architecture specific)
+      pint_t cfa = getCFA(addressSpace, prolog, registers);
+
        // restore registers that DWARF says were saved
-      R newRegisters = registers; 
+      R newRegisters = registers;
 
       // Typically, the CFA is the stack pointer at the call site in
       // the previous frame. However, there are scenarios in which this is not
@@ -193,39 +193,39 @@ int DwarfInstructions<A, R>::stepWithDwarf(A &addressSpace, pint_t pc,
       // by a CFI directive later on.
       newRegisters.setSP(cfa);
 
-      pint_t returnAddress = 0; 
-      const int lastReg = R::lastDwarfRegNum(); 
+      pint_t returnAddress = 0;
+      const int lastReg = R::lastDwarfRegNum();
       assert(static_cast<int>(CFI_Parser<A>::kMaxRegisterNumber) >= lastReg &&
-             "register range too large"); 
-      assert(lastReg >= (int)cieInfo.returnAddressRegister && 
-             "register range does not contain return address register"); 
-      for (int i = 0; i <= lastReg; ++i) { 
-        if (prolog.savedRegisters[i].location != 
-            CFI_Parser<A>::kRegisterUnused) { 
-          if (registers.validFloatRegister(i)) 
-            newRegisters.setFloatRegister( 
-                i, getSavedFloatRegister(addressSpace, registers, cfa, 
-                                         prolog.savedRegisters[i])); 
-          else if (registers.validVectorRegister(i)) 
-            newRegisters.setVectorRegister( 
-                i, getSavedVectorRegister(addressSpace, registers, cfa, 
-                                          prolog.savedRegisters[i])); 
-          else if (i == (int)cieInfo.returnAddressRegister) 
-            returnAddress = getSavedRegister(addressSpace, registers, cfa, 
-                                             prolog.savedRegisters[i]); 
-          else if (registers.validRegister(i)) 
-            newRegisters.setRegister( 
-                i, getSavedRegister(addressSpace, registers, cfa, 
-                                    prolog.savedRegisters[i])); 
-          else 
-            return UNW_EBADREG; 
+             "register range too large");
+      assert(lastReg >= (int)cieInfo.returnAddressRegister &&
+             "register range does not contain return address register");
+      for (int i = 0; i <= lastReg; ++i) {
+        if (prolog.savedRegisters[i].location !=
+            CFI_Parser<A>::kRegisterUnused) {
+          if (registers.validFloatRegister(i))
+            newRegisters.setFloatRegister(
+                i, getSavedFloatRegister(addressSpace, registers, cfa,
+                                         prolog.savedRegisters[i]));
+          else if (registers.validVectorRegister(i))
+            newRegisters.setVectorRegister(
+                i, getSavedVectorRegister(addressSpace, registers, cfa,
+                                          prolog.savedRegisters[i]));
+          else if (i == (int)cieInfo.returnAddressRegister)
+            returnAddress = getSavedRegister(addressSpace, registers, cfa,
+                                             prolog.savedRegisters[i]);
+          else if (registers.validRegister(i))
+            newRegisters.setRegister(
+                i, getSavedRegister(addressSpace, registers, cfa,
+                                    prolog.savedRegisters[i]));
+          else
+            return UNW_EBADREG;
         } else if (i == (int)cieInfo.returnAddressRegister) {
             // Leaf function keeps the return address in register and there is no
             // explicit intructions how to restore it.
             returnAddress = registers.getRegister(cieInfo.returnAddressRegister);
-        } 
-      } 
- 
+        }
+      }
+
       isSignalFrame = cieInfo.isSignalFrame;
 
 #if defined(_LIBUNWIND_TARGET_AARCH64)
@@ -310,562 +310,562 @@ int DwarfInstructions<A, R>::stepWithDwarf(A &addressSpace, pint_t pc,
       }
 #endif
 
-      // Return address is address after call site instruction, so setting IP to 
-      // that does simualates a return. 
-      newRegisters.setIP(returnAddress); 
- 
-      // Simulate the step by replacing the register set with the new ones. 
-      registers = newRegisters; 
- 
-      return UNW_STEP_SUCCESS; 
-    } 
-  } 
-  return UNW_EBADFRAME; 
-} 
- 
-template <typename A, typename R> 
-typename A::pint_t 
-DwarfInstructions<A, R>::evaluateExpression(pint_t expression, A &addressSpace, 
-                                            const R &registers, 
-                                            pint_t initialStackValue) { 
-  const bool log = false; 
-  pint_t p = expression; 
-  pint_t expressionEnd = expression + 20; // temp, until len read 
-  pint_t length = (pint_t)addressSpace.getULEB128(p, expressionEnd); 
-  expressionEnd = p + length; 
-  if (log) 
-    fprintf(stderr, "evaluateExpression(): length=%" PRIu64 "\n", 
-            (uint64_t)length); 
-  pint_t stack[100]; 
-  pint_t *sp = stack; 
-  *(++sp) = initialStackValue; 
- 
-  while (p < expressionEnd) { 
-    if (log) { 
-      for (pint_t *t = sp; t > stack; --t) { 
-        fprintf(stderr, "sp[] = 0x%" PRIx64 "\n", (uint64_t)(*t)); 
-      } 
-    } 
-    uint8_t opcode = addressSpace.get8(p++); 
-    sint_t svalue, svalue2; 
-    pint_t value; 
-    uint32_t reg; 
-    switch (opcode) { 
-    case DW_OP_addr: 
-      // push immediate address sized value 
-      value = addressSpace.getP(p); 
-      p += sizeof(pint_t); 
-      *(++sp) = value; 
-      if (log) 
-        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value); 
-      break; 
- 
-    case DW_OP_deref: 
-      // pop stack, dereference, push result 
-      value = *sp--; 
-      *(++sp) = addressSpace.getP(value); 
-      if (log) 
-        fprintf(stderr, "dereference 0x%" PRIx64 "\n", (uint64_t)value); 
-      break; 
- 
-    case DW_OP_const1u: 
-      // push immediate 1 byte value 
-      value = addressSpace.get8(p); 
-      p += 1; 
-      *(++sp) = value; 
-      if (log) 
-        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value); 
-      break; 
- 
-    case DW_OP_const1s: 
-      // push immediate 1 byte signed value 
-      svalue = (int8_t) addressSpace.get8(p); 
-      p += 1; 
-      *(++sp) = (pint_t)svalue; 
-      if (log) 
-        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue); 
-      break; 
- 
-    case DW_OP_const2u: 
-      // push immediate 2 byte value 
-      value = addressSpace.get16(p); 
-      p += 2; 
-      *(++sp) = value; 
-      if (log) 
-        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value); 
-      break; 
- 
-    case DW_OP_const2s: 
-      // push immediate 2 byte signed value 
-      svalue = (int16_t) addressSpace.get16(p); 
-      p += 2; 
-      *(++sp) = (pint_t)svalue; 
-      if (log) 
-        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue); 
-      break; 
- 
-    case DW_OP_const4u: 
-      // push immediate 4 byte value 
-      value = addressSpace.get32(p); 
-      p += 4; 
-      *(++sp) = value; 
-      if (log) 
-        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value); 
-      break; 
- 
-    case DW_OP_const4s: 
-      // push immediate 4 byte signed value 
-      svalue = (int32_t)addressSpace.get32(p); 
-      p += 4; 
-      *(++sp) = (pint_t)svalue; 
-      if (log) 
-        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue); 
-      break; 
- 
-    case DW_OP_const8u: 
-      // push immediate 8 byte value 
-      value = (pint_t)addressSpace.get64(p); 
-      p += 8; 
-      *(++sp) = value; 
-      if (log) 
-        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value); 
-      break; 
- 
-    case DW_OP_const8s: 
-      // push immediate 8 byte signed value 
-      value = (pint_t)addressSpace.get64(p); 
-      p += 8; 
-      *(++sp) = value; 
-      if (log) 
-        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value); 
-      break; 
- 
-    case DW_OP_constu: 
-      // push immediate ULEB128 value 
-      value = (pint_t)addressSpace.getULEB128(p, expressionEnd); 
-      *(++sp) = value; 
-      if (log) 
-        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value); 
-      break; 
- 
-    case DW_OP_consts: 
-      // push immediate SLEB128 value 
-      svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd); 
-      *(++sp) = (pint_t)svalue; 
-      if (log) 
-        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue); 
-      break; 
- 
-    case DW_OP_dup: 
-      // push top of stack 
-      value = *sp; 
-      *(++sp) = value; 
-      if (log) 
-        fprintf(stderr, "duplicate top of stack\n"); 
-      break; 
- 
-    case DW_OP_drop: 
-      // pop 
-      --sp; 
-      if (log) 
-        fprintf(stderr, "pop top of stack\n"); 
-      break; 
- 
-    case DW_OP_over: 
-      // dup second 
-      value = sp[-1]; 
-      *(++sp) = value; 
-      if (log) 
-        fprintf(stderr, "duplicate second in stack\n"); 
-      break; 
- 
-    case DW_OP_pick: 
-      // pick from 
-      reg = addressSpace.get8(p); 
-      p += 1; 
+      // Return address is address after call site instruction, so setting IP to
+      // that does simualates a return.
+      newRegisters.setIP(returnAddress);
+
+      // Simulate the step by replacing the register set with the new ones.
+      registers = newRegisters;
+
+      return UNW_STEP_SUCCESS;
+    }
+  }
+  return UNW_EBADFRAME;
+}
+
+template <typename A, typename R>
+typename A::pint_t
+DwarfInstructions<A, R>::evaluateExpression(pint_t expression, A &addressSpace,
+                                            const R &registers,
+                                            pint_t initialStackValue) {
+  const bool log = false;
+  pint_t p = expression;
+  pint_t expressionEnd = expression + 20; // temp, until len read
+  pint_t length = (pint_t)addressSpace.getULEB128(p, expressionEnd);
+  expressionEnd = p + length;
+  if (log)
+    fprintf(stderr, "evaluateExpression(): length=%" PRIu64 "\n",
+            (uint64_t)length);
+  pint_t stack[100];
+  pint_t *sp = stack;
+  *(++sp) = initialStackValue;
+
+  while (p < expressionEnd) {
+    if (log) {
+      for (pint_t *t = sp; t > stack; --t) {
+        fprintf(stderr, "sp[] = 0x%" PRIx64 "\n", (uint64_t)(*t));
+      }
+    }
+    uint8_t opcode = addressSpace.get8(p++);
+    sint_t svalue, svalue2;
+    pint_t value;
+    uint32_t reg;
+    switch (opcode) {
+    case DW_OP_addr:
+      // push immediate address sized value
+      value = addressSpace.getP(p);
+      p += sizeof(pint_t);
+      *(++sp) = value;
+      if (log)
+        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
+      break;
+
+    case DW_OP_deref:
+      // pop stack, dereference, push result
+      value = *sp--;
+      *(++sp) = addressSpace.getP(value);
+      if (log)
+        fprintf(stderr, "dereference 0x%" PRIx64 "\n", (uint64_t)value);
+      break;
+
+    case DW_OP_const1u:
+      // push immediate 1 byte value
+      value = addressSpace.get8(p);
+      p += 1;
+      *(++sp) = value;
+      if (log)
+        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
+      break;
+
+    case DW_OP_const1s:
+      // push immediate 1 byte signed value
+      svalue = (int8_t) addressSpace.get8(p);
+      p += 1;
+      *(++sp) = (pint_t)svalue;
+      if (log)
+        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue);
+      break;
+
+    case DW_OP_const2u:
+      // push immediate 2 byte value
+      value = addressSpace.get16(p);
+      p += 2;
+      *(++sp) = value;
+      if (log)
+        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
+      break;
+
+    case DW_OP_const2s:
+      // push immediate 2 byte signed value
+      svalue = (int16_t) addressSpace.get16(p);
+      p += 2;
+      *(++sp) = (pint_t)svalue;
+      if (log)
+        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue);
+      break;
+
+    case DW_OP_const4u:
+      // push immediate 4 byte value
+      value = addressSpace.get32(p);
+      p += 4;
+      *(++sp) = value;
+      if (log)
+        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
+      break;
+
+    case DW_OP_const4s:
+      // push immediate 4 byte signed value
+      svalue = (int32_t)addressSpace.get32(p);
+      p += 4;
+      *(++sp) = (pint_t)svalue;
+      if (log)
+        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue);
+      break;
+
+    case DW_OP_const8u:
+      // push immediate 8 byte value
+      value = (pint_t)addressSpace.get64(p);
+      p += 8;
+      *(++sp) = value;
+      if (log)
+        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
+      break;
+
+    case DW_OP_const8s:
+      // push immediate 8 byte signed value
+      value = (pint_t)addressSpace.get64(p);
+      p += 8;
+      *(++sp) = value;
+      if (log)
+        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
+      break;
+
+    case DW_OP_constu:
+      // push immediate ULEB128 value
+      value = (pint_t)addressSpace.getULEB128(p, expressionEnd);
+      *(++sp) = value;
+      if (log)
+        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
+      break;
+
+    case DW_OP_consts:
+      // push immediate SLEB128 value
+      svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd);
+      *(++sp) = (pint_t)svalue;
+      if (log)
+        fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue);
+      break;
+
+    case DW_OP_dup:
+      // push top of stack
+      value = *sp;
+      *(++sp) = value;
+      if (log)
+        fprintf(stderr, "duplicate top of stack\n");
+      break;
+
+    case DW_OP_drop:
+      // pop
+      --sp;
+      if (log)
+        fprintf(stderr, "pop top of stack\n");
+      break;
+
+    case DW_OP_over:
+      // dup second
+      value = sp[-1];
+      *(++sp) = value;
+      if (log)
+        fprintf(stderr, "duplicate second in stack\n");
+      break;
+
+    case DW_OP_pick:
+      // pick from
+      reg = addressSpace.get8(p);
+      p += 1;
       value = sp[-(int)reg];
-      *(++sp) = value; 
-      if (log) 
-        fprintf(stderr, "duplicate %d in stack\n", reg); 
-      break; 
- 
-    case DW_OP_swap: 
-      // swap top two 
-      value = sp[0]; 
-      sp[0] = sp[-1]; 
-      sp[-1] = value; 
-      if (log) 
-        fprintf(stderr, "swap top of stack\n"); 
-      break; 
- 
-    case DW_OP_rot: 
-      // rotate top three 
-      value = sp[0]; 
-      sp[0] = sp[-1]; 
-      sp[-1] = sp[-2]; 
-      sp[-2] = value; 
-      if (log) 
-        fprintf(stderr, "rotate top three of stack\n"); 
-      break; 
- 
-    case DW_OP_xderef: 
-      // pop stack, dereference, push result 
-      value = *sp--; 
-      *sp = *((pint_t*)value); 
-      if (log) 
-        fprintf(stderr, "x-dereference 0x%" PRIx64 "\n", (uint64_t)value); 
-      break; 
- 
-    case DW_OP_abs: 
-      svalue = (sint_t)*sp; 
-      if (svalue < 0) 
-        *sp = (pint_t)(-svalue); 
-      if (log) 
-        fprintf(stderr, "abs\n"); 
-      break; 
- 
-    case DW_OP_and: 
-      value = *sp--; 
-      *sp &= value; 
-      if (log) 
-        fprintf(stderr, "and\n"); 
-      break; 
- 
-    case DW_OP_div: 
-      svalue = (sint_t)(*sp--); 
-      svalue2 = (sint_t)*sp; 
-      *sp = (pint_t)(svalue2 / svalue); 
-      if (log) 
-        fprintf(stderr, "div\n"); 
-      break; 
- 
-    case DW_OP_minus: 
-      value = *sp--; 
-      *sp = *sp - value; 
-      if (log) 
-        fprintf(stderr, "minus\n"); 
-      break; 
- 
-    case DW_OP_mod: 
-      svalue = (sint_t)(*sp--); 
-      svalue2 = (sint_t)*sp; 
-      *sp = (pint_t)(svalue2 % svalue); 
-      if (log) 
-        fprintf(stderr, "module\n"); 
-      break; 
- 
-    case DW_OP_mul: 
-      svalue = (sint_t)(*sp--); 
-      svalue2 = (sint_t)*sp; 
-      *sp = (pint_t)(svalue2 * svalue); 
-      if (log) 
-        fprintf(stderr, "mul\n"); 
-      break; 
- 
-    case DW_OP_neg: 
-      *sp = 0 - *sp; 
-      if (log) 
-        fprintf(stderr, "neg\n"); 
-      break; 
- 
-    case DW_OP_not: 
-      svalue = (sint_t)(*sp); 
-      *sp = (pint_t)(~svalue); 
-      if (log) 
-        fprintf(stderr, "not\n"); 
-      break; 
- 
-    case DW_OP_or: 
-      value = *sp--; 
-      *sp |= value; 
-      if (log) 
-        fprintf(stderr, "or\n"); 
-      break; 
- 
-    case DW_OP_plus: 
-      value = *sp--; 
-      *sp += value; 
-      if (log) 
-        fprintf(stderr, "plus\n"); 
-      break; 
- 
-    case DW_OP_plus_uconst: 
-      // pop stack, add uelb128 constant, push result 
+      *(++sp) = value;
+      if (log)
+        fprintf(stderr, "duplicate %d in stack\n", reg);
+      break;
+
+    case DW_OP_swap:
+      // swap top two
+      value = sp[0];
+      sp[0] = sp[-1];
+      sp[-1] = value;
+      if (log)
+        fprintf(stderr, "swap top of stack\n");
+      break;
+
+    case DW_OP_rot:
+      // rotate top three
+      value = sp[0];
+      sp[0] = sp[-1];
+      sp[-1] = sp[-2];
+      sp[-2] = value;
+      if (log)
+        fprintf(stderr, "rotate top three of stack\n");
+      break;
+
+    case DW_OP_xderef:
+      // pop stack, dereference, push result
+      value = *sp--;
+      *sp = *((pint_t*)value);
+      if (log)
+        fprintf(stderr, "x-dereference 0x%" PRIx64 "\n", (uint64_t)value);
+      break;
+
+    case DW_OP_abs:
+      svalue = (sint_t)*sp;
+      if (svalue < 0)
+        *sp = (pint_t)(-svalue);
+      if (log)
+        fprintf(stderr, "abs\n");
+      break;
+
+    case DW_OP_and:
+      value = *sp--;
+      *sp &= value;
+      if (log)
+        fprintf(stderr, "and\n");
+      break;
+
+    case DW_OP_div:
+      svalue = (sint_t)(*sp--);
+      svalue2 = (sint_t)*sp;
+      *sp = (pint_t)(svalue2 / svalue);
+      if (log)
+        fprintf(stderr, "div\n");
+      break;
+
+    case DW_OP_minus:
+      value = *sp--;
+      *sp = *sp - value;
+      if (log)
+        fprintf(stderr, "minus\n");
+      break;
+
+    case DW_OP_mod:
+      svalue = (sint_t)(*sp--);
+      svalue2 = (sint_t)*sp;
+      *sp = (pint_t)(svalue2 % svalue);
+      if (log)
+        fprintf(stderr, "module\n");
+      break;
+
+    case DW_OP_mul:
+      svalue = (sint_t)(*sp--);
+      svalue2 = (sint_t)*sp;
+      *sp = (pint_t)(svalue2 * svalue);
+      if (log)
+        fprintf(stderr, "mul\n");
+      break;
+
+    case DW_OP_neg:
+      *sp = 0 - *sp;
+      if (log)
+        fprintf(stderr, "neg\n");
+      break;
+
+    case DW_OP_not:
+      svalue = (sint_t)(*sp);
+      *sp = (pint_t)(~svalue);
+      if (log)
+        fprintf(stderr, "not\n");
+      break;
+
+    case DW_OP_or:
+      value = *sp--;
+      *sp |= value;
+      if (log)
+        fprintf(stderr, "or\n");
+      break;
+
+    case DW_OP_plus:
+      value = *sp--;
+      *sp += value;
+      if (log)
+        fprintf(stderr, "plus\n");
+      break;
+
+    case DW_OP_plus_uconst:
+      // pop stack, add uelb128 constant, push result
       *sp += static_cast<pint_t>(addressSpace.getULEB128(p, expressionEnd));
-      if (log) 
-        fprintf(stderr, "add constant\n"); 
-      break; 
- 
-    case DW_OP_shl: 
-      value = *sp--; 
-      *sp = *sp << value; 
-      if (log) 
-        fprintf(stderr, "shift left\n"); 
-      break; 
- 
-    case DW_OP_shr: 
-      value = *sp--; 
-      *sp = *sp >> value; 
-      if (log) 
-        fprintf(stderr, "shift left\n"); 
-      break; 
- 
-    case DW_OP_shra: 
-      value = *sp--; 
-      svalue = (sint_t)*sp; 
-      *sp = (pint_t)(svalue >> value); 
-      if (log) 
-        fprintf(stderr, "shift left arithmetric\n"); 
-      break; 
- 
-    case DW_OP_xor: 
-      value = *sp--; 
-      *sp ^= value; 
-      if (log) 
-        fprintf(stderr, "xor\n"); 
-      break; 
- 
-    case DW_OP_skip: 
-      svalue = (int16_t) addressSpace.get16(p); 
-      p += 2; 
-      p = (pint_t)((sint_t)p + svalue); 
-      if (log) 
-        fprintf(stderr, "skip %" PRIu64 "\n", (uint64_t)svalue); 
-      break; 
- 
-    case DW_OP_bra: 
-      svalue = (int16_t) addressSpace.get16(p); 
-      p += 2; 
-      if (*sp--) 
-        p = (pint_t)((sint_t)p + svalue); 
-      if (log) 
-        fprintf(stderr, "bra %" PRIu64 "\n", (uint64_t)svalue); 
-      break; 
- 
-    case DW_OP_eq: 
-      value = *sp--; 
-      *sp = (*sp == value); 
-      if (log) 
-        fprintf(stderr, "eq\n"); 
-      break; 
- 
-    case DW_OP_ge: 
-      value = *sp--; 
-      *sp = (*sp >= value); 
-      if (log) 
-        fprintf(stderr, "ge\n"); 
-      break; 
- 
-    case DW_OP_gt: 
-      value = *sp--; 
-      *sp = (*sp > value); 
-      if (log) 
-        fprintf(stderr, "gt\n"); 
-      break; 
- 
-    case DW_OP_le: 
-      value = *sp--; 
-      *sp = (*sp <= value); 
-      if (log) 
-        fprintf(stderr, "le\n"); 
-      break; 
- 
-    case DW_OP_lt: 
-      value = *sp--; 
-      *sp = (*sp < value); 
-      if (log) 
-        fprintf(stderr, "lt\n"); 
-      break; 
- 
-    case DW_OP_ne: 
-      value = *sp--; 
-      *sp = (*sp != value); 
-      if (log) 
-        fprintf(stderr, "ne\n"); 
-      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: 
-      value = static_cast<pint_t>(opcode - DW_OP_lit0); 
-      *(++sp) = value; 
-      if (log) 
-        fprintf(stderr, "push literal 0x%" PRIx64 "\n", (uint64_t)value); 
-      break; 
- 
-    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: 
-      reg = static_cast<uint32_t>(opcode - DW_OP_reg0); 
-      *(++sp) = registers.getRegister((int)reg); 
-      if (log) 
-        fprintf(stderr, "push reg %d\n", reg); 
-      break; 
- 
-    case DW_OP_regx: 
-      reg = static_cast<uint32_t>(addressSpace.getULEB128(p, expressionEnd)); 
-      *(++sp) = registers.getRegister((int)reg); 
-      if (log) 
-        fprintf(stderr, "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue); 
-      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: 
-      reg = static_cast<uint32_t>(opcode - DW_OP_breg0); 
-      svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd); 
-      svalue += static_cast<sint_t>(registers.getRegister((int)reg)); 
-      *(++sp) = (pint_t)(svalue); 
-      if (log) 
-        fprintf(stderr, "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue); 
-      break; 
- 
-    case DW_OP_bregx: 
-      reg = static_cast<uint32_t>(addressSpace.getULEB128(p, expressionEnd)); 
-      svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd); 
-      svalue += static_cast<sint_t>(registers.getRegister((int)reg)); 
-      *(++sp) = (pint_t)(svalue); 
-      if (log) 
-        fprintf(stderr, "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue); 
-      break; 
- 
-    case DW_OP_fbreg: 
-      _LIBUNWIND_ABORT("DW_OP_fbreg not implemented"); 
-      break; 
- 
-    case DW_OP_piece: 
-      _LIBUNWIND_ABORT("DW_OP_piece not implemented"); 
-      break; 
- 
-    case DW_OP_deref_size: 
-      // pop stack, dereference, push result 
-      value = *sp--; 
-      switch (addressSpace.get8(p++)) { 
-      case 1: 
-        value = addressSpace.get8(value); 
-        break; 
-      case 2: 
-        value = addressSpace.get16(value); 
-        break; 
-      case 4: 
-        value = addressSpace.get32(value); 
-        break; 
-      case 8: 
-        value = (pint_t)addressSpace.get64(value); 
-        break; 
-      default: 
-        _LIBUNWIND_ABORT("DW_OP_deref_size with bad size"); 
-      } 
-      *(++sp) = value; 
-      if (log) 
-        fprintf(stderr, "sized dereference 0x%" PRIx64 "\n", (uint64_t)value); 
-      break; 
- 
-    case DW_OP_xderef_size: 
-    case DW_OP_nop: 
-    case DW_OP_push_object_addres: 
-    case DW_OP_call2: 
-    case DW_OP_call4: 
-    case DW_OP_call_ref: 
-    default: 
+      if (log)
+        fprintf(stderr, "add constant\n");
+      break;
+
+    case DW_OP_shl:
+      value = *sp--;
+      *sp = *sp << value;
+      if (log)
+        fprintf(stderr, "shift left\n");
+      break;
+
+    case DW_OP_shr:
+      value = *sp--;
+      *sp = *sp >> value;
+      if (log)
+        fprintf(stderr, "shift left\n");
+      break;
+
+    case DW_OP_shra:
+      value = *sp--;
+      svalue = (sint_t)*sp;
+      *sp = (pint_t)(svalue >> value);
+      if (log)
+        fprintf(stderr, "shift left arithmetric\n");
+      break;
+
+    case DW_OP_xor:
+      value = *sp--;
+      *sp ^= value;
+      if (log)
+        fprintf(stderr, "xor\n");
+      break;
+
+    case DW_OP_skip:
+      svalue = (int16_t) addressSpace.get16(p);
+      p += 2;
+      p = (pint_t)((sint_t)p + svalue);
+      if (log)
+        fprintf(stderr, "skip %" PRIu64 "\n", (uint64_t)svalue);
+      break;
+
+    case DW_OP_bra:
+      svalue = (int16_t) addressSpace.get16(p);
+      p += 2;
+      if (*sp--)
+        p = (pint_t)((sint_t)p + svalue);
+      if (log)
+        fprintf(stderr, "bra %" PRIu64 "\n", (uint64_t)svalue);
+      break;
+
+    case DW_OP_eq:
+      value = *sp--;
+      *sp = (*sp == value);
+      if (log)
+        fprintf(stderr, "eq\n");
+      break;
+
+    case DW_OP_ge:
+      value = *sp--;
+      *sp = (*sp >= value);
+      if (log)
+        fprintf(stderr, "ge\n");
+      break;
+
+    case DW_OP_gt:
+      value = *sp--;
+      *sp = (*sp > value);
+      if (log)
+        fprintf(stderr, "gt\n");
+      break;
+
+    case DW_OP_le:
+      value = *sp--;
+      *sp = (*sp <= value);
+      if (log)
+        fprintf(stderr, "le\n");
+      break;
+
+    case DW_OP_lt:
+      value = *sp--;
+      *sp = (*sp < value);
+      if (log)
+        fprintf(stderr, "lt\n");
+      break;
+
+    case DW_OP_ne:
+      value = *sp--;
+      *sp = (*sp != value);
+      if (log)
+        fprintf(stderr, "ne\n");
+      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:
+      value = static_cast<pint_t>(opcode - DW_OP_lit0);
+      *(++sp) = value;
+      if (log)
+        fprintf(stderr, "push literal 0x%" PRIx64 "\n", (uint64_t)value);
+      break;
+
+    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:
+      reg = static_cast<uint32_t>(opcode - DW_OP_reg0);
+      *(++sp) = registers.getRegister((int)reg);
+      if (log)
+        fprintf(stderr, "push reg %d\n", reg);
+      break;
+
+    case DW_OP_regx:
+      reg = static_cast<uint32_t>(addressSpace.getULEB128(p, expressionEnd));
+      *(++sp) = registers.getRegister((int)reg);
+      if (log)
+        fprintf(stderr, "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue);
+      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:
+      reg = static_cast<uint32_t>(opcode - DW_OP_breg0);
+      svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd);
+      svalue += static_cast<sint_t>(registers.getRegister((int)reg));
+      *(++sp) = (pint_t)(svalue);
+      if (log)
+        fprintf(stderr, "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue);
+      break;
+
+    case DW_OP_bregx:
+      reg = static_cast<uint32_t>(addressSpace.getULEB128(p, expressionEnd));
+      svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd);
+      svalue += static_cast<sint_t>(registers.getRegister((int)reg));
+      *(++sp) = (pint_t)(svalue);
+      if (log)
+        fprintf(stderr, "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue);
+      break;
+
+    case DW_OP_fbreg:
+      _LIBUNWIND_ABORT("DW_OP_fbreg not implemented");
+      break;
+
+    case DW_OP_piece:
+      _LIBUNWIND_ABORT("DW_OP_piece not implemented");
+      break;
+
+    case DW_OP_deref_size:
+      // pop stack, dereference, push result
+      value = *sp--;
+      switch (addressSpace.get8(p++)) {
+      case 1:
+        value = addressSpace.get8(value);
+        break;
+      case 2:
+        value = addressSpace.get16(value);
+        break;
+      case 4:
+        value = addressSpace.get32(value);
+        break;
+      case 8:
+        value = (pint_t)addressSpace.get64(value);
+        break;
+      default:
+        _LIBUNWIND_ABORT("DW_OP_deref_size with bad size");
+      }
+      *(++sp) = value;
+      if (log)
+        fprintf(stderr, "sized dereference 0x%" PRIx64 "\n", (uint64_t)value);
+      break;
+
+    case DW_OP_xderef_size:
+    case DW_OP_nop:
+    case DW_OP_push_object_addres:
+    case DW_OP_call2:
+    case DW_OP_call4:
+    case DW_OP_call_ref:
+    default:
       _LIBUNWIND_ABORT("DWARF opcode not implemented");
-    } 
- 
-  } 
-  if (log) 
-    fprintf(stderr, "expression evaluates to 0x%" PRIx64 "\n", (uint64_t)*sp); 
-  return *sp; 
-} 
- 
- 
- 
-} // namespace libunwind 
- 
-#endif // __DWARF_INSTRUCTIONS_HPP__ 
+    }
+
+  }
+  if (log)
+    fprintf(stderr, "expression evaluates to 0x%" PRIx64 "\n", (uint64_t)*sp);
+  return *sp;
+}
+
+
+
+} // namespace libunwind
+
+#endif // __DWARF_INSTRUCTIONS_HPP__