mirror of
https://github.com/intel/llvm.git
synced 2026-01-13 19:08:21 +08:00
8b3af63b89
A lot of comments in LLDB are surrounded by an ASCII line to delimit the begging and end of the comment. Its use is not really consistent across the code base, sometimes the lines are longer, sometimes they are shorter and sometimes they are omitted. Furthermore, it looks kind of weird with the 80 column limit, where the comment actually extends past the line, but not by much. Furthermore, when /// is used for Doxygen comments, it looks particularly odd. And when // is used, it incorrectly gives the impression that it's actually a Doxygen comment. I assume these lines were added to improve distinguishing between comments and code. However, given that todays editors and IDEs do a great job at highlighting comments, I think it's worth to drop this for the sake of consistency. The alternative is fixing all the inconsistencies, which would create a lot more churn. Differential revision: https://reviews.llvm.org/D60508 llvm-svn: 358135
98 lines
3.3 KiB
C++
98 lines
3.3 KiB
C++
//===-- ThreadPlanCallOnFunctionExit.cpp ------------------------*- C++ -*-===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Target/ThreadPlanCallOnFunctionExit.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
ThreadPlanCallOnFunctionExit::ThreadPlanCallOnFunctionExit(
|
|
Thread &thread, const Callback &callback)
|
|
: ThreadPlan(ThreadPlanKind::eKindGeneric, "CallOnFunctionExit", thread,
|
|
eVoteNoOpinion, eVoteNoOpinion // TODO check with Jim on these
|
|
),
|
|
m_callback(callback) {
|
|
// We are not a user-generated plan.
|
|
SetIsMasterPlan(false);
|
|
}
|
|
|
|
void ThreadPlanCallOnFunctionExit::DidPush() {
|
|
// We now want to queue the "step out" thread plan so it executes and
|
|
// completes.
|
|
|
|
// Set stop vote to eVoteNo.
|
|
Status status;
|
|
m_step_out_threadplan_sp = GetThread().QueueThreadPlanForStepOut(
|
|
false, // abort other plans
|
|
nullptr, // addr_context
|
|
true, // first instruction
|
|
true, // stop other threads
|
|
eVoteNo, // do not say "we're stopping"
|
|
eVoteNoOpinion, // don't care about run state broadcasting
|
|
0, // frame_idx
|
|
status, // status
|
|
eLazyBoolCalculate // avoid code w/o debinfo
|
|
);
|
|
}
|
|
|
|
// ThreadPlan API
|
|
|
|
void ThreadPlanCallOnFunctionExit::GetDescription(
|
|
Stream *s, lldb::DescriptionLevel level) {
|
|
if (!s)
|
|
return;
|
|
s->Printf("Running until completion of current function, then making "
|
|
"callback.");
|
|
}
|
|
|
|
bool ThreadPlanCallOnFunctionExit::ValidatePlan(Stream *error) {
|
|
// We'll say we're always good since I don't know what would make this
|
|
// invalid.
|
|
return true;
|
|
}
|
|
|
|
bool ThreadPlanCallOnFunctionExit::ShouldStop(Event *event_ptr) {
|
|
// If this is where we find out that an internal stop came in, then: Check if
|
|
// the step-out plan completed. If it did, then we want to run the callback
|
|
// here (our reason for living...)
|
|
if (m_step_out_threadplan_sp && m_step_out_threadplan_sp->IsPlanComplete()) {
|
|
m_callback();
|
|
|
|
// We no longer need the pointer to the step-out thread plan.
|
|
m_step_out_threadplan_sp.reset();
|
|
|
|
// Indicate that this plan is done and can be discarded.
|
|
SetPlanComplete();
|
|
|
|
// We're done now, but we want to return false so that we don't cause the
|
|
// thread to really stop.
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ThreadPlanCallOnFunctionExit::WillStop() {
|
|
// The code looks like the return value is ignored via ThreadList::
|
|
// ShouldStop(). This is called when we really are going to stop. We don't
|
|
// care and don't need to do anything here.
|
|
return false;
|
|
}
|
|
|
|
bool ThreadPlanCallOnFunctionExit::DoPlanExplainsStop(Event *event_ptr) {
|
|
// We don't ever explain a stop. The only stop that is relevant to us
|
|
// directly is the step_out plan we added to do the heavy lifting of getting
|
|
// us past the current method.
|
|
return false;
|
|
}
|
|
|
|
lldb::StateType ThreadPlanCallOnFunctionExit::GetPlanRunState() {
|
|
// This value doesn't matter - we'll never be the top thread plan, so nobody
|
|
// will ask us this question.
|
|
return eStateRunning;
|
|
}
|