FuncUnwinders: remove "current_offset" from function arguments

[labath]

Summary

This argument was added back in 2010 (r118882) to support the ability to unwind
from functions whose eh_frame entry does not cover the entire range of
the function.

However, due to the caching happening in FuncUnwinders, this solution is
very fragile. FuncUnwinders will cache the plan it got from eh_frame
regardless of the value of the current_offset, so our ability to unwind
from a given function depended what was the value of "current_offset" the
first time that this function was called.

Furthermore, since the "image show-unwind" command did not know what's
the right offset to pass, this created an unfortunate situation where
"image show-unwind" would show no valid plans for a function, even
though they were available and being used.

In this patch I implement the feature slightly differently. Instead of
giving just a base address to the eh_frame unwinder, I give it the
entire range we are interested in. Then, I change the unwinder to return
the first plan that covers (even partially) that range. This way even a
partial plan will be returned, regardless of the address in the function
where we are stopped at.

This solution is still not 100% correct, as it will not handle a
function which is covered by two independent fde entries. However, I
don't expect anybody will write this kind of functions, and this wasn't
handled by the previous implementation either. If this is ever needed in
the future. The eh_frame unwinder can be extended to return "composite"
unwind plans created by merging sevelar fde entries.

I also create a test which triggers this scenario. As doing this is
virtually impossible without hand-written assembly, the test only works
on x86 linux.

[jasonmolenda]

Thanks for digging in to this Pavel. I haven't had time to look over the patch today, but I'd like to; I'll make time for it in the next couple days if that's OK.

[labath]

Sure, that's no problem. Thanks for letting me know.

BTW, I have a couple more patches in the general unwinding area (part of the breakpad unwinding thing), but I still need to clean those up before they can be put up for review.

[jasonmolenda]

Sorry for the delay in looking at this. It looks like a good change, an improvement on the original for sure. I've never seen multiple eh_frame FDEs for a single function, so that's fine. The .ARM.exidx format and Apple's compact unwind format can theoretically have multiple different unwind plans for a single function - but I've never seen it done in practice. More commonly, a single unwind plan will be used for multiple functions that have the same unwind state. (these two formats don't describe prologue/epilogues - they only describe the unwind state in the middle of the function where exceptions can be thrown)

[labath]

Thanks for the review. Don't worry about the delay -- it has actually coincided with the public holidays on this side of the globe, so I was not working anyway. (but the delay wasn't long even if I had worked) :)

lldb/trunk/include/lldb/Symbol/DWARFCallFrameInfo.h

public:
 
   ~DWARFCallFrameInfo() = default;
 
   // Locate an AddressRange that includes the provided Address in this object's
   // eh_frame/debug_info Returns true if a range is found to cover that
   // address.
   bool GetAddressRange(Address addr, AddressRange &range);
 
-  // Return an UnwindPlan based on the call frame information encoded in the
-  // FDE of this DWARFCallFrameInfo section.
-  bool GetUnwindPlan(Address addr, UnwindPlan &unwind_plan);
+  /// Return an UnwindPlan based on the call frame information encoded in the
+  /// FDE of this DWARFCallFrameInfo section. The returned plan will be valid
+  /// (at least) for the given address.
+  bool GetUnwindPlan(const Address &addr, UnwindPlan &unwind_plan);
+
+  /// Return an UnwindPlan based on the call frame information encoded in the
+  /// FDE of this DWARFCallFrameInfo section. The returned plan will be valid
+  /// (at least) for some address in the given range.
+  bool GetUnwindPlan(const AddressRange &range, UnwindPlan &unwind_plan);
 
   typedef RangeVector<lldb::addr_t, uint32_t> FunctionAddressAndSizeVector;
 
   // Build a vector of file address and size for all functions in this Module
   // based on the eh_frame FDE entries.
   //
   // The eh_frame information can be a useful source of file address and size
   // of the functions in a Module.  Often a binary's non-exported symbols are
private:
 
   // Start address (file address), size, offset of FDE location used for
   // finding an FDE for a given File address; the start address field is an
   // offset into an individual Module.
   typedef RangeDataVector<lldb::addr_t, uint32_t, dw_offset_t> FDEEntryMap;
 
   bool IsEHFrame() const;
 
-  bool GetFDEEntryByFileAddress(lldb::addr_t file_offset,
-                                FDEEntryMap::Entry &fde_entry);
+  llvm::Optional<FDEEntryMap::Entry>
+  GetFirstFDEEntryInRange(const AddressRange &range);
 
   void GetFDEIndex();
 
   bool FDEToUnwindPlan(uint32_t offset, Address startaddr,
                        UnwindPlan &unwind_plan);
 
   const CIE *GetCIE(dw_offset_t cie_offset);
 

lldb/trunk/include/lldb/Symbol/FuncUnwinders.h

public:
   // Additionally, FuncUnwinds object can be asked where the prologue
   // instructions are finished for migrating breakpoints past the stack frame
   // setup instructions when we don't have line table information.
 
   FuncUnwinders(lldb_private::UnwindTable &unwind_table, AddressRange range);
 
   ~FuncUnwinders();
 
