Convert RegisterSaveLocation from array of structs to struct of arrays

[saugustine]

Summary

This patch reduces the size of PrologInfo from 580 bytes on
x86_linux to 320, greatly reducing the amount of time spent in
memset and memcpy to initialize and move it around inside the
parseInstructions infrastructure.

Unfortunately, due to cache misses and other issues, the overall
performance of the unwind is slightly slower.

So abandoned.

libunwind/src/DwarfInstructions.hpp

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;
+  typedef typename CFI_Parser<A>::RegisterSavedWhere RegisterSavedWhere;
+  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);
+                                 pint_t cfa, const RegisterSavedWhere location,
+                                 const int64_t value);
   static double getSavedFloatRegister(A &addressSpace, const R &registers,
-                                  pint_t cfa, const RegisterLocation &savedReg);
+                                      pint_t cfa,
+                                      const RegisterSavedWhere location,
+                                      const int64_t value);
   static v128 getSavedVectorRegister(A &addressSpace, const R &registers,
-                                  pint_t cfa, const RegisterLocation &savedReg);
+                                     pint_t cfa,
+                                     const RegisterSavedWhere location,
+                                     const int64_t value);
 
   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, 
+      return evaluateExpression((pint_t)prolog.cfaExpression, addressSpace,
                                 registers, 0);
     assert(0 && "getCFA(): unknown location");
     __builtin_unreachable();
   }
 };
 
 
 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) {
+    const RegisterSavedWhere location, const int64_t value) {
+  switch (location) {
   case CFI_Parser<A>::kRegisterInCFA:
-    return (pint_t)addressSpace.getRegister(cfa + (pint_t)savedReg.value);
+    return (pint_t)addressSpace.getRegister(cfa + (pint_t)value);
 
   case CFI_Parser<A>::kRegisterAtExpression:
-    return (pint_t)addressSpace.getRegister(evaluateExpression(
-        (pint_t)savedReg.value, addressSpace, registers, cfa));
+    return (pint_t)addressSpace.getRegister(
+        evaluateExpression((pint_t)value, addressSpace, registers, cfa));
 
   case CFI_Parser<A>::kRegisterIsExpression:
-    return evaluateExpression((pint_t)savedReg.value, addressSpace,
-                              registers, cfa);
+    return evaluateExpression((pint_t)value, addressSpace, registers, cfa);
 
   case CFI_Parser<A>::kRegisterInRegister:
-    return registers.getRegister((int)savedReg.value);
+    return registers.getRegister((int)value);
 
   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) {
+    const RegisterSavedWhere location, const int64_t value) {
+  switch (location) {
   case CFI_Parser<A>::kRegisterInCFA:
-    return addressSpace.getDouble(cfa + (pint_t)savedReg.value);
+    return addressSpace.getDouble(cfa + (pint_t)value);
 
   case CFI_Parser<A>::kRegisterAtExpression:
     return addressSpace.getDouble(
-        evaluateExpression((pint_t)savedReg.value, addressSpace,
-                            registers, cfa));
+        evaluateExpression((pint_t)value, addressSpace, registers, cfa));
 
   case CFI_Parser<A>::kRegisterIsExpression:
   case CFI_Parser<A>::kRegisterUnused:
   case CFI_Parser<A>::kRegisterOffsetFromCFA:
   case CFI_Parser<A>::kRegisterInRegister:
     // 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) {
+    const RegisterSavedWhere location, const int64_t value) {
+  switch (location) {
   case CFI_Parser<A>::kRegisterInCFA:
-    return addressSpace.getVector(cfa + (pint_t)savedReg.value);
+    return addressSpace.getVector(cfa + (pint_t)value);
 
   case CFI_Parser<A>::kRegisterAtExpression:
     return addressSpace.getVector(
-        evaluateExpression((pint_t)savedReg.value, addressSpace,
-                            registers, cfa));
+        evaluateExpression((pint_t)value, addressSpace, registers, cfa));
 
   case CFI_Parser<A>::kRegisterIsExpression:
   case CFI_Parser<A>::kRegisterUnused:
   case CFI_Parser<A>::kRegisterOffsetFromCFA:
   case CFI_Parser<A>::kRegisterInRegister:
     // FIX ME
     break;
   }
if (CFI_Parser<A>::parseFDEInstructions(addressSpace, fdeInfo, cieInfo, pc,
       R newRegisters = registers;
       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 !=
+        if (prolog.savedRegisterLocations[i] !=
             CFI_Parser<A>::kRegisterUnused) {
           if (registers.validFloatRegister(i))
             newRegisters.setFloatRegister(
                 i, getSavedFloatRegister(addressSpace, registers, cfa,
-                                         prolog.savedRegisters[i]));
+                                         prolog.savedRegisterLocations[i],
+                                         prolog.savedRegisterValues[i]));
           else if (registers.validVectorRegister(i))
             newRegisters.setVectorRegister(
                 i, getSavedVectorRegister(addressSpace, registers, cfa,
-                                          prolog.savedRegisters[i]));
+                                          prolog.savedRegisterLocations[i],
+                                          prolog.savedRegisterValues[i]));
           else if (i == (int)cieInfo.returnAddressRegister)
             returnAddress = getSavedRegister(addressSpace, registers, cfa,
-                                             prolog.savedRegisters[i]);
+                                             prolog.savedRegisterLocations[i],
+                                             prolog.savedRegisterValues[i]);
           else if (registers.validRegister(i))
             newRegisters.setRegister(
                 i, getSavedRegister(addressSpace, registers, cfa,
-                                    prolog.savedRegisters[i]));
+                                    prolog.savedRegisterLocations[i],
+                                    prolog.savedRegisterValues[i]));
           else
             return UNW_EBADREG;
         }
       }
 
       // By definition, the CFA is the stack pointer at the call site, so
       // restoring SP means setting it to CFA.
       newRegisters.setSP(cfa);
 
       isSignalFrame = cieInfo.isSignalFrame;
 
 #if defined(_LIBUNWIND_TARGET_AARCH64)
       // If the target is aarch64 then the return address may have been signed
       // using the v8.3 pointer authentication extensions. The original
       // return address needs to be authenticated before the return address is
       // restored. autia1716 is used instead of autia as autia1716 assembles
       // to a NOP on pre-v8.3a architectures.
       if ((R::getArch() == REGISTERS_ARM64) &&
-          prolog.savedRegisters[UNW_ARM64_RA_SIGN_STATE].value) {
+          prolog.savedRegisterValues[UNW_ARM64_RA_SIGN_STATE]) {
 #if !defined(_LIBUNWIND_IS_NATIVE_ONLY)
         return UNW_ECROSSRASIGNING;
 #else
         register unsigned long long x17 __asm("x17") = returnAddress;
         register unsigned long long x16 __asm("x16") = cfa;
 
         // These are the autia1716/autib1716 instructions. The hint instructions
         // are used here as gcc does not assemble autia1716/autib1716 for pre

libunwind/src/DwarfParser.hpp

struct FDE_Info {
     pint_t  pcStart;
     pint_t  pcEnd;
     pint_t  lsda;
   };
 
   enum {
     kMaxRegisterNumber = _LIBUNWIND_HIGHEST_DWARF_REGISTER
   };
-  enum RegisterSavedWhere {
+  enum RegisterSavedWhere : uint8_t {
     kRegisterUnused,
     kRegisterInCFA,
     kRegisterOffsetFromCFA,
     kRegisterInRegister,
     kRegisterAtExpression,
     kRegisterIsExpression
   };
-  struct RegisterLocation {
-    RegisterSavedWhere location;
-    int64_t value;
-  };
   /// Information about a frame layout and registers saved determined
   /// by "running" the DWARF FDE "instructions"
   struct PrologInfo {
-    uint32_t          cfaRegister;
-    int32_t           cfaRegisterOffset;  // CFA = (cfaRegister)+cfaRegisterOffset
-    int64_t           cfaExpression;      // CFA = expression
-    uint32_t          spExtraArgSize;
-    uint32_t          codeOffsetAtStackDecrement;
-    bool              registersInOtherRegisters;
-    bool              sameValueUsed;
-    RegisterLocation  savedRegisters[kMaxRegisterNumber + 1];
+    uint32_t           cfaRegister;
+    int32_t            cfaRegisterOffset;  // CFA = (cfaRegister)+cfaRegisterOffset
+    int64_t            cfaExpression;      // CFA = expression
+    uint32_t           spExtraArgSize;
+    uint32_t           codeOffsetAtStackDecrement;
+    bool               registersInOtherRegisters;
+    bool               sameValueUsed;
+    RegisterSavedWhere savedRegisterLocations[kMaxRegisterNumber + 1];
+    int64_t            savedRegisterValues[kMaxRegisterNumber + 1];
   };
 
   struct PrologInfoStackEntry {
     PrologInfoStackEntry(PrologInfoStackEntry *n, const PrologInfo &i)
         : next(n), info(i) {}
     PrologInfoStackEntry *next;
     PrologInfo info;
   };
case DW_CFA_offset_extended:
       reg = addressSpace.getULEB128(p, instructionsEnd);
       offset = (int64_t)addressSpace.getULEB128(p, instructionsEnd)
                                                   * cieInfo.dataAlignFactor;
       if (reg > kMaxRegisterNumber) {
         _LIBUNWIND_LOG0(
                 "malformed DW_CFA_offset_extended DWARF unwind, reg too big");
         return false;
       }
-      results->savedRegisters[reg].location = kRegisterInCFA;
-      results->savedRegisters[reg].value = offset;
+      results->savedRegisterLocations[reg] = kRegisterInCFA;
+      results->savedRegisterValues[reg] = offset;
       _LIBUNWIND_TRACE_DWARF("DW_CFA_offset_extended(reg=%" PRIu64 ", "
                              "offset=%" PRId64 ")\n",
                              reg, offset);
       break;
     case DW_CFA_restore_extended:
       reg = addressSpace.getULEB128(p, instructionsEnd);
       if (reg > kMaxRegisterNumber) {
         _LIBUNWIND_LOG0(
             "malformed DW_CFA_restore_extended DWARF unwind, reg too big");
         return false;
       }
-      results->savedRegisters[reg] = initialState.savedRegisters[reg];
+      results->savedRegisterLocations[reg] =
+          initialState.savedRegisterLocations[reg];
+      results->savedRegisterValues[reg] = initialState.savedRegisterValues[reg];
       _LIBUNWIND_TRACE_DWARF("DW_CFA_restore_extended(reg=%" PRIu64 ")\n", reg);
       break;
     case DW_CFA_undefined:
       reg = addressSpace.getULEB128(p, instructionsEnd);
       if (reg > kMaxRegisterNumber) {
         _LIBUNWIND_LOG0(
                 "malformed DW_CFA_undefined DWARF unwind, reg too big");
         return false;
       }
-      results->savedRegisters[reg].location = kRegisterUnused;
+      results->savedRegisterLocations[reg] = kRegisterUnused;
       _LIBUNWIND_TRACE_DWARF("DW_CFA_undefined(reg=%" PRIu64 ")\n", reg);
       break;
     case DW_CFA_same_value:
       reg = addressSpace.getULEB128(p, instructionsEnd);
       if (reg > kMaxRegisterNumber) {
         _LIBUNWIND_LOG0(
                 "malformed DW_CFA_same_value DWARF unwind, reg too big");
         return false;
       }
       // <rdar://problem/8456377> DW_CFA_same_value unsupported
       // "same value" means register was stored in frame, but its current
       // value has not changed, so no need to restore from frame.
       // We model this as if the register was never saved.
-      results->savedRegisters[reg].location = kRegisterUnused;
+      results->savedRegisterLocations[reg] = kRegisterUnused;
       // set flag to disable conversion to compact unwind
       results->sameValueUsed = true;
       _LIBUNWIND_TRACE_DWARF("DW_CFA_same_value(reg=%" PRIu64 ")\n", reg);
       break;
     case DW_CFA_register:
       reg = addressSpace.getULEB128(p, instructionsEnd);
       reg2 = addressSpace.getULEB128(p, instructionsEnd);
       if (reg > kMaxRegisterNumber) {
         _LIBUNWIND_LOG0(
                 "malformed DW_CFA_register DWARF unwind, reg too big");
         return false;
       }
       if (reg2 > kMaxRegisterNumber) {
         _LIBUNWIND_LOG0(
                 "malformed DW_CFA_register DWARF unwind, reg2 too big");
         return false;
       }
-      results->savedRegisters[reg].location = kRegisterInRegister;
-      results->savedRegisters[reg].value = (int64_t)reg2;
+      results->savedRegisterLocations[reg] = kRegisterInRegister;
+      results->savedRegisterValues[reg] = (int64_t)reg2;
       // set flag to disable conversion to compact unwind
       results->registersInOtherRegisters = true;
       _LIBUNWIND_TRACE_DWARF(
           "DW_CFA_register(reg=%" PRIu64 ", reg2=%" PRIu64 ")\n", reg, reg2);
       break;
 #if !defined(_LIBUNWIND_NO_HEAP)
     case DW_CFA_remember_state:
       // avoid operator new, because that would be an upward dependency
case DW_CFA_def_cfa_expression:
       break;
     case DW_CFA_expression:
       reg = addressSpace.getULEB128(p, instructionsEnd);
       if (reg > kMaxRegisterNumber) {
         _LIBUNWIND_LOG0(
                 "malformed DW_CFA_expression DWARF unwind, reg too big");
         return false;
       }
-      results->savedRegisters[reg].location = kRegisterAtExpression;
-      results->savedRegisters[reg].value = (int64_t)p;
+      results->savedRegisterLocations[reg] = kRegisterAtExpression;
+      results->savedRegisterValues[reg] = (int64_t)p;
       length = addressSpace.getULEB128(p, instructionsEnd);
       assert(length < static_cast<pint_t>(~0) && "pointer overflow");
       p += static_cast<pint_t>(length);
       _LIBUNWIND_TRACE_DWARF("DW_CFA_expression(reg=%" PRIu64 ", "
                              "expression=0x%" PRIx64 ", "
                              "length=%" PRIu64 ")\n",
-                             reg, results->savedRegisters[reg].value, length);
+                             reg, results->savedRegisterValues[reg], length);
       break;
     case DW_CFA_offset_extended_sf:
       reg = addressSpace.getULEB128(p, instructionsEnd);
       if (reg > kMaxRegisterNumber) {
         _LIBUNWIND_LOG0(
             "malformed DW_CFA_offset_extended_sf DWARF unwind, reg too big");
         return false;
       }
       offset =
           addressSpace.getSLEB128(p, instructionsEnd) * cieInfo.dataAlignFactor;
-      results->savedRegisters[reg].location = kRegisterInCFA;
-      results->savedRegisters[reg].value = offset;
+      results->savedRegisterLocations[reg] = kRegisterInCFA;
+      results->savedRegisterValues[reg] = offset;
       _LIBUNWIND_TRACE_DWARF("DW_CFA_offset_extended_sf(reg=%" PRIu64 ", "
                              "offset=%" PRId64 ")\n",
                              reg, offset);
       break;
     case DW_CFA_def_cfa_sf:
       reg = addressSpace.getULEB128(p, instructionsEnd);
       offset =
           addressSpace.getSLEB128(p, instructionsEnd) * cieInfo.dataAlignFactor;
case DW_CFA_val_offset:
         _LIBUNWIND_LOG(
                 "malformed DW_CFA_val_offset DWARF unwind, reg (%" PRIu64
                 ") out of range\n",
                 reg);
         return false;
       }
       offset = (int64_t)addressSpace.getULEB128(p, instructionsEnd)
                                                     * cieInfo.dataAlignFactor;
