maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Revert "[lldb/Target] Add Assert StackFrame Recognizer" 

This reverts commit 03a6b858fd.

The test doesn't pass on Debian.
This commit is contained in:
Med Ismail Bennani 2020-01-28 18:40:08 +01:00
parent ac9b2a6297
commit 954d04295b
17 changed files with 21 additions and 380 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lldb/docs/use/formatting.rst
View File

@ -134,9 +134,7 @@ A complete list of currently supported format string variables is listed below:
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``thread.queue`` | The queue name of the thread if the target OS supports dispatch queues |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``thread.stop-reason`` | A textual reason why the thread stopped. If the thread have a recognized frame, this displays its recognized stop reason. Otherwise, gets the stop info description. |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``thread.stop-reason-raw`` | A textual reason why the thread stopped. Always returns stop info description. |
| ``thread.stop-reason`` | A textual reason each thread stopped |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``thread.return-value`` | The return value of the latest step operation (currently only for step-out.) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

1
lldb/include/lldb/Core/FormatEntity.h
View File

@ -61,7 +61,6 @@ public:
ThreadName,
ThreadQueue,
ThreadStopReason,
ThreadStopReasonRaw,
ThreadReturnValue,
ThreadCompletedExpression,
ScriptThread,

55
lldb/include/lldb/Target/AssertFrameRecognizer.h
View File

@ -1,55 +0,0 @@
//===-- AssertFrameRecognizer.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
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_AssertFrameRecognizer_h_
#define liblldb_AssertFrameRecognizer_h_
#include "lldb/Target/Process.h"
#include "lldb/Target/StackFrameRecognizer.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/FileSpec.h"
#include <tuple>
namespace lldb_private {
/// Registers the assert stack frame recognizer.
///
/// \param[in] process
/// The process that is currently asserting. This will give us information on
/// the target and the platform.
void RegisterAssertFrameRecognizer(Process *process);
/// \class AssertRecognizedStackFrame
///
/// Holds the stack frame where the assert is called from.
class AssertRecognizedStackFrame : public RecognizedStackFrame {
public:
AssertRecognizedStackFrame(lldb::StackFrameSP most_relevant_frame_sp);
lldb::StackFrameSP GetMostRelevantFrame() override;
llvm::StringRef GetStopDescription() override;
private:
lldb::StackFrameSP m_most_relevant_frame;
};
/// \class AssertFrameRecognizer
///
/// When a thread stops, it checks depending on the platform if the top frame is
/// an abort stack frame. If so, it looks for an assert stack frame in the upper
/// frames and set it as the most relavant frame when found.
class AssertFrameRecognizer : public StackFrameRecognizer {
public:
std::string GetName() override { return "Assert StackFrame Recognizer"; }
lldb::RecognizedStackFrameSP
RecognizeFrame(lldb::StackFrameSP frame_sp) override;
};
} // namespace lldb_private
#endif // liblldb_AssertFrameRecognizer_h_

3
lldb/include/lldb/Target/StackFrameRecognizer.h
View File

@ -12,7 +12,6 @@
#include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectList.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/StopInfo.h"
#include "lldb/Utility/StructuredData.h"
#include "lldb/lldb-private-forward.h"
#include "lldb/lldb-public.h"
@ -34,8 +33,6 @@ public:
virtual lldb::ValueObjectSP GetExceptionObject() {
return lldb::ValueObjectSP();
}
virtual lldb::StackFrameSP GetMostRelevantFrame() { return nullptr; };
virtual llvm::StringRef GetStopDescription() { return ""; }
virtual ~RecognizedStackFrame(){};
protected:

6
lldb/include/lldb/Target/Thread.h
View File

@ -216,12 +216,6 @@ public:
virtual void RefreshStateAfterStop() = 0;
void SelectMostRelevantFrame();
llvm::StringRef GetStopDescription();
llvm::StringRef GetStopDescriptionRaw();
void WillStop();
bool ShouldStop(Event *event_ptr);

29
lldb/packages/Python/lldbsuite/test/functionalities/inferior-assert/TestInferiorAssert.py
View File