-  // current_offset is the byte offset into the function.
-  // 0 means no instructions have executed yet.  -1 means the offset is unknown.
-  // On architectures where the pc points to the next instruction that will
-  // execute, this offset value will have already been decremented by 1 to stay
-  // within the bounds of the correct function body.
-  lldb::UnwindPlanSP GetUnwindPlanAtCallSite(Target &target,
-                                             int current_offset);
+  lldb::UnwindPlanSP GetUnwindPlanAtCallSite(Target &target);
 
   lldb::UnwindPlanSP GetUnwindPlanAtNonCallSite(Target &target,
-                                                lldb_private::Thread &thread,
-                                                int current_offset);
+                                                lldb_private::Thread &thread);
 
   lldb::UnwindPlanSP GetUnwindPlanFastUnwind(Target &target,
                                              lldb_private::Thread &thread);
 
   lldb::UnwindPlanSP
   GetUnwindPlanArchitectureDefault(lldb_private::Thread &thread);
 
   lldb::UnwindPlanSP
public:
   // address of the personality routine, this will return it.  Read the target-
   // pointer at this address to get the personality function address.
   Address GetPersonalityRoutinePtrAddress(Target &target);
 
   // The following methods to retrieve specific unwind plans should rarely be
   // used. Instead, clients should ask for the *behavior* they are looking for,
   // using one of the above UnwindPlan retrieval methods.
 
-  lldb::UnwindPlanSP GetAssemblyUnwindPlan(Target &target, Thread &thread,
-                                           int current_offset);
+  lldb::UnwindPlanSP GetAssemblyUnwindPlan(Target &target, Thread &thread);
 
-  lldb::UnwindPlanSP GetEHFrameUnwindPlan(Target &target, int current_offset);
+  lldb::UnwindPlanSP GetEHFrameUnwindPlan(Target &target);
 
   lldb::UnwindPlanSP GetEHFrameAugmentedUnwindPlan(Target &target,
-                                                   Thread &thread,
-                                                   int current_offset);
+                                                   Thread &thread);
 
-  lldb::UnwindPlanSP GetDebugFrameUnwindPlan(Target &target,
-                                             int current_offset);
+  lldb::UnwindPlanSP GetDebugFrameUnwindPlan(Target &target);
 
   lldb::UnwindPlanSP GetDebugFrameAugmentedUnwindPlan(Target &target,
-                                                      Thread &thread,
-                                                      int current_offset);
+                                                      Thread &thread);
 
-  lldb::UnwindPlanSP GetCompactUnwindUnwindPlan(Target &target,
-                                                int current_offset);
+  lldb::UnwindPlanSP GetCompactUnwindUnwindPlan(Target &target);
 
-  lldb::UnwindPlanSP GetArmUnwindUnwindPlan(Target &target, int current_offset);
+  lldb::UnwindPlanSP GetArmUnwindUnwindPlan(Target &target);
 
   lldb::UnwindPlanSP GetArchDefaultUnwindPlan(Thread &thread);
 
   lldb::UnwindPlanSP GetArchDefaultAtFuncEntryUnwindPlan(Thread &thread);
 
 private:
   lldb::UnwindAssemblySP GetUnwindAssemblyProfiler(Target &target);
 

lldb/trunk/include/lldb/Utility/RangeMap.h