-      results->savedRegisters[reg].location = kRegisterOffsetFromCFA;
-      results->savedRegisters[reg].value = offset;
+      results->savedRegisterLocations[reg] = kRegisterOffsetFromCFA;
+      results->savedRegisterValues[reg] = offset;
       _LIBUNWIND_TRACE_DWARF("DW_CFA_val_offset(reg=%" PRIu64 ", "
                              "offset=%" PRId64 "\n",
                              reg, offset);
       break;
     case DW_CFA_val_offset_sf:
       reg = addressSpace.getULEB128(p, instructionsEnd);
       if (reg > kMaxRegisterNumber) {
         _LIBUNWIND_LOG0(
                 "malformed DW_CFA_val_offset_sf DWARF unwind, reg too big");
         return false;
       }
       offset =
           addressSpace.getSLEB128(p, instructionsEnd) * cieInfo.dataAlignFactor;
-      results->savedRegisters[reg].location = kRegisterOffsetFromCFA;
-      results->savedRegisters[reg].value = offset;
+      results->savedRegisterLocations[reg] = kRegisterOffsetFromCFA;
+      results->savedRegisterValues[reg] = offset;
       _LIBUNWIND_TRACE_DWARF("DW_CFA_val_offset_sf(reg=%" PRIu64 ", "
                              "offset=%" PRId64 "\n",
                              reg, offset);
       break;
     case DW_CFA_val_expression:
       reg = addressSpace.getULEB128(p, instructionsEnd);
       if (reg > kMaxRegisterNumber) {
         _LIBUNWIND_LOG0(
                 "malformed DW_CFA_val_expression DWARF unwind, reg too big");
         return false;
       }