@ -104,13 +104,12 @@ class AssertingInferiorTestCase(TestBase):
def check_stop_reason(self):
matched = lldbplatformutil.match_android_device(
self.getArchitecture(), valid_api_levels=list(range(1, 16 + 1)))
target = self.dbg.GetTargetAtIndex(0)
process = target.GetProcess()
thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal)
stop_reason = 'stop reason = ' + thread.GetStopDescription(256)
if matched:
# On android until API-16 the abort() call ended in a sigsegv
# instead of in a sigabrt
stop_reason = 'stop reason = signal SIGSEGV'
else:
stop_reason = 'stop reason = signal SIGABRT'
# The stop reason of the thread should be an abort signal or exception.
self.expect("thread list", STOPPED_DUE_TO_ASSERT,
@ -174,22 +173,6 @@ class AssertingInferiorTestCase(TestBase):
self.runCmd("run", RUN_SUCCEEDED)
self.check_stop_reason()
# change current frame to frame 0, since recognizer might have selected
# different frame.
target = self.dbg.GetTargetAtIndex(0)
self.assertTrue(target, VALID_TARGET)
process = target.GetProcess()
self.assertTrue(process.IsValid(), "current process is valid")
thread = process.GetSelectedThread()
self.assertTrue(thread.IsValid(), "current thread is valid")
thread.SetSelectedFrame(0)
frame = thread.GetSelectedFrame()
self.assertTrue(thread.GetFrameAtIndex(0) == frame, "Frame #0 selected")
# lldb should be able to read from registers from the inferior after
# asserting.
lldbplatformutil.check_first_register_readable(self)

4
lldb/packages/Python/lldbsuite/test/lang/objc/exceptions/TestObjCExceptions.py
View File

@ -25,8 +25,8 @@ class ObjCExceptionsTestCase(TestBase):
launch_info = lldb.SBLaunchInfo(["a.out", "0"])
lldbutil.run_to_name_breakpoint(self, "objc_exception_throw", launch_info=launch_info)
self.expect("thread list",
substrs=['stopped', 'stop reason = hit Objective-C exception'])
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint'])
self.expect('thread exception', substrs=[
'(NSException *) exception = ',

3
lldb/source/API/SBThread.cpp
View File

@ -325,8 +325,7 @@ size_t SBThread::GetStopDescription(char *dst, size_t dst_len) {
StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo();
if (stop_info_sp) {
const char *stop_desc =
exe_ctx.GetThreadPtr()->GetStopDescription().data();
const char *stop_desc = stop_info_sp->GetDescription();
if (stop_desc) {
if (dst)
return ::snprintf(dst, dst_len, "%s", stop_desc);

28
lldb/source/Core/FormatEntity.cpp
View File

@ -166,7 +166,6 @@ static FormatEntity::Entry::Definition g_thread_child_entries[] = {
ENTRY("queue", ThreadQueue),
ENTRY("name", ThreadName),
ENTRY("stop-reason", ThreadStopReason),
ENTRY("stop-reason-raw", ThreadStopReasonRaw),
ENTRY("return-value", ThreadReturnValue),
ENTRY("completed-expression", ThreadCompletedExpression),
};
@ -329,7 +328,6 @@ const char *FormatEntity::Entry::TypeToCString(Type t) {
ENUM_TO_CSTR(ThreadName);
ENUM_TO_CSTR(ThreadQueue);
ENUM_TO_CSTR(ThreadStopReason);
ENUM_TO_CSTR(ThreadStopReasonRaw);
ENUM_TO_CSTR(ThreadReturnValue);
ENUM_TO_CSTR(ThreadCompletedExpression);
ENUM_TO_CSTR(ScriptThread);
@ -1275,23 +1273,15 @@ bool FormatEntity::Format(const Entry &entry, Stream &s,
case Entry::Type::ThreadStopReason:
if (exe_ctx) {
if (Thread *thread = exe_ctx->GetThreadPtr()) {
llvm::StringRef stop_description = thread->GetStopDescription();
if (!stop_description.empty()) {
s.PutCString(stop_description);
return true;
}
}
}
return false;
case Entry::Type::ThreadStopReasonRaw:
if (exe_ctx) {
if (Thread *thread = exe_ctx->GetThreadPtr()) {
llvm::StringRef stop_description = thread->GetStopDescriptionRaw();
if (!stop_description.empty()) {
s.PutCString(stop_description);
return true;
Thread *thread = exe_ctx->GetThreadPtr();
if (thread) {
StopInfoSP stop_info_sp = thread->GetStopInfo();
if (stop_info_sp && stop_info_sp->IsValid()) {
const char *cstr = stop_info_sp->GetDescription();
if (cstr && cstr[0]) {
s.PutCString(cstr);
return true;
}
}
}
}

4
lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp
View File

@ -2673,10 +2673,6 @@ class ObjCExceptionRecognizedStackFrame : public RecognizedStackFrame {
ValueObjectSP exception;
lldb::ValueObjectSP GetExceptionObject() override { return exception; }
llvm::StringRef GetStopDescription() override {
return "hit Objective-C exception";
}
};
class ObjCExceptionThrowFrameRecognizer : public StackFrameRecognizer {

173
lldb/source/Target/AssertFrameRecognizer.cpp
View File

@ -1,173 +0,0 @@
#include "lldb/Core/Module.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/StackFrameList.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Logging.h"
#include "lldb/Target/AssertFrameRecognizer.h"
using namespace llvm;
using namespace lldb;
using namespace lldb_private;
namespace lldb_private {
/// Fetches the abort frame location depending on the current platform.
///
/// \param[in] process_sp
/// The process that is currently aborting. This will give us information on
/// the target and the platform.
/// \return
/// If the platform is supported, returns an optional tuple containing
/// the abort module as a \a FileSpec and the symbol name as a \a StringRef.
/// Otherwise, returns \a llvm::None.
llvm::Optional<std::tuple<FileSpec, StringRef>>
GetAbortLocation(Process *process) {
Target &target = process->GetTarget();
StringRef module_name;
StringRef symbol_name;
switch (target.GetArchitecture().GetTriple().getOS()) {
case llvm::Triple::Darwin:
case llvm::Triple::MacOSX:
module_name = "libsystem_kernel.dylib";
symbol_name = "__pthread_kill";
break;
case llvm::Triple::Linux:
module_name = "libc.so.6";
symbol_name = "__GI_raise";
break;
default:
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
LLDB_LOG(log, "AssertFrameRecognizer::GetAbortLocation Unsupported OS");
return llvm::None;
}
return std::make_tuple(FileSpec(module_name), symbol_name);
}
/// Fetches the assert frame location depending on the current platform.
///
/// \param[in] process_sp
/// The process that is currently asserting. This will give us information on
/// the target and the platform.
/// \return
/// If the platform is supported, returns an optional tuple containing
/// the asserting frame module as a \a FileSpec and the symbol name as a \a
/// StringRef.
/// Otherwise, returns \a llvm::None.
llvm::Optional<std::tuple<FileSpec, StringRef>>
GetAssertLocation(Process *process) {
Target &target = process->GetTarget();
StringRef module_name;
StringRef symbol_name;
switch (target.GetArchitecture().GetTriple().getOS()) {
case llvm::Triple::Darwin:
case llvm::Triple::MacOSX:
module_name = "libsystem_c.dylib";
symbol_name = "__assert_rtn";
break;
case llvm::Triple::Linux:
module_name = "libc.so.6";
symbol_name = "__GI___assert_fail";
break;
default:
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
LLDB_LOG(log, "AssertFrameRecognizer::GetAbortLocation Unsupported OS");
return llvm::None;
}
return std::make_tuple(FileSpec(module_name), symbol_name);
}
void RegisterAssertFrameRecognizer(Process *process) {
static llvm::once_flag g_once_flag;
llvm::call_once(g_once_flag, [process]() {
auto abort_location = GetAbortLocation(process);
if (!abort_location.hasValue())
return;
FileSpec module_spec;
StringRef function_name;
std::tie(module_spec, function_name) = *abort_location;
StackFrameRecognizerManager::AddRecognizer(
StackFrameRecognizerSP(new AssertFrameRecognizer()),
module_spec.GetFilename(), ConstString(function_name), false);
});
}
} // namespace lldb_private
AssertRecognizedStackFrame::AssertRecognizedStackFrame(
StackFrameSP most_relevant_frame_sp)
: m_most_relevant_frame(most_relevant_frame_sp) {}
lldb::RecognizedStackFrameSP
AssertFrameRecognizer::RecognizeFrame(lldb::StackFrameSP frame_sp) {
ThreadSP thread_sp = frame_sp->GetThread();
ProcessSP process_sp = thread_sp->GetProcess();
auto assert_location = GetAssertLocation(process_sp.get());
if (!assert_location.hasValue())
return RecognizedStackFrameSP();
FileSpec module_spec;
StringRef function_name;
std::tie(module_spec, function_name) = *assert_location;
const uint32_t frames_to_fetch = 5;
const uint32_t last_frame_index = frames_to_fetch - 1;
StackFrameSP prev_frame_sp = nullptr;
// Fetch most relevant frame
for (uint32_t frame_index = 0; frame_index < frames_to_fetch; frame_index++) {
prev_frame_sp = thread_sp->GetStackFrameAtIndex(frame_index);
if (!prev_frame_sp) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
LLDB_LOG(log, "Abort Recognizer: Hit unwinding bound ({1} frames)!",
frames_to_fetch);
break;
}
SymbolContext sym_ctx =
prev_frame_sp->GetSymbolContext(eSymbolContextEverything);
if (sym_ctx.module_sp->GetFileSpec().FileEquals(module_spec) &&
sym_ctx.GetFunctionName() == ConstString(function_name)) {
// We go a frame beyond the assert location because the most relevant
// frame for the user is the one in which the assert function was called.
// If the assert location is the last frame fetched, then it is set as
// the most relevant frame.
StackFrameSP most_relevant_frame_sp = thread_sp->GetStackFrameAtIndex(
std::min(frame_index + 1, last_frame_index));
// Pass assert location to AbortRecognizedStackFrame to set as most
// relevant frame.
return lldb::RecognizedStackFrameSP(
new AssertRecognizedStackFrame(most_relevant_frame_sp));
}
}
return RecognizedStackFrameSP();
};
lldb::StackFrameSP AssertRecognizedStackFrame::GetMostRelevantFrame() {
return m_most_relevant_frame;
}
llvm::StringRef AssertRecognizedStackFrame::GetStopDescription() {
return "hit program assert";
}

1
lldb/source/Target/CMakeLists.txt
View File

@ -8,7 +8,6 @@ lldb_tablegen(TargetPropertiesEnum.inc -gen-lldb-property-enum-defs
add_lldb_library(lldbTarget
ABI.cpp
AssertFrameRecognizer.cpp
ExecutionContext.cpp
InstrumentationRuntime.cpp
InstrumentationRuntimeStopInfo.cpp

11
lldb/source/Target/Process.cpp
View File

@ -38,7 +38,6 @@
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Target/ABI.h"
#include "lldb/Target/AssertFrameRecognizer.h"
#include "lldb/Target/DynamicLoader.h"
#include "lldb/Target/InstrumentationRuntime.h"
#include "lldb/Target/JITLoader.h"
@ -539,8 +538,6 @@ Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp,
target_sp->GetPlatform()->GetDefaultMemoryCacheLineSize();
if (!value_sp->OptionWasSet() && platform_cache_line_size != 0)
value_sp->SetUInt64Value(platform_cache_line_size);
RegisterAssertFrameRecognizer(this);
}
Process::~Process() {
@ -937,17 +934,11 @@ bool Process::HandleProcessStateChangedEvent(const EventSP &event_sp,
Debugger &debugger = process_sp->GetTarget().GetDebugger();
if (debugger.GetTargetList().GetSelectedTarget().get() ==
&process_sp->GetTarget()) {
ThreadSP thread_sp = process_sp->GetThreadList().GetSelectedThread();
if (!thread_sp || !thread_sp->IsValid())
return false;
const bool only_threads_with_stop_reason = true;
const uint32_t start_frame = thread_sp->GetSelectedFrameIndex();
const uint32_t start_frame = 0;
const uint32_t num_frames = 1;
const uint32_t num_frames_with_source = 1;
const bool stop_format = true;
process_sp->GetStatus(*stream);
process_sp->GetThreadStatus(*stream, only_threads_with_stop_reason,
start_frame, num_frames,

2
lldb/source/Target/StackFrameRecognizer.cpp
View File

@ -92,7 +92,7 @@ public:
StackFrameRecognizerSP GetRecognizerForFrame(StackFrameSP frame) {
const SymbolContext &symctx =
frame->GetSymbolContext(eSymbolContextEverything);
frame->GetSymbolContext(eSymbolContextModule | eSymbolContextFunction);
ConstString function_name = symctx.GetFunctionName();
ModuleSP module_sp = symctx.module_sp;
if (!module_sp) return StackFrameRecognizerSP();

55
lldb/source/Target/Thread.cpp
View File

@ -573,64 +573,9 @@ void Thread::SetState(StateType state) {
m_state = state;
}
llvm::StringRef Thread::GetStopDescription() {
StackFrameSP frame_sp = GetStackFrameAtIndex(0);
if (!frame_sp)
return GetStopDescriptionRaw();
auto recognized_frame_sp = frame_sp->GetRecognizedFrame();
if (!recognized_frame_sp)
return GetStopDescriptionRaw();
llvm::StringRef recognized_stop_description =
recognized_frame_sp->GetStopDescription();
if (!recognized_stop_description.empty())
return recognized_stop_description;
return GetStopDescriptionRaw();
}
llvm::StringRef Thread::GetStopDescriptionRaw() {
StopInfoSP stop_info_sp = GetStopInfo();
llvm::StringRef raw_stop_description;
if (stop_info_sp && stop_info_sp->IsValid())
raw_stop_description = stop_info_sp->GetDescription();
return raw_stop_description;
}
void Thread::SelectMostRelevantFrame() {
Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD);
auto frames_list_sp = GetStackFrameList();
// Only the top frame should be recognized.
auto frame_sp = frames_list_sp->GetFrameAtIndex(0);
auto recognized_frame_sp = frame_sp->GetRecognizedFrame();
if (!recognized_frame_sp) {
LLDB_LOG(log, "Frame #0 not recognized");
return;
}
if (StackFrameSP most_relevant_frame_sp =
recognized_frame_sp->GetMostRelevantFrame()) {
LLDB_LOG(log, "Found most relevant frame at index {0}",
most_relevant_frame_sp->GetFrameIndex());
SetSelectedFrame(most_relevant_frame_sp.get());
} else {
LLDB_LOG(log, "No relevant frame!");
}
}
void Thread::WillStop() {
ThreadPlan *current_plan = GetCurrentPlan();
SelectMostRelevantFrame();
// FIXME: I may decide to disallow threads with no plans. In which
// case this should go to an assert.

9
lldb/test/Shell/Recognizer/Inputs/assert.c
View File

@ -1,9 +0,0 @@
#include <assert.h>
int main() {
int a = 42;
assert(a == 42);
a--;
assert(a == 42);
return 0;
}

13
lldb/test/Shell/Recognizer/assert.test
View File

@ -1,13 +0,0 @@
# UNSUPPORTED: system-windows
# RUN: %clang_host -g -O0 %S/Inputs/assert.c -o %t.out
# RUN: %lldb -b -s %s %t.out | FileCheck %s
run
# CHECK: thread #{{.*}}stop reason = hit program assert
frame info
# CHECK: frame #{{.*}}`main at assert.c
frame recognizer info 0
# CHECK: frame 0 is recognized by Assert StackFrame Recognizer
set set thread-format "{${thread.stop-reason-raw}}\n"
thread info
# CHECK: signal SIGABRT
q