bool operator!=(const RangeData &rhs) const {
     return this->GetRangeBase() != rhs.GetRangeBase() ||
            this->GetByteSize() != rhs.GetByteSize() || this->data != rhs.data;
   }
 };
 
 template <typename B, typename S, typename T, unsigned N = 0>
 class RangeDataVector {
 public:
+  typedef lldb_private::Range<B, S> Range;
   typedef RangeData<B, S, T> Entry;
   typedef llvm::SmallVector<Entry, N> Collection;
 
   RangeDataVector() = default;
 
   ~RangeDataVector() = default;
 
   void Append(const Entry &entry) { m_entries.push_back(entry); }

lldb/trunk/lit/Unwind/Inputs/eh-frame-small-fde.s

+        .text
+        .globl  bar
+        .type   bar, @function
+bar:
+.LFB0:
+        .cfi_startproc
+        leal    (%edi, %edi), %eax
+        ret
+        .cfi_endproc
+.LFE0:
+        .size   bar, .-bar
+        .globl  foo
+        .type   foo, @function
+foo:
+.LFB1:
+        nop # Make the FDE entry start one byte later than the actual function.
+        .cfi_startproc
+        .cfi_register %rip, %r13
+        call    bar
+        addl    $1, %eax
+        jmp     *%r13 # Return
+        .cfi_endproc
+.LFE1:
+        .size   foo, .-foo
+        .globl  main
+        .type   main, @function
+main:
+.LFB2:
+        .cfi_startproc
+        pushq   %rbp
+        .cfi_def_cfa_offset 16
+        .cfi_offset 6, -16
+        movq    %rsp, %rbp
+        .cfi_def_cfa_register 6
+        movl    $47, %edi
+
+        # Non-standard calling convention. Put return address in r13.
+        pushq   %r13
+        leaq    1f(%rip), %r13
+        jmp     foo # call
+1:
+        popq    %r13
+        popq    %rbp
+        .cfi_def_cfa 7, 8
+        ret
+        .cfi_endproc
+.LFE2:
+        .size   main, .-main

lldb/trunk/lit/Unwind/eh-frame-small-fde.test

+# This test that we are able to unwind using eh_frame in case an FDE entry does
+# not cover the entire range of a function we are unwinding through.
+
+# REQUIRES: target-x86_64, system-linux, native
+
+# RUN: %clang %p/Inputs/eh-frame-small-fde.s -o %t
+# RUN: %lldb %t -s %s -o exit | FileCheck %s
+
+breakpoint set -n bar
+# CHECK: Breakpoint 1: where = {{.*}}`bar
+
+process launch
+# CHECK: stop reason = breakpoint 1.1
+
+thread backtrace
+# CHECK: frame #0: {{.*}}`bar
+# CHECK: frame #1: {{.*}}`foo + 6
+# CHECK: frame #2: {{.*}}`main + 20
+
+target modules show-unwind -n foo
+# CHECK: eh_frame UnwindPlan:
+# CHECK: row[0]: 0: CFA=rsp +8 => rip=r13

lldb/trunk/source/Commands/CommandObjectTarget.cpp

for (uint32_t idx = 0; idx < num_matches; idx++) {
         continue;
 
       result.GetOutputStream().Printf(
           "UNWIND PLANS for %s`%s (start addr 0x%" PRIx64 ")\n\n",
           sc.module_sp->GetPlatformFileSpec().GetFilename().AsCString(),
           funcname.AsCString(), start_addr);
 
       UnwindPlanSP non_callsite_unwind_plan =
-          func_unwinders_sp->GetUnwindPlanAtNonCallSite(*target, *thread, -1);
+          func_unwinders_sp->GetUnwindPlanAtNonCallSite(*target, *thread);
       if (non_callsite_unwind_plan) {
         result.GetOutputStream().Printf(
             "Asynchronous (not restricted to call-sites) UnwindPlan is '%s'\n",
             non_callsite_unwind_plan->GetSourceName().AsCString());
       }
       UnwindPlanSP callsite_unwind_plan =
-          func_unwinders_sp->GetUnwindPlanAtCallSite(*target, -1);
+          func_unwinders_sp->GetUnwindPlanAtCallSite(*target);
       if (callsite_unwind_plan) {
         result.GetOutputStream().Printf(
             "Synchronous (restricted to call-sites) UnwindPlan is '%s'\n",
             callsite_unwind_plan->GetSourceName().AsCString());
       }
       UnwindPlanSP fast_unwind_plan =
           func_unwinders_sp->GetUnwindPlanFastUnwind(*target, *thread);
       if (fast_unwind_plan) {
         result.GetOutputStream().Printf(
             "Fast UnwindPlan is '%s'\n",
             fast_unwind_plan->GetSourceName().AsCString());
       }
 
       result.GetOutputStream().Printf("\n");
 
       UnwindPlanSP assembly_sp =
-          func_unwinders_sp->GetAssemblyUnwindPlan(*target, *thread, 0);
+          func_unwinders_sp->GetAssemblyUnwindPlan(*target, *thread);
       if (assembly_sp) {
         result.GetOutputStream().Printf(
             "Assembly language inspection UnwindPlan:\n");
         assembly_sp->Dump(result.GetOutputStream(), thread.get(),
                           LLDB_INVALID_ADDRESS);
         result.GetOutputStream().Printf("\n");
       }
 
       UnwindPlanSP ehframe_sp =
-          func_unwinders_sp->GetEHFrameUnwindPlan(*target, 0);
+          func_unwinders_sp->GetEHFrameUnwindPlan(*target);
       if (ehframe_sp) {
         result.GetOutputStream().Printf("eh_frame UnwindPlan:\n");
         ehframe_sp->Dump(result.GetOutputStream(), thread.get(),
                          LLDB_INVALID_ADDRESS);
         result.GetOutputStream().Printf("\n");
       }
 
       UnwindPlanSP ehframe_augmented_sp =
-          func_unwinders_sp->GetEHFrameAugmentedUnwindPlan(*target, *thread, 0);
+          func_unwinders_sp->GetEHFrameAugmentedUnwindPlan(*target, *thread);
       if (ehframe_augmented_sp) {
         result.GetOutputStream().Printf("eh_frame augmented UnwindPlan:\n");
         ehframe_augmented_sp->Dump(result.GetOutputStream(), thread.get(),
                                    LLDB_INVALID_ADDRESS);
         result.GetOutputStream().Printf("\n");
       }
 
       if (UnwindPlanSP plan_sp =
-              func_unwinders_sp->GetDebugFrameUnwindPlan(*target, 0)) {
+              func_unwinders_sp->GetDebugFrameUnwindPlan(*target)) {
         result.GetOutputStream().Printf("debug_frame UnwindPlan:\n");
         plan_sp->Dump(result.GetOutputStream(), thread.get(),
                       LLDB_INVALID_ADDRESS);
         result.GetOutputStream().Printf("\n");
       }
 
       if (UnwindPlanSP plan_sp =
               func_unwinders_sp->GetDebugFrameAugmentedUnwindPlan(*target,
-                                                                  *thread, 0)) {
+                                                                  *thread)) {
         result.GetOutputStream().Printf("debug_frame augmented UnwindPlan:\n");
         plan_sp->Dump(result.GetOutputStream(), thread.get(),
                       LLDB_INVALID_ADDRESS);
         result.GetOutputStream().Printf("\n");
       }
 
       UnwindPlanSP arm_unwind_sp =
-          func_unwinders_sp->GetArmUnwindUnwindPlan(*target, 0);
+          func_unwinders_sp->GetArmUnwindUnwindPlan(*target);
       if (arm_unwind_sp) {
         result.GetOutputStream().Printf("ARM.exidx unwind UnwindPlan:\n");
         arm_unwind_sp->Dump(result.GetOutputStream(), thread.get(),
                             LLDB_INVALID_ADDRESS);
         result.GetOutputStream().Printf("\n");
       }
 
       UnwindPlanSP compact_unwind_sp =
-          func_unwinders_sp->GetCompactUnwindUnwindPlan(*target, 0);
+          func_unwinders_sp->GetCompactUnwindUnwindPlan(*target);
       if (compact_unwind_sp) {
         result.GetOutputStream().Printf("Compact unwind UnwindPlan:\n");
         compact_unwind_sp->Dump(result.GetOutputStream(), thread.get(),
                                 LLDB_INVALID_ADDRESS);
         result.GetOutputStream().Printf("\n");
       }
 
       if (fast_unwind_plan) {

lldb/trunk/source/Plugins/Process/Utility/RegisterContextLLDB.cpp

if (!ReadFrameAddress(row_register_kind, active_row->GetCFAValue(), m_cfa)) {
 
     if (m_sym_ctx_valid) {
       func_unwinders_sp =
           pc_module_sp->GetUnwindTable().GetFuncUnwindersContainingAddress(
               m_current_pc, m_sym_ctx);
     }
 
     if (func_unwinders_sp.get() != nullptr)
-      call_site_unwind_plan = func_unwinders_sp->GetUnwindPlanAtCallSite(
-          process->GetTarget(), m_current_offset_backed_up_one);
+      call_site_unwind_plan =
+          func_unwinders_sp->GetUnwindPlanAtCallSite(process->GetTarget());
 
     if (call_site_unwind_plan.get() != nullptr) {
       m_fallback_unwind_plan_sp = call_site_unwind_plan;
       if (TryFallbackUnwindPlan())
         cfa_status = true;
     }
     if (!cfa_status) {
       UnwindLogMsg("could not read CFA value for first frame.");
UnwindPlanSP RegisterContextLLDB::GetFullUnwindPlanForFrame() {
 
   // If we're in _sigtramp(), unwinding past this frame requires special
   // knowledge.  On Mac OS X this knowledge is properly encoded in the eh_frame
   // section, so prefer that if available. On other platforms we may need to
   // provide a platform-specific UnwindPlan which encodes the details of how to
   // unwind out of sigtramp.
   if (m_frame_type == eTrapHandlerFrame && process) {
     m_fast_unwind_plan_sp.reset();
-    unwind_plan_sp = func_unwinders_sp->GetEHFrameUnwindPlan(
-        process->GetTarget(), m_current_offset_backed_up_one);
+    unwind_plan_sp =
+        func_unwinders_sp->GetEHFrameUnwindPlan(process->GetTarget());
     if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc) &&
         unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolYes) {
       return unwind_plan_sp;
     }
   }
 
   // Ask the DynamicLoader if the eh_frame CFI should be trusted in this frame
   // even when it's frame zero This comes up if we have hand-written functions
   // in a Module and hand-written eh_frame.  The assembly instruction
   // inspection may fail and the eh_frame CFI were probably written with some
   // care to do the right thing.  It'd be nice if there was a way to ask the
   // eh_frame directly if it is asynchronous (can be trusted at every
   // instruction point) or synchronous (the normal case - only at call sites).
   // But there is not.
   if (process && process->GetDynamicLoader() &&
       process->GetDynamicLoader()->AlwaysRelyOnEHUnwindInfo(m_sym_ctx)) {
     // We must specifically call the GetEHFrameUnwindPlan() method here --
     // normally we would call GetUnwindPlanAtCallSite() -- because CallSite may
     // return an unwind plan sourced from either eh_frame (that's what we
     // intend) or compact unwind (this won't work)
-    unwind_plan_sp = func_unwinders_sp->GetEHFrameUnwindPlan(
-        process->GetTarget(), m_current_offset_backed_up_one);
+    unwind_plan_sp =
+        func_unwinders_sp->GetEHFrameUnwindPlan(process->GetTarget());
     if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
       UnwindLogMsgVerbose("frame uses %s for full UnwindPlan because the "
                           "DynamicLoader suggested we prefer it",
                           unwind_plan_sp->GetSourceName().GetCString());
       return unwind_plan_sp;
     }
   }
 
   // Typically the NonCallSite UnwindPlan is the unwind created by inspecting
   // the assembly language instructions
   if (behaves_like_zeroth_frame && process) {
     unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite(
-        process->GetTarget(), m_thread, m_current_offset_backed_up_one);
+        process->GetTarget(), m_thread);
     if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
       if (unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolNo) {
         // We probably have an UnwindPlan created by inspecting assembly
         // instructions. The assembly profilers work really well with compiler-
         // generated functions but hand- written assembly can be problematic.
         // We set the eh_frame based unwind plan as our fallback unwind plan if
         // instruction emulation doesn't work out even for non call sites if it
         // is available and use the architecture default unwind plan if it is
         // not available. The eh_frame unwind plan is more reliable even on non
         // call sites then the architecture default plan and for hand written
         // assembly code it is often written in a way that it valid at all
         // location what helps in the most common cases when the instruction
         // emulation fails.
         UnwindPlanSP call_site_unwind_plan =
-            func_unwinders_sp->GetUnwindPlanAtCallSite(
-                process->GetTarget(), m_current_offset_backed_up_one);
+            func_unwinders_sp->GetUnwindPlanAtCallSite(process->GetTarget());
         if (call_site_unwind_plan &&
             call_site_unwind_plan.get() != unwind_plan_sp.get() &&
             call_site_unwind_plan->GetSourceName() !=
                 unwind_plan_sp->GetSourceName()) {
           m_fallback_unwind_plan_sp = call_site_unwind_plan;
         } else {
           m_fallback_unwind_plan_sp = arch_default_unwind_plan_sp;
         }
       }
       UnwindLogMsgVerbose("frame uses %s for full UnwindPlan",
                           unwind_plan_sp->GetSourceName().GetCString());
       return unwind_plan_sp;
     }
   }
 
   // Typically this is unwind info from an eh_frame section intended for
   // exception handling; only valid at call sites
   if (process) {
-    unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtCallSite(
-        process->GetTarget(), m_current_offset_backed_up_one);
+    unwind_plan_sp =
+        func_unwinders_sp->GetUnwindPlanAtCallSite(process->GetTarget());
   }
   int valid_offset = -1;
   if (IsUnwindPlanValidForCurrentPC(unwind_plan_sp, valid_offset)) {
     UnwindLogMsgVerbose("frame uses %s for full UnwindPlan",
                         unwind_plan_sp->GetSourceName().GetCString());
     return unwind_plan_sp;
   }
 
   // We'd prefer to use an UnwindPlan intended for call sites when we're at a
   // call site but if we've struck out on that, fall back to using the non-
   // call-site assembly inspection UnwindPlan if possible.
   if (process) {
     unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite(
-        process->GetTarget(), m_thread, m_current_offset_backed_up_one);
+        process->GetTarget(), m_thread);
   }
   if (unwind_plan_sp &&
       unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolNo) {
     // We probably have an UnwindPlan created by inspecting assembly
     // instructions. The assembly profilers work really well with compiler-
     // generated functions but hand- written assembly can be problematic. We
     // set the eh_frame based unwind plan as our fallback unwind plan if
     // instruction emulation doesn't work out even for non call sites if it is
     // available and use the architecture default unwind plan if it is not
     // available. The eh_frame unwind plan is more reliable even on non call
     // sites then the architecture default plan and for hand written assembly
     // code it is often written in a way that it valid at all location what
     // helps in the most common cases when the instruction emulation fails.
     UnwindPlanSP call_site_unwind_plan =
-        func_unwinders_sp->GetUnwindPlanAtCallSite(
-            process->GetTarget(), m_current_offset_backed_up_one);
+        func_unwinders_sp->GetUnwindPlanAtCallSite(process->GetTarget());
     if (call_site_unwind_plan &&
         call_site_unwind_plan.get() != unwind_plan_sp.get() &&
         call_site_unwind_plan->GetSourceName() !=
             unwind_plan_sp->GetSourceName()) {
       m_fallback_unwind_plan_sp = call_site_unwind_plan;
     } else {
       m_fallback_unwind_plan_sp = arch_default_unwind_plan_sp;
     }

lldb/trunk/source/Symbol/DWARFCallFrameInfo.cpp

GetGNUEHPointer(const DataExtractor &DE, offset_t *offset_ptr,
   }
   return baseAddress + addressValue;
 }
 
 DWARFCallFrameInfo::DWARFCallFrameInfo(ObjectFile &objfile,
                                        SectionSP &section_sp, Type type)
     : m_objfile(objfile), m_section_sp(section_sp), m_type(type) {}
 