-      results->savedRegisters[reg].location = kRegisterIsExpression;
-      results->savedRegisters[reg].value = (int64_t)p;
+      results->savedRegisterLocations[reg] = kRegisterIsExpression;
+      results->savedRegisterValues[reg] = (int64_t)p;
       length = addressSpace.getULEB128(p, instructionsEnd);
       assert(length < static_cast<pint_t>(~0) && "pointer overflow");
       p += static_cast<pint_t>(length);
       _LIBUNWIND_TRACE_DWARF("DW_CFA_val_expression(reg=%" PRIu64 ", "
                              "expression=0x%" PRIx64 ", length=%" PRIu64 ")\n",
-                             reg, results->savedRegisters[reg].value, length);
+                             reg, results->savedRegisterValues[reg], length);
       break;
     case DW_CFA_GNU_args_size:
       length = addressSpace.getULEB128(p, instructionsEnd);
       results->spExtraArgSize = (uint32_t)length;
       _LIBUNWIND_TRACE_DWARF("DW_CFA_GNU_args_size(%" PRIu64 ")\n", length);
       break;
     case DW_CFA_GNU_negative_offset_extended:
       reg = addressSpace.getULEB128(p, instructionsEnd);
       if (reg > kMaxRegisterNumber) {
         _LIBUNWIND_LOG0("malformed DW_CFA_GNU_negative_offset_extended DWARF "
                         "unwind, reg too big");
         return false;
       }
       offset = (int64_t)addressSpace.getULEB128(p, instructionsEnd)
                                                     * cieInfo.dataAlignFactor;
