caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
4b2f3269ab4103e1acdc94de09058856a75d1434
clang-p2996/lldb/source/Plugins/InstrumentationRuntime/ThreadSanitizer/ThreadSanitizerRuntime.cpp
Zachary Turner 97206d5727 Rename Error -> Status. 
This renames the LLDB error class to Status, as discussed
on the lldb-dev mailing list.

A change of this magnitude cannot easily be done without
find and replace, but that has potential to catch unwanted
occurrences of common strings such as "Error".  Every effort
was made to find all the obvious things such as the word "Error"
appearing in a string, etc, but it's possible there are still
some lingering occurences left around.  Hopefully nothing too
serious.

llvm-svn: 302872
2017-05-12 04:51:55 +00:00

1072 lines
39 KiB
C++
Raw Blame History

//===-- ThreadSanitizerRuntime.cpp ------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "ThreadSanitizerRuntime.h"
#include "Plugins/Process/Utility/HistoryThread.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/PluginInterface.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Expression/UserExpression.h"
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/Variable.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/InstrumentationRuntimeStopInfo.h"
#include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Stream.h"
using namespace lldb;
using namespace lldb_private;
lldb::InstrumentationRuntimeSP
ThreadSanitizerRuntime::CreateInstance(const lldb::ProcessSP &process_sp) {
return InstrumentationRuntimeSP(new ThreadSanitizerRuntime(process_sp));
}
void ThreadSanitizerRuntime::Initialize() {
PluginManager::RegisterPlugin(
GetPluginNameStatic(), "ThreadSanitizer instrumentation runtime plugin.",
CreateInstance, GetTypeStatic);
}
void ThreadSanitizerRuntime::Terminate() {
PluginManager::UnregisterPlugin(CreateInstance);
}
lldb_private::ConstString ThreadSanitizerRuntime::GetPluginNameStatic() {
return ConstString("ThreadSanitizer");
}
lldb::InstrumentationRuntimeType ThreadSanitizerRuntime::GetTypeStatic() {
return eInstrumentationRuntimeTypeThreadSanitizer;
}
ThreadSanitizerRuntime::~ThreadSanitizerRuntime() { Deactivate(); }
static constexpr std::chrono::seconds g_retrieve_data_function_timeout(2);
const char *thread_sanitizer_retrieve_report_data_prefix = R"(
extern "C"
{
void *__tsan_get_current_report();
int __tsan_get_report_data(void *report, const char **description, int *count,
int *stack_count, int *mop_count, int *loc_count,
int *mutex_count, int *thread_count,
int *unique_tid_count, void **sleep_trace,
unsigned long trace_size);
int __tsan_get_report_stack(void *report, unsigned long idx, void **trace,
unsigned long trace_size);
int __tsan_get_report_mop(void *report, unsigned long idx, int *tid, void **addr,
int *size, int *write, int *atomic, void **trace,
unsigned long trace_size);
int __tsan_get_report_loc(void *report, unsigned long idx, const char **type,
void **addr, unsigned long *start, unsigned long *size, int *tid,
int *fd, int *suppressable, void **trace,
unsigned long trace_size);
int __tsan_get_report_mutex(void *report, unsigned long idx, unsigned long *mutex_id, void **addr,
int *destroyed, void **trace, unsigned long trace_size);
int __tsan_get_report_thread(void *report, unsigned long idx, int *tid, unsigned long *os_id,
int *running, const char **name, int *parent_tid,
void **trace, unsigned long trace_size);
int __tsan_get_report_unique_tid(void *report, unsigned long idx, int *tid);
// TODO: dlsym won't work on Windows.
void *dlsym(void* handle, const char* symbol);
int (*ptr__tsan_get_report_loc_object_type)(void *report, unsigned long idx, const char **object_type);
}
const int REPORT_TRACE_SIZE = 128;
const int REPORT_ARRAY_SIZE = 4;
struct data {
void *report;
const char *description;
int report_count;
void *sleep_trace[REPORT_TRACE_SIZE];
int stack_count;
struct {
int idx;
void *trace[REPORT_TRACE_SIZE];
} stacks[REPORT_ARRAY_SIZE];
int mop_count;
struct {
int idx;
int tid;
int size;
int write;
int atomic;
void *addr;
void *trace[REPORT_TRACE_SIZE];
} mops[REPORT_ARRAY_SIZE];
int loc_count;
struct {
int idx;
const char *type;
void *addr;
unsigned long start;
unsigned long size;
int tid;
int fd;
int suppressable;
void *trace[REPORT_TRACE_SIZE];
const char *object_type;
} locs[REPORT_ARRAY_SIZE];
int mutex_count;
struct {
int idx;
unsigned long mutex_id;
void *addr;
int destroyed;
void *trace[REPORT_TRACE_SIZE];
} mutexes[REPORT_ARRAY_SIZE];
int thread_count;
struct {
int idx;
int tid;
unsigned long os_id;
int running;
const char *name;
int parent_tid;
void *trace[REPORT_TRACE_SIZE];
} threads[REPORT_ARRAY_SIZE];
int unique_tid_count;
struct {
int idx;
int tid;
} unique_tids[REPORT_ARRAY_SIZE];
};
)";
const char *thread_sanitizer_retrieve_report_data_command = R"(
data t = {0};
ptr__tsan_get_report_loc_object_type = (typeof(ptr__tsan_get_report_loc_object_type))(void *)dlsym((void*)-2 /*RTLD_DEFAULT*/, "__tsan_get_report_loc_object_type");
t.report = __tsan_get_current_report();
__tsan_get_report_data(t.report, &t.description, &t.report_count, &t.stack_count, &t.mop_count, &t.loc_count, &t.mutex_count, &t.thread_count, &t.unique_tid_count, t.sleep_trace, REPORT_TRACE_SIZE);
if (t.stack_count > REPORT_ARRAY_SIZE) t.stack_count = REPORT_ARRAY_SIZE;
for (int i = 0; i < t.stack_count; i++) {
t.stacks[i].idx = i;
__tsan_get_report_stack(t.report, i, t.stacks[i].trace, REPORT_TRACE_SIZE);
}
if (t.mop_count > REPORT_ARRAY_SIZE) t.mop_count = REPORT_ARRAY_SIZE;
for (int i = 0; i < t.mop_count; i++) {
t.mops[i].idx = i;
__tsan_get_report_mop(t.report, i, &t.mops[i].tid, &t.mops[i].addr, &t.mops[i].size, &t.mops[i].write, &t.mops[i].atomic, t.mops[i].trace, REPORT_TRACE_SIZE);
}
if (t.loc_count > REPORT_ARRAY_SIZE) t.loc_count = REPORT_ARRAY_SIZE;
for (int i = 0; i < t.loc_count; i++) {
t.locs[i].idx = i;
__tsan_get_report_loc(t.report, i, &t.locs[i].type, &t.locs[i].addr, &t.locs[i].start, &t.locs[i].size, &t.locs[i].tid, &t.locs[i].fd, &t.locs[i].suppressable, t.locs[i].trace, REPORT_TRACE_SIZE);
if (ptr__tsan_get_report_loc_object_type)
ptr__tsan_get_report_loc_object_type(t.report, i, &t.locs[i].object_type);
}
if (t.mutex_count > REPORT_ARRAY_SIZE) t.mutex_count = REPORT_ARRAY_SIZE;
for (int i = 0; i < t.mutex_count; i++) {
t.mutexes[i].idx = i;
__tsan_get_report_mutex(t.report, i, &t.mutexes[i].mutex_id, &t.mutexes[i].addr, &t.mutexes[i].destroyed, t.mutexes[i].trace, REPORT_TRACE_SIZE);
}
if (t.thread_count > REPORT_ARRAY_SIZE) t.thread_count = REPORT_ARRAY_SIZE;
for (int i = 0; i < t.thread_count; i++) {
t.threads[i].idx = i;
__tsan_get_report_thread(t.report, i, &t.threads[i].tid, &t.threads[i].os_id, &t.threads[i].running, &t.threads[i].name, &t.threads[i].parent_tid, t.threads[i].trace, REPORT_TRACE_SIZE);
}
if (t.unique_tid_count > REPORT_ARRAY_SIZE) t.unique_tid_count = REPORT_ARRAY_SIZE;
for (int i = 0; i < t.unique_tid_count; i++) {
t.unique_tids[i].idx = i;
__tsan_get_report_unique_tid(t.report, i, &t.unique_tids[i].tid);
}
t;
)";
static StructuredData::Array *
CreateStackTrace(ValueObjectSP o,
const std::string &trace_item_name = ".trace") {
StructuredData::Array *trace = new StructuredData::Array();
ValueObjectSP trace_value_object =
o->GetValueForExpressionPath(trace_item_name.c_str());
size_t count = trace_value_object->GetNumChildren();
for (size_t j = 0; j < count; j++) {
addr_t trace_addr =
trace_value_object->GetChildAtIndex(j, true)->GetValueAsUnsigned(0);
if (trace_addr == 0)
break;
trace->AddItem(
StructuredData::ObjectSP(new StructuredData::Integer(trace_addr)));
}
return trace;
}
static StructuredData::Array *ConvertToStructuredArray(
ValueObjectSP return_value_sp, const std::string &items_name,
const std::string &count_name,
std::function<void(ValueObjectSP o, StructuredData::Dictionary *dict)> const
&callback) {
StructuredData::Array *array = new StructuredData::Array();
unsigned int count =
return_value_sp->GetValueForExpressionPath(count_name.c_str())
->GetValueAsUnsigned(0);
ValueObjectSP objects =
return_value_sp->GetValueForExpressionPath(items_name.c_str());
for (unsigned int i = 0; i < count; i++) {
ValueObjectSP o = objects->GetChildAtIndex(i, true);
StructuredData::Dictionary *dict = new StructuredData::Dictionary();
callback(o, dict);
array->AddItem(StructuredData::ObjectSP(dict));
}
return array;
}
static std::string RetrieveString(ValueObjectSP return_value_sp,
ProcessSP process_sp,
const std::string &expression_path) {
addr_t ptr =
return_value_sp->GetValueForExpressionPath(expression_path.c_str())
->GetValueAsUnsigned(0);
std::string str;
Status error;
process_sp->ReadCStringFromMemory(ptr, str, error);
return str;
}
static void
GetRenumberedThreadIds(ProcessSP process_sp, ValueObjectSP data,
std::map<uint64_t, user_id_t> &thread_id_map) {
ConvertToStructuredArray(
data, ".threads", ".thread_count",
[process_sp, &thread_id_map](ValueObjectSP o,
StructuredData::Dictionary *dict) {
uint64_t thread_id =
o->GetValueForExpressionPath(".tid")->GetValueAsUnsigned(0);
uint64_t thread_os_id =
o->GetValueForExpressionPath(".os_id")->GetValueAsUnsigned(0);
user_id_t lldb_user_id = 0;
bool can_update = true;
ThreadSP lldb_thread = process_sp->GetThreadList().FindThreadByID(
thread_os_id, can_update);
if (lldb_thread) {
lldb_user_id = lldb_thread->GetIndexID();
} else {
// This isn't a live thread anymore. Ask process to assign a new
// Index ID (or return an old one if we've already seen this
// thread_os_id).
// It will also make sure that no new threads are assigned this Index
// ID.
lldb_user_id = process_sp->AssignIndexIDToThread(thread_os_id);
}
thread_id_map[thread_id] = lldb_user_id;
});
}
static user_id_t Renumber(uint64_t id,
std::map<uint64_t, user_id_t> &thread_id_map) {
auto IT = thread_id_map.find(id);
if (IT == thread_id_map.end())
return 0;
return IT->second;
}
StructuredData::ObjectSP
ThreadSanitizerRuntime::RetrieveReportData(ExecutionContextRef exe_ctx_ref) {
ProcessSP process_sp = GetProcessSP();
if (!process_sp)
return StructuredData::ObjectSP();
ThreadSP thread_sp = exe_ctx_ref.GetThreadSP();
StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
if (!frame_sp)
return StructuredData::ObjectSP();
EvaluateExpressionOptions options;
options.SetUnwindOnError(true);
options.SetTryAllThreads(true);
options.SetStopOthers(true);
options.SetIgnoreBreakpoints(true);
options.SetTimeout(g_retrieve_data_function_timeout);
options.SetPrefix(thread_sanitizer_retrieve_report_data_prefix);
options.SetAutoApplyFixIts(false);
options.SetLanguage(eLanguageTypeObjC_plus_plus);
ValueObjectSP main_value;
ExecutionContext exe_ctx;
Status eval_error;
frame_sp->CalculateExecutionContext(exe_ctx);
ExpressionResults result = UserExpression::Evaluate(
exe_ctx, options, thread_sanitizer_retrieve_report_data_command, "",
main_value, eval_error);
if (result != eExpressionCompleted) {
process_sp->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
"Warning: Cannot evaluate ThreadSanitizer expression:\n%s\n",
eval_error.AsCString());
return StructuredData::ObjectSP();
}
std::map<uint64_t, user_id_t> thread_id_map;
GetRenumberedThreadIds(process_sp, main_value, thread_id_map);
StructuredData::Dictionary *dict = new StructuredData::Dictionary();
dict->AddStringItem("instrumentation_class", "ThreadSanitizer");
dict->AddStringItem("issue_type",
RetrieveString(main_value, process_sp, ".description"));
dict->AddIntegerItem("report_count",
main_value->GetValueForExpressionPath(".report_count")
->GetValueAsUnsigned(0));
dict->AddItem("sleep_trace", StructuredData::ObjectSP(CreateStackTrace(
main_value, ".sleep_trace")));
StructuredData::Array *stacks = ConvertToStructuredArray(
main_value, ".stacks", ".stack_count",
[thread_sp](ValueObjectSP o, StructuredData::Dictionary *dict) {
dict->AddIntegerItem(
"index",
o->GetValueForExpressionPath(".idx")->GetValueAsUnsigned(0));
dict->AddItem("trace", StructuredData::ObjectSP(CreateStackTrace(o)));
// "stacks" happen on the current thread
dict->AddIntegerItem("thread_id", thread_sp->GetIndexID());
});
dict->AddItem("stacks", StructuredData::ObjectSP(stacks));
StructuredData::Array *mops = ConvertToStructuredArray(
main_value, ".mops", ".mop_count",
[&thread_id_map](ValueObjectSP o, StructuredData::Dictionary *dict) {
dict->AddIntegerItem(
"index",
o->GetValueForExpressionPath(".idx")->GetValueAsUnsigned(0));
dict->AddIntegerItem(
"thread_id",
Renumber(
o->GetValueForExpressionPath(".tid")->GetValueAsUnsigned(0),
thread_id_map));
dict->AddIntegerItem(
"size",
o->GetValueForExpressionPath(".size")->GetValueAsUnsigned(0));
dict->AddBooleanItem(
"is_write",
o->GetValueForExpressionPath(".write")->GetValueAsUnsigned(0));
dict->AddBooleanItem(
"is_atomic",
o->GetValueForExpressionPath(".atomic")->GetValueAsUnsigned(0));
dict->AddIntegerItem(
"address",
o->GetValueForExpressionPath(".addr")->GetValueAsUnsigned(0));
dict->AddItem("trace", StructuredData::ObjectSP(CreateStackTrace(o)));
});
dict->AddItem("mops", StructuredData::ObjectSP(mops));
StructuredData::Array *locs = ConvertToStructuredArray(
main_value, ".locs", ".loc_count",
[process_sp, &thread_id_map](ValueObjectSP o,
StructuredData::Dictionary *dict) {
dict->AddIntegerItem(
"index",
o->GetValueForExpressionPath(".idx")->GetValueAsUnsigned(0));
dict->AddStringItem("type", RetrieveString(o, process_sp, ".type"));
dict->AddIntegerItem(
"address",
o->GetValueForExpressionPath(".addr")->GetValueAsUnsigned(0));
dict->AddIntegerItem(
"start",
o->GetValueForExpressionPath(".start")->GetValueAsUnsigned(0));
dict->AddIntegerItem(
"size",
o->GetValueForExpressionPath(".size")->GetValueAsUnsigned(0));
dict->AddIntegerItem(
"thread_id",
Renumber(
o->GetValueForExpressionPath(".tid")->GetValueAsUnsigned(0),
thread_id_map));
dict->AddIntegerItem(
"file_descriptor",
o->GetValueForExpressionPath(".fd")->GetValueAsUnsigned(0));
dict->AddIntegerItem("suppressable",
o->GetValueForExpressionPath(".suppressable")
->GetValueAsUnsigned(0));
dict->AddItem("trace", StructuredData::ObjectSP(CreateStackTrace(o)));
dict->AddStringItem("object_type",
RetrieveString(o, process_sp, ".object_type"));
});
dict->AddItem("locs", StructuredData::ObjectSP(locs));
StructuredData::Array *mutexes = ConvertToStructuredArray(
main_value, ".mutexes", ".mutex_count",
[](ValueObjectSP o, StructuredData::Dictionary *dict) {
dict->AddIntegerItem(
"index",
o->GetValueForExpressionPath(".idx")->GetValueAsUnsigned(0));
dict->AddIntegerItem(
"mutex_id",
o->GetValueForExpressionPath(".mutex_id")->GetValueAsUnsigned(0));
dict->AddIntegerItem(
"address",
o->GetValueForExpressionPath(".addr")->GetValueAsUnsigned(0));
dict->AddIntegerItem(
"destroyed",
o->GetValueForExpressionPath(".destroyed")->GetValueAsUnsigned(0));
dict->AddItem("trace", StructuredData::ObjectSP(CreateStackTrace(o)));
});
dict->AddItem("mutexes", StructuredData::ObjectSP(mutexes));
StructuredData::Array *threads = ConvertToStructuredArray(
main_value, ".threads", ".thread_count",
[process_sp, &thread_id_map](ValueObjectSP o,
StructuredData::Dictionary *dict) {
dict->AddIntegerItem(
"index",
o->GetValueForExpressionPath(".idx")->GetValueAsUnsigned(0));
dict->AddIntegerItem(
"thread_id",
Renumber(
o->GetValueForExpressionPath(".tid")->GetValueAsUnsigned(0),
thread_id_map));
dict->AddIntegerItem(
"thread_os_id",
o->GetValueForExpressionPath(".os_id")->GetValueAsUnsigned(0));
dict->AddIntegerItem(
"running",
o->GetValueForExpressionPath(".running")->GetValueAsUnsigned(0));
dict->AddStringItem("name", RetrieveString(o, process_sp, ".name"));
dict->AddIntegerItem(
"parent_thread_id",
Renumber(o->GetValueForExpressionPath(".parent_tid")
->GetValueAsUnsigned(0),
thread_id_map));
dict->AddItem("trace", StructuredData::ObjectSP(CreateStackTrace(o)));
});
dict->AddItem("threads", StructuredData::ObjectSP(threads));
StructuredData::Array *unique_tids = ConvertToStructuredArray(
main_value, ".unique_tids", ".unique_tid_count",
[&thread_id_map](ValueObjectSP o, StructuredData::Dictionary *dict) {
dict->AddIntegerItem(
"index",
o->GetValueForExpressionPath(".idx")->GetValueAsUnsigned(0));
dict->AddIntegerItem(
"tid",
Renumber(
o->GetValueForExpressionPath(".tid")->GetValueAsUnsigned(0),
thread_id_map));
});
dict->AddItem("unique_tids", StructuredData::ObjectSP(unique_tids));
return StructuredData::ObjectSP(dict);
}
std::string
ThreadSanitizerRuntime::FormatDescription(StructuredData::ObjectSP report) {
std::string description = report->GetAsDictionary()
->GetValueForKey("issue_type")
->GetAsString()
->GetValue();
if (description == "data-race") {
return "Data race";
} else if (description == "data-race-vptr") {
return "Data race on C++ virtual pointer";
} else if (description == "heap-use-after-free") {
return "Use of deallocated memory";
} else if (description == "heap-use-after-free-vptr") {
return "Use of deallocated C++ virtual pointer";
} else if (description == "thread-leak") {
return "Thread leak";
} else if (description == "locked-mutex-destroy") {
return "Destruction of a locked mutex";
} else if (description == "mutex-double-lock") {
return "Double lock of a mutex";
} else if (description == "mutex-invalid-access") {
return "Use of an uninitialized or destroyed mutex";
} else if (description == "mutex-bad-unlock") {
return "Unlock of an unlocked mutex (or by a wrong thread)";
} else if (description == "mutex-bad-read-lock") {
return "Read lock of a write locked mutex";
} else if (description == "mutex-bad-read-unlock") {
return "Read unlock of a write locked mutex";
} else if (description == "signal-unsafe-call") {
return "Signal-unsafe call inside a signal handler";
} else if (description == "errno-in-signal-handler") {
return "Overwrite of errno in a signal handler";
} else if (description == "lock-order-inversion") {
return "Lock order inversion (potential deadlock)";
} else if (description == "external-race") {
return "Race on a library object";
} else if (description == "swift-access-race") {
return "Swift access race";
}
// for unknown report codes just show the code
return description;
}
static std::string Sprintf(const char *format, ...) {
StreamString s;
va_list args;
va_start(args, format);
s.PrintfVarArg(format, args);
va_end(args);
return s.GetString();
}
static std::string GetSymbolNameFromAddress(ProcessSP process_sp, addr_t addr) {
lldb_private::Address so_addr;
if (!process_sp->GetTarget().GetSectionLoadList().ResolveLoadAddress(addr,
so_addr))
return "";
lldb_private::Symbol *symbol = so_addr.CalculateSymbolContextSymbol();
if (!symbol)
return "";
std::string sym_name = symbol->GetName().GetCString();
return sym_name;
}
static void GetSymbolDeclarationFromAddress(ProcessSP process_sp, addr_t addr,
Declaration &decl) {
lldb_private::Address so_addr;
if (!process_sp->GetTarget().GetSectionLoadList().ResolveLoadAddress(addr,
so_addr))
return;
lldb_private::Symbol *symbol = so_addr.CalculateSymbolContextSymbol();
if (!symbol)
return;
ConstString sym_name = symbol->GetMangled().GetName(
lldb::eLanguageTypeUnknown, Mangled::ePreferMangled);
ModuleSP module = symbol->CalculateSymbolContextModule();
if (!module)
return;
VariableList var_list;
module->FindGlobalVariables(sym_name, nullptr, true, 1U, var_list);
if (var_list.GetSize() < 1)
return;
VariableSP var = var_list.GetVariableAtIndex(0);
decl = var->GetDeclaration();
}
addr_t ThreadSanitizerRuntime::GetFirstNonInternalFramePc(
StructuredData::ObjectSP trace, bool skip_one_frame) {
ProcessSP process_sp = GetProcessSP();
ModuleSP runtime_module_sp = GetRuntimeModuleSP();
StructuredData::Array *trace_array = trace->GetAsArray();
for (size_t i = 0; i < trace_array->GetSize(); i++) {
if (skip_one_frame && i == 0)
continue;
addr_t addr;
if (!trace_array->GetItemAtIndexAsInteger(i, addr))
continue;
lldb_private::Address so_addr;
if (!process_sp->GetTarget().GetSectionLoadList().ResolveLoadAddress(
addr, so_addr))
continue;
if (so_addr.GetModule() == runtime_module_sp)
continue;
return addr;
}
return 0;
}
std::string
ThreadSanitizerRuntime::GenerateSummary(StructuredData::ObjectSP report) {
ProcessSP process_sp = GetProcessSP();
std::string summary = report->GetAsDictionary()
->GetValueForKey("description")
->GetAsString()
->GetValue();
bool skip_one_frame =
report->GetObjectForDotSeparatedPath("issue_type")->GetStringValue() ==
"external-race";
addr_t pc = 0;
if (report->GetAsDictionary()
->GetValueForKey("mops")
->GetAsArray()
->GetSize() > 0)
pc = GetFirstNonInternalFramePc(report->GetAsDictionary()
->GetValueForKey("mops")
->GetAsArray()
->GetItemAtIndex(0)
->GetAsDictionary()
->GetValueForKey("trace"),
skip_one_frame);
if (report->GetAsDictionary()
->GetValueForKey("stacks")
->GetAsArray()
->GetSize() > 0)
pc = GetFirstNonInternalFramePc(report->GetAsDictionary()
->GetValueForKey("stacks")
->GetAsArray()
->GetItemAtIndex(0)
->GetAsDictionary()
->GetValueForKey("trace"),
skip_one_frame);
if (pc != 0) {
summary = summary + " in " + GetSymbolNameFromAddress(process_sp, pc);
}
if (report->GetAsDictionary()
->GetValueForKey("locs")
->GetAsArray()
->GetSize() > 0) {
StructuredData::ObjectSP loc = report->GetAsDictionary()
->GetValueForKey("locs")
->GetAsArray()
->GetItemAtIndex(0);
std::string object_type = loc->GetAsDictionary()
->GetValueForKey("object_type")
->GetAsString()
->GetValue();
if (!object_type.empty()) {
summary = "Race on " + object_type + " object";
}
addr_t addr = loc->GetAsDictionary()
->GetValueForKey("address")
->GetAsInteger()
->GetValue();
if (addr == 0)
addr = loc->GetAsDictionary()
->GetValueForKey("start")
->GetAsInteger()
->GetValue();
if (addr != 0) {
std::string global_name = GetSymbolNameFromAddress(process_sp, addr);
if (!global_name.empty()) {
summary = summary + " at " + global_name;
} else {
summary = summary + " at " + Sprintf("0x%llx", addr);
}
} else {
int fd = loc->GetAsDictionary()
->GetValueForKey("file_descriptor")
->GetAsInteger()
->GetValue();
if (fd != 0) {
summary = summary + " on file descriptor " + Sprintf("%d", fd);
}
}
}
return summary;
}
addr_t
ThreadSanitizerRuntime::GetMainRacyAddress(StructuredData::ObjectSP report) {
addr_t result = (addr_t)-1;
report->GetObjectForDotSeparatedPath("mops")->GetAsArray()->ForEach(
[&result](StructuredData::Object *o) -> bool {
addr_t addr =
o->GetObjectForDotSeparatedPath("address")->GetIntegerValue();
if (addr < result)
result = addr;
return true;
});
return (result == (addr_t)-1) ? 0 : result;
}
std::string ThreadSanitizerRuntime::GetLocationDescription(
StructuredData::ObjectSP report, addr_t &global_addr,
std::string &global_name, std::string &filename, uint32_t &line) {
std::string result = "";
ProcessSP process_sp = GetProcessSP();
if (report->GetAsDictionary()
->GetValueForKey("locs")
->GetAsArray()
->GetSize() > 0) {
StructuredData::ObjectSP loc = report->GetAsDictionary()
->GetValueForKey("locs")
->GetAsArray()
->GetItemAtIndex(0);
std::string type =
loc->GetAsDictionary()->GetValueForKey("type")->GetStringValue();
if (type == "global") {
global_addr = loc->GetAsDictionary()
->GetValueForKey("address")
->GetAsInteger()
->GetValue();
global_name = GetSymbolNameFromAddress(process_sp, global_addr);
if (!global_name.empty()) {
result = Sprintf("'%s' is a global variable (0x%llx)",
global_name.c_str(), global_addr);
} else {
result = Sprintf("0x%llx is a global variable", global_addr);
}
Declaration decl;
GetSymbolDeclarationFromAddress(process_sp, global_addr, decl);
if (decl.GetFile()) {
filename = decl.GetFile().GetPath();
line = decl.GetLine();
}
} else if (type == "heap") {
addr_t addr = loc->GetAsDictionary()
->GetValueForKey("start")
->GetAsInteger()
->GetValue();
long size = loc->GetAsDictionary()
->GetValueForKey("size")
->GetAsInteger()
->GetValue();
std::string object_type = loc->GetAsDictionary()
->GetValueForKey("object_type")
->GetAsString()
->GetValue();
if (!object_type.empty()) {
result = Sprintf("Location is a %ld-byte %s object at 0x%llx", size,
object_type.c_str(), addr);
} else {
result =
Sprintf("Location is a %ld-byte heap object at 0x%llx", size, addr);
}
} else if (type == "stack") {
int tid = loc->GetAsDictionary()
->GetValueForKey("thread_id")
->GetAsInteger()
->GetValue();
result = Sprintf("Location is stack of thread %d", tid);
} else if (type == "tls") {
int tid = loc->GetAsDictionary()
->GetValueForKey("thread_id")
->GetAsInteger()
->GetValue();
result = Sprintf("Location is TLS of thread %d", tid);
} else if (type == "fd") {
int fd = loc->GetAsDictionary()
->GetValueForKey("file_descriptor")
->GetAsInteger()
->GetValue();
result = Sprintf("Location is file descriptor %d", fd);
}
}
return result;
}
bool ThreadSanitizerRuntime::NotifyBreakpointHit(
void *baton, StoppointCallbackContext *context, user_id_t break_id,
user_id_t break_loc_id) {
assert(baton && "null baton");
if (!baton)
return false;
ThreadSanitizerRuntime *const instance =
static_cast<ThreadSanitizerRuntime *>(baton);
StructuredData::ObjectSP report =
instance->RetrieveReportData(context->exe_ctx_ref);
std::string stop_reason_description;
if (report) {
std::string issue_description = instance->FormatDescription(report);
report->GetAsDictionary()->AddStringItem("description", issue_description);
stop_reason_description = issue_description + " detected";
report->GetAsDictionary()->AddStringItem("stop_description",
stop_reason_description);
std::string summary = instance->GenerateSummary(report);
report->GetAsDictionary()->AddStringItem("summary", summary);
addr_t main_address = instance->GetMainRacyAddress(report);
report->GetAsDictionary()->AddIntegerItem("memory_address", main_address);
addr_t global_addr = 0;
std::string global_name = "";
std::string location_filename = "";
uint32_t location_line = 0;
std::string location_description = instance->GetLocationDescription(
report, global_addr, global_name, location_filename, location_line);
report->GetAsDictionary()->AddStringItem("location_description",
location_description);
if (global_addr != 0) {
report->GetAsDictionary()->AddIntegerItem("global_address", global_addr);
}
if (!global_name.empty()) {
report->GetAsDictionary()->AddStringItem("global_name", global_name);
}
if (location_filename != "") {
report->GetAsDictionary()->AddStringItem("location_filename",
location_filename);
report->GetAsDictionary()->AddIntegerItem("location_line", location_line);
}
bool all_addresses_are_same = true;
report->GetObjectForDotSeparatedPath("mops")->GetAsArray()->ForEach(
[&all_addresses_are_same,
main_address](StructuredData::Object *o) -> bool {
addr_t addr =
o->GetObjectForDotSeparatedPath("address")->GetIntegerValue();
if (main_address != addr)
all_addresses_are_same = false;
return true;
});
report->GetAsDictionary()->AddBooleanItem("all_addresses_are_same",
all_addresses_are_same);
}
ProcessSP process_sp = instance->GetProcessSP();
// Make sure this is the right process
if (process_sp && process_sp == context->exe_ctx_ref.GetProcessSP()) {
ThreadSP thread_sp = context->exe_ctx_ref.GetThreadSP();
if (thread_sp)
thread_sp->SetStopInfo(
InstrumentationRuntimeStopInfo::
CreateStopReasonWithInstrumentationData(
*thread_sp, stop_reason_description, report));
StreamFileSP stream_sp(
process_sp->GetTarget().GetDebugger().GetOutputFile());
if (stream_sp) {
stream_sp->Printf("ThreadSanitizer report breakpoint hit. Use 'thread "
"info -s' to get extended information about the "
"report.\n");
}
return true; // Return true to stop the target
} else
return false; // Let target run
}
const RegularExpression &ThreadSanitizerRuntime::GetPatternForRuntimeLibrary() {
static RegularExpression regex(llvm::StringRef("libclang_rt.tsan_"));
return regex;
}
bool ThreadSanitizerRuntime::CheckIfRuntimeIsValid(
const lldb::ModuleSP module_sp) {
static ConstString g_tsan_get_current_report("__tsan_get_current_report");
const Symbol *symbol = module_sp->FindFirstSymbolWithNameAndType(
g_tsan_get_current_report, lldb::eSymbolTypeAny);
return symbol != nullptr;
}
void ThreadSanitizerRuntime::Activate() {
if (IsActive())
return;
ProcessSP process_sp = GetProcessSP();
if (!process_sp)
return;
ConstString symbol_name("__tsan_on_report");
const Symbol *symbol = GetRuntimeModuleSP()->FindFirstSymbolWithNameAndType(
symbol_name, eSymbolTypeCode);
if (symbol == NULL)
return;
if (!symbol->ValueIsAddress() || !symbol->GetAddressRef().IsValid())
return;
Target &target = process_sp->GetTarget();
addr_t symbol_address = symbol->GetAddressRef().GetOpcodeLoadAddress(&target);
if (symbol_address == LLDB_INVALID_ADDRESS)
return;
bool internal = true;
bool hardware = false;
Breakpoint *breakpoint =
process_sp->GetTarget()
.CreateBreakpoint(symbol_address, internal, hardware)
.get();
breakpoint->SetCallback(ThreadSanitizerRuntime::NotifyBreakpointHit, this,
true);
breakpoint->SetBreakpointKind("thread-sanitizer-report");
SetBreakpointID(breakpoint->GetID());
StreamFileSP stream_sp(process_sp->GetTarget().GetDebugger().GetOutputFile());
if (stream_sp) {
stream_sp->Printf("ThreadSanitizer debugger support is active.\n");
}
SetActive(true);
}
void ThreadSanitizerRuntime::Deactivate() {
if (GetBreakpointID() != LLDB_INVALID_BREAK_ID) {
ProcessSP process_sp = GetProcessSP();
if (process_sp) {
process_sp->GetTarget().RemoveBreakpointByID(GetBreakpointID());
SetBreakpointID(LLDB_INVALID_BREAK_ID);
}
}
SetActive(false);
}
static std::string GenerateThreadName(const std::string &path,
StructuredData::Object *o,
StructuredData::ObjectSP main_info) {
std::string result = "additional information";
if (path == "mops") {
int size = o->GetObjectForDotSeparatedPath("size")->GetIntegerValue();
int thread_id =
o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
bool is_write =
o->GetObjectForDotSeparatedPath("is_write")->GetBooleanValue();
bool is_atomic =
o->GetObjectForDotSeparatedPath("is_atomic")->GetBooleanValue();
addr_t addr = o->GetObjectForDotSeparatedPath("address")->GetIntegerValue();
std::string addr_string = Sprintf(" at 0x%llx", addr);
if (main_info->GetObjectForDotSeparatedPath("all_addresses_are_same")
->GetBooleanValue()) {
addr_string = "";
}
if (main_info->GetObjectForDotSeparatedPath("issue_type")
->GetStringValue() == "external-race") {
result = Sprintf("%s access by thread %d",
is_write ? "mutating" : "read-only", thread_id);
} else if (main_info->GetObjectForDotSeparatedPath("issue_type")
->GetStringValue() == "swift-access-race") {
result = Sprintf("modifying access by thread %d", thread_id);
} else {
result = Sprintf("%s%s of size %d%s by thread %d",
is_atomic ? "atomic " : "", is_write ? "write" : "read",
size, addr_string.c_str(), thread_id);
}
}
if (path == "threads") {
int thread_id =
o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
result = Sprintf("Thread %d created", thread_id);
}
if (path == "locs") {
std::string type =
o->GetAsDictionary()->GetValueForKey("type")->GetStringValue();
int thread_id =
o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
int fd =
o->GetObjectForDotSeparatedPath("file_descriptor")->GetIntegerValue();
if (type == "heap") {
result = Sprintf("Heap block allocated by thread %d", thread_id);
} else if (type == "fd") {
result =
Sprintf("File descriptor %d created by thread %t", fd, thread_id);
}
}
if (path == "mutexes") {
int mutex_id =
o->GetObjectForDotSeparatedPath("mutex_id")->GetIntegerValue();
result = Sprintf("Mutex M%d created", mutex_id);
}
if (path == "stacks") {
int thread_id =
o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
result = Sprintf("Thread %d", thread_id);
}
result[0] = toupper(result[0]);
return result;
}
static void AddThreadsForPath(const std::string &path,
ThreadCollectionSP threads, ProcessSP process_sp,
StructuredData::ObjectSP info) {
info->GetObjectForDotSeparatedPath(path)->GetAsArray()->ForEach(
[process_sp, threads, path, info](StructuredData::Object *o) -> bool {
std::vector<lldb::addr_t> pcs;
o->GetObjectForDotSeparatedPath("trace")->GetAsArray()->ForEach(
[&pcs](StructuredData::Object *pc) -> bool {
pcs.push_back(pc->GetAsInteger()->GetValue());
return true;
});
if (pcs.size() == 0)
return true;
StructuredData::ObjectSP thread_id_obj =
o->GetObjectForDotSeparatedPath("thread_os_id");
tid_t tid = thread_id_obj ? thread_id_obj->GetIntegerValue() : 0;
uint32_t stop_id = 0;
bool stop_id_is_valid = false;
HistoryThread *history_thread =
new HistoryThread(*process_sp, tid, pcs, stop_id, stop_id_is_valid);
ThreadSP new_thread_sp(history_thread);
new_thread_sp->SetName(GenerateThreadName(path, o, info).c_str());
// Save this in the Process' ExtendedThreadList so a strong pointer
// retains the object
process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
threads->AddThread(new_thread_sp);
return true;
});
}
lldb::ThreadCollectionSP
ThreadSanitizerRuntime::GetBacktracesFromExtendedStopInfo(
StructuredData::ObjectSP info) {
ThreadCollectionSP threads;
threads.reset(new ThreadCollection());
if (info->GetObjectForDotSeparatedPath("instrumentation_class")
->GetStringValue() != "ThreadSanitizer")
return threads;
ProcessSP process_sp = GetProcessSP();
AddThreadsForPath("stacks", threads, process_sp, info);
AddThreadsForPath("mops", threads, process_sp, info);
AddThreadsForPath("locs", threads, process_sp, info);
AddThreadsForPath("mutexes", threads, process_sp, info);
AddThreadsForPath("threads", threads, process_sp, info);
return threads;
}
Reference in New Issue View Git Blame Copy Permalink