-bool DWARFCallFrameInfo::GetUnwindPlan(Address addr, UnwindPlan &unwind_plan) {
+bool DWARFCallFrameInfo::GetUnwindPlan(const Address &addr,
+                                       UnwindPlan &unwind_plan) {
+  return GetUnwindPlan(AddressRange(addr, 1), unwind_plan);
+}
+
+bool DWARFCallFrameInfo::GetUnwindPlan(const AddressRange &range,
+                                       UnwindPlan &unwind_plan) {
   FDEEntryMap::Entry fde_entry;
+  Address addr = range.GetBaseAddress();
 
   // Make sure that the Address we're searching for is the same object file as
   // this DWARFCallFrameInfo, we only store File offsets in m_fde_index.
   ModuleSP module_sp = addr.GetModule();
   if (module_sp.get() == nullptr || module_sp->GetObjectFile() == nullptr ||
       module_sp->GetObjectFile() != &m_objfile)
     return false;
 
-  if (!GetFDEEntryByFileAddress(addr.GetFileAddress(), fde_entry))
-    return false;
-  return FDEToUnwindPlan(fde_entry.data, addr, unwind_plan);
+  if (llvm::Optional<FDEEntryMap::Entry> entry = GetFirstFDEEntryInRange(range))
+    return FDEToUnwindPlan(entry->data, addr, unwind_plan);
 }
 
 bool DWARFCallFrameInfo::GetAddressRange(Address addr, AddressRange &range) {
 
   // Make sure that the Address we're searching for is the same object file as
   // this DWARFCallFrameInfo, we only store File offsets in m_fde_index.
   ModuleSP module_sp = addr.GetModule();
   if (module_sp.get() == nullptr || module_sp->GetObjectFile() == nullptr ||
       module_sp->GetObjectFile() != &m_objfile)
     return false;
 
   if (m_section_sp.get() == nullptr || m_section_sp->IsEncrypted())
     return false;
   GetFDEIndex();
   FDEEntryMap::Entry *fde_entry =
       m_fde_index.FindEntryThatContains(addr.GetFileAddress());
   if (!fde_entry)
     return false;
 
   range = AddressRange(fde_entry->base, fde_entry->size,
                        m_objfile.GetSectionList());
   return true;
 }
 
-bool DWARFCallFrameInfo::GetFDEEntryByFileAddress(
-    addr_t file_addr, FDEEntryMap::Entry &fde_entry) {
-  if (m_section_sp.get() == nullptr || m_section_sp->IsEncrypted())
-    return false;
+llvm::Optional<DWARFCallFrameInfo::FDEEntryMap::Entry>
+DWARFCallFrameInfo::GetFirstFDEEntryInRange(const AddressRange &range) {
+  if (!m_section_sp || m_section_sp->IsEncrypted())
+    return llvm::None;
 
   GetFDEIndex();
 
-  if (m_fde_index.IsEmpty())
-    return false;
-
-  FDEEntryMap::Entry *fde = m_fde_index.FindEntryThatContains(file_addr);
+  addr_t start_file_addr = range.GetBaseAddress().GetFileAddress();
+  const FDEEntryMap::Entry *fde =
+      m_fde_index.FindEntryThatContainsOrFollows(start_file_addr);
+  if (fde && fde->DoesIntersect(
+                 FDEEntryMap::Range(start_file_addr, range.GetByteSize())))
+    return *fde;
 
-  if (fde == nullptr)
-    return false;
-
-  fde_entry = *fde;
-  return true;
+  return llvm::None;
 }
 
 void DWARFCallFrameInfo::GetFunctionAddressAndSizeVector(
     FunctionAddressAndSizeVector &function_info) {
   GetFDEIndex();
   const size_t count = m_fde_index.GetSize();
   function_info.Clear();
   if (count > 0)

lldb/trunk/source/Symbol/FuncUnwinders.cpp

: m_unwind_table(unwind_table), m_range(range), m_mutex(),
       m_tried_unwind_arch_default(false),
       m_tried_unwind_arch_default_at_func_entry(false),
       m_first_non_prologue_insn() {}
 
 /// destructor
 
 FuncUnwinders::~FuncUnwinders() {}
 
-UnwindPlanSP FuncUnwinders::GetUnwindPlanAtCallSite(Target &target,
-                                                    int current_offset) {
+UnwindPlanSP FuncUnwinders::GetUnwindPlanAtCallSite(Target &target) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
-  if (UnwindPlanSP plan_sp = GetEHFrameUnwindPlan(target, current_offset))
+  if (UnwindPlanSP plan_sp = GetEHFrameUnwindPlan(target))
     return plan_sp;
-  if (UnwindPlanSP plan_sp = GetDebugFrameUnwindPlan(target, current_offset))
+  if (UnwindPlanSP plan_sp = GetDebugFrameUnwindPlan(target))
     return plan_sp;
-  if (UnwindPlanSP plan_sp = GetCompactUnwindUnwindPlan(target, current_offset))
+  if (UnwindPlanSP plan_sp = GetCompactUnwindUnwindPlan(target))
     return plan_sp;
-  if (UnwindPlanSP plan_sp = GetArmUnwindUnwindPlan(target, current_offset))
+  if (UnwindPlanSP plan_sp = GetArmUnwindUnwindPlan(target))
     return plan_sp;
 
   return nullptr;
 }
 
-UnwindPlanSP FuncUnwinders::GetCompactUnwindUnwindPlan(Target &target,
-                                                       int current_offset) {
+UnwindPlanSP FuncUnwinders::GetCompactUnwindUnwindPlan(Target &target) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_compact_unwind.size() > 0)
     return m_unwind_plan_compact_unwind[0]; // FIXME support multiple compact
                                             // unwind plans for one func
   if (m_tried_unwind_plan_compact_unwind)
     return UnwindPlanSP();
 
   m_tried_unwind_plan_compact_unwind = true;
   if (m_range.GetBaseAddress().IsValid()) {
     Address current_pc(m_range.GetBaseAddress());
-    if (current_offset != -1)
-      current_pc.SetOffset(current_pc.GetOffset() + current_offset);
     CompactUnwindInfo *compact_unwind = m_unwind_table.GetCompactUnwindInfo();
     if (compact_unwind) {
       UnwindPlanSP unwind_plan_sp(new UnwindPlan(lldb::eRegisterKindGeneric));
       if (compact_unwind->GetUnwindPlan(target, current_pc, *unwind_plan_sp)) {
         m_unwind_plan_compact_unwind.push_back(unwind_plan_sp);
         return m_unwind_plan_compact_unwind[0]; // FIXME support multiple
                                                 // compact unwind plans for one
                                                 // func
       }
     }
   }
   return UnwindPlanSP();
 }
 
-UnwindPlanSP FuncUnwinders::GetEHFrameUnwindPlan(Target &target,
-                                                 int current_offset) {
+UnwindPlanSP FuncUnwinders::GetEHFrameUnwindPlan(Target &target) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_eh_frame_sp.get() || m_tried_unwind_plan_eh_frame)
     return m_unwind_plan_eh_frame_sp;
 
   m_tried_unwind_plan_eh_frame = true;
   if (m_range.GetBaseAddress().IsValid()) {
-    Address current_pc(m_range.GetBaseAddress());
-    if (current_offset != -1)
-      current_pc.SetOffset(current_pc.GetOffset() + current_offset);
     DWARFCallFrameInfo *eh_frame = m_unwind_table.GetEHFrameInfo();
     if (eh_frame) {
       m_unwind_plan_eh_frame_sp =
           std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
-      if (!eh_frame->GetUnwindPlan(current_pc, *m_unwind_plan_eh_frame_sp))
+      if (!eh_frame->GetUnwindPlan(m_range, *m_unwind_plan_eh_frame_sp))
         m_unwind_plan_eh_frame_sp.reset();
     }
   }
   return m_unwind_plan_eh_frame_sp;
 }
 
-UnwindPlanSP FuncUnwinders::GetDebugFrameUnwindPlan(Target &target,
-                                                    int current_offset) {
+UnwindPlanSP FuncUnwinders::GetDebugFrameUnwindPlan(Target &target) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_debug_frame_sp || m_tried_unwind_plan_debug_frame)
     return m_unwind_plan_debug_frame_sp;
 
   m_tried_unwind_plan_debug_frame = true;
   if (m_range.GetBaseAddress().IsValid()) {
-    Address current_pc(m_range.GetBaseAddress());
-    if (current_offset != -1)
-      current_pc.SetOffset(current_pc.GetOffset() + current_offset);
     DWARFCallFrameInfo *debug_frame = m_unwind_table.GetDebugFrameInfo();
     if (debug_frame) {
       m_unwind_plan_debug_frame_sp =
           std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
-      if (!debug_frame->GetUnwindPlan(current_pc,
-                                      *m_unwind_plan_debug_frame_sp))
+      if (!debug_frame->GetUnwindPlan(m_range, *m_unwind_plan_debug_frame_sp))
         m_unwind_plan_debug_frame_sp.reset();
     }
   }
   return m_unwind_plan_debug_frame_sp;
 }
 
