[libunwind] Delete unused codeOffsetAtStackDecrement/registersInOtherRegisters/sameValueUsed

[MaskRay]

Summary

ld64 uses them to create compact unwind from DWARF call frame information.
When the code was ported to libunwind, the variables were not deleted.

libunwind/src/DwarfParser.hpp

#endif
   };
   /// 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];
     enum class InitializeTime { kLazy, kNormal };
 
     // When saving registers, this data structure is lazily initialized.
     PrologInfo(InitializeTime IT = InitializeTime::kNormal) {
       if (IT == InitializeTime::kNormal)
         memset(this, 0, sizeof(*this));
     }
while ((p < instructionsEnd) && (codeOffset < pcoffset)) {
               "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->setRegisterLocation(reg, kRegisterUnused, initialState);
-        // 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->setRegister(reg, kRegisterInRegister, (int64_t)reg2,
                              initialState);
-        // 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;
       case DW_CFA_remember_state: {
         // Avoid operator new because that would be an upward dependency.
         // Avoid malloc because it needs heap allocation.
         PrologInfoStackEntry *entry =
             (PrologInfoStackEntry *)_LIBUNWIND_REMEMBER_ALLOC(
while ((p < instructionsEnd) && (codeOffset < pcoffset)) {
           return false;
         }
         results->cfaRegister = (uint32_t)reg;
         _LIBUNWIND_TRACE_DWARF("DW_CFA_def_cfa_register(%" PRIu64 ")\n", reg);
         break;
       case DW_CFA_def_cfa_offset:
         results->cfaRegisterOffset =
             (int32_t)addressSpace.getULEB128(p, instructionsEnd);
-        results->codeOffsetAtStackDecrement = (uint32_t)codeOffset;
         _LIBUNWIND_TRACE_DWARF("DW_CFA_def_cfa_offset(%d)\n",
                                results->cfaRegisterOffset);
         break;
       case DW_CFA_def_cfa_expression:
         results->cfaRegister = 0;
         results->cfaExpression = (int64_t)p;
         length = addressSpace.getULEB128(p, instructionsEnd);
         assert(length < static_cast<pint_t>(~0) && "pointer overflow");
while ((p < instructionsEnd) && (codeOffset < pcoffset)) {
         _LIBUNWIND_TRACE_DWARF("DW_CFA_def_cfa_sf(reg=%" PRIu64 ", "
                                "offset=%" PRId64 ")\n",
                                reg, offset);
         break;
       case DW_CFA_def_cfa_offset_sf:
         results->cfaRegisterOffset =
             (int32_t)(addressSpace.getSLEB128(p, instructionsEnd) *
                       cieInfo.dataAlignFactor);
-        results->codeOffsetAtStackDecrement = (uint32_t)codeOffset;
         _LIBUNWIND_TRACE_DWARF("DW_CFA_def_cfa_offset_sf(%d)\n",
                                results->cfaRegisterOffset);
         break;
       case DW_CFA_val_offset:
         reg = addressSpace.getULEB128(p, instructionsEnd);
         if (reg > kMaxRegisterNumber) {
           _LIBUNWIND_LOG(
               "malformed DW_CFA_val_offset DWARF unwind, reg (%" PRIu64