[lldb][NFC] Fix all formatting errors in .cpp file headers
Summary:
A *.cpp file header in LLDB (and in LLDB) should like this:
```
//===-- TestUtilities.cpp -------------------------------------------------===//
```
However in LLDB most of our source files have arbitrary changes to this format and
these changes are spreading through LLDB as folks usually just use the existing
source files as templates for their new files (most notably the unnecessary
editor language indicator `-*- C++ -*-` is spreading and in every review
someone is pointing out that this is wrong, resulting in people pointing out that this
is done in the same way in other files).
This patch removes most of these inconsistencies including the editor language indicators,
all the different missing/additional '-' characters, files that center the file name, missing
trailing `===//` (mostly caused by clang-format breaking the line).
Reviewers: aprantl, espindola, jfb, shafik, JDevlieghere
Reviewed By: JDevlieghere
Subscribers: dexonsmith, wuzish, emaste, sdardis, nemanjai, kbarton, MaskRay, atanasyan, arphaman, jfb, abidh, jsji, JDevlieghere, usaxena95, lldb-commits
Tags: #lldb
Differential Revision: https://reviews.llvm.org/D73258
2020-01-24 15:23:27 +08:00
|
|
|
//===-- StackFrameList.cpp ------------------------------------------------===//
|
2010-06-09 00:52:24 +08:00
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2010-06-09 00:52:24 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2016-02-19 02:52:47 +08:00
|
|
|
#include "lldb/Target/StackFrameList.h"
|
2012-09-08 08:26:49 +08:00
|
|
|
#include "lldb/Breakpoint/Breakpoint.h"
|
|
|
|
#include "lldb/Breakpoint/BreakpointLocation.h"
|
2011-09-09 06:13:49 +08:00
|
|
|
#include "lldb/Core/SourceManager.h"
|
2010-08-28 02:24:16 +08:00
|
|
|
#include "lldb/Core/StreamFile.h"
|
2010-08-25 08:35:26 +08:00
|
|
|
#include "lldb/Symbol/Block.h"
|
|
|
|
#include "lldb/Symbol/Function.h"
|
2010-08-31 02:11:35 +08:00
|
|
|
#include "lldb/Symbol/Symbol.h"
|
2011-09-09 06:13:49 +08:00
|
|
|
#include "lldb/Target/Process.h"
|
2010-08-25 08:35:26 +08:00
|
|
|
#include "lldb/Target/RegisterContext.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
#include "lldb/Target/StackFrame.h"
|
2012-09-01 09:02:41 +08:00
|
|
|
#include "lldb/Target/StopInfo.h"
|
2011-09-09 06:13:49 +08:00
|
|
|
#include "lldb/Target/Target.h"
|
2010-08-25 08:35:26 +08:00
|
|
|
#include "lldb/Target/Thread.h"
|
|
|
|
#include "lldb/Target/Unwind.h"
|
2017-03-04 04:56:28 +08:00
|
|
|
#include "lldb/Utility/Log.h"
|
2018-10-06 07:23:15 +08:00
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2019-02-12 07:13:08 +08:00
|
|
|
#include <memory>
|
|
|
|
|
2010-08-28 02:24:16 +08:00
|
|
|
//#define DEBUG_STACK_FRAMES 1
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
using namespace lldb;
|
|
|
|
using namespace lldb_private;
|
|
|
|
|
|
|
|
// StackFrameList constructor
|
2016-05-19 13:13:57 +08:00
|
|
|
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) {
|
2012-09-01 09:02:41 +08:00
|
|
|
if (prev_frames_sp) {
|
|
|
|
m_current_inlined_depth = prev_frames_sp->m_current_inlined_depth;
|
2016-05-19 13:13:57 +08:00
|
|
|
m_current_inlined_pc = prev_frames_sp->m_current_inlined_pc;
|
2012-09-01 09:02:41 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
StackFrameList::~StackFrameList() {
|
2018-05-01 00:49:04 +08:00
|
|
|
// Call clear since this takes a lock and clears the stack frame list in case
|
|
|
|
// another thread is currently using this stack frame list
|
2013-03-29 02:41:44 +08:00
|
|
|
Clear();
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2012-09-01 09:02:41 +08:00
|
|
|
void StackFrameList::CalculateCurrentInlinedDepth() {
|
|
|
|
uint32_t cur_inlined_depth = GetCurrentInlinedDepth();
|
|
|
|
if (cur_inlined_depth == UINT32_MAX) {
|
|
|
|
ResetCurrentInlinedDepth();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t StackFrameList::GetCurrentInlinedDepth() {
|
2012-09-08 07:35:54 +08:00
|
|
|
if (m_show_inlined_frames && m_current_inlined_pc != LLDB_INVALID_ADDRESS) {
|
2012-09-01 09:02:41 +08:00
|
|
|
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;
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
|
2012-09-08 07:35:54 +08:00
|
|
|
if (log && log->GetVerbose())
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(
|
|
|
|
log,
|
2012-09-08 07:35:54 +08:00
|
|
|
"GetCurrentInlinedDepth: invalidating current inlined depth.\n");
|
2012-09-01 09:02:41 +08:00
|
|
|
}
|
|
|
|
return m_current_inlined_depth;
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
2012-09-01 09:02:41 +08:00
|
|
|
return UINT32_MAX;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-09-01 09:02:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void StackFrameList::ResetCurrentInlinedDepth() {
|
2018-08-02 01:07:56 +08:00
|
|
|
if (!m_show_inlined_frames)
|
|
|
|
return;
|
|
|
|
|
2016-05-19 13:13:57 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-08-02 01:07:56 +08:00
|
|
|
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())
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(
|
|
|
|
log,
|
2018-08-02 01:07:56 +08:00
|
|
|
"ResetCurrentInlinedDepth: Invalidating current inlined depth.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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.
|
|
|
|
|
|
|
|
Block *block_ptr = m_frames[0]->GetFrameBlock();
|
|
|
|
if (!block_ptr)
|
|
|
|
return;
|
|
|
|
|
|
|
|
Address pc_as_address;
|
|
|
|
lldb::addr_t curr_pc = m_thread.GetRegisterContext()->GetPC();
|
|
|
|
pc_as_address.SetLoadAddress(curr_pc, &(m_thread.GetProcess()->GetTarget()));
|
|
|
|
AddressRange containing_range;
|
|
|
|
if (!block_ptr->GetRangeContainingAddress(pc_as_address, containing_range) ||
|
|
|
|
pc_as_address != containing_range.GetBaseAddress())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// 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)
|
|
|
|
return;
|
|
|
|
switch (stop_info_sp->GetStopReason()) {
|
|
|
|
case eStopReasonWatchpoint:
|
|
|
|
case eStopReasonException:
|
|
|
|
case eStopReasonExec:
|
2021-03-29 23:05:30 +08:00
|
|
|
case eStopReasonFork:
|
|
|
|
case eStopReasonVFork:
|
|
|
|
case eStopReasonVForkDone:
|
2018-08-02 01:07:56 +08:00
|
|
|
case eStopReasonSignal:
|
|
|
|
// In all these cases we want to stop in the deepest 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;
|
2012-09-01 09:02:41 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-09-01 09:02:41 +08:00
|
|
|
}
|
2018-08-02 01:07:56 +08:00
|
|
|
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())
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log,
|
|
|
|
"ResetCurrentInlinedDepth: setting inlined "
|
|
|
|
"depth: %d 0x%" PRIx64 ".\n",
|
|
|
|
m_current_inlined_depth, curr_pc);
|
2018-08-02 01:07:56 +08:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-09-01 09:02:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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--;
|
2012-09-07 03:24:57 +08:00
|
|
|
return true;
|
2012-09-01 09:02:41 +08:00
|
|
|
}
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-09-01 09:02:41 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-09-08 07:35:54 +08:00
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
2018-08-02 01:07:40 +08:00
|
|
|
void StackFrameList::GetOnlyConcreteFramesUpTo(uint32_t end_idx,
|
2020-03-09 21:10:41 +08:00
|
|
|
Unwind &unwinder) {
|
2018-08-02 01:07:40 +08:00
|
|
|
assert(m_thread.IsValid() && "Expected valid thread");
|
|
|
|
assert(m_frames.size() <= end_idx && "Expected there to be frames to fill");
|
|
|
|
|
|
|
|
if (end_idx < m_concrete_frames_fetched)
|
|
|
|
return;
|
|
|
|
|
2020-03-09 21:10:41 +08:00
|
|
|
uint32_t num_frames = unwinder.GetFramesUpTo(end_idx);
|
2018-08-02 01:07:40 +08:00
|
|
|
if (num_frames <= end_idx + 1) {
|
|
|
|
// Done unwinding.
|
|
|
|
m_concrete_frames_fetched = UINT32_MAX;
|
|
|
|
}
|
2018-08-08 07:48:25 +08:00
|
|
|
|
|
|
|
// Don't create the frames eagerly. Defer this work to GetFrameAtIndex,
|
|
|
|
// which can lazily query the unwinder to create frames.
|
2018-08-02 01:07:40 +08:00
|
|
|
m_frames.resize(num_frames);
|
|
|
|
}
|
|
|
|
|
2020-03-18 08:59:08 +08:00
|
|
|
/// A sequence of calls that comprise some portion of a backtrace. Each frame
|
|
|
|
/// is represented as a pair of a callee (Function *) and an address within the
|
|
|
|
/// callee.
|
2020-06-02 22:01:11 +08:00
|
|
|
struct CallDescriptor {
|
|
|
|
Function *func;
|
2020-06-09 17:53:59 +08:00
|
|
|
CallEdge::AddrType address_type = CallEdge::AddrType::Call;
|
|
|
|
addr_t address = LLDB_INVALID_ADDRESS;
|
2020-06-02 22:01:11 +08:00
|
|
|
};
|
|
|
|
using CallSequence = std::vector<CallDescriptor>;
|
2020-03-18 08:59:08 +08:00
|
|
|
|
2018-10-06 07:23:15 +08:00
|
|
|
/// Find the unique path through the call graph from \p begin (with return PC
|
|
|
|
/// \p return_pc) to \p end. On success this path is stored into \p path, and
|
|
|
|
/// on failure \p path is unchanged.
|
|
|
|
static void FindInterveningFrames(Function &begin, Function &end,
|
2019-09-15 10:43:16 +08:00
|
|
|
ExecutionContext &exe_ctx, Target &target,
|
2020-03-18 08:59:08 +08:00
|
|
|
addr_t return_pc, CallSequence &path,
|
2018-10-06 07:23:15 +08:00
|
|
|
ModuleList &images, Log *log) {
|
|
|
|
LLDB_LOG(log, "Finding frames between {0} and {1}, retn-pc={2:x}",
|
|
|
|
begin.GetDisplayName(), end.GetDisplayName(), return_pc);
|
|
|
|
|
|
|
|
// Find a non-tail calling edge with the correct return PC.
|
|
|
|
if (log)
|
2019-09-15 10:43:16 +08:00
|
|
|
for (const auto &edge : begin.GetCallEdges())
|
2018-10-06 07:23:15 +08:00
|
|
|
LLDB_LOG(log, "FindInterveningFrames: found call with retn-PC = {0:x}",
|
2019-09-15 10:43:16 +08:00
|
|
|
edge->GetReturnPCAddress(begin, target));
|
2019-09-11 02:36:50 +08:00
|
|
|
CallEdge *first_edge = begin.GetCallEdgeForReturnAddress(return_pc, target);
|
|
|
|
if (!first_edge) {
|
2018-10-06 07:23:15 +08:00
|
|
|
LLDB_LOG(log, "No call edge outgoing from {0} with retn-PC == {1:x}",
|
|
|
|
begin.GetDisplayName(), return_pc);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// The first callee may not be resolved, or there may be nothing to fill in.
|
2019-09-15 10:43:16 +08:00
|
|
|
Function *first_callee = first_edge->GetCallee(images, exe_ctx);
|
2018-10-06 07:23:15 +08:00
|
|
|
if (!first_callee) {
|
|
|
|
LLDB_LOG(log, "Could not resolve callee");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (first_callee == &end) {
|
|
|
|
LLDB_LOG(log, "Not searching further, first callee is {0} (retn-PC: {1:x})",
|
|
|
|
end.GetDisplayName(), return_pc);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Run DFS on the tail-calling edges out of the first callee to find \p end.
|
|
|
|
// Fully explore the set of functions reachable from the first edge via tail
|
|
|
|
// calls in order to detect ambiguous executions.
|
|
|
|
struct DFS {
|
2020-03-18 08:59:08 +08:00
|
|
|
CallSequence active_path = {};
|
|
|
|
CallSequence solution_path = {};
|
2018-10-06 07:23:15 +08:00
|
|
|
llvm::SmallPtrSet<Function *, 2> visited_nodes = {};
|
|
|
|
bool ambiguous = false;
|
|
|
|
Function *end;
|
|
|
|
ModuleList &images;
|
2020-03-18 08:59:08 +08:00
|
|
|
Target ⌖
|
2019-09-15 10:43:16 +08:00
|
|
|
ExecutionContext &context;
|
2018-10-06 07:23:15 +08:00
|
|
|
|
2020-03-18 08:59:08 +08:00
|
|
|
DFS(Function *end, ModuleList &images, Target &target,
|
|
|
|
ExecutionContext &context)
|
|
|
|
: end(end), images(images), target(target), context(context) {}
|
2018-10-06 07:23:15 +08:00
|
|
|
|
2020-03-18 08:59:08 +08:00
|
|
|
void search(CallEdge &first_edge, Function &first_callee,
|
|
|
|
CallSequence &path) {
|
|
|
|
dfs(first_edge, first_callee);
|
2018-10-06 07:23:15 +08:00
|
|
|
if (!ambiguous)
|
|
|
|
path = std::move(solution_path);
|
|
|
|
}
|
|
|
|
|
2020-03-18 08:59:08 +08:00
|
|
|
void dfs(CallEdge ¤t_edge, Function &callee) {
|
2018-10-06 07:23:15 +08:00
|
|
|
// Found a path to the target function.
|
2019-10-01 05:20:14 +08:00
|
|
|
if (&callee == end) {
|
2018-10-06 07:23:15 +08:00
|
|
|
if (solution_path.empty())
|
|
|
|
solution_path = active_path;
|
|
|
|
else
|
|
|
|
ambiguous = true;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Terminate the search if tail recursion is found, or more generally if
|
|
|
|
// there's more than one way to reach a target. This errs on the side of
|
|
|
|
// caution: it conservatively stops searching when some solutions are
|
|
|
|
// still possible to save time in the average case.
|
2019-10-01 05:20:14 +08:00
|
|
|
if (!visited_nodes.insert(&callee).second) {
|
2018-10-06 07:23:15 +08:00
|
|
|
ambiguous = true;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Search the calls made from this callee.
|
2020-06-02 22:01:11 +08:00
|
|
|
active_path.push_back(CallDescriptor{&callee});
|
2019-09-15 10:43:16 +08:00
|
|
|
for (const auto &edge : callee.GetTailCallingEdges()) {
|
|
|
|
Function *next_callee = edge->GetCallee(images, context);
|
2018-10-06 07:23:15 +08:00
|
|
|
if (!next_callee)
|
|
|
|
continue;
|
|
|
|
|
2020-06-02 22:01:11 +08:00
|
|
|
std::tie(active_path.back().address_type, active_path.back().address) =
|
|
|
|
edge->GetCallerAddress(callee, target);
|
2020-03-18 08:59:08 +08:00
|
|
|
|
|
|
|
dfs(*edge, *next_callee);
|
2018-10-06 07:23:15 +08:00
|
|
|
if (ambiguous)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
active_path.pop_back();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2020-03-18 08:59:08 +08:00
|
|
|
DFS(&end, images, target, exe_ctx).search(*first_edge, *first_callee, path);
|
2018-10-06 07:23:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Given that \p next_frame will be appended to the frame list, synthesize
|
|
|
|
/// tail call frames between the current end of the list and \p next_frame.
|
|
|
|
/// If any frames are added, adjust the frame index of \p next_frame.
|
|
|
|
///
|
|
|
|
/// --------------
|
|
|
|
/// | ... | <- Completed frames.
|
|
|
|
/// --------------
|
|
|
|
/// | prev_frame |
|
|
|
|
/// --------------
|
|
|
|
/// | ... | <- Artificial frames inserted here.
|
|
|
|
/// --------------
|
|
|
|
/// | next_frame |
|
|
|
|
/// --------------
|
|
|
|
/// | ... | <- Not-yet-visited frames.
|
|
|
|
/// --------------
|
|
|
|
void StackFrameList::SynthesizeTailCallFrames(StackFrame &next_frame) {
|
2020-02-05 02:12:47 +08:00
|
|
|
// Cannot synthesize tail call frames when the stack is empty (there is no
|
|
|
|
// "previous" frame).
|
|
|
|
if (m_frames.empty())
|
|
|
|
return;
|
|
|
|
|
2018-10-06 07:23:15 +08:00
|
|
|
TargetSP target_sp = next_frame.CalculateTarget();
|
|
|
|
if (!target_sp)
|
|
|
|
return;
|
|
|
|
|
|
|
|
lldb::RegisterContextSP next_reg_ctx_sp = next_frame.GetRegisterContext();
|
|
|
|
if (!next_reg_ctx_sp)
|
|
|
|
return;
|
|
|
|
|
|
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
|
|
|
|
|
|
|
|
StackFrame &prev_frame = *m_frames.back().get();
|
|
|
|
|
|
|
|
// Find the functions prev_frame and next_frame are stopped in. The function
|
|
|
|
// objects are needed to search the lazy call graph for intervening frames.
|
|
|
|
Function *prev_func =
|
|
|
|
prev_frame.GetSymbolContext(eSymbolContextFunction).function;
|
|
|
|
if (!prev_func) {
|
|
|
|
LLDB_LOG(log, "SynthesizeTailCallFrames: can't find previous function");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
Function *next_func =
|
|
|
|
next_frame.GetSymbolContext(eSymbolContextFunction).function;
|
|
|
|
if (!next_func) {
|
|
|
|
LLDB_LOG(log, "SynthesizeTailCallFrames: can't find next function");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Try to find the unique sequence of (tail) calls which led from next_frame
|
|
|
|
// to prev_frame.
|
2020-03-18 08:59:08 +08:00
|
|
|
CallSequence path;
|
2018-10-06 07:23:15 +08:00
|
|
|
addr_t return_pc = next_reg_ctx_sp->GetPC();
|
|
|
|
Target &target = *target_sp.get();
|
|
|
|
ModuleList &images = next_frame.CalculateTarget()->GetImages();
|
2019-09-15 10:43:16 +08:00
|
|
|
ExecutionContext exe_ctx(target_sp, /*get_process=*/true);
|
|
|
|
exe_ctx.SetFramePtr(&next_frame);
|
|
|
|
FindInterveningFrames(*next_func, *prev_func, exe_ctx, target, return_pc,
|
|
|
|
path, images, log);
|
2018-10-06 07:23:15 +08:00
|
|
|
|
|
|
|
// Push synthetic tail call frames.
|
2020-03-18 08:59:08 +08:00
|
|
|
for (auto calleeInfo : llvm::reverse(path)) {
|
2020-06-02 22:01:11 +08:00
|
|
|
Function *callee = calleeInfo.func;
|
2018-10-06 07:23:15 +08:00
|
|
|
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;
|
2020-06-02 22:01:11 +08:00
|
|
|
addr_t pc = calleeInfo.address;
|
|
|
|
// If the callee address refers to the call instruction, we do not want to
|
|
|
|
// subtract 1 from this value.
|
|
|
|
const bool behaves_like_zeroth_frame =
|
|
|
|
calleeInfo.address_type == CallEdge::AddrType::Call;
|
2018-10-06 07:23:15 +08:00
|
|
|
SymbolContext sc;
|
|
|
|
callee->CalculateSymbolContext(&sc);
|
|
|
|
auto synth_frame = std::make_shared<StackFrame>(
|
|
|
|
m_thread.shared_from_this(), frame_idx, concrete_frame_idx, cfa,
|
2019-08-03 00:53:42 +08:00
|
|
|
cfa_is_valid, pc, StackFrame::Kind::Artificial,
|
|
|
|
behaves_like_zeroth_frame, &sc);
|
2018-10-06 07:23:15 +08:00
|
|
|
m_frames.push_back(synth_frame);
|
2020-03-18 08:59:08 +08:00
|
|
|
LLDB_LOG(log, "Pushed frame {0} at {1:x}", callee->GetDisplayName(), pc);
|
2018-10-06 07:23:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// If any frames were created, adjust next_frame's index.
|
|
|
|
if (!path.empty())
|
|
|
|
next_frame.SetFrameIndex(m_frames.size());
|
|
|
|
}
|
|
|
|
|
2012-02-29 11:40:22 +08:00
|
|
|
void StackFrameList::GetFramesUpTo(uint32_t end_idx) {
|
2018-08-02 01:07:40 +08:00
|
|
|
// Do not fetch frames for an invalid thread.
|
2016-02-19 02:52:47 +08:00
|
|
|
if (!m_thread.IsValid())
|
2013-03-16 01:25:04 +08:00
|
|
|
return;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-02-29 11:40:22 +08:00
|
|
|
// We've already gotten more frames than asked for, or we've already finished
|
|
|
|
// unwinding, return.
|
|
|
|
if (m_frames.size() > end_idx || GetAllFramesFetched())
|
|
|
|
return;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2020-03-09 21:10:41 +08:00
|
|
|
Unwind &unwinder = m_thread.GetUnwinder();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-08-02 01:07:40 +08:00
|
|
|
if (!m_show_inlined_frames) {
|
|
|
|
GetOnlyConcreteFramesUpTo(end_idx, unwinder);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-08-28 02:24:16 +08:00
|
|
|
#if defined(DEBUG_STACK_FRAMES)
|
2018-08-02 01:07:40 +08:00
|
|
|
StreamFile s(stdout, false);
|
2010-08-28 02:24:16 +08:00
|
|
|
#endif
|
2018-08-02 01:07:40 +08:00
|
|
|
// 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;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2018-08-02 01:07:40 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-08-02 01:07:40 +08:00
|
|
|
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;
|
2019-08-03 00:53:42 +08:00
|
|
|
bool behaves_like_zeroth_frame = (idx == 0);
|
2018-08-02 01:07:40 +08:00
|
|
|
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) {
|
2020-03-09 21:10:41 +08:00
|
|
|
const bool success = unwinder.GetFrameInfoAtIndex(
|
|
|
|
idx, cfa, pc, behaves_like_zeroth_frame);
|
2018-08-02 01:07:40 +08:00
|
|
|
// 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();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2018-08-02 01:07:40 +08:00
|
|
|
|
2019-02-12 07:13:08 +08:00
|
|
|
unwind_frame_sp = std::make_shared<StackFrame>(
|
|
|
|
m_thread.shared_from_this(), m_frames.size(), idx, reg_ctx_sp,
|
2019-08-03 00:53:42 +08:00
|
|
|
cfa, pc, behaves_like_zeroth_frame, nullptr);
|
2018-08-02 01:07:40 +08:00
|
|
|
m_frames.push_back(unwind_frame_sp);
|
2012-09-01 09:02:41 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
2018-08-02 01:07:40 +08:00
|
|
|
unwind_frame_sp = m_frames.front();
|
|
|
|
cfa = unwind_frame_sp->m_id.GetCallFrameAddress();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2018-08-02 01:07:40 +08:00
|
|
|
} else {
|
2020-03-09 21:10:41 +08:00
|
|
|
const bool success =
|
|
|
|
unwinder.GetFrameInfoAtIndex(idx, cfa, pc, behaves_like_zeroth_frame);
|
2018-08-02 01:07:40 +08:00
|
|
|
if (!success) {
|
|
|
|
// We've gotten to the end of the stack.
|
|
|
|
SetAllFramesFetched();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
const bool cfa_is_valid = true;
|
2019-02-12 07:13:08 +08:00
|
|
|
unwind_frame_sp = std::make_shared<StackFrame>(
|
|
|
|
m_thread.shared_from_this(), m_frames.size(), idx, cfa, cfa_is_valid,
|
2019-08-03 00:53:42 +08:00
|
|
|
pc, StackFrame::Kind::Regular, behaves_like_zeroth_frame, nullptr);
|
2018-10-06 07:23:15 +08:00
|
|
|
|
|
|
|
// 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());
|
|
|
|
|
2018-08-02 01:07:40 +08:00
|
|
|
m_frames.push_back(unwind_frame_sp);
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-08-02 01:07:40 +08:00
|
|
|
assert(unwind_frame_sp);
|
|
|
|
SymbolContext unwind_sc = unwind_frame_sp->GetSymbolContext(
|
|
|
|
eSymbolContextBlock | eSymbolContextFunction);
|
|
|
|
Block *unwind_block = unwind_sc.block;
|
2021-03-04 11:25:30 +08:00
|
|
|
TargetSP target_sp = m_thread.CalculateTarget();
|
2018-08-02 01:07:40 +08:00
|
|
|
if (unwind_block) {
|
2021-03-04 11:25:30 +08:00
|
|
|
Address curr_frame_address(
|
|
|
|
unwind_frame_sp->GetFrameCodeAddressForSymbolication());
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-08-02 01:07:40 +08:00
|
|
|
SymbolContext next_frame_sc;
|
|
|
|
Address next_frame_address;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-08-02 01:07:40 +08:00
|
|
|
while (unwind_sc.GetParentOfInlinedScope(
|
|
|
|
curr_frame_address, next_frame_sc, next_frame_address)) {
|
|
|
|
next_frame_sc.line_entry.ApplyFileMappings(target_sp);
|
2019-08-03 00:53:42 +08:00
|
|
|
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));
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-08-02 01:07:40 +08:00
|
|
|
m_frames.push_back(frame_sp);
|
|
|
|
unwind_sc = next_frame_sc;
|
|
|
|
curr_frame_address = next_frame_address;
|
2010-08-28 02:24:16 +08:00
|
|
|
}
|
2018-08-02 01:07:40 +08:00
|
|
|
}
|
|
|
|
} while (m_frames.size() - 1 < end_idx);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-08-02 01:07:40 +08:00
|
|
|
// 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;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-08-28 02:24:16 +08:00
|
|
|
#if defined(DEBUG_STACK_FRAMES)
|
2018-08-02 01:07:40 +08:00
|
|
|
s.PutCString("\nprev_frames:\n");
|
|
|
|
prev_frames->Dump(&s);
|
|
|
|
s.PutCString("\ncurr_frames:\n");
|
|
|
|
curr_frames->Dump(&s);
|
|
|
|
s.EOL();
|
2010-08-28 02:24:16 +08:00
|
|
|
#endif
|
2018-08-02 01:07:40 +08:00
|
|
|
size_t curr_frame_num, prev_frame_num;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-08-02 01:07:40 +08:00
|
|
|
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]);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-08-28 02:24:16 +08:00
|
|
|
#if defined(DEBUG_STACK_FRAMES)
|
2018-08-02 01:07:40 +08:00
|
|
|
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");
|
2010-08-28 02:24:16 +08:00
|
|
|
#endif
|
|
|
|
|
2018-08-02 01:07:40 +08:00
|
|
|
StackFrame *curr_frame = curr_frame_sp.get();
|
|
|
|
StackFrame *prev_frame = prev_frame_sp.get();
|
2012-02-29 11:40:22 +08:00
|
|
|
|
2018-08-02 01:07:40 +08:00
|
|
|
if (curr_frame == nullptr || prev_frame == nullptr)
|
|
|
|
break;
|
2012-02-29 11:40:22 +08:00
|
|
|
|
2018-08-02 01:07:40 +08:00
|
|
|
// Check the stack ID to make sure they are equal.
|
|
|
|
if (curr_frame->GetStackID() != prev_frame->GetStackID())
|
|
|
|
break;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-08-02 01:07:40 +08:00
|
|
|
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;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-08-28 02:24:16 +08:00
|
|
|
#if defined(DEBUG_STACK_FRAMES)
|
2018-08-02 01:07:40 +08:00
|
|
|
s.Printf("\n Copying previous frame to current frame");
|
2010-08-28 05:47:54 +08:00
|
|
|
#endif
|
2012-02-29 11:40:22 +08:00
|
|
|
}
|
2018-08-02 01:07:40 +08:00
|
|
|
// We are done with the old stack frame list, we can release it now.
|
|
|
|
m_prev_frames_sp.reset();
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-08-28 05:47:54 +08:00
|
|
|
#if defined(DEBUG_STACK_FRAMES)
|
2018-08-02 01:07:40 +08:00
|
|
|
s.PutCString("\n\nNew frames:\n");
|
|
|
|
Dump(&s);
|
|
|
|
s.EOL();
|
2016-09-07 04:57:50 +08:00
|
|
|
#endif
|
2012-02-29 11:40:22 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t StackFrameList::GetNumFrames(bool can_create) {
|
2016-05-19 13:13:57 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2012-02-29 11:40:22 +08:00
|
|
|
|
|
|
|
if (can_create)
|
|
|
|
GetFramesUpTo(UINT32_MAX);
|
2012-09-01 09:02:41 +08:00
|
|
|
|
2018-08-02 01:08:11 +08:00
|
|
|
return GetVisibleStackFrameIndex(m_frames.size());
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2010-08-28 02:24:16 +08:00
|
|
|
void StackFrameList::Dump(Stream *s) {
|
2016-02-19 02:52:47 +08:00
|
|
|
if (s == nullptr)
|
2010-08-28 02:24:16 +08:00
|
|
|
return;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2016-05-19 13:13:57 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-08-28 02:24:16 +08:00
|
|
|
const_iterator pos, begin = m_frames.begin(), end = m_frames.end();
|
|
|
|
for (pos = begin; pos != end; ++pos) {
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrame *frame = (*pos).get();
|
2014-04-04 12:06:10 +08:00
|
|
|
s->Printf("%p: ", static_cast<void *>(frame));
|
2010-08-28 02:24:16 +08:00
|
|
|
if (frame) {
|
2010-08-31 02:11:35 +08:00
|
|
|
frame->GetStackID().Dump(s);
|
2010-10-04 09:05:56 +08:00
|
|
|
frame->DumpUsingSettingsFormat(s);
|
2010-08-28 02:24:16 +08:00
|
|
|
} else
|
2011-11-04 11:34:56 +08:00
|
|
|
s->Printf("frame #%u", (uint32_t)std::distance(begin, pos));
|
2010-08-28 02:24:16 +08:00
|
|
|
s->EOL();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-08-28 02:24:16 +08:00
|
|
|
s->EOL();
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2010-08-25 08:35:26 +08:00
|
|
|
StackFrameSP StackFrameList::GetFrameAtIndex(uint32_t idx) {
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrameSP frame_sp;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2013-03-28 08:13:30 +08:00
|
|
|
uint32_t original_idx = idx;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-09-01 09:02:41 +08:00
|
|
|
uint32_t inlined_depth = GetCurrentInlinedDepth();
|
|
|
|
if (inlined_depth != UINT32_MAX)
|
|
|
|
idx += inlined_depth;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-08-28 02:24:16 +08:00
|
|
|
if (idx < m_frames.size())
|
|
|
|
frame_sp = m_frames[idx];
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-08-28 02:24:16 +08:00
|
|
|
if (frame_sp)
|
|
|
|
return frame_sp;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-05-01 00:49:04 +08:00
|
|
|
// 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.
|
2013-03-28 08:13:30 +08:00
|
|
|
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 {
|
2020-03-09 21:10:41 +08:00
|
|
|
addr_t pc, cfa;
|
|
|
|
bool behaves_like_zeroth_frame = (idx == 0);
|
|
|
|
if (m_thread.GetUnwinder().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, 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 {
|
|
|
|
// Set the symbol scope from the symbol regardless if it is nullptr
|
|
|
|
// or valid.
|
|
|
|
frame_sp->SetSymbolContextScope(
|
|
|
|
frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol);
|
2010-08-25 08:35:26 +08:00
|
|
|
}
|
2020-03-09 21:10:41 +08:00
|
|
|
SetFrameAtIndex(idx, frame_sp);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2013-03-28 08:13:30 +08:00
|
|
|
}
|
|
|
|
} else if (original_idx == 0) {
|
|
|
|
// There should ALWAYS be a frame at index 0. If something went wrong with
|
2018-05-01 00:49:04 +08:00
|
|
|
// the CurrentInlinedDepth such that there weren't as many frames as we
|
|
|
|
// thought taking that into account, then reset the current inlined depth
|
2013-03-28 08:13:30 +08:00
|
|
|
// and return the real zeroth frame.
|
2016-02-19 02:52:47 +08:00
|
|
|
if (m_frames.empty()) {
|
2013-03-28 08:13:30 +08:00
|
|
|
// Why do we have a thread with zero frames, that should not ever
|
|
|
|
// happen...
|
2017-01-06 08:38:06 +08:00
|
|
|
assert(!m_thread.IsValid() && "A valid thread has no frames.");
|
2016-02-19 02:52:47 +08:00
|
|
|
} else {
|
|
|
|
ResetCurrentInlinedDepth();
|
|
|
|
frame_sp = m_frames[original_idx];
|
2013-03-28 08:13:30 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
return frame_sp;
|
|
|
|
}
|
|
|
|
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrameSP
|
2011-01-07 06:15:06 +08:00
|
|
|
StackFrameList::GetFrameWithConcreteFrameIndex(uint32_t unwind_idx) {
|
|
|
|
// First try assuming the unwind index is the same as the frame index. The
|
2018-05-01 00:49:04 +08:00
|
|
|
// 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.
|
2011-01-07 06:15:06 +08:00
|
|
|
uint32_t frame_idx = unwind_idx;
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrameSP frame_sp(GetFrameAtIndex(frame_idx));
|
2011-01-07 06:15:06 +08:00
|
|
|
while (frame_sp) {
|
|
|
|
if (frame_sp->GetFrameIndex() == unwind_idx)
|
|
|
|
break;
|
|
|
|
frame_sp = GetFrameAtIndex(++frame_idx);
|
|
|
|
}
|
|
|
|
return frame_sp;
|
|
|
|
}
|
|
|
|
|
2013-11-04 17:33:30 +08:00
|
|
|
static bool CompareStackID(const StackFrameSP &stack_sp,
|
|
|
|
const StackID &stack_id) {
|
2013-05-24 08:58:29 +08:00
|
|
|
return stack_sp->GetStackID() < stack_id;
|
|
|
|
}
|
|
|
|
|
2012-02-17 15:49:44 +08:00
|
|
|
StackFrameSP StackFrameList::GetFrameWithStackID(const StackID &stack_id) {
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrameSP frame_sp;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-05-24 08:58:29 +08:00
|
|
|
if (stack_id.IsValid()) {
|
2016-05-19 13:13:57 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2013-05-24 08:58:29 +08:00
|
|
|
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);
|
2014-11-18 03:39:20 +08:00
|
|
|
if (pos != end) {
|
|
|
|
if ((*pos)->GetStackID() == stack_id)
|
|
|
|
return *pos;
|
|
|
|
}
|
2011-03-31 08:15:49 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
do {
|
Centralized a lot of the status information for processes,
threads, and stack frame down in the lldb_private::Process,
lldb_private::Thread, lldb_private::StackFrameList and the
lldb_private::StackFrame classes. We had some command line
commands that had duplicate versions of the process status
output ("thread list" and "process status" for example).
Removed the "file" command and placed it where it should
have been: "target create". Made an alias for "file" to
"target create" so we stay compatible with GDB commands.
We can now have multple usable targets in lldb at the
same time. This is nice for comparing two runs of a program
or debugging more than one binary at the same time. The
new command is "target select <target-idx>" and also to see
a list of the current targets you can use the new "target list"
command. The flow in a debug session can be:
(lldb) target create /path/to/exe/a.out
(lldb) breakpoint set --name main
(lldb) run
... hit breakpoint
(lldb) target create /bin/ls
(lldb) run /tmp
Process 36001 exited with status = 0 (0x00000000)
(lldb) target list
Current targets:
target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
* target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) target select 0
Current targets:
* target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) bt
* thread #1: tid = 0x2d03, 0x0000000100000b9a a.out`main + 42 at main.c:16, stop reason = breakpoint 1.1
frame #0: 0x0000000100000b9a a.out`main + 42 at main.c:16
frame #1: 0x0000000100000b64 a.out`start + 52
Above we created a target for "a.out" and ran and hit a
breakpoint at "main". Then we created a new target for /bin/ls
and ran it. Then we listed the targest and selected our original
"a.out" program, so we showed two concurent debug sessions
going on at the same time.
llvm-svn: 129695
2011-04-18 16:33:37 +08:00
|
|
|
frame_sp = GetFrameAtIndex(frame_idx);
|
2013-05-24 08:58:29 +08:00
|
|
|
if (frame_sp && frame_sp->GetStackID() == stack_id)
|
2016-09-07 04:57:50 +08:00
|
|
|
break;
|
2013-05-24 08:58:29 +08:00
|
|
|
frame_idx++;
|
|
|
|
} while (frame_sp);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-03-31 08:15:49 +08:00
|
|
|
return frame_sp;
|
|
|
|
}
|
2011-01-07 06:15:06 +08:00
|
|
|
|
2013-11-04 17:33:30 +08:00
|
|
|
bool StackFrameList::SetFrameAtIndex(uint32_t idx, StackFrameSP &frame_sp) {
|
2010-08-28 02:24:16 +08:00
|
|
|
if (idx >= m_frames.size())
|
|
|
|
m_frames.resize(idx + 1);
|
2010-08-25 08:35:26 +08:00
|
|
|
// Make sure allocation succeeded by checking bounds again
|
2010-08-28 02:24:16 +08:00
|
|
|
if (idx < m_frames.size()) {
|
|
|
|
m_frames[idx] = frame_sp;
|
2010-06-09 00:52:24 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false; // resize failed, out of memory?
|
|
|
|
}
|
|
|
|
|
2010-08-27 05:32:51 +08:00
|
|
|
uint32_t StackFrameList::GetSelectedFrameIndex() const {
|
2016-05-19 13:13:57 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2010-08-27 05:32:51 +08:00
|
|
|
return m_selected_frame_idx;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2013-11-04 17:33:30 +08:00
|
|
|
uint32_t StackFrameList::SetSelectedFrame(lldb_private::StackFrame *frame) {
|
2016-05-19 13:13:57 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2010-08-25 08:35:26 +08:00
|
|
|
const_iterator pos;
|
2010-08-28 02:24:16 +08:00
|
|
|
const_iterator begin = m_frames.begin();
|
|
|
|
const_iterator end = m_frames.end();
|
2011-09-09 06:13:49 +08:00
|
|
|
m_selected_frame_idx = 0;
|
2010-06-09 00:52:24 +08:00
|
|
|
for (pos = begin; pos != end; ++pos) {
|
|
|
|
if (pos->get() == frame) {
|
2010-08-27 05:32:51 +08:00
|
|
|
m_selected_frame_idx = std::distance(begin, pos);
|
2012-09-01 09:02:41 +08:00
|
|
|
uint32_t inlined_depth = GetCurrentInlinedDepth();
|
|
|
|
if (inlined_depth != UINT32_MAX)
|
|
|
|
m_selected_frame_idx -= inlined_depth;
|
2011-09-09 06:13:49 +08:00
|
|
|
break;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-09-09 06:13:49 +08:00
|
|
|
SetDefaultFileAndLineToSelectedFrame();
|
2010-08-27 05:32:51 +08:00
|
|
|
return m_selected_frame_idx;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2010-08-27 05:32:51 +08:00
|
|
|
bool StackFrameList::SetSelectedFrameByIndex(uint32_t idx) {
|
2016-05-19 13:13:57 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrameSP frame_sp(GetFrameAtIndex(idx));
|
2012-02-29 11:40:22 +08:00
|
|
|
if (frame_sp) {
|
|
|
|
SetSelectedFrame(frame_sp.get());
|
|
|
|
return true;
|
|
|
|
} else
|
|
|
|
return false;
|
2011-09-09 06:13:49 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void StackFrameList::SetDefaultFileAndLineToSelectedFrame() {
|
2012-02-21 08:09:25 +08:00
|
|
|
if (m_thread.GetID() ==
|
|
|
|
m_thread.GetProcess()->GetThreadList().GetSelectedThread()->GetID()) {
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrameSP frame_sp(GetFrameAtIndex(GetSelectedFrameIndex()));
|
2011-09-09 06:13:49 +08:00
|
|
|
if (frame_sp) {
|
2011-10-05 11:14:31 +08:00
|
|
|
SymbolContext sc = frame_sp->GetSymbolContext(eSymbolContextLineEntry);
|
2011-09-09 06:13:49 +08:00
|
|
|
if (sc.line_entry.file)
|
2012-02-21 08:09:25 +08:00
|
|
|
m_thread.CalculateTarget()->GetSourceManager().SetDefaultFileAndLine(
|
2011-10-05 11:14:31 +08:00
|
|
|
sc.line_entry.file, sc.line_entry.line);
|
2011-09-09 06:13:49 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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() {
|
2016-05-19 13:13:57 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2010-08-28 02:24:16 +08:00
|
|
|
m_frames.clear();
|
2012-02-29 11:40:22 +08:00
|
|
|
m_concrete_frames_fetched = 0;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2013-11-04 17:33:30 +08:00
|
|
|
lldb::StackFrameSP
|
|
|
|
StackFrameList::GetStackFrameSPForStackFramePtr(StackFrame *stack_frame_ptr) {
|
2010-09-24 01:40:12 +08:00
|
|
|
const_iterator pos;
|
|
|
|
const_iterator begin = m_frames.begin();
|
|
|
|
const_iterator end = m_frames.end();
|
2013-11-04 17:33:30 +08:00
|
|
|
lldb::StackFrameSP ret_sp;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-09-24 01:40:12 +08:00
|
|
|
for (pos = begin; pos != end; ++pos) {
|
|
|
|
if (pos->get() == stack_frame_ptr) {
|
|
|
|
ret_sp = (*pos);
|
|
|
|
break;
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-09-24 01:40:12 +08:00
|
|
|
return ret_sp;
|
|
|
|
}
|
|
|
|
|
Centralized a lot of the status information for processes,
threads, and stack frame down in the lldb_private::Process,
lldb_private::Thread, lldb_private::StackFrameList and the
lldb_private::StackFrame classes. We had some command line
commands that had duplicate versions of the process status
output ("thread list" and "process status" for example).
Removed the "file" command and placed it where it should
have been: "target create". Made an alias for "file" to
"target create" so we stay compatible with GDB commands.
We can now have multple usable targets in lldb at the
same time. This is nice for comparing two runs of a program
or debugging more than one binary at the same time. The
new command is "target select <target-idx>" and also to see
a list of the current targets you can use the new "target list"
command. The flow in a debug session can be:
(lldb) target create /path/to/exe/a.out
(lldb) breakpoint set --name main
(lldb) run
... hit breakpoint
(lldb) target create /bin/ls
(lldb) run /tmp
Process 36001 exited with status = 0 (0x00000000)
(lldb) target list
Current targets:
target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
* target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) target select 0
Current targets:
* target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) bt
* thread #1: tid = 0x2d03, 0x0000000100000b9a a.out`main + 42 at main.c:16, stop reason = breakpoint 1.1
frame #0: 0x0000000100000b9a a.out`main + 42 at main.c:16
frame #1: 0x0000000100000b64 a.out`start + 52
Above we created a target for "a.out" and ran and hit a
breakpoint at "main". Then we created a new target for /bin/ls
and ran it. Then we listed the targest and selected our original
"a.out" program, so we showed two concurent debug sessions
going on at the same time.
llvm-svn: 129695
2011-04-18 16:33:37 +08:00
|
|
|
size_t StackFrameList::GetStatus(Stream &strm, uint32_t first_frame,
|
|
|
|
uint32_t num_frames, bool show_frame_info,
|
2013-10-19 01:38:31 +08:00
|
|
|
uint32_t num_frames_with_source,
|
2017-06-13 00:25:24 +08:00
|
|
|
bool show_unique,
|
2013-10-19 01:38:31 +08:00
|
|
|
const char *selected_frame_marker) {
|
Centralized a lot of the status information for processes,
threads, and stack frame down in the lldb_private::Process,
lldb_private::Thread, lldb_private::StackFrameList and the
lldb_private::StackFrame classes. We had some command line
commands that had duplicate versions of the process status
output ("thread list" and "process status" for example).
Removed the "file" command and placed it where it should
have been: "target create". Made an alias for "file" to
"target create" so we stay compatible with GDB commands.
We can now have multple usable targets in lldb at the
same time. This is nice for comparing two runs of a program
or debugging more than one binary at the same time. The
new command is "target select <target-idx>" and also to see
a list of the current targets you can use the new "target list"
command. The flow in a debug session can be:
(lldb) target create /path/to/exe/a.out
(lldb) breakpoint set --name main
(lldb) run
... hit breakpoint
(lldb) target create /bin/ls
(lldb) run /tmp
Process 36001 exited with status = 0 (0x00000000)
(lldb) target list
Current targets:
target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
* target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) target select 0
Current targets:
* target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) bt
* thread #1: tid = 0x2d03, 0x0000000100000b9a a.out`main + 42 at main.c:16, stop reason = breakpoint 1.1
frame #0: 0x0000000100000b9a a.out`main + 42 at main.c:16
frame #1: 0x0000000100000b64 a.out`start + 52
Above we created a target for "a.out" and ran and hit a
breakpoint at "main". Then we created a new target for /bin/ls
and ran it. Then we listed the targest and selected our original
"a.out" program, so we showed two concurent debug sessions
going on at the same time.
llvm-svn: 129695
2011-04-18 16:33:37 +08:00
|
|
|
size_t num_frames_displayed = 0;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
Centralized a lot of the status information for processes,
threads, and stack frame down in the lldb_private::Process,
lldb_private::Thread, lldb_private::StackFrameList and the
lldb_private::StackFrame classes. We had some command line
commands that had duplicate versions of the process status
output ("thread list" and "process status" for example).
Removed the "file" command and placed it where it should
have been: "target create". Made an alias for "file" to
"target create" so we stay compatible with GDB commands.
We can now have multple usable targets in lldb at the
same time. This is nice for comparing two runs of a program
or debugging more than one binary at the same time. The
new command is "target select <target-idx>" and also to see
a list of the current targets you can use the new "target list"
command. The flow in a debug session can be:
(lldb) target create /path/to/exe/a.out
(lldb) breakpoint set --name main
(lldb) run
... hit breakpoint
(lldb) target create /bin/ls
(lldb) run /tmp
Process 36001 exited with status = 0 (0x00000000)
(lldb) target list
Current targets:
target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
* target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) target select 0
Current targets:
* target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) bt
* thread #1: tid = 0x2d03, 0x0000000100000b9a a.out`main + 42 at main.c:16, stop reason = breakpoint 1.1
frame #0: 0x0000000100000b9a a.out`main + 42 at main.c:16
frame #1: 0x0000000100000b64 a.out`start + 52
Above we created a target for "a.out" and ran and hit a
breakpoint at "main". Then we created a new target for /bin/ls
and ran it. Then we listed the targest and selected our original
"a.out" program, so we showed two concurent debug sessions
going on at the same time.
llvm-svn: 129695
2011-04-18 16:33:37 +08:00
|
|
|
if (num_frames == 0)
|
|
|
|
return 0;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrameSP frame_sp;
|
Centralized a lot of the status information for processes,
threads, and stack frame down in the lldb_private::Process,
lldb_private::Thread, lldb_private::StackFrameList and the
lldb_private::StackFrame classes. We had some command line
commands that had duplicate versions of the process status
output ("thread list" and "process status" for example).
Removed the "file" command and placed it where it should
have been: "target create". Made an alias for "file" to
"target create" so we stay compatible with GDB commands.
We can now have multple usable targets in lldb at the
same time. This is nice for comparing two runs of a program
or debugging more than one binary at the same time. The
new command is "target select <target-idx>" and also to see
a list of the current targets you can use the new "target list"
command. The flow in a debug session can be:
(lldb) target create /path/to/exe/a.out
(lldb) breakpoint set --name main
(lldb) run
... hit breakpoint
(lldb) target create /bin/ls
(lldb) run /tmp
Process 36001 exited with status = 0 (0x00000000)
(lldb) target list
Current targets:
target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
* target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) target select 0
Current targets:
* target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) bt
* thread #1: tid = 0x2d03, 0x0000000100000b9a a.out`main + 42 at main.c:16, stop reason = breakpoint 1.1
frame #0: 0x0000000100000b9a a.out`main + 42 at main.c:16
frame #1: 0x0000000100000b64 a.out`start + 52
Above we created a target for "a.out" and ran and hit a
breakpoint at "main". Then we created a new target for /bin/ls
and ran it. Then we listed the targest and selected our original
"a.out" program, so we showed two concurent debug sessions
going on at the same time.
llvm-svn: 129695
2011-04-18 16:33:37 +08:00
|
|
|
uint32_t frame_idx = 0;
|
|
|
|
uint32_t last_frame;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
Centralized a lot of the status information for processes,
threads, and stack frame down in the lldb_private::Process,
lldb_private::Thread, lldb_private::StackFrameList and the
lldb_private::StackFrame classes. We had some command line
commands that had duplicate versions of the process status
output ("thread list" and "process status" for example).
Removed the "file" command and placed it where it should
have been: "target create". Made an alias for "file" to
"target create" so we stay compatible with GDB commands.
We can now have multple usable targets in lldb at the
same time. This is nice for comparing two runs of a program
or debugging more than one binary at the same time. The
new command is "target select <target-idx>" and also to see
a list of the current targets you can use the new "target list"
command. The flow in a debug session can be:
(lldb) target create /path/to/exe/a.out
(lldb) breakpoint set --name main
(lldb) run
... hit breakpoint
(lldb) target create /bin/ls
(lldb) run /tmp
Process 36001 exited with status = 0 (0x00000000)
(lldb) target list
Current targets:
target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
* target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) target select 0
Current targets:
* target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) bt
* thread #1: tid = 0x2d03, 0x0000000100000b9a a.out`main + 42 at main.c:16, stop reason = breakpoint 1.1
frame #0: 0x0000000100000b9a a.out`main + 42 at main.c:16
frame #1: 0x0000000100000b64 a.out`start + 52
Above we created a target for "a.out" and ran and hit a
breakpoint at "main". Then we created a new target for /bin/ls
and ran it. Then we listed the targest and selected our original
"a.out" program, so we showed two concurent debug sessions
going on at the same time.
llvm-svn: 129695
2011-04-18 16:33:37 +08:00
|
|
|
// Don't let the last frame wrap around...
|
|
|
|
if (num_frames == UINT32_MAX)
|
|
|
|
last_frame = UINT32_MAX;
|
|
|
|
else
|
|
|
|
last_frame = first_frame + num_frames;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrameSP selected_frame_sp = m_thread.GetSelectedFrame();
|
2016-02-19 02:52:47 +08:00
|
|
|
const char *unselected_marker = nullptr;
|
2013-10-19 01:38:31 +08:00
|
|
|
std::string buffer;
|
|
|
|
if (selected_frame_marker) {
|
|
|
|
size_t len = strlen(selected_frame_marker);
|
|
|
|
buffer.insert(buffer.begin(), len, ' ');
|
|
|
|
unselected_marker = buffer.c_str();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2016-02-19 02:52:47 +08:00
|
|
|
const char *marker = nullptr;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
Centralized a lot of the status information for processes,
threads, and stack frame down in the lldb_private::Process,
lldb_private::Thread, lldb_private::StackFrameList and the
lldb_private::StackFrame classes. We had some command line
commands that had duplicate versions of the process status
output ("thread list" and "process status" for example).
Removed the "file" command and placed it where it should
have been: "target create". Made an alias for "file" to
"target create" so we stay compatible with GDB commands.
We can now have multple usable targets in lldb at the
same time. This is nice for comparing two runs of a program
or debugging more than one binary at the same time. The
new command is "target select <target-idx>" and also to see
a list of the current targets you can use the new "target list"
command. The flow in a debug session can be:
(lldb) target create /path/to/exe/a.out
(lldb) breakpoint set --name main
(lldb) run
... hit breakpoint
(lldb) target create /bin/ls
(lldb) run /tmp
Process 36001 exited with status = 0 (0x00000000)
(lldb) target list
Current targets:
target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
* target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) target select 0
Current targets:
* target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) bt
* thread #1: tid = 0x2d03, 0x0000000100000b9a a.out`main + 42 at main.c:16, stop reason = breakpoint 1.1
frame #0: 0x0000000100000b9a a.out`main + 42 at main.c:16
frame #1: 0x0000000100000b64 a.out`start + 52
Above we created a target for "a.out" and ran and hit a
breakpoint at "main". Then we created a new target for /bin/ls
and ran it. Then we listed the targest and selected our original
"a.out" program, so we showed two concurent debug sessions
going on at the same time.
llvm-svn: 129695
2011-04-18 16:33:37 +08:00
|
|
|
for (frame_idx = first_frame; frame_idx < last_frame; ++frame_idx) {
|
|
|
|
frame_sp = GetFrameAtIndex(frame_idx);
|
2016-02-19 02:52:47 +08:00
|
|
|
if (!frame_sp)
|
2016-09-07 04:57:50 +08:00
|
|
|
break;
|
|
|
|
|
2016-02-19 02:52:47 +08:00
|
|
|
if (selected_frame_marker != nullptr) {
|
2013-10-19 01:38:31 +08:00
|
|
|
if (frame_sp == selected_frame_sp)
|
|
|
|
marker = selected_frame_marker;
|
2016-09-07 04:57:50 +08:00
|
|
|
else
|
2013-10-19 01:38:31 +08:00
|
|
|
marker = unselected_marker;
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
Centralized a lot of the status information for processes,
threads, and stack frame down in the lldb_private::Process,
lldb_private::Thread, lldb_private::StackFrameList and the
lldb_private::StackFrame classes. We had some command line
commands that had duplicate versions of the process status
output ("thread list" and "process status" for example).
Removed the "file" command and placed it where it should
have been: "target create". Made an alias for "file" to
"target create" so we stay compatible with GDB commands.
We can now have multple usable targets in lldb at the
same time. This is nice for comparing two runs of a program
or debugging more than one binary at the same time. The
new command is "target select <target-idx>" and also to see
a list of the current targets you can use the new "target list"
command. The flow in a debug session can be:
(lldb) target create /path/to/exe/a.out
(lldb) breakpoint set --name main
(lldb) run
... hit breakpoint
(lldb) target create /bin/ls
(lldb) run /tmp
Process 36001 exited with status = 0 (0x00000000)
(lldb) target list
Current targets:
target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
* target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) target select 0
Current targets:
* target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) bt
* thread #1: tid = 0x2d03, 0x0000000100000b9a a.out`main + 42 at main.c:16, stop reason = breakpoint 1.1
frame #0: 0x0000000100000b9a a.out`main + 42 at main.c:16
frame #1: 0x0000000100000b64 a.out`start + 52
Above we created a target for "a.out" and ran and hit a
breakpoint at "main". Then we created a new target for /bin/ls
and ran it. Then we listed the targest and selected our original
"a.out" program, so we showed two concurent debug sessions
going on at the same time.
llvm-svn: 129695
2011-04-18 16:33:37 +08:00
|
|
|
if (!frame_sp->GetStatus(strm, show_frame_info,
|
|
|
|
num_frames_with_source > (first_frame - frame_idx),
|
2017-06-13 00:25:24 +08:00
|
|
|
show_unique, marker))
|
Centralized a lot of the status information for processes,
threads, and stack frame down in the lldb_private::Process,
lldb_private::Thread, lldb_private::StackFrameList and the
lldb_private::StackFrame classes. We had some command line
commands that had duplicate versions of the process status
output ("thread list" and "process status" for example).
Removed the "file" command and placed it where it should
have been: "target create". Made an alias for "file" to
"target create" so we stay compatible with GDB commands.
We can now have multple usable targets in lldb at the
same time. This is nice for comparing two runs of a program
or debugging more than one binary at the same time. The
new command is "target select <target-idx>" and also to see
a list of the current targets you can use the new "target list"
command. The flow in a debug session can be:
(lldb) target create /path/to/exe/a.out
(lldb) breakpoint set --name main
(lldb) run
... hit breakpoint
(lldb) target create /bin/ls
(lldb) run /tmp
Process 36001 exited with status = 0 (0x00000000)
(lldb) target list
Current targets:
target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
* target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) target select 0
Current targets:
* target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) bt
* thread #1: tid = 0x2d03, 0x0000000100000b9a a.out`main + 42 at main.c:16, stop reason = breakpoint 1.1
frame #0: 0x0000000100000b9a a.out`main + 42 at main.c:16
frame #1: 0x0000000100000b64 a.out`start + 52
Above we created a target for "a.out" and ran and hit a
breakpoint at "main". Then we created a new target for /bin/ls
and ran it. Then we listed the targest and selected our original
"a.out" program, so we showed two concurent debug sessions
going on at the same time.
llvm-svn: 129695
2011-04-18 16:33:37 +08:00
|
|
|
break;
|
|
|
|
++num_frames_displayed;
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
Centralized a lot of the status information for processes,
threads, and stack frame down in the lldb_private::Process,
lldb_private::Thread, lldb_private::StackFrameList and the
lldb_private::StackFrame classes. We had some command line
commands that had duplicate versions of the process status
output ("thread list" and "process status" for example).
Removed the "file" command and placed it where it should
have been: "target create". Made an alias for "file" to
"target create" so we stay compatible with GDB commands.
We can now have multple usable targets in lldb at the
same time. This is nice for comparing two runs of a program
or debugging more than one binary at the same time. The
new command is "target select <target-idx>" and also to see
a list of the current targets you can use the new "target list"
command. The flow in a debug session can be:
(lldb) target create /path/to/exe/a.out
(lldb) breakpoint set --name main
(lldb) run
... hit breakpoint
(lldb) target create /bin/ls
(lldb) run /tmp
Process 36001 exited with status = 0 (0x00000000)
(lldb) target list
Current targets:
target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
* target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) target select 0
Current targets:
* target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) bt
* thread #1: tid = 0x2d03, 0x0000000100000b9a a.out`main + 42 at main.c:16, stop reason = breakpoint 1.1
frame #0: 0x0000000100000b9a a.out`main + 42 at main.c:16
frame #1: 0x0000000100000b64 a.out`start + 52
Above we created a target for "a.out" and ran and hit a
breakpoint at "main". Then we created a new target for /bin/ls
and ran it. Then we listed the targest and selected our original
"a.out" program, so we showed two concurent debug sessions
going on at the same time.
llvm-svn: 129695
2011-04-18 16:33:37 +08:00
|
|
|
strm.IndentLess();
|
|
|
|
return num_frames_displayed;
|
|
|
|
}
|