-UnwindPlanSP FuncUnwinders::GetArmUnwindUnwindPlan(Target &target,
-                                                   int current_offset) {
+UnwindPlanSP FuncUnwinders::GetArmUnwindUnwindPlan(Target &target) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_arm_unwind_sp.get() || m_tried_unwind_plan_arm_unwind)
     return m_unwind_plan_arm_unwind_sp;
 
   m_tried_unwind_plan_arm_unwind = true;
   if (m_range.GetBaseAddress().IsValid()) {
     Address current_pc(m_range.GetBaseAddress());
-    if (current_offset != -1)
-      current_pc.SetOffset(current_pc.GetOffset() + current_offset);
     ArmUnwindInfo *arm_unwind_info = m_unwind_table.GetArmUnwindInfo();
     if (arm_unwind_info) {
       m_unwind_plan_arm_unwind_sp =
           std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
       if (!arm_unwind_info->GetUnwindPlan(target, current_pc,
                                           *m_unwind_plan_arm_unwind_sp))
         m_unwind_plan_arm_unwind_sp.reset();
     }
   }
   return m_unwind_plan_arm_unwind_sp;
 }
 
 UnwindPlanSP FuncUnwinders::GetEHFrameAugmentedUnwindPlan(Target &target,
-                                                          Thread &thread,
-                                                          int current_offset) {
+                                                          Thread &thread) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_eh_frame_augmented_sp.get() ||
       m_tried_unwind_plan_eh_frame_augmented)
     return m_unwind_plan_eh_frame_augmented_sp;
 
   // Only supported on x86 architectures where we get eh_frame from the
   // compiler that describes the prologue instructions perfectly, and sometimes
   // the epilogue instructions too.
   if (target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_32_i386 &&
       target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_64_x86_64 &&
       target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_64_x86_64h) {
     m_tried_unwind_plan_eh_frame_augmented = true;
     return m_unwind_plan_eh_frame_augmented_sp;
   }
 
   m_tried_unwind_plan_eh_frame_augmented = true;
 
