aboutsummaryrefslogtreecommitdiffstats
path: root/source/Target/StackFrameList.cpp
diff options
context:
space:
mode:
authorDimitry Andric <dim@FreeBSD.org>2017-01-02 19:26:05 +0000
committerDimitry Andric <dim@FreeBSD.org>2017-01-02 19:26:05 +0000
commit14f1b3e8826ce43b978db93a62d1166055db5394 (patch)
tree0a00ad8d3498783fe0193f3b656bca17c4c8697d /source/Target/StackFrameList.cpp
parent4ee8c119c71a06dcad1e0fecc8c675e480e59337 (diff)
downloadsrc-14f1b3e8826ce43b978db93a62d1166055db5394.tar.gz
src-14f1b3e8826ce43b978db93a62d1166055db5394.zip
Vendor import of lldb trunk r290819:vendor/lldb/lldb-trunk-r290819
Notes
Notes: svn path=/vendor/lldb/dist/; revision=311128 svn path=/vendor/lldb/lldb-trunk-r290819/; revision=311129; tag=vendor/lldb/lldb-trunk-r290819
Diffstat (limited to 'source/Target/StackFrameList.cpp')
-rw-r--r--source/Target/StackFrameList.cpp1522
1 files changed, 716 insertions, 806 deletions
diff --git a/source/Target/StackFrameList.cpp b/source/Target/StackFrameList.cpp
index 8304caf5710f..872e153ddb06 100644
--- a/source/Target/StackFrameList.cpp
+++ b/source/Target/StackFrameList.cpp
@@ -12,11 +12,11 @@
// Other libraries and framework includes
// Project includes
#include "lldb/Target/StackFrameList.h"
-#include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Breakpoint/Breakpoint.h"
+#include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Log.h"
-#include "lldb/Core/StreamFile.h"
#include "lldb/Core/SourceManager.h"
+#include "lldb/Core/StreamFile.h"
#include "lldb/Symbol/Block.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h"
@@ -36,908 +36,818 @@ using namespace lldb_private;
//----------------------------------------------------------------------
// StackFrameList constructor
//----------------------------------------------------------------------
-StackFrameList::StackFrameList(Thread &thread, const lldb::StackFrameListSP &prev_frames_sp, bool show_inline_frames)
- : m_thread(thread),
- m_prev_frames_sp(prev_frames_sp),
- m_mutex(),
- m_frames(),
- m_selected_frame_idx(0),
- m_concrete_frames_fetched(0),
+StackFrameList::StackFrameList(Thread &thread,
+ const lldb::StackFrameListSP &prev_frames_sp,
+ bool show_inline_frames)
+ : m_thread(thread), m_prev_frames_sp(prev_frames_sp), m_mutex(), m_frames(),
+ m_selected_frame_idx(0), m_concrete_frames_fetched(0),
m_current_inlined_depth(UINT32_MAX),
m_current_inlined_pc(LLDB_INVALID_ADDRESS),
- m_show_inlined_frames(show_inline_frames)
-{
- if (prev_frames_sp)
- {
- m_current_inlined_depth = prev_frames_sp->m_current_inlined_depth;
- m_current_inlined_pc = prev_frames_sp->m_current_inlined_pc;
- }
+ m_show_inlined_frames(show_inline_frames) {
+ if (prev_frames_sp) {
+ m_current_inlined_depth = prev_frames_sp->m_current_inlined_depth;
+ m_current_inlined_pc = prev_frames_sp->m_current_inlined_pc;
+ }
}
-StackFrameList::~StackFrameList()
-{
- // Call clear since this takes a lock and clears the stack frame list
- // in case another thread is currently using this stack frame list
- Clear();
+StackFrameList::~StackFrameList() {
+ // Call clear since this takes a lock and clears the stack frame list
+ // in case another thread is currently using this stack frame list
+ Clear();
}
-void
-StackFrameList::CalculateCurrentInlinedDepth()
-{
- uint32_t cur_inlined_depth = GetCurrentInlinedDepth();
- if (cur_inlined_depth == UINT32_MAX)
- {
- ResetCurrentInlinedDepth();
- }
+void StackFrameList::CalculateCurrentInlinedDepth() {
+ uint32_t cur_inlined_depth = GetCurrentInlinedDepth();
+ if (cur_inlined_depth == UINT32_MAX) {
+ ResetCurrentInlinedDepth();
+ }
}
-uint32_t
-StackFrameList::GetCurrentInlinedDepth ()
-{
- if (m_show_inlined_frames && m_current_inlined_pc != LLDB_INVALID_ADDRESS)
- {
- lldb::addr_t cur_pc = m_thread.GetRegisterContext()->GetPC();
- if (cur_pc != m_current_inlined_pc)
- {
- m_current_inlined_pc = LLDB_INVALID_ADDRESS;
- m_current_inlined_depth = UINT32_MAX;
- Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
- if (log && log->GetVerbose())
- log->Printf ("GetCurrentInlinedDepth: invalidating current inlined depth.\n");
- }
- return m_current_inlined_depth;
- }
- else
- {
- return UINT32_MAX;
+uint32_t StackFrameList::GetCurrentInlinedDepth() {
+ if (m_show_inlined_frames && m_current_inlined_pc != LLDB_INVALID_ADDRESS) {
+ lldb::addr_t cur_pc = m_thread.GetRegisterContext()->GetPC();
+ if (cur_pc != m_current_inlined_pc) {
+ m_current_inlined_pc = LLDB_INVALID_ADDRESS;
+ m_current_inlined_depth = UINT32_MAX;
+ Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
+ if (log && log->GetVerbose())
+ log->Printf(
+ "GetCurrentInlinedDepth: invalidating current inlined depth.\n");
}
+ return m_current_inlined_depth;
+ } else {
+ return UINT32_MAX;
+ }
}
-void
-StackFrameList::ResetCurrentInlinedDepth ()
-{
- std::lock_guard<std::recursive_mutex> guard(m_mutex);
-
- if (m_show_inlined_frames)
- {
- GetFramesUpTo(0);
- if (m_frames.empty())
- return;
- if (!m_frames[0]->IsInlined())
- {
- m_current_inlined_depth = UINT32_MAX;
- m_current_inlined_pc = LLDB_INVALID_ADDRESS;
- Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
- if (log && log->GetVerbose())
- log->Printf ("ResetCurrentInlinedDepth: Invalidating current inlined depth.\n");
- }
- else
- {
- // We only need to do something special about inlined blocks when we
- // are at the beginning of an inlined function:
- // FIXME: We probably also have to do something special if the PC is at the END
- // of an inlined function, which coincides with the end of either its containing
- // function or another inlined function.
-
- lldb::addr_t curr_pc = m_thread.GetRegisterContext()->GetPC();
- Block *block_ptr = m_frames[0]->GetFrameBlock();
- if (block_ptr)
- {
- Address pc_as_address;
- pc_as_address.SetLoadAddress(curr_pc, &(m_thread.GetProcess()->GetTarget()));
- AddressRange containing_range;
- if (block_ptr->GetRangeContainingAddress(pc_as_address, containing_range))
- {
- if (pc_as_address == containing_range.GetBaseAddress())
- {
- // If we got here because of a breakpoint hit, then set the inlined depth depending on where
- // the breakpoint was set.
- // If we got here because of a crash, then set the inlined depth to the deepest most block.
- // Otherwise, we stopped here naturally as the result of a step, so set ourselves in the
- // containing frame of the whole set of nested inlines, so the user can then "virtually"
- // step into the frames one by one, or next over the whole mess.
- // Note: We don't have to handle being somewhere in the middle of the stack here, since
- // ResetCurrentInlinedDepth doesn't get called if there is a valid inlined depth set.
- StopInfoSP stop_info_sp = m_thread.GetStopInfo();
- if (stop_info_sp)
- {
- switch (stop_info_sp->GetStopReason())
- {
- case eStopReasonWatchpoint:
- case eStopReasonException:
- case eStopReasonExec:
- case eStopReasonSignal:
- // In all these cases we want to stop in the deepest most frame.
- m_current_inlined_pc = curr_pc;
- m_current_inlined_depth = 0;
- break;
- case eStopReasonBreakpoint:
- {
- // FIXME: Figure out what this break point is doing, and set the inline depth
- // appropriately. Be careful to take into account breakpoints that implement
- // step over prologue, since that should do the default calculation.
- // For now, if the breakpoints corresponding to this hit are all internal,
- // I set the stop location to the top of the inlined stack, since that will make
- // things like stepping over prologues work right. But if there are any non-internal
- // breakpoints I do to the bottom of the stack, since that was the old behavior.
- uint32_t bp_site_id = stop_info_sp->GetValue();
- BreakpointSiteSP bp_site_sp(m_thread.GetProcess()->GetBreakpointSiteList().FindByID(bp_site_id));
- bool all_internal = true;
- if (bp_site_sp)
- {
- uint32_t num_owners = bp_site_sp->GetNumberOfOwners();
- for (uint32_t i = 0; i < num_owners; i++)
- {
- Breakpoint &bp_ref = bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint();
- if (!bp_ref.IsInternal())
- {
- all_internal = false;
- }
- }
- }
- if (!all_internal)
- {
- m_current_inlined_pc = curr_pc;
- m_current_inlined_depth = 0;
- break;
- }
- }
- LLVM_FALLTHROUGH;
- default:
- {
- // Otherwise, we should set ourselves at the container of the inlining, so that the
- // user can descend into them.
- // So first we check whether we have more than one inlined block sharing this PC:
- int num_inlined_functions = 0;
-
- for (Block *container_ptr = block_ptr->GetInlinedParent();
- container_ptr != nullptr;
- container_ptr = container_ptr->GetInlinedParent())
- {
- if (!container_ptr->GetRangeContainingAddress(pc_as_address, containing_range))
- break;
- if (pc_as_address != containing_range.GetBaseAddress())
- break;
-
- num_inlined_functions++;
- }
- m_current_inlined_pc = curr_pc;
- m_current_inlined_depth = num_inlined_functions + 1;
- Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
- if (log && log->GetVerbose())
- log->Printf ("ResetCurrentInlinedDepth: setting inlined depth: %d 0x%" PRIx64 ".\n", m_current_inlined_depth, curr_pc);
-
- }
- break;
- }
- }
+void StackFrameList::ResetCurrentInlinedDepth() {
+ std::lock_guard<std::recursive_mutex> guard(m_mutex);
+
+ if (m_show_inlined_frames) {
+ GetFramesUpTo(0);
+ if (m_frames.empty())
+ return;
+ if (!m_frames[0]->IsInlined()) {
+ m_current_inlined_depth = UINT32_MAX;
+ m_current_inlined_pc = LLDB_INVALID_ADDRESS;
+ Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
+ if (log && log->GetVerbose())
+ log->Printf(
+ "ResetCurrentInlinedDepth: Invalidating current inlined depth.\n");
+ } else {
+ // We only need to do something special about inlined blocks when we
+ // are at the beginning of an inlined function:
+ // FIXME: We probably also have to do something special if the PC is at
+ // the END
+ // of an inlined function, which coincides with the end of either its
+ // containing
+ // function or another inlined function.
+
+ lldb::addr_t curr_pc = m_thread.GetRegisterContext()->GetPC();
+ Block *block_ptr = m_frames[0]->GetFrameBlock();
+ if (block_ptr) {
+ Address pc_as_address;
+ pc_as_address.SetLoadAddress(curr_pc,
+ &(m_thread.GetProcess()->GetTarget()));
+ AddressRange containing_range;
+ if (block_ptr->GetRangeContainingAddress(pc_as_address,
+ containing_range)) {
+ if (pc_as_address == containing_range.GetBaseAddress()) {
+ // If we got here because of a breakpoint hit, then set the inlined
+ // depth depending on where
+ // the breakpoint was set.
+ // If we got here because of a crash, then set the inlined depth to
+ // the deepest most block.
+ // Otherwise, we stopped here naturally as the result of a step, so
+ // set ourselves in the
+ // containing frame of the whole set of nested inlines, so the user
+ // can then "virtually"
+ // step into the frames one by one, or next over the whole mess.
+ // Note: We don't have to handle being somewhere in the middle of
+ // the stack here, since
+ // ResetCurrentInlinedDepth doesn't get called if there is a valid
+ // inlined depth set.
+ StopInfoSP stop_info_sp = m_thread.GetStopInfo();
+ if (stop_info_sp) {
+ switch (stop_info_sp->GetStopReason()) {
+ case eStopReasonWatchpoint:
+ case eStopReasonException:
+ case eStopReasonExec:
+ case eStopReasonSignal:
+ // In all these cases we want to stop in the deepest most frame.
+ m_current_inlined_pc = curr_pc;
+ m_current_inlined_depth = 0;
+ break;
+ case eStopReasonBreakpoint: {
+ // FIXME: Figure out what this break point is doing, and set the
+ // inline depth
+ // appropriately. Be careful to take into account breakpoints
+ // that implement
+ // step over prologue, since that should do the default
+ // calculation.
+ // For now, if the breakpoints corresponding to this hit are all
+ // internal,
+ // I set the stop location to the top of the inlined stack,
+ // since that will make
+ // things like stepping over prologues work right. But if there
+ // are any non-internal
+ // breakpoints I do to the bottom of the stack, since that was
+ // the old behavior.
+ uint32_t bp_site_id = stop_info_sp->GetValue();
+ BreakpointSiteSP bp_site_sp(
+ m_thread.GetProcess()->GetBreakpointSiteList().FindByID(
+ bp_site_id));
+ bool all_internal = true;
+ if (bp_site_sp) {
+ uint32_t num_owners = bp_site_sp->GetNumberOfOwners();
+ for (uint32_t i = 0; i < num_owners; i++) {
+ Breakpoint &bp_ref =
+ bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint();
+ if (!bp_ref.IsInternal()) {
+ all_internal = false;
}
+ }
+ }
+ if (!all_internal) {
+ m_current_inlined_pc = curr_pc;
+ m_current_inlined_depth = 0;
+ break;
+ }
+ }
+ LLVM_FALLTHROUGH;
+ default: {
+ // Otherwise, we should set ourselves at the container of the
+ // inlining, so that the
+ // user can descend into them.
+ // So first we check whether we have more than one inlined block
+ // sharing this PC:
+ int num_inlined_functions = 0;
+
+ for (Block *container_ptr = block_ptr->GetInlinedParent();
+ container_ptr != nullptr;
+ container_ptr = container_ptr->GetInlinedParent()) {
+ if (!container_ptr->GetRangeContainingAddress(
+ pc_as_address, containing_range))
+ break;
+ if (pc_as_address != containing_range.GetBaseAddress())
+ break;
+
+ num_inlined_functions++;
}
+ m_current_inlined_pc = curr_pc;
+ m_current_inlined_depth = num_inlined_functions + 1;
+ Log *log(
+ lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
+ if (log && log->GetVerbose())
+ log->Printf("ResetCurrentInlinedDepth: setting inlined "
+ "depth: %d 0x%" PRIx64 ".\n",
+ m_current_inlined_depth, curr_pc);
+
+ } break;
+ }
}
+ }
}
+ }
}
+ }
}
-bool
-StackFrameList::DecrementCurrentInlinedDepth ()
-{
- if (m_show_inlined_frames)
- {
- uint32_t current_inlined_depth = GetCurrentInlinedDepth();
- if (current_inlined_depth != UINT32_MAX)
- {
- if (current_inlined_depth > 0)
- {
- m_current_inlined_depth--;
- return true;
- }
- }
+bool StackFrameList::DecrementCurrentInlinedDepth() {
+ if (m_show_inlined_frames) {
+ uint32_t current_inlined_depth = GetCurrentInlinedDepth();
+ if (current_inlined_depth != UINT32_MAX) {
+ if (current_inlined_depth > 0) {
+ m_current_inlined_depth--;
+ return true;
+ }
}
- return false;
+ }
+ return false;
}
-void
-StackFrameList::SetCurrentInlinedDepth (uint32_t new_depth)
-{
- m_current_inlined_depth = new_depth;
- if (new_depth == UINT32_MAX)
- m_current_inlined_pc = LLDB_INVALID_ADDRESS;
- else
- m_current_inlined_pc = m_thread.GetRegisterContext()->GetPC();
+void StackFrameList::SetCurrentInlinedDepth(uint32_t new_depth) {
+ m_current_inlined_depth = new_depth;
+ if (new_depth == UINT32_MAX)
+ m_current_inlined_pc = LLDB_INVALID_ADDRESS;
+ else
+ m_current_inlined_pc = m_thread.GetRegisterContext()->GetPC();
}
-void
-StackFrameList::GetFramesUpTo(uint32_t end_idx)
-{
- // this makes sure we do not fetch frames for an invalid thread
- if (!m_thread.IsValid())
- return;
-
- // We've already gotten more frames than asked for, or we've already finished unwinding, return.
- if (m_frames.size() > end_idx || GetAllFramesFetched())
- return;
-
- Unwind *unwinder = m_thread.GetUnwinder ();
-
- if (m_show_inlined_frames)
- {
-#if defined (DEBUG_STACK_FRAMES)
- StreamFile s(stdout, false);
+void StackFrameList::GetFramesUpTo(uint32_t end_idx) {
+ // this makes sure we do not fetch frames for an invalid thread
+ if (!m_thread.IsValid())
+ return;
+
+ // We've already gotten more frames than asked for, or we've already finished
+ // unwinding, return.
+ if (m_frames.size() > end_idx || GetAllFramesFetched())
+ return;
+
+ Unwind *unwinder = m_thread.GetUnwinder();
+
+ if (m_show_inlined_frames) {
+#if defined(DEBUG_STACK_FRAMES)
+ StreamFile s(stdout, false);
#endif
- // If we are hiding some frames from the outside world, we need to add those onto the total count of
- // frames to fetch. However, we don't need to do that if end_idx is 0 since in that case we always
- // get the first concrete frame and all the inlined frames below it... And of course, if end_idx is
- // UINT32_MAX that means get all, so just do that...
-
- uint32_t inlined_depth = 0;
- if (end_idx > 0 && end_idx != UINT32_MAX)
- {
- inlined_depth = GetCurrentInlinedDepth();
- if (inlined_depth != UINT32_MAX)
- {
- if (end_idx > 0)
- end_idx += inlined_depth;
+ // If we are hiding some frames from the outside world, we need to add those
+ // onto the total count of
+ // frames to fetch. However, we don't need to do that if end_idx is 0 since
+ // in that case we always
+ // get the first concrete frame and all the inlined frames below it... And
+ // of course, if end_idx is
+ // UINT32_MAX that means get all, so just do that...
+
+ uint32_t inlined_depth = 0;
+ if (end_idx > 0 && end_idx != UINT32_MAX) {
+ inlined_depth = GetCurrentInlinedDepth();
+ if (inlined_depth != UINT32_MAX) {
+ if (end_idx > 0)
+ end_idx += inlined_depth;
+ }
+ }
+
+ 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;
+ 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);
+ // 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.reset(new StackFrame(m_thread.shared_from_this(),
+ m_frames.size(), idx,
+ reg_ctx_sp, cfa, pc, nullptr));
+ m_frames.push_back(unwind_frame_sp);
+ }
+ } else {
+ unwind_frame_sp = m_frames.front();
+ cfa = unwind_frame_sp->m_id.GetCallFrameAddress();
}
-
- 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;
- 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);
- // 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.reset(new StackFrame(m_thread.shared_from_this(),
- m_frames.size(),
- idx,
- reg_ctx_sp,
- cfa,
- pc,
- 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);
- if (!success)
- {
- // We've gotten to the end of the stack.
- SetAllFramesFetched();
- break;
- }
- const bool cfa_is_valid = true;
- const bool stop_id_is_valid = false;
- const bool is_history_frame = false;
- unwind_frame_sp.reset(new StackFrame(m_thread.shared_from_this(), m_frames.size(), idx, cfa, cfa_is_valid, pc,
- 0, stop_id_is_valid, is_history_frame, nullptr));
- m_frames.push_back (unwind_frame_sp);
- }
-
- assert(unwind_frame_sp);
- SymbolContext unwind_sc = unwind_frame_sp->GetSymbolContext (eSymbolContextBlock | eSymbolContextFunction);
- Block *unwind_block = unwind_sc.block;
- if (unwind_block)
- {
- Address curr_frame_address (unwind_frame_sp->GetFrameCodeAddress());
- TargetSP target_sp = m_thread.CalculateTarget();
- // Be sure to adjust the frame address to match the address
- // that was used to lookup the symbol context above. If we are
- // in the first concrete frame, then we lookup using the current
- // address, else we decrement the address by one to get the correct
- // location.
- if (idx > 0)
- {
- if (curr_frame_address.GetOffset() == 0)
- {
- // If curr_frame_address points to the first address in a section then after
- // adjustment it will point to an other section. In that case resolve the
- // address again to the correct section plus offset form.
- addr_t load_addr = curr_frame_address.GetOpcodeLoadAddress(target_sp.get(), eAddressClassCode);
- curr_frame_address.SetOpcodeLoadAddress(load_addr - 1, target_sp.get(), eAddressClassCode);
- }
- else
- {
- curr_frame_address.Slide(-1);
- }
- }
-
- 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));
-
- m_frames.push_back (frame_sp);
- unwind_sc = next_frame_sc;
- curr_frame_address = next_frame_address;
- }
- }
- } while (m_frames.size() - 1 < end_idx);
-
- // Don't try to merge till you've calculated all the frames in this stack.
- if (GetAllFramesFetched() && m_prev_frames_sp)
- {
- StackFrameList *prev_frames = m_prev_frames_sp.get();
- StackFrameList *curr_frames = this;
-
- //curr_frames->m_current_inlined_depth = prev_frames->m_current_inlined_depth;
- //curr_frames->m_current_inlined_pc = prev_frames->m_current_inlined_pc;
- //printf ("GetFramesUpTo: Copying current inlined depth: %d 0x%" PRIx64 ".\n", curr_frames->m_current_inlined_depth, curr_frames->m_current_inlined_pc);
-
-#if defined (DEBUG_STACK_FRAMES)
- s.PutCString("\nprev_frames:\n");
- prev_frames->Dump (&s);
- s.PutCString("\ncurr_frames:\n");
- curr_frames->Dump (&s);
- s.EOL();
+ } else {
+ const bool success =
+ unwinder && unwinder->GetFrameInfoAtIndex(idx, cfa, pc);
+ if (!success) {
+ // We've gotten to the end of the stack.
+ SetAllFramesFetched();
+ break;
+ }
+ const bool cfa_is_valid = true;
+ const bool stop_id_is_valid = false;
+ const bool is_history_frame = false;
+ unwind_frame_sp.reset(new StackFrame(
+ m_thread.shared_from_this(), m_frames.size(), idx, cfa,
+ cfa_is_valid, pc, 0, stop_id_is_valid, is_history_frame, nullptr));
+ m_frames.push_back(unwind_frame_sp);
+ }
+
+ assert(unwind_frame_sp);
+ SymbolContext unwind_sc = unwind_frame_sp->GetSymbolContext(
+ eSymbolContextBlock | eSymbolContextFunction);
+ Block *unwind_block = unwind_sc.block;
+ if (unwind_block) {
+ Address curr_frame_address(unwind_frame_sp->GetFrameCodeAddress());
+ TargetSP target_sp = m_thread.CalculateTarget();
+ // Be sure to adjust the frame address to match the address
+ // that was used to lookup the symbol context above. If we are
+ // in the first concrete frame, then we lookup using the current
+ // address, else we decrement the address by one to get the correct
+ // location.
+ if (idx > 0) {
+ if (curr_frame_address.GetOffset() == 0) {
+ // If curr_frame_address points to the first address in a section
+ // then after
+ // adjustment it will point to an other section. In that case
+ // resolve the
+ // address again to the correct section plus offset form.
+ addr_t load_addr = curr_frame_address.GetOpcodeLoadAddress(
+ target_sp.get(), eAddressClassCode);
+ curr_frame_address.SetOpcodeLoadAddress(
+ load_addr - 1, target_sp.get(), eAddressClassCode);
+ } else {
+ curr_frame_address.Slide(-1);
+ }
+ }
+
+ 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));
+
+ m_frames.push_back(frame_sp);
+ unwind_sc = next_frame_sc;
+ curr_frame_address = next_frame_address;
+ }
+ }
+ } while (m_frames.size() - 1 < end_idx);
+
+ // Don't try to merge till you've calculated all the frames in this stack.
+ if (GetAllFramesFetched() && m_prev_frames_sp) {
+ StackFrameList *prev_frames = m_prev_frames_sp.get();
+ StackFrameList *curr_frames = this;
+
+// curr_frames->m_current_inlined_depth = prev_frames->m_current_inlined_depth;
+// curr_frames->m_current_inlined_pc = prev_frames->m_current_inlined_pc;
+// printf ("GetFramesUpTo: Copying current inlined depth: %d 0x%" PRIx64 ".\n",
+// curr_frames->m_current_inlined_depth, curr_frames->m_current_inlined_pc);
+
+#if defined(DEBUG_STACK_FRAMES)
+ s.PutCString("\nprev_frames:\n");
+ prev_frames->Dump(&s);
+ s.PutCString("\ncurr_frames:\n");
+ curr_frames->Dump(&s);
+ s.EOL();
#endif
- size_t curr_frame_num, prev_frame_num;
-
- for (curr_frame_num = curr_frames->m_frames.size(), prev_frame_num = prev_frames->m_frames.size();
- curr_frame_num > 0 && prev_frame_num > 0;
- --curr_frame_num, --prev_frame_num)
- {
- const size_t curr_frame_idx = curr_frame_num-1;
- const size_t prev_frame_idx = prev_frame_num-1;
- StackFrameSP curr_frame_sp (curr_frames->m_frames[curr_frame_idx]);
- StackFrameSP prev_frame_sp (prev_frames->m_frames[prev_frame_idx]);
-
-#if defined (DEBUG_STACK_FRAMES)
- s.Printf("\n\nCurr frame #%u ", curr_frame_idx);
- if (curr_frame_sp)
- curr_frame_sp->Dump (&s, true, false);
- else
- s.PutCString("NULL");
- s.Printf("\nPrev frame #%u ", prev_frame_idx);
- if (prev_frame_sp)
- prev_frame_sp->Dump (&s, true, false);
- else
- s.PutCString("NULL");
+ size_t curr_frame_num, prev_frame_num;
+
+ for (curr_frame_num = curr_frames->m_frames.size(),
+ prev_frame_num = prev_frames->m_frames.size();
+ curr_frame_num > 0 && prev_frame_num > 0;
+ --curr_frame_num, --prev_frame_num) {
+ const size_t curr_frame_idx = curr_frame_num - 1;
+ const size_t prev_frame_idx = prev_frame_num - 1;
+ StackFrameSP curr_frame_sp(curr_frames->m_frames[curr_frame_idx]);
+ StackFrameSP prev_frame_sp(prev_frames->m_frames[prev_frame_idx]);
+
+#if defined(DEBUG_STACK_FRAMES)
+ s.Printf("\n\nCurr frame #%u ", curr_frame_idx);
+ if (curr_frame_sp)
+ curr_frame_sp->Dump(&s, true, false);
+ else
+ s.PutCString("NULL");
+ s.Printf("\nPrev frame #%u ", prev_frame_idx);
+ if (prev_frame_sp)
+ prev_frame_sp->Dump(&s, true, false);
+ else
+ s.PutCString("NULL");
#endif
- StackFrame *curr_frame = curr_frame_sp.get();
- StackFrame *prev_frame = prev_frame_sp.get();
-
- if (curr_frame == nullptr || prev_frame == nullptr)
- break;
+ StackFrame *curr_frame = curr_frame_sp.get();
+ StackFrame *prev_frame = prev_frame_sp.get();
- // Check the stack ID to make sure they are equal
- if (curr_frame->GetStackID() != prev_frame->GetStackID())
- break;
+ if (curr_frame == nullptr || prev_frame == nullptr)
+ break;
- prev_frame->UpdatePreviousFrameFromCurrentFrame (*curr_frame);
- // Now copy the fixed up previous frame into the current frames
- // so the pointer doesn't change
- m_frames[curr_frame_idx] = prev_frame_sp;
- //curr_frame->UpdateCurrentFrameFromPreviousFrame (*prev_frame);
-
-#if defined (DEBUG_STACK_FRAMES)
- s.Printf("\n Copying previous frame to current frame");
-#endif
- }
- // We are done with the old stack frame list, we can release it now
- m_prev_frames_sp.reset();
- }
-
-#if defined (DEBUG_STACK_FRAMES)
- s.PutCString("\n\nNew frames:\n");
- Dump (&s);
- s.EOL();
+ // Check the stack ID to make sure they are equal
+ if (curr_frame->GetStackID() != prev_frame->GetStackID())
+ break;
+
+ prev_frame->UpdatePreviousFrameFromCurrentFrame(*curr_frame);
+ // Now copy the fixed up previous frame into the current frames
+ // so the pointer doesn't change
+ m_frames[curr_frame_idx] = prev_frame_sp;
+// curr_frame->UpdateCurrentFrameFromPreviousFrame (*prev_frame);
+
+#if defined(DEBUG_STACK_FRAMES)
+ s.Printf("\n Copying previous frame to current frame");
#endif
+ }
+ // We are done with the old stack frame list, we can release it now
+ m_prev_frames_sp.reset();
}
- else
- {
- if (end_idx < m_concrete_frames_fetched)
- return;
-
- if (unwinder)
- {
- uint32_t num_frames = unwinder->GetFramesUpTo(end_idx);
- if (num_frames <= end_idx + 1)
- {
- //Done unwinding.
- m_concrete_frames_fetched = UINT32_MAX;
- }
- m_frames.resize(num_frames);
- }
+
+#if defined(DEBUG_STACK_FRAMES)
+ s.PutCString("\n\nNew frames:\n");
+ Dump(&s);
+ s.EOL();
+#endif
+ } else {
+ if (end_idx < m_concrete_frames_fetched)
+ return;
+
+ if (unwinder) {
+ uint32_t num_frames = unwinder->GetFramesUpTo(end_idx);
+ if (num_frames <= end_idx + 1) {
+ // Done unwinding.
+ m_concrete_frames_fetched = UINT32_MAX;
+ }
+ m_frames.resize(num_frames);
}
+ }
}
-uint32_t
-StackFrameList::GetNumFrames (bool can_create)
-{
- std::lock_guard<std::recursive_mutex> guard(m_mutex);
+uint32_t StackFrameList::GetNumFrames(bool can_create) {
+ std::lock_guard<std::recursive_mutex> guard(m_mutex);
- if (can_create)
- GetFramesUpTo (UINT32_MAX);
+ if (can_create)
+ GetFramesUpTo(UINT32_MAX);
- uint32_t inlined_depth = GetCurrentInlinedDepth();
- if (inlined_depth == UINT32_MAX)
- return m_frames.size();
- else
- return m_frames.size() - inlined_depth;
+ uint32_t inlined_depth = GetCurrentInlinedDepth();
+ if (inlined_depth == UINT32_MAX)
+ return m_frames.size();
+ else
+ return m_frames.size() - inlined_depth;
}
-void
-StackFrameList::Dump (Stream *s)
-{
- if (s == nullptr)
- return;
-
- std::lock_guard<std::recursive_mutex> guard(m_mutex);
-
- const_iterator pos, begin = m_frames.begin(), end = m_frames.end();
- for (pos = begin; pos != end; ++pos)
- {
- StackFrame *frame = (*pos).get();
- s->Printf("%p: ", static_cast<void*>(frame));
- if (frame)
- {
- frame->GetStackID().Dump (s);
- frame->DumpUsingSettingsFormat (s);
- }
- else
- s->Printf("frame #%u", (uint32_t)std::distance (begin, pos));
- s->EOL();
- }
+void StackFrameList::Dump(Stream *s) {
+ if (s == nullptr)
+ return;
+
+ std::lock_guard<std::recursive_mutex> guard(m_mutex);
+
+ const_iterator pos, begin = m_frames.begin(), end = m_frames.end();
+ for (pos = begin; pos != end; ++pos) {
+ StackFrame *frame = (*pos).get();
+ s->Printf("%p: ", static_cast<void *>(frame));
+ if (frame) {
+ frame->GetStackID().Dump(s);
+ frame->DumpUsingSettingsFormat(s);
+ } else
+ s->Printf("frame #%u", (uint32_t)std::distance(begin, pos));
s->EOL();
+ }
+ s->EOL();
}
-StackFrameSP
-StackFrameList::GetFrameAtIndex (uint32_t idx)
-{
- StackFrameSP frame_sp;
- std::lock_guard<std::recursive_mutex> guard(m_mutex);
- uint32_t original_idx = idx;
-
- uint32_t inlined_depth = GetCurrentInlinedDepth();
- if (inlined_depth != UINT32_MAX)
- idx += inlined_depth;
-
- if (idx < m_frames.size())
- frame_sp = m_frames[idx];
-
- if (frame_sp)
- return frame_sp;
-
- // GetFramesUpTo will fill m_frames with as many frames as you asked for,
- // if there are that many. If there weren't then you asked for too many
- // frames.
- GetFramesUpTo (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))
- {
- const bool cfa_is_valid = true;
- const bool stop_id_is_valid = false;
- const bool is_history_frame = false;
- frame_sp.reset(new StackFrame(m_thread.shared_from_this(), idx, idx, cfa, cfa_is_valid, pc, 0,
- stop_id_is_valid, is_history_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
- {
- // Set the symbol scope from the symbol regardless if it is nullptr or valid.
- frame_sp->SetSymbolContextScope (frame_sp->GetSymbolContext (eSymbolContextSymbol).symbol);
- }
- SetFrameAtIndex(idx, frame_sp);
- }
- }
+StackFrameSP StackFrameList::GetFrameAtIndex(uint32_t idx) {
+ StackFrameSP frame_sp;
+ std::lock_guard<std::recursive_mutex> guard(m_mutex);
+ uint32_t original_idx = idx;
+
+ uint32_t inlined_depth = GetCurrentInlinedDepth();
+ if (inlined_depth != UINT32_MAX)
+ idx += inlined_depth;
+
+ if (idx < m_frames.size())
+ frame_sp = m_frames[idx];
+
+ if (frame_sp)
+ return frame_sp;
+
+ // GetFramesUpTo will fill m_frames with as many frames as you asked for,
+ // if there are that many. If there weren't then you asked for too many
+ // frames.
+ GetFramesUpTo(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)) {
+ const bool cfa_is_valid = true;
+ const bool stop_id_is_valid = false;
+ const bool is_history_frame = false;
+ frame_sp.reset(new StackFrame(
+ m_thread.shared_from_this(), idx, idx, cfa, cfa_is_valid, pc, 0,
+ stop_id_is_valid, is_history_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 {
+ // Set the symbol scope from the symbol regardless if it is nullptr
+ // or valid.
+ frame_sp->SetSymbolContextScope(
+ frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol);
+ }
+ SetFrameAtIndex(idx, frame_sp);
}
+ }
}
- else if (original_idx == 0)
- {
- // There should ALWAYS be a frame at index 0. If something went wrong with the CurrentInlinedDepth such that
- // there weren't as many frames as we thought taking that into account, then reset the current inlined depth
- // and return the real zeroth frame.
- if (m_frames.empty())
- {
- // Why do we have a thread with zero frames, that should not ever happen...
- if (m_thread.IsValid())
- assert ("A valid thread has no frames.");
- }
- else
- {
- ResetCurrentInlinedDepth();
- frame_sp = m_frames[original_idx];
- }
+ } else if (original_idx == 0) {
+ // There should ALWAYS be a frame at index 0. If something went wrong with
+ // the CurrentInlinedDepth such that
+ // there weren't as many frames as we thought taking that into account, then
+ // reset the current inlined depth
+ // and return the real zeroth frame.
+ if (m_frames.empty()) {
+ // Why do we have a thread with zero frames, that should not ever
+ // happen...
+ if (m_thread.IsValid())
+ assert("A valid thread has no frames.");
+ } else {
+ ResetCurrentInlinedDepth();
+ frame_sp = m_frames[original_idx];
}
-
- return frame_sp;
+ }
+
+ return frame_sp;
}
StackFrameSP
-StackFrameList::GetFrameWithConcreteFrameIndex (uint32_t unwind_idx)
-{
- // First try assuming the unwind index is the same as the frame index. The
- // unwind index is always greater than or equal to the frame index, so it
- // is a good place to start. If we have inlined frames we might have 5
- // concrete frames (frame unwind indexes go from 0-4), but we might have 15
- // frames after we make all the inlined frames. Most of the time the unwind
- // frame index (or the concrete frame index) is the same as the frame index.
- uint32_t frame_idx = unwind_idx;
- StackFrameSP frame_sp (GetFrameAtIndex (frame_idx));
- while (frame_sp)
- {
- if (frame_sp->GetFrameIndex() == unwind_idx)
- break;
- frame_sp = GetFrameAtIndex (++frame_idx);
- }
- return frame_sp;
+StackFrameList::GetFrameWithConcreteFrameIndex(uint32_t unwind_idx) {
+ // First try assuming the unwind index is the same as the frame index. The
+ // unwind index is always greater than or equal to the frame index, so it
+ // is a good place to start. If we have inlined frames we might have 5
+ // concrete frames (frame unwind indexes go from 0-4), but we might have 15
+ // frames after we make all the inlined frames. Most of the time the unwind
+ // frame index (or the concrete frame index) is the same as the frame index.
+ uint32_t frame_idx = unwind_idx;
+ StackFrameSP frame_sp(GetFrameAtIndex(frame_idx));
+ while (frame_sp) {
+ if (frame_sp->GetFrameIndex() == unwind_idx)
+ break;
+ frame_sp = GetFrameAtIndex(++frame_idx);
+ }
+ return frame_sp;
}
-static bool
-CompareStackID (const StackFrameSP &stack_sp, const StackID &stack_id)
-{
- return stack_sp->GetStackID() < stack_id;
+static bool CompareStackID(const StackFrameSP &stack_sp,
+ const StackID &stack_id) {
+ return stack_sp->GetStackID() < stack_id;
}
-StackFrameSP
-StackFrameList::GetFrameWithStackID (const StackID &stack_id)
-{
- StackFrameSP frame_sp;
-
- if (stack_id.IsValid())
- {
- std::lock_guard<std::recursive_mutex> guard(m_mutex);
- uint32_t frame_idx = 0;
- // Do a binary search in case the stack frame is already in our cache
- collection::const_iterator begin = m_frames.begin();
- collection::const_iterator end = m_frames.end();
- if (begin != end)
- {
- collection::const_iterator pos = std::lower_bound (begin, end, stack_id, CompareStackID);
- if (pos != end)
- {
- if ((*pos)->GetStackID() == stack_id)
- return *pos;
- }
-
-// if (m_frames.back()->GetStackID() < stack_id)
-// frame_idx = m_frames.size();
- }
- do
- {
- frame_sp = GetFrameAtIndex (frame_idx);
- if (frame_sp && frame_sp->GetStackID() == stack_id)
- break;
- frame_idx++;
- }
- while (frame_sp);
+StackFrameSP StackFrameList::GetFrameWithStackID(const StackID &stack_id) {
+ StackFrameSP frame_sp;
+
+ if (stack_id.IsValid()) {
+ std::lock_guard<std::recursive_mutex> guard(m_mutex);
+ uint32_t frame_idx = 0;
+ // Do a binary search in case the stack frame is already in our cache
+ collection::const_iterator begin = m_frames.begin();
+ collection::const_iterator end = m_frames.end();
+ if (begin != end) {
+ collection::const_iterator pos =
+ std::lower_bound(begin, end, stack_id, CompareStackID);
+ if (pos != end) {
+ if ((*pos)->GetStackID() == stack_id)
+ return *pos;
+ }
+
+ // if (m_frames.back()->GetStackID() < stack_id)
+ // frame_idx = m_frames.size();
}
- return frame_sp;
+ do {
+ frame_sp = GetFrameAtIndex(frame_idx);
+ if (frame_sp && frame_sp->GetStackID() == stack_id)
+ break;
+ frame_idx++;
+ } while (frame_sp);
+ }
+ return frame_sp;
}
-bool
-StackFrameList::SetFrameAtIndex (uint32_t idx, StackFrameSP &frame_sp)
-{
- if (idx >= m_frames.size())
- m_frames.resize(idx + 1);
- // Make sure allocation succeeded by checking bounds again
- if (idx < m_frames.size())
- {
- m_frames[idx] = frame_sp;
- return true;
- }
- return false; // resize failed, out of memory?
+bool StackFrameList::SetFrameAtIndex(uint32_t idx, StackFrameSP &frame_sp) {
+ if (idx >= m_frames.size())
+ m_frames.resize(idx + 1);
+ // Make sure allocation succeeded by checking bounds again
+ if (idx < m_frames.size()) {
+ m_frames[idx] = frame_sp;
+ return true;
+ }
+ return false; // resize failed, out of memory?
}
-uint32_t
-StackFrameList::GetSelectedFrameIndex () const
-{
- std::lock_guard<std::recursive_mutex> guard(m_mutex);
- return m_selected_frame_idx;
+uint32_t StackFrameList::GetSelectedFrameIndex() const {
+ std::lock_guard<std::recursive_mutex> guard(m_mutex);
+ return m_selected_frame_idx;
}
-uint32_t
-StackFrameList::SetSelectedFrame (lldb_private::StackFrame *frame)
-{
- std::lock_guard<std::recursive_mutex> guard(m_mutex);
- const_iterator pos;
- const_iterator begin = m_frames.begin();
- const_iterator end = m_frames.end();
- m_selected_frame_idx = 0;
- for (pos = begin; pos != end; ++pos)
- {
- if (pos->get() == frame)
- {
- m_selected_frame_idx = std::distance (begin, pos);
- uint32_t inlined_depth = GetCurrentInlinedDepth();
- if (inlined_depth != UINT32_MAX)
- m_selected_frame_idx -= inlined_depth;
- break;
- }
+uint32_t StackFrameList::SetSelectedFrame(lldb_private::StackFrame *frame) {
+ std::lock_guard<std::recursive_mutex> guard(m_mutex);
+ const_iterator pos;
+ const_iterator begin = m_frames.begin();
+ const_iterator end = m_frames.end();
+ m_selected_frame_idx = 0;
+ for (pos = begin; pos != end; ++pos) {
+ if (pos->get() == frame) {
+ m_selected_frame_idx = std::distance(begin, pos);
+ uint32_t inlined_depth = GetCurrentInlinedDepth();
+ if (inlined_depth != UINT32_MAX)
+ m_selected_frame_idx -= inlined_depth;
+ break;
}
- SetDefaultFileAndLineToSelectedFrame();
- return m_selected_frame_idx;
+ }
+ SetDefaultFileAndLineToSelectedFrame();
+ return m_selected_frame_idx;
}
// Mark a stack frame as the current frame using the frame index
-bool
-StackFrameList::SetSelectedFrameByIndex (uint32_t idx)
-{
- std::lock_guard<std::recursive_mutex> guard(m_mutex);
- StackFrameSP frame_sp (GetFrameAtIndex (idx));
- if (frame_sp)
- {
- SetSelectedFrame(frame_sp.get());
- return true;
- }
- else
- return false;
+bool StackFrameList::SetSelectedFrameByIndex(uint32_t idx) {
+ std::lock_guard<std::recursive_mutex> guard(m_mutex);
+ StackFrameSP frame_sp(GetFrameAtIndex(idx));
+ if (frame_sp) {
+ SetSelectedFrame(frame_sp.get());
+ return true;
+ } else
+ return false;
}
-void
-StackFrameList::SetDefaultFileAndLineToSelectedFrame()
-{
- if (m_thread.GetID() == m_thread.GetProcess()->GetThreadList().GetSelectedThread()->GetID())
- {
- StackFrameSP frame_sp (GetFrameAtIndex (GetSelectedFrameIndex()));
- if (frame_sp)
- {
- SymbolContext sc = frame_sp->GetSymbolContext(eSymbolContextLineEntry);
- if (sc.line_entry.file)
- m_thread.CalculateTarget()->GetSourceManager().SetDefaultFileAndLine (sc.line_entry.file,
- sc.line_entry.line);
- }
+void StackFrameList::SetDefaultFileAndLineToSelectedFrame() {
+ if (m_thread.GetID() ==
+ m_thread.GetProcess()->GetThreadList().GetSelectedThread()->GetID()) {
+ StackFrameSP frame_sp(GetFrameAtIndex(GetSelectedFrameIndex()));
+ if (frame_sp) {
+ SymbolContext sc = frame_sp->GetSymbolContext(eSymbolContextLineEntry);
+ if (sc.line_entry.file)
+ m_thread.CalculateTarget()->GetSourceManager().SetDefaultFileAndLine(
+ sc.line_entry.file, sc.line_entry.line);
}
+ }
}
// The thread has been run, reset the number stack frames to zero so we can
// determine how many frames we have lazily.
-void
-StackFrameList::Clear ()
-{
- std::lock_guard<std::recursive_mutex> guard(m_mutex);
- m_frames.clear();
- m_concrete_frames_fetched = 0;
+void StackFrameList::Clear() {
+ std::lock_guard<std::recursive_mutex> guard(m_mutex);
+ m_frames.clear();
+ m_concrete_frames_fetched = 0;
}
-void
-StackFrameList::InvalidateFrames (uint32_t start_idx)
-{
- std::lock_guard<std::recursive_mutex> guard(m_mutex);
- if (m_show_inlined_frames)
- {
- Clear();
- }
- else
- {
- const size_t num_frames = m_frames.size();
- while (start_idx < num_frames)
- {
- m_frames[start_idx].reset();
- ++start_idx;
- }
+void StackFrameList::InvalidateFrames(uint32_t start_idx) {
+ std::lock_guard<std::recursive_mutex> guard(m_mutex);
+ if (m_show_inlined_frames) {
+ Clear();
+ } else {
+ const size_t num_frames = m_frames.size();
+ while (start_idx < num_frames) {
+ m_frames[start_idx].reset();
+ ++start_idx;
}
+ }
}
-void
-StackFrameList::Merge (std::unique_ptr<StackFrameList>& curr_ap, lldb::StackFrameListSP& prev_sp)
-{
- std::unique_lock<std::recursive_mutex> current_lock, previous_lock;
- if (curr_ap)
- current_lock = std::unique_lock<std::recursive_mutex>(curr_ap->m_mutex);
- if (prev_sp)
- previous_lock = std::unique_lock<std::recursive_mutex>(prev_sp->m_mutex);
-
-#if defined (DEBUG_STACK_FRAMES)
- StreamFile s(stdout, false);
- s.PutCString("\n\nStackFrameList::Merge():\nPrev:\n");
- if (prev_sp)
- prev_sp->Dump (&s);
- else
- s.PutCString ("NULL");
- s.PutCString("\nCurr:\n");
- if (curr_ap)
- curr_ap->Dump (&s);
- else
- s.PutCString ("NULL");
- s.EOL();
+void StackFrameList::Merge(std::unique_ptr<StackFrameList> &curr_ap,
+ lldb::StackFrameListSP &prev_sp) {
+ std::unique_lock<std::recursive_mutex> current_lock, previous_lock;
+ if (curr_ap)
+ current_lock = std::unique_lock<std::recursive_mutex>(curr_ap->m_mutex);
+ if (prev_sp)
+ previous_lock = std::unique_lock<std::recursive_mutex>(prev_sp->m_mutex);
+
+#if defined(DEBUG_STACK_FRAMES)
+ StreamFile s(stdout, false);
+ s.PutCString("\n\nStackFrameList::Merge():\nPrev:\n");
+ if (prev_sp)
+ prev_sp->Dump(&s);
+ else
+ s.PutCString("NULL");
+ s.PutCString("\nCurr:\n");
+ if (curr_ap)
+ curr_ap->Dump(&s);
+ else
+ s.PutCString("NULL");
+ s.EOL();
#endif
- if (!curr_ap || curr_ap->GetNumFrames(false) == 0)
- {
-#if defined (DEBUG_STACK_FRAMES)
- s.PutCString("No current frames, leave previous frames alone...\n");
+ if (!curr_ap || curr_ap->GetNumFrames(false) == 0) {
+#if defined(DEBUG_STACK_FRAMES)
+ s.PutCString("No current frames, leave previous frames alone...\n");
#endif
- curr_ap.release();
- return;
- }
+ curr_ap.release();
+ return;
+ }
- if (!prev_sp || prev_sp->GetNumFrames(false) == 0)
- {
-#if defined (DEBUG_STACK_FRAMES)
- s.PutCString("No previous frames, so use current frames...\n");
+ if (!prev_sp || prev_sp->GetNumFrames(false) == 0) {
+#if defined(DEBUG_STACK_FRAMES)
+ s.PutCString("No previous frames, so use current frames...\n");
#endif
- // We either don't have any previous frames, or since we have more than
- // one current frames it means we have all the frames and can safely
- // replace our previous frames.
- prev_sp.reset (curr_ap.release());
- return;
- }
-
- const uint32_t num_curr_frames = curr_ap->GetNumFrames (false);
-
- if (num_curr_frames > 1)
- {
-#if defined (DEBUG_STACK_FRAMES)
- s.PutCString("We have more than one current frame, so use current frames...\n");
+ // We either don't have any previous frames, or since we have more than
+ // one current frames it means we have all the frames and can safely
+ // replace our previous frames.
+ prev_sp.reset(curr_ap.release());
+ return;
+ }
+
+ const uint32_t num_curr_frames = curr_ap->GetNumFrames(false);
+
+ if (num_curr_frames > 1) {
+#if defined(DEBUG_STACK_FRAMES)
+ s.PutCString(
+ "We have more than one current frame, so use current frames...\n");
#endif
- // We have more than one current frames it means we have all the frames
- // and can safely replace our previous frames.
- prev_sp.reset (curr_ap.release());
+ // We have more than one current frames it means we have all the frames
+ // and can safely replace our previous frames.
+ prev_sp.reset(curr_ap.release());
-#if defined (DEBUG_STACK_FRAMES)
- s.PutCString("\nMerged:\n");
- prev_sp->Dump (&s);
+#if defined(DEBUG_STACK_FRAMES)
+ s.PutCString("\nMerged:\n");
+ prev_sp->Dump(&s);
#endif
- return;
- }
+ return;
+ }
- StackFrameSP prev_frame_zero_sp(prev_sp->GetFrameAtIndex (0));
- StackFrameSP curr_frame_zero_sp(curr_ap->GetFrameAtIndex (0));
- StackID curr_stack_id (curr_frame_zero_sp->GetStackID());
- StackID prev_stack_id (prev_frame_zero_sp->GetStackID());
+ StackFrameSP prev_frame_zero_sp(prev_sp->GetFrameAtIndex(0));
+ StackFrameSP curr_frame_zero_sp(curr_ap->GetFrameAtIndex(0));
+ StackID curr_stack_id(curr_frame_zero_sp->GetStackID());
+ StackID prev_stack_id(prev_frame_zero_sp->GetStackID());
-#if defined (DEBUG_STACK_FRAMES)
- const uint32_t num_prev_frames = prev_sp->GetNumFrames (false);
- s.Printf("\n%u previous frames with one current frame\n", num_prev_frames);
+#if defined(DEBUG_STACK_FRAMES)
+ const uint32_t num_prev_frames = prev_sp->GetNumFrames(false);
+ s.Printf("\n%u previous frames with one current frame\n", num_prev_frames);
#endif
- // We have only a single current frame
- // Our previous stack frames only had a single frame as well...
- if (curr_stack_id == prev_stack_id)
- {
-#if defined (DEBUG_STACK_FRAMES)
- s.Printf("\nPrevious frame #0 is same as current frame #0, merge the cached data\n");
+ // We have only a single current frame
+ // Our previous stack frames only had a single frame as well...
+ if (curr_stack_id == prev_stack_id) {
+#if defined(DEBUG_STACK_FRAMES)
+ s.Printf("\nPrevious frame #0 is same as current frame #0, merge the "
+ "cached data\n");
#endif
- curr_frame_zero_sp->UpdateCurrentFrameFromPreviousFrame (*prev_frame_zero_sp);
-// prev_frame_zero_sp->UpdatePreviousFrameFromCurrentFrame (*curr_frame_zero_sp);
-// prev_sp->SetFrameAtIndex (0, prev_frame_zero_sp);
- }
- else if (curr_stack_id < prev_stack_id)
- {
-#if defined (DEBUG_STACK_FRAMES)
- s.Printf("\nCurrent frame #0 has a stack ID that is less than the previous frame #0, insert current frame zero in front of previous\n");
+ curr_frame_zero_sp->UpdateCurrentFrameFromPreviousFrame(
+ *prev_frame_zero_sp);
+ // prev_frame_zero_sp->UpdatePreviousFrameFromCurrentFrame
+ // (*curr_frame_zero_sp);
+ // prev_sp->SetFrameAtIndex (0, prev_frame_zero_sp);
+ } else if (curr_stack_id < prev_stack_id) {
+#if defined(DEBUG_STACK_FRAMES)
+ s.Printf("\nCurrent frame #0 has a stack ID that is less than the previous "
+ "frame #0, insert current frame zero in front of previous\n");
#endif
- prev_sp->m_frames.insert (prev_sp->m_frames.begin(), curr_frame_zero_sp);
- }
-
- curr_ap.release();
+ prev_sp->m_frames.insert(prev_sp->m_frames.begin(), curr_frame_zero_sp);
+ }
-#if defined (DEBUG_STACK_FRAMES)
- s.PutCString("\nMerged:\n");
- prev_sp->Dump (&s);
+ curr_ap.release();
+
+#if defined(DEBUG_STACK_FRAMES)
+ s.PutCString("\nMerged:\n");
+ prev_sp->Dump(&s);
#endif
}
lldb::StackFrameSP
-StackFrameList::GetStackFrameSPForStackFramePtr (StackFrame *stack_frame_ptr)
-{
- const_iterator pos;
- const_iterator begin = m_frames.begin();
- const_iterator end = m_frames.end();
- lldb::StackFrameSP ret_sp;
-
- for (pos = begin; pos != end; ++pos)
- {
- if (pos->get() == stack_frame_ptr)
- {
- ret_sp = (*pos);
- break;
- }
+StackFrameList::GetStackFrameSPForStackFramePtr(StackFrame *stack_frame_ptr) {
+ const_iterator pos;
+ const_iterator begin = m_frames.begin();
+ const_iterator end = m_frames.end();
+ lldb::StackFrameSP ret_sp;
+
+ for (pos = begin; pos != end; ++pos) {
+ if (pos->get() == stack_frame_ptr) {
+ ret_sp = (*pos);
+ break;
}
- return ret_sp;
+ }
+ return ret_sp;
}
-size_t
-StackFrameList::GetStatus (Stream& strm,
- uint32_t first_frame,
- uint32_t num_frames,
- bool show_frame_info,
- uint32_t num_frames_with_source,
- const char *selected_frame_marker)
-{
- size_t num_frames_displayed = 0;
-
- if (num_frames == 0)
- return 0;
-
- StackFrameSP frame_sp;
- uint32_t frame_idx = 0;
- uint32_t last_frame;
-
- // Don't let the last frame wrap around...
- if (num_frames == UINT32_MAX)
- last_frame = UINT32_MAX;
- else
- last_frame = first_frame + num_frames;
-
- StackFrameSP selected_frame_sp = m_thread.GetSelectedFrame();
- const char *unselected_marker = nullptr;
- std::string buffer;
- if (selected_frame_marker)
- {
- size_t len = strlen(selected_frame_marker);
- buffer.insert(buffer.begin(), len, ' ');
- unselected_marker = buffer.c_str();
+size_t StackFrameList::GetStatus(Stream &strm, uint32_t first_frame,
+ uint32_t num_frames, bool show_frame_info,
+ uint32_t num_frames_with_source,
+ const char *selected_frame_marker) {
+ size_t num_frames_displayed = 0;
+
+ if (num_frames == 0)
+ return 0;
+
+ StackFrameSP frame_sp;
+ uint32_t frame_idx = 0;
+ uint32_t last_frame;
+
+ // Don't let the last frame wrap around...
+ if (num_frames == UINT32_MAX)
+ last_frame = UINT32_MAX;
+ else
+ last_frame = first_frame + num_frames;
+
+ StackFrameSP selected_frame_sp = m_thread.GetSelectedFrame();
+ const char *unselected_marker = nullptr;
+ std::string buffer;
+ if (selected_frame_marker) {
+ size_t len = strlen(selected_frame_marker);
+ buffer.insert(buffer.begin(), len, ' ');
+ unselected_marker = buffer.c_str();
+ }
+ const char *marker = nullptr;
+
+ for (frame_idx = first_frame; frame_idx < last_frame; ++frame_idx) {
+ frame_sp = GetFrameAtIndex(frame_idx);
+ if (!frame_sp)
+ break;
+
+ if (selected_frame_marker != nullptr) {
+ if (frame_sp == selected_frame_sp)
+ marker = selected_frame_marker;
+ else
+ marker = unselected_marker;
}
- const char *marker = nullptr;
-
- for (frame_idx = first_frame; frame_idx < last_frame; ++frame_idx)
- {
- frame_sp = GetFrameAtIndex(frame_idx);
- if (!frame_sp)
- break;
-
- if (selected_frame_marker != nullptr)
- {
- if (frame_sp == selected_frame_sp)
- marker = selected_frame_marker;
- else
- marker = unselected_marker;
- }
-
- if (!frame_sp->GetStatus (strm,
- show_frame_info,
- num_frames_with_source > (first_frame - frame_idx), marker))
- break;
- ++num_frames_displayed;
- }
-
- strm.IndentLess();
- return num_frames_displayed;
+
+ if (!frame_sp->GetStatus(strm, show_frame_info,
+ num_frames_with_source > (first_frame - frame_idx),
+ marker))
+ break;
+ ++num_frames_displayed;
+ }
+
+ strm.IndentLess();
+ return num_frames_displayed;
}