Fix PC adjustment in StackFrame::GetSymbolContext

[JosephTremoulet]

Summary

Update StackFrame::GetSymbolContext to mirror the logic in
RegisterContextLLDB::InitializeNonZerothFrame that knows not to do the
pc decrement when the given frame is a signal trap handler frame or the
parent of one, because the pc may not follow a call in these frames.
Accomplish this by adding a behaves_like_zeroth_frame field to
lldb_private::StackFrame, set to true for the zeroth frame, for
signal handler frames, and for parents of signal handler frames.

Also add logic to propagate the signal handler flag from UnwindPlan to
the FrameType on the RegisterContextLLDB it generates, and factor out a
helper to resolve symbol and address range for a RegisterContextLLDB now
that we have it in four places.

[JosephTremoulet]

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

1760 ↗

(On Diff #210831)

I'm a bit ambivalent about adding this part -- the downside is that it's not concretely helping today, because if an eh_frame record has the 'S' flag in its augmentation (which is what unwind_Plan->GetUnwindPlanForSignalTrap() reports), we'll have already decremented pc and generated unwind plans based on the prior function when initializing the register context. But the upside is that this connects the dots between the otherwise-unused bit on the unwind plan and the frame type, and will be in place should we subsequently add code to try the second function's unwind plan as a fallback.

lldb/source/Target/StackFrame.cpp

297 ↗

(On Diff #210831)

I've verified that this fixes the issue with the function name in the stack trace mentioned in D63667, but I haven't figured a way to add a test to that effect without putting a brittle assumption about particular trap handler names in the test.

[JosephTremoulet]

@jasonmolenda @clayborg ping. To clarify, the issue this fixes is, using test functionalities/signal/handle-abrt as an example:

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>

void handler(int sig)
{
    printf("Set a breakpoint here.\n");
    exit(0);
}

void abort_caller() {
    abort();
}

int main()
{
    if (signal(SIGABRT, handler) == SIG_ERR)
    {
        perror("signal");
        return 1;
    }

    abort_caller();
    return 2;
}

When stopped at the breakpoint in "handler", backtrace currently gives this:

(lldb) bt
* thread #1, name = 'sigtest', stop reason = breakpoint 1.1
  * frame #0: 0x0000000000400651 sigtest`handler(sig=6) at main.c:7
    frame #1: 0x00007ffff7a424b0 libc.so.6`___lldb_unnamed_symbol1$$libc.so.6 + 1    <----- the symbol context of this frame is the issue
    frame #2: 0x00007ffff7a42428 libc.so.6`__GI_raise(sig=6) at raise.c:54
    frame #3: 0x00007ffff7a4402a libc.so.6`__GI_abort at abort.c:89
    frame #4: 0x000000000040066e sigtest`abort_caller() at main.c:12
    frame #5: 0x00000000004006a2 sigtest`main at main.c:23
    frame #6: 0x00007ffff7a2d830 libc.so.6`__libc_start_main(main=(sigtest`main at main.c:16), argc=1, argv=0x00007fffffffe328, init=<unavailable>, fini=<unavailable>, rtld_fini=<unavailable>, stack_end=0x00007fffffffe318) at libc-start.c:291
    frame #7: 0x0000000000400579 sigtest`_start + 41

the pc of frame 1 is actually on the first byte of the relevant function, not following a call:

(lldb) frame select 1
frame #1: 0x00007ffff7a424b0 libc.so.6`___lldb_unnamed_symbol1$$libc.so.6 + 1
libc.so.6`__restore_rt:
->  0x7ffff7a424b0 <+0>: movq   $0xf, %rax
    0x7ffff7a424b7 <+7>: syscall 
    0x7ffff7a424b9 <+9>: nopl   (%rax)

libc.so.6`__GI___libc_sigaction:
    0x7ffff7a424c0 <+0>: subq   $0xd0, %rsp
(lldb) disassemble -s '$pc - 2'
    0x7ffff7a424ae:       addb   %al, (%rax)
libc.so.6`__restore_rt:
->  0x7ffff7a424b0 <+0>:  movq   $0xf, %rax
    0x7ffff7a424b7 <+7>:  syscall 
    0x7ffff7a424b9 <+9>:  nopl   (%rax)

libc.so.6`__GI___libc_sigaction:
    0x7ffff7a424c0 <+0>:  subq   $0xd0, %rsp
    0x7ffff7a424c7 <+7>:  testq  %rsi, %rsi
    0x7ffff7a424ca <+10>: movq   %rdx, %r8

With this fix, we instead get this backtrace:

(lldb) bt
* thread #1, name = 'sigtest', stop reason = breakpoint 1.1
  * frame #0: 0x0000000000400651 sigtest`handler(sig=6) at main.c:7
    frame #1: 0x00007ffff7a424b0 libc.so.6`__restore_rt                <-------------- correct symbol context here
    frame #2: 0x00007ffff7a42428 libc.so.6`__GI_raise(sig=6) at raise.c:54
    frame #3: 0x00007ffff7a4402a libc.so.6`__GI_abort at abort.c:89
    frame #4: 0x000000000040066e sigtest`abort_caller() at main.c:12
    frame #5: 0x00000000004006a2 sigtest`main at main.c:23
    frame #6: 0x00007ffff7a2d830 libc.so.6`__libc_start_main(main=(sigtest`main at main.c:16), argc=1, argv=0x00007fffffffe328, init=<unavailable>, fini=<unavailable>, rtld_fini=<unavailable>, stack_end=0x00007fffffffe318) at libc-start.c:291
    frame #7: 0x0000000000400579 sigtest`_start + 41

[clayborg]

I will let Jason comment on the unwind specifics since this is his area. I caught a few other things that need to be cleaned up.

lldb/include/lldb/Target/Unwind.h

40 ↗

(On Diff #210831)

initialize with value just in case.

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

153–155 ↗

(On Diff #210831)

See comment for RegisterContextLLDB::TryResolveSymbolContextAndAddressRange, but if we change as suggested this will become:

m_sym_ctx_valid = m_current_pc.ResolveFunctionScope(m_sym_ctx, nullptr);

430–432 ↗

(On Diff #210831)

See comment for RegisterContextLLDB::TryResolveSymbolContextAndAddressRange, but if we change as suggested this will become:

m_sym_ctx_valid = m_current_pc.ResolveFunctionScope(m_sym_ctx, nullptr);

486–487 ↗

(On Diff #210831)

See comment for RegisterContextLLDB::TryResolveSymbolContextAndAddressRange, but if we change as suggested this will become:

m_sym_ctx_valid = m_current_pc.ResolveFunctionScope(m_sym_ctx, &addr_range);

595–624 ↗

(On Diff #210831)

This function doesn't belong in RegisterContextLLDB. It think lldb_private::Address would be a better place:

/// if "addr_range_ptr" is not NULL, then fill in with the address range of the function.
bool lldb_private::Address::ResolveFunctionScope(lldb_private::SymbolContext &sym_ctx, lldb_private::AddressRange *addr_range_ptr) {
  constexpr bool resolve_tail_call_address = false;
  constexpr SymbolContextItem resolve_scope = eSymbolContextFunction | eSymbolContextSymbol;
  if (!CalculateSymbolContext(&sym_ctx, resolve_scope))
   return false;
  if (!addr_range_ptr)
    return true;
  return sym_ctx.GetAddressRange(resolve_scope, 0, false, *addr_range_ptr);  
}

1760 ↗

(On Diff #210831)

I will let Jason comment on this one.

lldb/source/Target/StackFrameList.cpp

453 ↗

(On Diff #210831)

init with value

670 ↗

(On Diff #210831)

init with value

[labath]

I haven't looked at the implementation, but I did run into the problem you are fixing in the past, and I am happy that someone is finally implementing this. I just wanted to say that for testing, I think you should be able to create some hand-written assembly that creates the kind of stack frames and unwind info you need to trigger this. You can look at existing tests in lldb/lit/Unwind for examples.

[JosephTremoulet]

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

595–624 ↗

(On Diff #210831)

Sure, will update. Just to double-check a couple points:

1. I'll actually want to pass &addr_range at all three callsites, rather than passing nullptr at two of them, correct? (at the callsite on 154 to preserve the addr_range previously defined on 175, and at the callsite on 431to preserve the addr_range previously defined on 470)
2. I see you removed the resolve_scope & resolved_scope check. Am I correct that that was intentional and it's redundant with the checks in GetAddressRange that require function or symbol to be non-null, or is there something more subtle going on here?

Thanks.

[clayborg]

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

595–624 ↗

(On Diff #210831)

For 1) above, it seems like you were making a new local variable just so you could pass it. If it is actually used somewhere, then yes, do include it. It seemed like you were just making a new local for no reason.

For 2) above: You can restore the resolve_scope & resolved_scope if needed. Can't remember if we will return eSymbolContextModule if we fail to find eSymbolContextFunction or eSymbolContextSymbol. So problably safest to restore that so we don't change functionality

[JosephTremoulet]

• Move resolution helper from RegisterContextLLDB to lldb_private::Address
• Defensively initialize out arguments

[clayborg]

Code looks fine now. Now Jason will need to chime in with comments on the new unwind functionality.

[JosephTremoulet]

• add test

[JosephTremoulet]

In D64993#1608452, @labath wrote:

I haven't looked at the implementation, but I did run into the problem you are fixing in the past, and I am happy that someone is finally implementing this. I just wanted to say that for testing, I think you should be able to create some hand-written assembly that creates the kind of stack frames and unwind info you need to trigger this. You can look at existing tests in lldb/lit/Unwind for examples.

Thanks for the tip! I was indeed able to copy one of those and adapt it to test this.

[labath]

In D64993#1608946, @JosephTremoulet wrote:

In D64993#1608452, @labath wrote:

I haven't looked at the implementation, but I did run into the problem you are fixing in the past, and I am happy that someone is finally implementing this. I just wanted to say that for testing, I think you should be able to create some hand-written assembly that creates the kind of stack frames and unwind info you need to trigger this. You can look at existing tests in lldb/lit/Unwind for examples.

Thanks for the tip! I was indeed able to copy one of those and adapt it to test this.

Awesome. Thanks for adding the test. The test looks great.

[jasonmolenda]

This looks good, this is in line with what we discussed, thanks for taking it on! Sorry for the delay at looking this over, it has been a little crazy this week.

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

1760 ↗

(On Diff #210831)

Yeah, this was my impression of the S augmentation flag in the eh_frame too -- we can't really use it in lldb today without forcing a scan of eh_frame entries the first time we unwind a function from that Module, and that would be unfortunate. But I like to see the flag being parsed and recorded; at some point in the future we may find a good way to use it.

1744 ↗

(On Diff #212642)

This is more a personal preference thing, but I would explicitly call out that we're addressing a problem on a platform where a trap handler is "added" to the stack by the kernel, but it hasn't actually been called and executed the way a normal function is, the PC is sitting on the first instruction of the function, so backing the pc up by 1 points us to the wrong function.

The kernel is presenting us with a stack frame that doesn't follow the normal ABI and execution models, and we're hacking around that. It's perfectly OK to do that, but it's a specific enough thing we're addressing here, I think it'll be helpful to Future Us to name it explicitly.

lldb/source/Plugins/Process/Utility/RegisterContextLLDB.h

125 ↗

(On Diff #212642)

This is very much a personal preference, but I might call this something like UpdateTrapHandlerFlagFromUnwindPlan. I'm fine with this name if you find it clearer.

[JosephTremoulet]

• Expand comment about return trampolines
• rename PropagateTrapHandlerFlag -> PropagateTrapHandlerFlagFromUnwindPlan

[JDevlieghere]

Hey Joseph,

The test trap_frame_sym_ctx is failing on GreenDragon. Can you please have a look?

http://lab.llvm.org:8080/green/view/LLDB/job/lldb-cmake/32449/testReport/junit/LLDB/Unwind/trap_frame_sym_ctx_test/

[JosephTremoulet]

In D64993#1612746, @JDevlieghere wrote:

Hey Joseph,

The test trap_frame_sym_ctx is failing on GreenDragon. Can you please have a look?

http://lab.llvm.org:8080/green/view/LLDB/job/lldb-cmake/32449/testReport/junit/LLDB/Unwind/trap_frame_sym_ctx_test/

Sorry about that. Hopefully fixed by r367706.

Thanks for the heads-up, though I'm surprised I didn't see one from the bot on either email or IRC; is it not sending them out, or am I just not looking in the right places?

[JDevlieghere]

In D64993#1612825, @JosephTremoulet wrote:

In D64993#1612746, @JDevlieghere wrote:

Hey Joseph,

The test trap_frame_sym_ctx is failing on GreenDragon. Can you please have a look?

http://lab.llvm.org:8080/green/view/LLDB/job/lldb-cmake/32449/testReport/junit/LLDB/Unwind/trap_frame_sym_ctx_test/

Sorry about that. Hopefully fixed by r367706.

Thanks, the bot is green again :-)

Thanks for the heads-up, though I'm surprised I didn't see one from the bot on either email or IRC; is it not sending them out, or am I just not looking in the right places?

Interesting. I'll check with the infrastructure team.

[JosephTremoulet]

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

1760 ↗

(On Diff #210831)

Yeah, this was my impression of the S augmentation flag in the eh_frame too -- we can't really use it in lldb today without forcing a scan of eh_frame entries the first time we unwind a function from that Module

"Thinking out lout" a bit... we could consider doing the check only when the pc is at the very start of a function -- in that case, either it's one of these signal frames where it's worth paying the price to check eh_frame, or it's a call at the end of the previous function... am I understanding correctly that the non-signal case is specifically when a noreturn non-tail call gets laid out at the end of a function and there's no alignment padding between it and the next function? I'd naively think that's an uncommon case, is there reason to believe otherwise? I don't think this will be a high enough priority for me to actually investigate any time soon, but if I were going to investigate, do we have some standard test suite for assessing that sort of thing (either statically how often that code pattern happens or dynamically what slowdown is observed from a particular lldb source change)?

Thanks!

lldb/trunk/include/lldb/Core/Address.h

///     A const Address object reference to \a this.
   /// one of the file sections.
   ///
   /// \return
   ///     Returns \b true if \a addr was able to be resolved, \b false
   ///     otherwise.
   bool ResolveAddressUsingFileSections(lldb::addr_t addr,
                                        const SectionList *sections);
 
+  /// Resolve this address to its containing function and optionally get
+  /// that function's address range.
+  ///
+  /// \param[out] sym_ctx
+  ///     The symbol context describing the function in which this address lies
+  ///
+  /// \parm[out] addr_range_ptr
+  ///     Pointer to the AddressRange to fill in with the function's address
+  ///     range.  Caller may pass null if they don't need the address range.
+  ///
+  /// \return
+  ///     Returns \b false if the function/symbol could not be resolved
+  ///     or if the address range was requested and could not be resolved;
+  ///     returns \b true otherwise.
+  bool ResolveFunctionScope(lldb_private::SymbolContext &sym_ctx,
+                            lldb_private::AddressRange *addr_range_ptr = nullptr);
+
   /// Set the address to represent \a load_addr.
   ///
   /// The address will attempt to find a loaded section within \a target that
   /// contains \a load_addr. If successful, this address object will have a
   /// valid section and offset. Else this address object will have no section
   /// (NULL) and the offset will be \a load_addr.
   ///
   /// \param[in] load_addr

lldb/trunk/include/lldb/Target/StackFrame.h

public:
   ///
   /// \param [in] sc_ptr
   ///   Optionally seed the StackFrame with the SymbolContext information that
   ///   has
   ///   already been discovered.
   StackFrame(const lldb::ThreadSP &thread_sp, lldb::user_id_t frame_idx,
              lldb::user_id_t concrete_frame_idx, lldb::addr_t cfa,
              bool cfa_is_valid, lldb::addr_t pc, Kind frame_kind,
-             const SymbolContext *sc_ptr);
+             bool behaves_like_zeroth_frame, const SymbolContext *sc_ptr);
 
   StackFrame(const lldb::ThreadSP &thread_sp, lldb::user_id_t frame_idx,
              lldb::user_id_t concrete_frame_idx,
              const lldb::RegisterContextSP &reg_context_sp, lldb::addr_t cfa,
-             lldb::addr_t pc, const SymbolContext *sc_ptr);
+             lldb::addr_t pc, bool behaves_like_zeroth_frame,
+             const SymbolContext *sc_ptr);
 
   StackFrame(const lldb::ThreadSP &thread_sp, lldb::user_id_t frame_idx,
              lldb::user_id_t concrete_frame_idx,
              const lldb::RegisterContextSP &reg_context_sp, lldb::addr_t cfa,
-             const Address &pc, const SymbolContext *sc_ptr);
+             const Address &pc, bool behaves_like_zeroth_frame,
+             const SymbolContext *sc_ptr);
 
   ~StackFrame() override;
 
   lldb::ThreadSP GetThread() const { return m_thread_wp.lock(); }
 
   StackID &GetStackID();
 
   /// Get an Address for the current pc value in this StackFrame.
public:
   /// Query whether this frame is part of a historical backtrace.
   bool IsHistorical() const;
 
   /// Query whether this frame is artificial (e.g a synthesized result of
   /// inferring missing tail call frames from a backtrace). Artificial frames
   /// may have limited support for inspecting variables.
   bool IsArtificial() const;
 
+  /// Query whether this frame behaves like the zeroth frame, in the sense
+  /// that its pc value might not immediately follow a call (and thus might
+  /// be the first address of its function).  True for actual frame zero as
+  /// well as any other frame with the same trait.
+  bool BehavesLikeZerothFrame() const;
+
   /// Query this frame to find what frame it is in this Thread's
   /// StackFrameList.
   ///
   /// \return
   ///   StackFrame index 0 indicates the currently-executing function.  Inline
   ///   frames are included in this frame index count.
   uint32_t GetFrameIndex() const;
 
Address m_frame_code_addr; // The frame code address (might not be the same as
                              // section/offset address
   SymbolContext m_sc;
   Flags m_flags;
   Scalar m_frame_base;
   Status m_frame_base_error;
   bool m_cfa_is_valid; // Does this frame have a CFA?  Different from CFA ==
                        // LLDB_INVALID_ADDRESS
   Kind m_stack_frame_kind;
+  bool m_behaves_like_zeroth_frame;
   lldb::VariableListSP m_variable_list_sp;
   ValueObjectList m_variable_list_value_objects; // Value objects for each
                                                  // variable in
                                                  // m_variable_list_sp
   lldb::RecognizedStackFrameSP m_recognized_frame_sp;
   StreamString m_disassembly;
   std::recursive_mutex m_mutex;
 
   DISALLOW_COPY_AND_ASSIGN(StackFrame);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_StackFrame_h_

lldb/trunk/include/lldb/Target/Unwind.h

uint32_t GetFrameCount() {
     std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex);
     return DoGetFrameCount();
   }
 
   uint32_t GetFramesUpTo(uint32_t end_idx) {
     lldb::addr_t cfa;
     lldb::addr_t pc;
     uint32_t idx;
+    bool behaves_like_zeroth_frame = (end_idx == 0);
 
     for (idx = 0; idx < end_idx; idx++) {
-      if (!DoGetFrameInfoAtIndex(idx, cfa, pc)) {
+      if (!DoGetFrameInfoAtIndex(idx, cfa, pc, behaves_like_zeroth_frame)) {
         break;
       }
     }
     return idx;
   }
 
   bool GetFrameInfoAtIndex(uint32_t frame_idx, lldb::addr_t &cfa,
-                           lldb::addr_t &pc) {
+                           lldb::addr_t &pc, bool &behaves_like_zeroth_frame) {
     std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex);
-    return DoGetFrameInfoAtIndex(frame_idx, cfa, pc);
+    return DoGetFrameInfoAtIndex(frame_idx, cfa, pc, behaves_like_zeroth_frame);
   }
 
   lldb::RegisterContextSP CreateRegisterContextForFrame(StackFrame *frame) {
     std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex);
     return DoCreateRegisterContextForFrame(frame);
   }
 
   Thread &GetThread() { return m_thread; }
 
 protected:
   // Classes that inherit from Unwind can see and modify these
   virtual void DoClear() = 0;
 
   virtual uint32_t DoGetFrameCount() = 0;
 
   virtual bool DoGetFrameInfoAtIndex(uint32_t frame_idx, lldb::addr_t &cfa,
-                                     lldb::addr_t &pc) = 0;
+                                     lldb::addr_t &pc,
+                                     bool &behaves_like_zeroth_frame) = 0;
 
   virtual lldb::RegisterContextSP
   DoCreateRegisterContextForFrame(StackFrame *frame) = 0;
 
   Thread &m_thread;
   std::recursive_mutex m_unwind_mutex;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(Unwind);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_Unwind_h_

lldb/trunk/lit/Unwind/Inputs/trap_frame_sym_ctx.s

+        .text
+        .globl  bar
+bar:
+        .cfi_startproc
+        leal    (%edi, %edi), %eax
+        ret
+        .cfi_endproc
+
+        .globl  asm_main
+asm_main:
+        .cfi_startproc
+        pushq   %rbp
+        .cfi_def_cfa_offset 16
+        .cfi_offset %rbp, -16
+        movq    %rsp, %rbp
+        .cfi_def_cfa_register %rbp
+        movl    $47, %edi
+
+        # install tramp as return address
+        # (similar to signal return trampolines on some platforms)
+        leaq    tramp, %rax
+        pushq   %rax
+        jmp     bar # call, with return address pointing to tramp
+
+        popq    %rbp
+        .cfi_def_cfa %rsp, 8
+        ret
+        .cfi_endproc
+
+        .globl  tramp
+tramp:
+        .cfi_startproc
+        .cfi_signal_frame
+        # Emit cfi to line up with the frame created by asm_main
+        .cfi_def_cfa_offset 16
+        .cfi_offset %rbp, -16
+        .cfi_def_cfa_register %rbp
+        # copy asm_main's epilog to clean up the frame
+        popq    %rbp
+        .cfi_def_cfa %rsp, 8
+        ret
+        .cfi_endproc

lldb/trunk/lit/Unwind/trap_frame_sym_ctx.test

+# Test that symbol contexts for trap handler frames are set correctly even when
+# the pc is at the start of the function.
+
+# UNSUPPORTED: system-windows
+# REQUIRES: target-x86_64, native
+
+# RUN: %clang %p/Inputs/call-asm.c %p/Inputs/trap_frame_sym_ctx.s -o %t
+# RUN: %lldb %t -s %s -o exit | FileCheck %s
+
+settings append target.trap-handler-names tramp
+
+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: {{.*}}`tramp
+# CHECK: frame #2: {{.*}}`main

lldb/trunk/source/Core/Address.cpp

if (section_sp) {
       return true; // Successfully transformed addr into a section offset
                    // address
     }
   }
   m_offset = file_addr;
   return false; // Failed to resolve this address to a section offset value
 }
 
+/// if "addr_range_ptr" is not NULL, then fill in with the address range of the function.
+bool Address::ResolveFunctionScope(SymbolContext &sym_ctx,
+                                   AddressRange *addr_range_ptr) {
+  constexpr SymbolContextItem resolve_scope =
+    eSymbolContextFunction | eSymbolContextSymbol;
+
+  if (!(CalculateSymbolContext(&sym_ctx, resolve_scope) & resolve_scope)) {
+    if (addr_range_ptr)
+      addr_range_ptr->Clear();
+   return false;
+  }
+
+  if (!addr_range_ptr)
+    return true;
+
+  return sym_ctx.GetAddressRange(resolve_scope, 0, false, *addr_range_ptr);
+}
+
 ModuleSP Address::GetModule() const {
   lldb::ModuleSP module_sp;
   SectionSP section_sp(GetSection());
   if (section_sp)
     module_sp = section_sp->GetModule();
   return module_sp;
 }
 

lldb/trunk/source/Plugins/Process/Utility/HistoryUnwind.h

 
 protected:
   void DoClear() override;
 
   lldb::RegisterContextSP
   DoCreateRegisterContextForFrame(StackFrame *frame) override;
 
   bool DoGetFrameInfoAtIndex(uint32_t frame_idx, lldb::addr_t &cfa,
-                             lldb::addr_t &pc) override;
+                             lldb::addr_t &pc,
+                             bool &behaves_like_zeroth_frame) override;
   uint32_t DoGetFrameCount() override;
 
 private:
   std::vector<lldb::addr_t> m_pcs;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_HistoryUnwind_h_

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

if (pc != LLDB_INVALID_ADDRESS) {
           *frame->GetThread().get(), frame->GetConcreteFrameIndex(),
           frame->GetThread()->GetProcess()->GetAddressByteSize(), pc);
     }
   }
   return rctx;
 }
 
 bool HistoryUnwind::DoGetFrameInfoAtIndex(uint32_t frame_idx, lldb::addr_t &cfa,
-                                          lldb::addr_t &pc) {
+                                          lldb::addr_t &pc,
+                                          bool &behaves_like_zeroth_frame) {
   // FIXME do not throw away the lock after we acquire it..
   std::unique_lock<std::recursive_mutex> guard(m_unwind_mutex);
   guard.unlock();
   if (frame_idx < m_pcs.size()) {
     cfa = frame_idx;
     pc = m_pcs[frame_idx];
+    behaves_like_zeroth_frame = (frame_idx == 0);
     return true;
   }
   return false;
 }
 
 uint32_t HistoryUnwind::DoGetFrameCount() { return m_pcs.size(); }

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

private:
   /// Given a SymbolContext, determines if this is a trap handler function
   /// aka asynchronous signal handler.
   ///
   /// \return
   ///     Returns true if the SymbolContext is a trap handler.
   bool IsTrapHandlerSymbol(lldb_private::Process *process,
                            const lldb_private::SymbolContext &m_sym_ctx) const;
 
+  /// Check if the given unwind plan indicates a signal trap handler, and
+  /// update frame type and symbol context if so.
+  void PropagateTrapHandlerFlagFromUnwindPlan(lldb::UnwindPlanSP unwind_plan);
+
   // Provide a location for where THIS function saved the CALLER's register
   // value
   // Or a frame "below" this one saved it, i.e. a function called by this one,
   // preserved a register that this
   // function didn't modify/use.
   //
   // The RegisterLocation type may be set to eRegisterNotAvailable -- this will
   // happen for a volatile register

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

void RegisterContextLLDB::InitializeZerothFrame() {
   // If we don't have a Module for some reason, we're not going to find
   // symbol/function information - just stick in some reasonable defaults and
   // hope we can unwind past this frame.
   ModuleSP pc_module_sp(m_current_pc.GetModule());
   if (!m_current_pc.IsValid() || !pc_module_sp) {
     UnwindLogMsg("using architectural default unwind method");
   }
 
-  // We require either a symbol or function in the symbols context to be
-  // successfully filled in or this context is of no use to us.
-  const SymbolContextItem resolve_scope =
-      eSymbolContextFunction | eSymbolContextSymbol;
-  if (pc_module_sp.get() && (pc_module_sp->ResolveSymbolContextForAddress(
-                                 m_current_pc, resolve_scope, m_sym_ctx) &
-                             resolve_scope)) {
-    m_sym_ctx_valid = true;
-  }
+  AddressRange addr_range;
+  m_sym_ctx_valid = m_current_pc.ResolveFunctionScope(m_sym_ctx, &addr_range);
 
   if (m_sym_ctx.symbol) {
     UnwindLogMsg("with pc value of 0x%" PRIx64 ", symbol name is '%s'",
                  current_pc, GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
   } else if (m_sym_ctx.function) {
     UnwindLogMsg("with pc value of 0x%" PRIx64 ", function name is '%s'",
                  current_pc, GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
   } else {
     UnwindLogMsg("with pc value of 0x%" PRIx64
                  ", no symbol/function name is known.",
                  current_pc);
   }
 
-  AddressRange addr_range;
-  m_sym_ctx.GetAddressRange(resolve_scope, 0, false, addr_range);
-
   if (IsTrapHandlerSymbol(process, m_sym_ctx)) {
     m_frame_type = eTrapHandlerFrame;
   } else {
     // FIXME:  Detect eDebuggerFrame here.
     m_frame_type = eNormalFrame;
   }
 
   // If we were able to find a symbol/function, set addr_range to the bounds of
if (abi) {
       return;
     }
     m_frame_type = eNotAValidFrame;
     UnwindLogMsg("could not find any symbol for this pc, or a default unwind "
                  "plan, to continue unwind.");
     return;
   }
 
-  bool resolve_tail_call_address = false; // m_current_pc can be one past the
-                                          // address range of the function...
-  // If the saved pc does not point to a function/symbol because it is beyond
-  // the bounds of the correct function and there's no symbol there, we do
-  // *not* want ResolveSymbolContextForAddress to back up the pc by 1, because
-  // then we might not find the correct unwind information later. Instead, let
-  // ResolveSymbolContextForAddress fail, and handle the case via
-  // decr_pc_and_recompute_addr_range below.
-  const SymbolContextItem resolve_scope =
-      eSymbolContextFunction | eSymbolContextSymbol;
-  uint32_t resolved_scope = pc_module_sp->ResolveSymbolContextForAddress(
-      m_current_pc, resolve_scope, m_sym_ctx, resolve_tail_call_address);
-
-  // We require either a symbol or function in the symbols context to be
-  // successfully filled in or this context is of no use to us.
-  if (resolve_scope & resolved_scope) {
-    m_sym_ctx_valid = true;
-  }
+  AddressRange addr_range;
+  m_sym_ctx_valid = m_current_pc.ResolveFunctionScope(m_sym_ctx, &addr_range);
 
   if (m_sym_ctx.symbol) {
     UnwindLogMsg("with pc value of 0x%" PRIx64 ", symbol name is '%s'", pc,
                  GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
   } else if (m_sym_ctx.function) {
     UnwindLogMsg("with pc value of 0x%" PRIx64 ", function name is '%s'", pc,
                  GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
   } else {
     UnwindLogMsg("with pc value of 0x%" PRIx64
                  ", no symbol/function name is known.",
                  pc);
   }
 
-  AddressRange addr_range;
-  if (!m_sym_ctx.GetAddressRange(resolve_scope, 0, false, addr_range)) {
-    m_sym_ctx_valid = false;
-  }
-
   bool decr_pc_and_recompute_addr_range;
 
   if (!m_sym_ctx_valid) {
     // Always decrement and recompute if the symbol lookup failed
     decr_pc_and_recompute_addr_range = true;
   } else if (GetNextFrame()->m_frame_type == eTrapHandlerFrame ||
              GetNextFrame()->m_frame_type == eDebuggerFrame) {
     // Don't decrement if we're "above" an asynchronous event like
void RegisterContextLLDB::InitializeNonZerothFrame() {
   // to the ABI plugin and consult that.
   if (decr_pc_and_recompute_addr_range) {
     UnwindLogMsg("Backing up the pc value of 0x%" PRIx64
                  " by 1 and re-doing symbol lookup; old symbol was %s",
                  pc, GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
     Address temporary_pc;
     temporary_pc.SetLoadAddress(pc - 1, &process->GetTarget());
     m_sym_ctx.Clear(false);
-    m_sym_ctx_valid = false;
-    SymbolContextItem resolve_scope =
-        eSymbolContextFunction | eSymbolContextSymbol;
+    m_sym_ctx_valid = temporary_pc.ResolveFunctionScope(m_sym_ctx, &addr_range);
 
-    ModuleSP temporary_module_sp = temporary_pc.GetModule();
-    if (temporary_module_sp &&
-        temporary_module_sp->ResolveSymbolContextForAddress(
-            temporary_pc, resolve_scope, m_sym_ctx) &
-            resolve_scope) {
-      if (m_sym_ctx.GetAddressRange(resolve_scope, 0, false, addr_range))
-        m_sym_ctx_valid = true;
-    }
     UnwindLogMsg("Symbol is now %s",
                  GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
   }
 
   // If we were able to find a symbol/function, set addr_range_ptr to the
   // bounds of that symbol/function. else treat the current pc value as the
   // start_pc and record no offset.
   if (addr_range.GetBaseAddress().IsValid()) {
void RegisterContextLLDB::InitializeNonZerothFrame() {
   // UnwindPlan may be expensive to get (e.g. if we have to parse the entire
   // eh_frame section of an ObjectFile for the first time.)
 
   if (m_fast_unwind_plan_sp &&
       m_fast_unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
     active_row =
         m_fast_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
     row_register_kind = m_fast_unwind_plan_sp->GetRegisterKind();
+    PropagateTrapHandlerFlagFromUnwindPlan(m_fast_unwind_plan_sp);
     if (active_row.get() && log) {
       StreamString active_row_strm;
       active_row->Dump(active_row_strm, m_fast_unwind_plan_sp.get(), &m_thread,
                        m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
       UnwindLogMsg("active row: %s", active_row_strm.GetData());
     }
   } else {
     m_full_unwind_plan_sp = GetFullUnwindPlanForFrame();
     int valid_offset = -1;
     if (IsUnwindPlanValidForCurrentPC(m_full_unwind_plan_sp, valid_offset)) {
       active_row = m_full_unwind_plan_sp->GetRowForFunctionOffset(valid_offset);
       row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
+      PropagateTrapHandlerFlagFromUnwindPlan(m_full_unwind_plan_sp);
       if (active_row.get() && log) {
         StreamString active_row_strm;
         active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(),
                          &m_thread,
                          m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
         UnwindLogMsg("active row: %s", active_row_strm.GetData());
       }
     }
if (active_row &&
     UnwindLogMsg("trying to unwind from this function with the UnwindPlan '%s' "
                  "because UnwindPlan '%s' failed.",
                  m_fallback_unwind_plan_sp->GetSourceName().GetCString(),
                  original_full_unwind_plan_sp->GetSourceName().GetCString());
 
     // We've copied the fallback unwind plan into the full - now clear the
     // fallback.
     m_fallback_unwind_plan_sp.reset();
+    PropagateTrapHandlerFlagFromUnwindPlan(m_full_unwind_plan_sp);
   }
 
   return true;
 }
 
 bool RegisterContextLLDB::ForceSwitchToFallbackUnwindPlan() {
   if (m_fallback_unwind_plan_sp.get() == nullptr)
     return false;
if (active_row &&
 
     m_full_unwind_plan_sp = m_fallback_unwind_plan_sp;
     m_fallback_unwind_plan_sp.reset();
 
     m_registers.clear();
 
     m_cfa = new_cfa;
 
+    PropagateTrapHandlerFlagFromUnwindPlan(m_full_unwind_plan_sp);
+
     UnwindLogMsg("switched unconditionally to the fallback unwindplan %s",
                  m_full_unwind_plan_sp->GetSourceName().GetCString());
     return true;
   }
   return false;
 }
 
+void RegisterContextLLDB::PropagateTrapHandlerFlagFromUnwindPlan(
+    lldb::UnwindPlanSP unwind_plan) {
+  if (unwind_plan->GetUnwindPlanForSignalTrap() != eLazyBoolYes) {
+    // Unwind plan does not indicate trap handler.  Do nothing.  We may
+    // already be flagged as trap handler flag due to the symbol being
+    // in the trap handler symbol list, and that should take precedence.
+    return;
+  } else if (m_frame_type != eNormalFrame) {
+    // If this is already a trap handler frame, nothing to do.
+    // If this is a skip or debug or invalid frame, don't override that.
+    return;
+  }
+
+  m_frame_type = eTrapHandlerFrame;
+
+  if (m_current_offset_backed_up_one != m_current_offset) {
+    // We backed up the pc by 1 to compute the symbol context, but
+    // now need to undo that because the pc of the trap handler
+    // frame may in fact be the first instruction of a signal return
+    // trampoline, rather than the instruction after a call.  This
+    // happens on systems where the signal handler dispatch code, rather
+    // than calling the handler and being returned to, jumps to the
+    // handler after pushing the address of a return trampoline on the
+    // stack -- on these systems, when the handler returns, control will
+    // be transferred to the return trampoline, so that's the best
+    // symbol we can present in the callstack.
+    UnwindLogMsg("Resetting current offset and re-doing symbol lookup; "
+                 "old symbol was %s",
+                 GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
+    m_current_offset_backed_up_one = m_current_offset;
+
+    AddressRange addr_range;
+    m_sym_ctx_valid = m_current_pc.ResolveFunctionScope(m_sym_ctx, &addr_range);
+
+    UnwindLogMsg("Symbol is now %s",
+                 GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
+
+    ExecutionContext exe_ctx(m_thread.shared_from_this());
+    Process *process = exe_ctx.GetProcessPtr();
+    Target *target = &process->GetTarget();
+
+    m_start_pc = addr_range.GetBaseAddress();
+    m_current_offset =
+        m_current_pc.GetLoadAddress(target) - m_start_pc.GetLoadAddress(target);
+  }
+}
+
 bool RegisterContextLLDB::ReadFrameAddress(
     lldb::RegisterKind row_register_kind, UnwindPlan::Row::FAValue &fa,
     addr_t &address) {
   RegisterValue reg_value;
 
   address = LLDB_INVALID_ADDRESS;
   addr_t cfa_reg_contents;
 

lldb/trunk/source/Plugins/Process/Utility/UnwindLLDB.h

void DoClear() override {
     m_frames.clear();
     m_candidate_frame.reset();
     m_unwind_complete = false;
   }
 
   uint32_t DoGetFrameCount() override;
 
   bool DoGetFrameInfoAtIndex(uint32_t frame_idx, lldb::addr_t &cfa,
-                             lldb::addr_t &start_pc) override;
+                             lldb::addr_t &start_pc,
+                             bool &behaves_like_zeroth_frame) override;
 
   lldb::RegisterContextSP
   DoCreateRegisterContextForFrame(lldb_private::StackFrame *frame) override;
 
   typedef std::shared_ptr<RegisterContextLLDB> RegisterContextLLDBSP;
 
   // Needed to retrieve the "next" frame (e.g. frame 2 needs to retrieve frame
   // 1's RegisterContextLLDB)

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

bool UnwindLLDB::AddOneMoreFrame(ABI *abi) {
 
   // The new frame hasn't helped in unwinding. Fall back to the original one as
   // the default unwind plan is usually more reliable then the fallback one.
   m_frames.pop_back();
   m_frames.push_back(new_frame);
   return true;
 }
 
-bool UnwindLLDB::DoGetFrameInfoAtIndex(uint32_t idx, addr_t &cfa, addr_t &pc) {
+bool UnwindLLDB::DoGetFrameInfoAtIndex(uint32_t idx, addr_t &cfa, addr_t &pc,
+                                       bool &behaves_like_zeroth_frame) {
   if (m_frames.size() == 0) {
     if (!AddFirstFrame())
       return false;
   }
 
   ProcessSP process_sp(m_thread.GetProcess());
   ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
 
   while (idx >= m_frames.size() && AddOneMoreFrame(abi))
     ;
 
   if (idx < m_frames.size()) {
     cfa = m_frames[idx]->cfa;
     pc = m_frames[idx]->start_pc;
+    if (idx == 0) {
+      // Frame zero always behaves like it.
+      behaves_like_zeroth_frame = true;
+    } else if (m_frames[idx - 1]->reg_ctx_lldb_sp->IsTrapHandlerFrame()) {
+      // This could be an asynchronous signal, thus the
+      // pc might point to the interrupted instruction rather
+      // than a post-call instruction
+      behaves_like_zeroth_frame = true;
+    } else if (m_frames[idx]->reg_ctx_lldb_sp->IsTrapHandlerFrame()) {
+      // This frame may result from signal processing installing
+      // a pointer to the first byte of a signal-return trampoline
+      // in the return address slot of the frame below, so this
+      // too behaves like the zeroth frame (i.e. the pc might not
+      // be pointing just past a call in it)
+      behaves_like_zeroth_frame = true;
+    } else {
+      behaves_like_zeroth_frame = false;
+    }
     return true;
   }
   return false;
 }
 
 lldb::RegisterContextSP
 UnwindLLDB::DoCreateRegisterContextForFrame(StackFrame *frame) {
   lldb::RegisterContextSP reg_ctx_sp;

lldb/trunk/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.h

public:
   ~UnwindMacOSXFrameBackchain() override = default;
 
 protected:
   void DoClear() override { m_cursors.clear(); }
 
   uint32_t DoGetFrameCount() override;
 
   bool DoGetFrameInfoAtIndex(uint32_t frame_idx, lldb::addr_t &cfa,
-                             lldb::addr_t &pc) override;
+                             lldb::addr_t &pc,
+                             bool &behaves_like_zeroth_frame) override;
 
   lldb::RegisterContextSP
   DoCreateRegisterContextForFrame(lldb_private::StackFrame *frame) override;
 
   friend class RegisterContextMacOSXFrameBackchain;
 
   struct Cursor {
     lldb::addr_t pc; // Program counter

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

if (target) {
         GetStackFrameData_x86_64(exe_ctx);
       else
         GetStackFrameData_i386(exe_ctx);
     }
   }
   return m_cursors.size();
 }
 
-bool UnwindMacOSXFrameBackchain::DoGetFrameInfoAtIndex(uint32_t idx,
-                                                       addr_t &cfa,
-                                                       addr_t &pc) {
+bool UnwindMacOSXFrameBackchain::DoGetFrameInfoAtIndex(
+    uint32_t idx, addr_t &cfa, addr_t &pc, bool &behaves_like_zeroth_frame) {
   const uint32_t frame_count = GetFrameCount();
   if (idx < frame_count) {
     if (m_cursors[idx].pc == LLDB_INVALID_ADDRESS)
       return false;
     if (m_cursors[idx].fp == LLDB_INVALID_ADDRESS)
       return false;
 
     pc = m_cursors[idx].pc;
     cfa = m_cursors[idx].fp;
+    behaves_like_zeroth_frame = (idx == 0);
 
     return true;
   }
   return false;
 }
 
 lldb::RegisterContextSP
 UnwindMacOSXFrameBackchain::DoCreateRegisterContextForFrame(StackFrame *frame) {

lldb/trunk/source/Target/StackFrame.cpp

 #define RESOLVED_FRAME_ID_SYMBOL_SCOPE (RESOLVED_FRAME_CODE_ADDR << 1)
 #define GOT_FRAME_BASE (RESOLVED_FRAME_ID_SYMBOL_SCOPE << 1)
 #define RESOLVED_VARIABLES (GOT_FRAME_BASE << 1)
 #define RESOLVED_GLOBAL_VARIABLES (RESOLVED_VARIABLES << 1)
 
 StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
                        user_id_t unwind_frame_index, addr_t cfa,
                        bool cfa_is_valid, addr_t pc, StackFrame::Kind kind,
+                       bool behaves_like_zeroth_frame,
                        const SymbolContext *sc_ptr)
     : m_thread_wp(thread_sp), m_frame_index(frame_idx),
       m_concrete_frame_index(unwind_frame_index), m_reg_context_sp(),
       m_id(pc, cfa, nullptr), m_frame_code_addr(pc), m_sc(), m_flags(),
       m_frame_base(), m_frame_base_error(), m_cfa_is_valid(cfa_is_valid),
-      m_stack_frame_kind(kind), m_variable_list_sp(),
-      m_variable_list_value_objects(), m_recognized_frame_sp(), m_disassembly(),
-      m_mutex() {
+      m_stack_frame_kind(kind),
+      m_behaves_like_zeroth_frame(behaves_like_zeroth_frame),
+      m_variable_list_sp(), m_variable_list_value_objects(),
+      m_recognized_frame_sp(), m_disassembly(), m_mutex() {
   // If we don't have a CFA value, use the frame index for our StackID so that
   // recursive functions properly aren't confused with one another on a history
   // stack.
   if (IsHistorical() && !m_cfa_is_valid) {
     m_id.SetCFA(m_frame_index);
   }
 
   if (sc_ptr != nullptr) {
     m_sc = *sc_ptr;
     m_flags.Set(m_sc.GetResolvedMask());
   }
 }
 
 StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
                        user_id_t unwind_frame_index,
                        const RegisterContextSP &reg_context_sp, addr_t cfa,
-                       addr_t pc, const SymbolContext *sc_ptr)
+                       addr_t pc, bool behaves_like_zeroth_frame,
+                       const SymbolContext *sc_ptr)
     : m_thread_wp(thread_sp), m_frame_index(frame_idx),
       m_concrete_frame_index(unwind_frame_index),
       m_reg_context_sp(reg_context_sp), m_id(pc, cfa, nullptr),
       m_frame_code_addr(pc), m_sc(), m_flags(), m_frame_base(),
       m_frame_base_error(), m_cfa_is_valid(true),
-      m_stack_frame_kind(StackFrame::Kind::Regular), m_variable_list_sp(),
-      m_variable_list_value_objects(), m_recognized_frame_sp(), m_disassembly(),
-      m_mutex() {
+      m_stack_frame_kind(StackFrame::Kind::Regular),
+      m_behaves_like_zeroth_frame(behaves_like_zeroth_frame),
+      m_variable_list_sp(), m_variable_list_value_objects(),
+      m_recognized_frame_sp(), m_disassembly(), m_mutex() {
   if (sc_ptr != nullptr) {
     m_sc = *sc_ptr;
     m_flags.Set(m_sc.GetResolvedMask());
   }
 
   if (reg_context_sp && !m_sc.target_sp) {
     m_sc.target_sp = reg_context_sp->CalculateTarget();
     if (m_sc.target_sp)
       m_flags.Set(eSymbolContextTarget);
   }
 }
 
 StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
                        user_id_t unwind_frame_index,
                        const RegisterContextSP &reg_context_sp, addr_t cfa,
-                       const Address &pc_addr, const SymbolContext *sc_ptr)
+                       const Address &pc_addr, bool behaves_like_zeroth_frame,
+                       const SymbolContext *sc_ptr)
     : m_thread_wp(thread_sp), m_frame_index(frame_idx),
       m_concrete_frame_index(unwind_frame_index),
       m_reg_context_sp(reg_context_sp),
       m_id(pc_addr.GetLoadAddress(thread_sp->CalculateTarget().get()), cfa,
            nullptr),
       m_frame_code_addr(pc_addr), m_sc(), m_flags(), m_frame_base(),
       m_frame_base_error(), m_cfa_is_valid(true),
-      m_stack_frame_kind(StackFrame::Kind::Regular), m_variable_list_sp(),
-      m_variable_list_value_objects(), m_recognized_frame_sp(), m_disassembly(),
-      m_mutex() {
+      m_stack_frame_kind(StackFrame::Kind::Regular),
+      m_behaves_like_zeroth_frame(behaves_like_zeroth_frame),
+      m_variable_list_sp(), m_variable_list_value_objects(),
+      m_recognized_frame_sp(), m_disassembly(), m_mutex() {
   if (sc_ptr != nullptr) {
     m_sc = *sc_ptr;
     m_flags.Set(m_sc.GetResolvedMask());
   }
 
   if (!m_sc.target_sp && reg_context_sp) {
     m_sc.target_sp = reg_context_sp->CalculateTarget();
     if (m_sc.target_sp)
if ((m_flags.Get() & resolve_scope) != resolve_scope) {
     if (!m_sc.module_sp && m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR))
       GetFrameCodeAddress();
 
     // If this is not frame zero, then we need to subtract 1 from the PC value
     // when doing address lookups since the PC will be on the instruction
     // following the function call instruction...
 
     Address lookup_addr(GetFrameCodeAddress());
-    if (m_frame_index > 0 && lookup_addr.IsValid()) {
+    if (!m_behaves_like_zeroth_frame && lookup_addr.IsValid()) {
       addr_t offset = lookup_addr.GetOffset();
       if (offset > 0) {
         lookup_addr.SetOffset(offset - 1);
 
       } else {
         // lookup_addr is the start of a section.  We need do the math on the
         // actual load address and re-compute the section.  We're working with
         // a 'noreturn' function at the end of a section.

lldb/trunk/source/Target/StackFrameList.cpp

void StackFrameList::SynthesizeTailCallFrames(StackFrame &next_frame) {
   // Push synthetic tail call frames.
   for (Function *callee : llvm::reverse(path)) {
     uint32_t frame_idx = m_frames.size();
     uint32_t concrete_frame_idx = next_frame.GetConcreteFrameIndex();
     addr_t cfa = LLDB_INVALID_ADDRESS;
     bool cfa_is_valid = false;
     addr_t pc =
         callee->GetAddressRange().GetBaseAddress().GetLoadAddress(&target);
+    constexpr bool behaves_like_zeroth_frame = false;
     SymbolContext sc;
     callee->CalculateSymbolContext(&sc);
     auto synth_frame = std::make_shared<StackFrame>(
         m_thread.shared_from_this(), frame_idx, concrete_frame_idx, cfa,
-        cfa_is_valid, pc, StackFrame::Kind::Artificial, &sc);
+        cfa_is_valid, pc, StackFrame::Kind::Artificial,
+        behaves_like_zeroth_frame, &sc);
     m_frames.push_back(synth_frame);
     LLDB_LOG(log, "Pushed frame {0}", callee->GetDisplayName());
   }
 
   // If any frames were created, adjust next_frame's index.
   if (!path.empty())
     next_frame.SetFrameIndex(m_frames.size());
 }
if (end_idx > 0 && end_idx != UINT32_MAX) {
     }
   }
 
   StackFrameSP unwind_frame_sp;
   do {
     uint32_t idx = m_concrete_frames_fetched++;
     lldb::addr_t pc = LLDB_INVALID_ADDRESS;
     lldb::addr_t cfa = LLDB_INVALID_ADDRESS;
+    bool behaves_like_zeroth_frame = (idx == 0);
     if (idx == 0) {
       // We might have already created frame zero, only create it if we need
       // to.
       if (m_frames.empty()) {
         RegisterContextSP reg_ctx_sp(m_thread.GetRegisterContext());
 
         if (reg_ctx_sp) {
-          const bool success =
-              unwinder && unwinder->GetFrameInfoAtIndex(idx, cfa, pc);
+          const bool success = unwinder &&
+                               unwinder->GetFrameInfoAtIndex(
+                                   idx, cfa, pc, behaves_like_zeroth_frame);
           // There shouldn't be any way not to get the frame info for frame
           // 0. But if the unwinder can't make one, lets make one by hand
           // with the SP as the CFA and see if that gets any further.
           if (!success) {
             cfa = reg_ctx_sp->GetSP();
             pc = reg_ctx_sp->GetPC();
           }
 
           unwind_frame_sp = std::make_shared<StackFrame>(
               m_thread.shared_from_this(), m_frames.size(), idx, reg_ctx_sp,
-              cfa, pc, nullptr);
+              cfa, pc, behaves_like_zeroth_frame, nullptr);
           m_frames.push_back(unwind_frame_sp);
         }
       } else {
         unwind_frame_sp = m_frames.front();
         cfa = unwind_frame_sp->m_id.GetCallFrameAddress();
       }
     } else {
-      const bool success =
-          unwinder && unwinder->GetFrameInfoAtIndex(idx, cfa, pc);
+      const bool success = unwinder &&
+                           unwinder->GetFrameInfoAtIndex(
+                               idx, cfa, pc, behaves_like_zeroth_frame);
       if (!success) {
         // We've gotten to the end of the stack.
         SetAllFramesFetched();
         break;
       }
       const bool cfa_is_valid = true;
       unwind_frame_sp = std::make_shared<StackFrame>(
           m_thread.shared_from_this(), m_frames.size(), idx, cfa, cfa_is_valid,
-          pc, StackFrame::Kind::Regular, nullptr);
+          pc, StackFrame::Kind::Regular, behaves_like_zeroth_frame, nullptr);
 
       // Create synthetic tail call frames between the previous frame and the
       // newly-found frame. The new frame's index may change after this call,
       // although its concrete index will stay the same.
       SynthesizeTailCallFrames(*unwind_frame_sp.get());
 
       m_frames.push_back(unwind_frame_sp);
     }
if (unwind_block) {
       }
 
       SymbolContext next_frame_sc;
       Address next_frame_address;
 
       while (unwind_sc.GetParentOfInlinedScope(
           curr_frame_address, next_frame_sc, next_frame_address)) {
         next_frame_sc.line_entry.ApplyFileMappings(target_sp);
-        StackFrameSP frame_sp(
-            new StackFrame(m_thread.shared_from_this(), m_frames.size(), idx,
-                           unwind_frame_sp->GetRegisterContextSP(), cfa,
-                           next_frame_address, &next_frame_sc));
+        behaves_like_zeroth_frame = false;
+        StackFrameSP frame_sp(new StackFrame(
+            m_thread.shared_from_this(), m_frames.size(), idx,
+            unwind_frame_sp->GetRegisterContextSP(), cfa, next_frame_address,
+            behaves_like_zeroth_frame, &next_frame_sc));
 
         m_frames.push_back(frame_sp);
         unwind_sc = next_frame_sc;
         curr_frame_address = next_frame_address;
       }
     }
   } while (m_frames.size() - 1 < end_idx);
 
if (idx < m_frames.size()) {
     if (m_show_inlined_frames) {
       // When inline frames are enabled we actually create all the frames in
       // GetFramesUpTo.
       frame_sp = m_frames[idx];
     } else {
       Unwind *unwinder = m_thread.GetUnwinder();
       if (unwinder) {
         addr_t pc, cfa;
-        if (unwinder->GetFrameInfoAtIndex(idx, cfa, pc)) {
+        bool behaves_like_zeroth_frame = (idx == 0);
+        if (unwinder->GetFrameInfoAtIndex(idx, cfa, pc,
+                                          behaves_like_zeroth_frame)) {
           const bool cfa_is_valid = true;
           frame_sp = std::make_shared<StackFrame>(
               m_thread.shared_from_this(), idx, idx, cfa, cfa_is_valid, pc,
-              StackFrame::Kind::Regular, nullptr);
+              StackFrame::Kind::Regular, behaves_like_zeroth_frame, nullptr);
 
           Function *function =
               frame_sp->GetSymbolContext(eSymbolContextFunction).function;
           if (function) {
             // When we aren't showing inline functions we always use the top
             // most function block as the scope.
             frame_sp->SetSymbolContextScope(&function->GetBlock(false));
           } else {