-  UnwindPlanSP eh_frame_plan = GetEHFrameUnwindPlan(target, current_offset);
+  UnwindPlanSP eh_frame_plan = GetEHFrameUnwindPlan(target);
   if (!eh_frame_plan)
     return m_unwind_plan_eh_frame_augmented_sp;
 
   m_unwind_plan_eh_frame_augmented_sp =
       std::make_shared<UnwindPlan>(*eh_frame_plan);
 
   // Augment the eh_frame instructions with epilogue descriptions if necessary
   // so the UnwindPlan can be used at any instruction in the function.
 
   UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
   if (assembly_profiler_sp) {
     if (!assembly_profiler_sp->AugmentUnwindPlanFromCallSite(
             m_range, thread, *m_unwind_plan_eh_frame_augmented_sp)) {
       m_unwind_plan_eh_frame_augmented_sp.reset();
     }
   } else {
     m_unwind_plan_eh_frame_augmented_sp.reset();
   }
   return m_unwind_plan_eh_frame_augmented_sp;
 }
 
-UnwindPlanSP
-FuncUnwinders::GetDebugFrameAugmentedUnwindPlan(Target &target, Thread &thread,
-                                                int current_offset) {
+UnwindPlanSP FuncUnwinders::GetDebugFrameAugmentedUnwindPlan(Target &target,
+                                                             Thread &thread) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_debug_frame_augmented_sp.get() ||
       m_tried_unwind_plan_debug_frame_augmented)
     return m_unwind_plan_debug_frame_augmented_sp;
 
   // Only supported on x86 architectures where we get debug_frame from the
   // compiler that describes the prologue instructions perfectly, and sometimes
   // the epilogue instructions too.
   if (target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_32_i386 &&
       target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_64_x86_64 &&
       target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_64_x86_64h) {
     m_tried_unwind_plan_debug_frame_augmented = true;
     return m_unwind_plan_debug_frame_augmented_sp;
   }
 
   m_tried_unwind_plan_debug_frame_augmented = true;
 