-      results->savedRegisters[reg].location = kRegisterInCFA;
-      results->savedRegisters[reg].value = -offset;
+      results->savedRegisterLocations[reg] = kRegisterInCFA;
+      results->savedRegisterValues[reg] = -offset;
       _LIBUNWIND_TRACE_DWARF(
           "DW_CFA_GNU_negative_offset_extended(%" PRId64 ")\n", offset);
       break;
 
 #if defined(_LIBUNWIND_TARGET_AARCH64) || defined(_LIBUNWIND_TARGET_SPARC)
     // The same constant is used to represent different instructions on
     // AArch64 (negate_ra_state) and SPARC (window_save).
     static_assert(DW_CFA_AARCH64_negate_ra_state == DW_CFA_GNU_window_save,
                   "uses the same constant");
     case DW_CFA_AARCH64_negate_ra_state:
       switch (arch) {
 #if defined(_LIBUNWIND_TARGET_AARCH64)
       case REGISTERS_ARM64:
-        results->savedRegisters[UNW_ARM64_RA_SIGN_STATE].value ^= 0x1;
+        results->savedRegisterValues[UNW_ARM64_RA_SIGN_STATE] ^= 0x1;
         _LIBUNWIND_TRACE_DWARF("DW_CFA_AARCH64_negate_ra_state\n");
         break;
 #endif
 #if defined(_LIBUNWIND_TARGET_SPARC)
       // case DW_CFA_GNU_window_save:
       case REGISTERS_SPARC:
         _LIBUNWIND_TRACE_DWARF("DW_CFA_GNU_window_save()\n");
         for (reg = UNW_SPARC_O0; reg <= UNW_SPARC_O7; reg++) {
-          results->savedRegisters[reg].location = kRegisterInRegister;
-          results->savedRegisters[reg].value =
+          results->savedRegisterLocations[reg] = kRegisterInRegister;
+          results->savedRegisterValues[reg] =
               ((int64_t)reg - UNW_SPARC_O0) + UNW_SPARC_I0;
         }
 
         for (reg = UNW_SPARC_L0; reg <= UNW_SPARC_I7; reg++) {
-          results->savedRegisters[reg].location = kRegisterInCFA;
-          results->savedRegisters[reg].value =
-              ((int64_t)reg - UNW_SPARC_L0) * 4;
+          results->savedRegisterLocations[reg] = kRegisterInCFA;
+          results->savedRegisterValues[reg] = ((int64_t)reg - UNW_SPARC_L0) * 4;
         }
         break;
 #endif
       }
       break;
 #else
       (void)arch;
 #endif
 
     default:
       operand = opcode & 0x3F;
       switch (opcode & 0xC0) {
       case DW_CFA_offset:
         reg = operand;
         if (reg > kMaxRegisterNumber) {
           _LIBUNWIND_LOG("malformed DW_CFA_offset DWARF unwind, reg (%" PRIu64
                          ") out of range",
                   reg);
           return false;
         }
         offset = (int64_t)addressSpace.getULEB128(p, instructionsEnd)
                                                     * cieInfo.dataAlignFactor;
-        results->savedRegisters[reg].location = kRegisterInCFA;
-        results->savedRegisters[reg].value = offset;
+        results->savedRegisterLocations[reg] = kRegisterInCFA;
+        results->savedRegisterValues[reg] = offset;
         _LIBUNWIND_TRACE_DWARF("DW_CFA_offset(reg=%d, offset=%" PRId64 ")\n",
                                operand, offset);
         break;
       case DW_CFA_advance_loc:
         codeOffset += operand * cieInfo.codeAlignFactor;
         _LIBUNWIND_TRACE_DWARF("DW_CFA_advance_loc: new offset=%" PRIu64 "\n",
                                static_cast<uint64_t>(codeOffset));
         break;
       case DW_CFA_restore:
         reg = operand;
         if (reg > kMaxRegisterNumber) {
           _LIBUNWIND_LOG("malformed DW_CFA_restore DWARF unwind, reg (%" PRIu64
                          ") out of range",
                   reg);
           return false;
         }
-        results->savedRegisters[reg] = initialState.savedRegisters[reg];
+        results->savedRegisterLocations[reg] =
+            initialState.savedRegisterLocations[reg];
+        results->savedRegisterValues[reg] =
+            initialState.savedRegisterValues[reg];
         _LIBUNWIND_TRACE_DWARF("DW_CFA_restore(reg=%" PRIu64 ")\n",
                                static_cast<uint64_t>(operand));
         break;
       default:
         _LIBUNWIND_TRACE_DWARF("unknown CFA opcode 0x%02X\n", opcode);
         return false;
       }
     }
   }
 
   return true;
 }
 
 } // namespace libunwind
 
 #endif // __DWARF_PARSER_HPP__