ae088e52f3
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files
Each time a SymbolFile::FindTypes() is called, it needs to check the searched_symbol_files list to make sure it hasn't already been asked to find the type and return immediately if it has been checked. This will stop circular dependencies from also crashing LLDB during type queries.
This has proven to be an issue when debugging large applications on MacOSX that use DWARF in .o files.
<rdar://problem/24581488>
llvm-svn: 260434
242 lines
7.7 KiB
C++
242 lines
7.7 KiB
C++
//===-- GoLanguageRuntime.cpp --------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "GoLanguageRuntime.h"
|
|
|
|
#include "lldb/Breakpoint/BreakpointLocation.h"
|
|
#include "lldb/Core/ConstString.h"
|
|
#include "lldb/Core/Error.h"
|
|
#include "lldb/Core/Log.h"
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/PluginManager.h"
|
|
#include "lldb/Core/Scalar.h"
|
|
#include "lldb/Core/ValueObject.h"
|
|
#include "lldb/Core/ValueObjectMemory.h"
|
|
#include "lldb/Symbol/GoASTContext.h"
|
|
#include "lldb/Symbol/Symbol.h"
|
|
#include "lldb/Symbol/SymbolFile.h"
|
|
#include "lldb/Symbol/TypeList.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/RegisterContext.h"
|
|
#include "lldb/Target/SectionLoadList.h"
|
|
#include "lldb/Target/StopInfo.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Target/Thread.h"
|
|
#include "llvm/ADT/Twine.h"
|
|
|
|
#include <vector>
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
namespace {
|
|
ValueObjectSP GetChild(ValueObject& obj, const char* name, bool dereference = true) {
|
|
ConstString name_const_str(name);
|
|
ValueObjectSP result = obj.GetChildMemberWithName(name_const_str, true);
|
|
if (dereference && result && result->IsPointerType()) {
|
|
Error err;
|
|
result = result->Dereference(err);
|
|
if (err.Fail())
|
|
result.reset();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
ConstString ReadString(ValueObject& str, Process* process) {
|
|
ConstString result;
|
|
ValueObjectSP data = GetChild(str, "str", false);
|
|
ValueObjectSP len = GetChild(str, "len");
|
|
if (len && data)
|
|
{
|
|
Error err;
|
|
lldb::addr_t addr = data->GetPointerValue();
|
|
if (addr == LLDB_INVALID_ADDRESS)
|
|
return result;
|
|
uint64_t byte_size = len->GetValueAsUnsigned(0);
|
|
char* buf = new char[byte_size + 1];
|
|
buf[byte_size] = 0;
|
|
size_t bytes_read = process->ReadMemory (addr,
|
|
buf,
|
|
byte_size,
|
|
err);
|
|
if (!(err.Fail() || bytes_read != byte_size))
|
|
result = ConstString(buf, bytes_read);
|
|
delete[] buf;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
ConstString
|
|
ReadTypeName(ValueObjectSP type, Process* process)
|
|
{
|
|
if (ValueObjectSP uncommon = GetChild(*type, "x"))
|
|
{
|
|
ValueObjectSP name = GetChild(*uncommon, "name");
|
|
ValueObjectSP package = GetChild(*uncommon, "pkgpath");
|
|
if (name && name->GetPointerValue() != 0 && package && package->GetPointerValue() != 0)
|
|
{
|
|
ConstString package_const_str = ReadString(*package, process);
|
|
ConstString name_const_str = ReadString(*name, process);
|
|
if (package_const_str.GetLength() == 0)
|
|
return name_const_str;
|
|
return ConstString((package_const_str.GetStringRef() + "." + name_const_str.GetStringRef()).str());
|
|
}
|
|
}
|
|
ValueObjectSP name = GetChild(*type, "_string");
|
|
if (name)
|
|
return ReadString(*name, process);
|
|
return ConstString("");
|
|
}
|
|
|
|
CompilerType
|
|
LookupRuntimeType(ValueObjectSP type, ExecutionContext* exe_ctx, bool* is_direct)
|
|
{
|
|
uint8_t kind = GetChild(*type, "kind")->GetValueAsUnsigned(0);
|
|
*is_direct = GoASTContext::IsDirectIface(kind);
|
|
if (GoASTContext::IsPointerKind(kind))
|
|
{
|
|
CompilerType type_ptr = type->GetCompilerType().GetPointerType();
|
|
Error err;
|
|
ValueObjectSP elem = type->CreateValueObjectFromAddress("elem", type->GetAddressOf() + type->GetByteSize(), *exe_ctx, type_ptr)->Dereference(err);
|
|
if (err.Fail())
|
|
return CompilerType();
|
|
bool tmp_direct;
|
|
return LookupRuntimeType(elem, exe_ctx, &tmp_direct).GetPointerType();
|
|
}
|
|
Target *target = exe_ctx->GetTargetPtr();
|
|
Process *process = exe_ctx->GetProcessPtr();
|
|
|
|
ConstString const_typename = ReadTypeName(type, process);
|
|
if (const_typename.GetLength() == 0)
|
|
return CompilerType();
|
|
|
|
SymbolContext sc;
|
|
TypeList type_list;
|
|
llvm::DenseSet<SymbolFile *> searched_symbol_files;
|
|
uint32_t num_matches = target->GetImages().FindTypes (sc,
|
|
const_typename,
|
|
false,
|
|
2,
|
|
searched_symbol_files,
|
|
type_list);
|
|
if (num_matches > 0) {
|
|
return type_list.GetTypeAtIndex(0)->GetFullCompilerType();
|
|
}
|
|
return CompilerType();
|
|
}
|
|
|
|
}
|
|
|
|
bool
|
|
GoLanguageRuntime::CouldHaveDynamicValue (ValueObject &in_value)
|
|
{
|
|
return GoASTContext::IsGoInterface(in_value.GetCompilerType());
|
|
}
|
|
|
|
bool
|
|
GoLanguageRuntime::GetDynamicTypeAndAddress(ValueObject &in_value, lldb::DynamicValueType use_dynamic,
|
|
TypeAndOrName &class_type_or_name, Address &dynamic_address,
|
|
Value::ValueType &value_type)
|
|
{
|
|
value_type = Value::eValueTypeScalar;
|
|
class_type_or_name.Clear();
|
|
if (CouldHaveDynamicValue (in_value))
|
|
{
|
|
Error err;
|
|
ValueObjectSP iface = in_value.GetStaticValue();
|
|
ValueObjectSP data_sp = GetChild(*iface, "data", false);
|
|
if (!data_sp)
|
|
return false;
|
|
|
|
if (ValueObjectSP tab = GetChild(*iface, "tab"))
|
|
iface = tab;
|
|
ValueObjectSP type = GetChild(*iface, "_type");
|
|
if (!type)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool direct;
|
|
ExecutionContext exe_ctx (in_value.GetExecutionContextRef());
|
|
CompilerType final_type = LookupRuntimeType(type, &exe_ctx, &direct);
|
|
if (!final_type)
|
|
return false;
|
|
if (direct)
|
|
{
|
|
class_type_or_name.SetCompilerType(final_type);
|
|
}
|
|
else
|
|
{
|
|
// TODO: implement reference types or fix caller to support dynamic types that aren't pointers
|
|
// so we don't have to introduce this extra pointer.
|
|
class_type_or_name.SetCompilerType(final_type.GetPointerType());
|
|
}
|
|
|
|
dynamic_address.SetLoadAddress(data_sp->GetPointerValue(), exe_ctx.GetTargetPtr());
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
TypeAndOrName
|
|
GoLanguageRuntime::FixUpDynamicType(const TypeAndOrName &type_and_or_name, ValueObject &static_value)
|
|
{
|
|
return type_and_or_name;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Static Functions
|
|
//------------------------------------------------------------------
|
|
LanguageRuntime *
|
|
GoLanguageRuntime::CreateInstance (Process *process, lldb::LanguageType language)
|
|
{
|
|
if (language == eLanguageTypeGo)
|
|
return new GoLanguageRuntime (process);
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
GoLanguageRuntime::Initialize()
|
|
{
|
|
PluginManager::RegisterPlugin (GetPluginNameStatic(),
|
|
"Go Language Runtime",
|
|
CreateInstance);
|
|
}
|
|
|
|
void
|
|
GoLanguageRuntime::Terminate()
|
|
{
|
|
PluginManager::UnregisterPlugin (CreateInstance);
|
|
}
|
|
|
|
lldb_private::ConstString
|
|
GoLanguageRuntime::GetPluginNameStatic()
|
|
{
|
|
static ConstString g_name("golang");
|
|
return g_name;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// PluginInterface protocol
|
|
//------------------------------------------------------------------
|
|
lldb_private::ConstString
|
|
GoLanguageRuntime::GetPluginName()
|
|
{
|
|
return GetPluginNameStatic();
|
|
}
|
|
|
|
uint32_t
|
|
GoLanguageRuntime::GetPluginVersion()
|
|
{
|
|
return 1;
|
|
}
|
|
|