-  UnwindPlanSP debug_frame_plan =
-      GetDebugFrameUnwindPlan(target, current_offset);
+  UnwindPlanSP debug_frame_plan = GetDebugFrameUnwindPlan(target);
   if (!debug_frame_plan)
     return m_unwind_plan_debug_frame_augmented_sp;
 
   m_unwind_plan_debug_frame_augmented_sp =
       std::make_shared<UnwindPlan>(*debug_frame_plan);
 
   // Augment the debug_frame instructions with epilogue descriptions if
   // necessary so the UnwindPlan can be used at any instruction in the
   // function.
 
   UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
   if (assembly_profiler_sp) {
     if (!assembly_profiler_sp->AugmentUnwindPlanFromCallSite(
             m_range, thread, *m_unwind_plan_debug_frame_augmented_sp)) {
       m_unwind_plan_debug_frame_augmented_sp.reset();
     }
   } else
     m_unwind_plan_debug_frame_augmented_sp.reset();
   return m_unwind_plan_debug_frame_augmented_sp;
 }
 
 UnwindPlanSP FuncUnwinders::GetAssemblyUnwindPlan(Target &target,
-                                                  Thread &thread,
-                                                  int current_offset) {
+                                                  Thread &thread) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_assembly_sp.get() || m_tried_unwind_plan_assembly ||
       !m_unwind_table.GetAllowAssemblyEmulationUnwindPlans()) {
     return m_unwind_plan_assembly_sp;
   }
 
   m_tried_unwind_plan_assembly = true;
 
if (a_first_row.get() && b_first_row.get()) {
         plans_are_identical = eLazyBoolNo;
       }
     }
   }
   return plans_are_identical;
 }
 
 UnwindPlanSP FuncUnwinders::GetUnwindPlanAtNonCallSite(Target &target,
-                                                       Thread &thread,
-                                                       int current_offset) {
-  UnwindPlanSP eh_frame_sp = GetEHFrameUnwindPlan(target, current_offset);
+                                                       Thread &thread) {
+  UnwindPlanSP eh_frame_sp = GetEHFrameUnwindPlan(target);
   if (!eh_frame_sp)
-    eh_frame_sp = GetDebugFrameUnwindPlan(target, current_offset);
+    eh_frame_sp = GetDebugFrameUnwindPlan(target);
   UnwindPlanSP arch_default_at_entry_sp =
       GetUnwindPlanArchitectureDefaultAtFunctionEntry(thread);
   UnwindPlanSP arch_default_sp = GetUnwindPlanArchitectureDefault(thread);
-  UnwindPlanSP assembly_sp =
-      GetAssemblyUnwindPlan(target, thread, current_offset);
+  UnwindPlanSP assembly_sp = GetAssemblyUnwindPlan(target, thread);
 
   // This point of this code is to detect when a function is using a non-
   // standard ABI, and the eh_frame correctly describes that alternate ABI.
   // This is addressing a specific situation on x86_64 linux systems where one
   // function in a library pushes a value on the stack and jumps to another
   // function.  So using an assembly instruction based unwind will not work
   // when you're in the second function - the stack has been modified in a non-
   // ABI way.  But we have eh_frame that correctly describes how to unwind from
if (CompareUnwindPlansForIdenticalInitialPCLocation(
           thread, eh_frame_sp, arch_default_at_entry_sp) == eLazyBoolNo &&
       CompareUnwindPlansForIdenticalInitialPCLocation(
           thread, eh_frame_sp, arch_default_sp) == eLazyBoolNo &&
       CompareUnwindPlansForIdenticalInitialPCLocation(
           thread, assembly_sp, arch_default_sp) == eLazyBoolNo) {
     return eh_frame_sp;
   }
 
-  if (UnwindPlanSP plan_sp =
-          GetEHFrameAugmentedUnwindPlan(target, thread, current_offset))
+  if (UnwindPlanSP plan_sp = GetEHFrameAugmentedUnwindPlan(target, thread))
     return plan_sp;
-  if (UnwindPlanSP plan_sp =
-          GetDebugFrameAugmentedUnwindPlan(target, thread, current_offset))
+  if (UnwindPlanSP plan_sp = GetDebugFrameAugmentedUnwindPlan(target, thread))
     return plan_sp;
 
   return assembly_sp;
 }
 
 UnwindPlanSP FuncUnwinders::GetUnwindPlanFastUnwind(Target &target,
                                                     Thread &thread) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
if (ArchSpec arch = m_unwind_table.GetArchitecture()) {
     assembly_profiler_sp = UnwindAssembly::FindPlugin(arch);
   }
   return assembly_profiler_sp;
 }
 
 Address FuncUnwinders::GetLSDAAddress(Target &target) {
   Address lsda_addr;
 
-  UnwindPlanSP unwind_plan_sp = GetEHFrameUnwindPlan(target, -1);
+  UnwindPlanSP unwind_plan_sp = GetEHFrameUnwindPlan(target);
   if (unwind_plan_sp.get() == nullptr) {
-    unwind_plan_sp = GetCompactUnwindUnwindPlan(target, -1);
+    unwind_plan_sp = GetCompactUnwindUnwindPlan(target);
   }
   if (unwind_plan_sp.get() && unwind_plan_sp->GetLSDAAddress().IsValid()) {
     lsda_addr = unwind_plan_sp->GetLSDAAddress();
   }
   return lsda_addr;
 }
 
 Address FuncUnwinders::GetPersonalityRoutinePtrAddress(Target &target) {
   Address personality_addr;
 
-  UnwindPlanSP unwind_plan_sp = GetEHFrameUnwindPlan(target, -1);
+  UnwindPlanSP unwind_plan_sp = GetEHFrameUnwindPlan(target);
   if (unwind_plan_sp.get() == nullptr) {
-    unwind_plan_sp = GetCompactUnwindUnwindPlan(target, -1);
+    unwind_plan_sp = GetCompactUnwindUnwindPlan(target);
   }
   if (unwind_plan_sp.get() &&
       unwind_plan_sp->GetPersonalityFunctionPtr().IsValid()) {
     personality_addr = unwind_plan_sp->GetPersonalityFunctionPtr();
   }
 
   return personality_addr;
 }