Google Git
Sign in
fuchsia / third_party / swift-lldb / upstream/stable / . / source / Target / SwiftLanguageRuntime.cpp
blob: 5f332506e58bd9320fe9a6028e086656559c7866 [file] [log] [blame]
//===-- SwiftLanguageRuntime.cpp --------------------------------*- C++ -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
#include "lldb/Target/SwiftLanguageRuntime.h"
#include <string.h>
#include "llvm/Support/raw_ostream.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclCXX.h"
#include "swift/ABI/MetadataValues.h"
#include "swift/ABI/System.h"
#include "swift/AST/ASTContext.h"
#include "swift/AST/ASTMangler.h"
#include "swift/AST/Decl.h"
#include "swift/AST/Module.h"
#include "swift/AST/Types.h"
#include "swift/Demangling/Demangle.h"
#include "swift/Demangling/Demangler.h"
#include "swift/Remote/MemoryReader.h"
#include "swift/RemoteAST/RemoteAST.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Utility/Status.h"
#include "lldb/Core/Mangled.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Core/UniqueCStringMap.h"
#include "lldb/Core/Value.h"
#include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/StringPrinter.h"
#include "lldb/DataFormatters/TypeSynthetic.h"
#include "lldb/DataFormatters/ValueObjectPrinter.h"
#include "lldb/Host/HostInfo.h"
#include "lldb/Host/OptionParser.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandObject.h"
#include "lldb/Interpreter/CommandObjectMultiword.h"
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/OptionValueBoolean.h"
#include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/SwiftASTContext.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/TypeList.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/ProcessStructReader.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/ThreadPlanRunToAddress.h"
#include "lldb/Target/ThreadPlanStepInRange.h"
#include "lldb/Target/ThreadPlanStepOverRange.h"
#include "lldb/Utility/CleanUp.h"
#include "lldb/Utility/DataBuffer.h"
#include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/StringLexer.h"
// FIXME: we should not need this
#include "Plugins/Language/Swift/SwiftFormatters.h"
using namespace lldb;
using namespace lldb_private;
//----------------------------------------------------------------------
// Destructor
//----------------------------------------------------------------------
SwiftLanguageRuntime::~SwiftLanguageRuntime() {}
SwiftLanguageRuntime::SwiftLanguageRuntime(Process *process)
: LanguageRuntime(process), m_negative_cache_mutex(),
m_SwiftNativeNSErrorISA(), m_memory_reader_sp(), m_promises_map(),
m_resolvers_map(), m_bridged_synthetics_map(), m_box_metadata_type() {
SetupSwiftError();
SetupExclusivity();
}
static llvm::Optional<lldb::addr_t>
FindSymbolForSwiftObject(Target &target, const ConstString &object,
const SymbolType sym_type) {
llvm::Optional<lldb::addr_t> retval;
SymbolContextList sc_list;
if (target.GetImages().FindSymbolsWithNameAndType(object, sym_type,
sc_list)) {
SymbolContext SwiftObject_Class;
if (sc_list.GetSize() == 1 &&
sc_list.GetContextAtIndex(0, SwiftObject_Class)) {
if (SwiftObject_Class.symbol) {
lldb::addr_t SwiftObject_class_addr =
SwiftObject_Class.symbol->GetAddress().GetLoadAddress(&target);
if (SwiftObject_class_addr &&
SwiftObject_class_addr != LLDB_INVALID_ADDRESS)
retval = SwiftObject_class_addr;
}
}
}
return retval;
}
AppleObjCRuntimeV2 *SwiftLanguageRuntime::GetObjCRuntime() {
if (auto objc_runtime = GetProcess()->GetObjCLanguageRuntime()) {
if (objc_runtime->GetPluginName() ==
AppleObjCRuntimeV2::GetPluginNameStatic())
return (AppleObjCRuntimeV2 *)objc_runtime;
}
return nullptr;
}
void SwiftLanguageRuntime::SetupSwiftError() {
Target &target(m_process->GetTarget());
if (m_SwiftNativeNSErrorISA.hasValue())
return;
ConstString g_SwiftNativeNSError("_SwiftNativeNSError");
m_SwiftNativeNSErrorISA = FindSymbolForSwiftObject(
target, g_SwiftNativeNSError, eSymbolTypeObjCClass);
}
void SwiftLanguageRuntime::SetupExclusivity() {
Target &target(m_process->GetTarget());
ConstString g_disableExclusivityChecking("_swift_disableExclusivityChecking");
m_dynamic_exclusivity_flag_addr = FindSymbolForSwiftObject(
target, g_disableExclusivityChecking, eSymbolTypeData);
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
if (log)
log->Printf("SwiftLanguageRuntime: _swift_disableExclusivityChecking = %llu",
m_dynamic_exclusivity_flag_addr ?
*m_dynamic_exclusivity_flag_addr : 0);
}
void SwiftLanguageRuntime::ModulesDidLoad(const ModuleList &module_list) {}
static bool GetObjectDescription_ResultVariable(Process *process, Stream &str,
ValueObject &object) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
StreamString expr_string;
expr_string.Printf("Swift._DebuggerSupport.stringForPrintObject(%s)",
object.GetName().GetCString());
if (log)
log->Printf("[GetObjectDescription_ResultVariable] expression: %s",
expr_string.GetData());
ValueObjectSP result_sp;
EvaluateExpressionOptions eval_options;
eval_options.SetLanguage(lldb::eLanguageTypeSwift);
eval_options.SetResultIsInternal(true);
eval_options.SetGenerateDebugInfo(true);
auto eval_result = process->GetTarget().EvaluateExpression(
expr_string.GetData(),
process->GetThreadList().GetSelectedThread()->GetSelectedFrame().get(),
result_sp, eval_options);
if (log) {
switch (eval_result) {
case eExpressionCompleted:
log->Printf("[GetObjectDescription_ResultVariable] eExpressionCompleted");
break;
case eExpressionSetupError:
log->Printf(
"[GetObjectDescription_ResultVariable] eExpressionSetupError");
break;
case eExpressionParseError:
log->Printf(
"[GetObjectDescription_ResultVariable] eExpressionParseError");
break;
case eExpressionDiscarded:
log->Printf("[GetObjectDescription_ResultVariable] eExpressionDiscarded");
break;
case eExpressionInterrupted:
log->Printf(
"[GetObjectDescription_ResultVariable] eExpressionInterrupted");
break;
case eExpressionHitBreakpoint:
log->Printf(
"[GetObjectDescription_ResultVariable] eExpressionHitBreakpoint");
break;
case eExpressionTimedOut:
log->Printf("[GetObjectDescription_ResultVariable] eExpressionTimedOut");
break;
case eExpressionResultUnavailable:
log->Printf(
"[GetObjectDescription_ResultVariable] eExpressionResultUnavailable");
break;
case eExpressionStoppedForDebug:
log->Printf(
"[GetObjectDescription_ResultVariable] eExpressionStoppedForDebug");
break;
}
}
// sanitize the result of the expression before moving forward
if (!result_sp) {
if (log)
log->Printf("[GetObjectDescription_ResultVariable] expression generated "
"no result");
return false;
}
if (result_sp->GetError().Fail()) {
if (log)
log->Printf("[GetObjectDescription_ResultVariable] expression generated "
"error: %s",
result_sp->GetError().AsCString());
return false;
}
if (false == result_sp->GetCompilerType().IsValid()) {
if (log)
log->Printf("[GetObjectDescription_ResultVariable] expression generated "
"invalid type");
return false;
}
lldb_private::formatters::StringPrinter::ReadStringAndDumpToStreamOptions
dump_options;
dump_options.SetEscapeNonPrintables(false).SetQuote('\0').SetPrefixToken(
nullptr);
if (lldb_private::formatters::swift::String_SummaryProvider(
*result_sp.get(), str, TypeSummaryOptions()
.SetLanguage(lldb::eLanguageTypeSwift)
.SetCapping(eTypeSummaryUncapped),
dump_options)) {
if (log)
log->Printf("[GetObjectDescription_ResultVariable] expression completed "
"successfully");
return true;
} else {
if (log)
log->Printf("[GetObjectDescription_ResultVariable] expression generated "
"invalid string data");
return false;
}
}
static bool GetObjectDescription_ObjectReference(Process *process, Stream &str,
ValueObject &object) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
StreamString expr_string;
expr_string.Printf("Swift._DebuggerSupport.stringForPrintObject(Swift."
"unsafeBitCast(0x%" PRIx64 ", to: AnyObject.self))",
object.GetValueAsUnsigned(0));
if (log)
log->Printf("[GetObjectDescription_ObjectReference] expression: %s",
expr_string.GetData());
ValueObjectSP result_sp;
EvaluateExpressionOptions eval_options;
eval_options.SetLanguage(lldb::eLanguageTypeSwift);
eval_options.SetResultIsInternal(true);
eval_options.SetGenerateDebugInfo(true);
auto eval_result = process->GetTarget().EvaluateExpression(
expr_string.GetData(),
process->GetThreadList().GetSelectedThread()->GetSelectedFrame().get(),
result_sp, eval_options);
if (log) {
switch (eval_result) {
case eExpressionCompleted:
log->Printf(
"[GetObjectDescription_ObjectReference] eExpressionCompleted");
break;
case eExpressionSetupError:
log->Printf(
"[GetObjectDescription_ObjectReference] eExpressionSetupError");
break;
case eExpressionParseError:
log->Printf(
"[GetObjectDescription_ObjectReference] eExpressionParseError");
break;
case eExpressionDiscarded:
log->Printf(
"[GetObjectDescription_ObjectReference] eExpressionDiscarded");
break;
case eExpressionInterrupted:
log->Printf(
"[GetObjectDescription_ObjectReference] eExpressionInterrupted");
break;
case eExpressionHitBreakpoint:
log->Printf(
"[GetObjectDescription_ObjectReference] eExpressionHitBreakpoint");
break;
case eExpressionTimedOut:
log->Printf("[GetObjectDescription_ObjectReference] eExpressionTimedOut");
break;
case eExpressionResultUnavailable:
log->Printf("[GetObjectDescription_ObjectReference] "
"eExpressionResultUnavailable");
break;
case eExpressionStoppedForDebug:
log->Printf(
"[GetObjectDescription_ObjectReference] eExpressionStoppedForDebug");
break;
}
}
// sanitize the result of the expression before moving forward
if (!result_sp) {
if (log)
log->Printf("[GetObjectDescription_ObjectReference] expression generated "
"no result");
return false;
}
if (result_sp->GetError().Fail()) {
if (log)
log->Printf("[GetObjectDescription_ObjectReference] expression generated "
"error: %s",
result_sp->GetError().AsCString());
return false;
}
if (false == result_sp->GetCompilerType().IsValid()) {
if (log)
log->Printf("[GetObjectDescription_ObjectReference] expression generated "
"invalid type");
return false;
}
lldb_private::formatters::StringPrinter::ReadStringAndDumpToStreamOptions
dump_options;
dump_options.SetEscapeNonPrintables(false).SetQuote('\0').SetPrefixToken(
nullptr);
if (lldb_private::formatters::swift::String_SummaryProvider(
*result_sp.get(), str, TypeSummaryOptions()
.SetLanguage(lldb::eLanguageTypeSwift)
.SetCapping(eTypeSummaryUncapped),
dump_options)) {
if (log)
log->Printf("[GetObjectDescription_ObjectReference] expression completed "
"successfully");
return true;
} else {
if (log)
log->Printf("[GetObjectDescription_ObjectReference] expression generated "
"invalid string data");
return false;
}
}
static bool GetObjectDescription_ObjectCopy(Process *process, Stream &str,
ValueObject &object) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
ValueObjectSP static_sp(object.GetStaticValue());
CompilerType static_type(static_sp->GetCompilerType());
if (auto non_reference_type = static_type.GetNonReferenceType())
static_type = non_reference_type;
Status error;
lldb::addr_t copy_location = process->AllocateMemory(
static_type.GetByteStride(), ePermissionsReadable | ePermissionsWritable,
error);
if (copy_location == LLDB_INVALID_ADDRESS) {
if (log)
log->Printf("[GetObjectDescription_ObjectCopy] copy_location invalid");
return false;
}
CleanUp cleanup(
[process, copy_location] { process->DeallocateMemory(copy_location); });
DataExtractor data_extractor;
if (0 == static_sp->GetData(data_extractor, error)) {
if (log)
log->Printf("[GetObjectDescription_ObjectCopy] data extraction failed");
return false;
}
if (0 ==
process->WriteMemory(copy_location, data_extractor.GetDataStart(),
data_extractor.GetByteSize(), error)) {
if (log)
log->Printf("[GetObjectDescription_ObjectCopy] memory copy failed");
return false;
}
StreamString expr_string;
expr_string.Printf("Swift._DebuggerSupport.stringForPrintObject(Swift."
"UnsafePointer<%s>(bitPattern: 0x%" PRIx64 ")!.pointee)",
static_type.GetTypeName().GetCString(), copy_location);
if (log)
log->Printf("[GetObjectDescription_ObjectCopy] expression: %s",
expr_string.GetData());
ValueObjectSP result_sp;
EvaluateExpressionOptions eval_options;
eval_options.SetLanguage(lldb::eLanguageTypeSwift);
eval_options.SetResultIsInternal(true);
eval_options.SetGenerateDebugInfo(true);
auto eval_result = process->GetTarget().EvaluateExpression(
expr_string.GetData(),
process->GetThreadList().GetSelectedThread()->GetSelectedFrame().get(),
result_sp, eval_options);
if (log) {
switch (eval_result) {
case eExpressionCompleted:
log->Printf("[GetObjectDescription_ObjectCopy] eExpressionCompleted");
break;
case eExpressionSetupError:
log->Printf("[GetObjectDescription_ObjectCopy] eExpressionSetupError");
break;
case eExpressionParseError:
log->Printf("[GetObjectDescription_ObjectCopy] eExpressionParseError");
break;
case eExpressionDiscarded:
log->Printf("[GetObjectDescription_ObjectCopy] eExpressionDiscarded");
break;
case eExpressionInterrupted:
log->Printf("[GetObjectDescription_ObjectCopy] eExpressionInterrupted");
break;
case eExpressionHitBreakpoint:
log->Printf("[GetObjectDescription_ObjectCopy] eExpressionHitBreakpoint");
break;
case eExpressionTimedOut:
log->Printf("[GetObjectDescription_ObjectCopy] eExpressionTimedOut");
break;
case eExpressionResultUnavailable:
log->Printf(
"[GetObjectDescription_ObjectCopy] eExpressionResultUnavailable");
break;
case eExpressionStoppedForDebug:
log->Printf(
"[GetObjectDescription_ObjectCopy] eExpressionStoppedForDebug");
break;
}
}
// sanitize the result of the expression before moving forward
if (!result_sp) {
if (log)
log->Printf(
"[GetObjectDescription_ObjectCopy] expression generated no result");
str.Printf("expression produced no result");
return true;
}
if (result_sp->GetError().Fail()) {
if (log)
log->Printf(
"[GetObjectDescription_ObjectCopy] expression generated error: %s",
result_sp->GetError().AsCString());
str.Printf("expression produced error: %s",
result_sp->GetError().AsCString());
return true;
}
if (false == result_sp->GetCompilerType().IsValid()) {
if (log)
log->Printf("[GetObjectDescription_ObjectCopy] expression generated "
"invalid type");
str.Printf("expression produced invalid result type");
return true;
}
lldb_private::formatters::StringPrinter::ReadStringAndDumpToStreamOptions
dump_options;
dump_options.SetEscapeNonPrintables(false).SetQuote('\0').SetPrefixToken(
nullptr);
if (lldb_private::formatters::swift::String_SummaryProvider(
*result_sp.get(), str, TypeSummaryOptions()
.SetLanguage(lldb::eLanguageTypeSwift)
.SetCapping(eTypeSummaryUncapped),
dump_options)) {
if (log)
log->Printf("[GetObjectDescription_ObjectCopy] expression completed "
"successfully");
} else {
if (log)
log->Printf("[GetObjectDescription_ObjectCopy] expression generated "
"invalid string data");
str.Printf("expression produced unprintable string");
}
return true;
}
static bool IsSwiftResultVariable(const ConstString &name) {
if (name) {
llvm::StringRef name_sr(name.GetStringRef());
if (name_sr.size() > 2 &&
(name_sr.startswith("$R") || name_sr.startswith("$E")) &&
::isdigit(name_sr[2]))
return true;
}
return false;
}
static bool IsSwiftReferenceType(ValueObject &object) {
CompilerType object_type(object.GetCompilerType());
if (llvm::dyn_cast_or_null<SwiftASTContext>(object_type.GetTypeSystem())) {
Flags type_flags(object_type.GetTypeInfo());
if (type_flags.AllSet(eTypeIsClass | eTypeHasValue |
eTypeInstanceIsPointer))
return true;
}
return false;
}
bool SwiftLanguageRuntime::GetObjectDescription(Stream &str,
ValueObject &object) {
if (object.IsUninitializedReference()) {
str.Printf("<uninitialized>");
return true;
}
if (::IsSwiftResultVariable(object.GetName())) {
// if this thing is a Swift expression result variable, it has two
// properties:
// a) its name is something we can refer to in expressions for free
// b) its type may be something we can't actually talk about in expressions
// so, just use the result variable's name in the expression and be done
// with it
StreamString probe_stream;
if (GetObjectDescription_ResultVariable(m_process, probe_stream, object)) {
str.Printf("%s", probe_stream.GetData());
return true;
}
} else if (::IsSwiftReferenceType(object)) {
// if this is a Swift class, it has two properties:
// a) we do not need its type name, AnyObject is just as good
// b) its value is something we can directly use to refer to it
// so, just use the ValueObject's pointer-value and be done with it
StreamString probe_stream;
if (GetObjectDescription_ObjectReference(m_process, probe_stream, object)) {
str.Printf("%s", probe_stream.GetData());
return true;
}
}
// in general, don't try to use the name of the ValueObject as it might end up
// referring to the wrong thing
return GetObjectDescription_ObjectCopy(m_process, str, object);
}
bool SwiftLanguageRuntime::GetObjectDescription(
Stream &str, Value &value, ExecutionContextScope *exe_scope) {
// This is only interesting to do with a ValueObject for Swift
return false;
}
bool SwiftLanguageRuntime::IsSwiftMangledName(const char *name) {
return swift::Demangle::isSwiftSymbol(name);
}
std::string SwiftLanguageRuntime::DemangleSymbolAsString (const char *symbol,
bool simplified) {
if (simplified) {
swift::Demangle::DemangleOptions options(swift::Demangle::DemangleOptions::
SimplifiedUIDemangleOptions());
return swift::Demangle::demangleSymbolAsString(
symbol, strlen(symbol), options);
} else
return swift::Demangle::demangleSymbolAsString(symbol, strlen(symbol));
}
std::string SwiftLanguageRuntime::DemangleSymbolAsString (const ConstString &symbol,
bool simplified) {
if (simplified) {
swift::Demangle::DemangleOptions options(swift::Demangle::DemangleOptions::
SimplifiedUIDemangleOptions());
return swift::Demangle::demangleSymbolAsString(
symbol.GetStringRef(), options);
} else
return swift::Demangle::demangleSymbolAsString(symbol.GetStringRef());
}
bool SwiftLanguageRuntime::IsSwiftClassName(const char *name)
{
return swift::Demangle::isClass(name);
}
const std::string SwiftLanguageRuntime::GetCurrentMangledName(const char *mangled_name)
{
#ifndef USE_NEW_MANGLING
return std::string(mangled_name);
#else
//FIXME: Check if we need to cache these lookups...
swift::Demangle::Context demangle_ctx;
swift::Demangle::NodePointer node_ptr = demangle_ctx.demangleSymbolAsNode(mangled_name);
if (!node_ptr)
{
// Sometimes this gets passed the prefix of a name, in which case we
// won't be able to demangle it. In that case return what was passed in.
printf ("Couldn't get mangled name for %s.\n", mangled_name);
return mangled_name;
}
else
return swift::Demangle::mangleNode(node_ptr);
#endif
}
void SwiftLanguageRuntime::MethodName::Clear() {
m_full.Clear();
m_basename = llvm::StringRef();
m_context = llvm::StringRef();
m_arguments = llvm::StringRef();
m_qualifiers = llvm::StringRef();
m_template_args = llvm::StringRef();
m_metatype_ref = llvm::StringRef();
m_return_type = llvm::StringRef();
m_type = eTypeInvalid;
m_parsed = false;
m_parse_error = false;
}
static bool StringHasAllOf(const llvm::StringRef &s, const char *which) {
for (const char *c = which; *c != 0; c++) {
if (s.find(*c) == llvm::StringRef::npos)
return false;
}
return true;
}
static bool StringHasAnyOf(const llvm::StringRef &s,
std::initializer_list<const char *> which,
size_t &where) {
for (const char *item : which) {
size_t where_item = s.find(item);
if (where_item != llvm::StringRef::npos) {
where = where_item;
return true;
}
}
where = llvm::StringRef::npos;
return false;
}
bool StringHasAnyOf(const llvm::StringRef &s, const char *which,
size_t &where) {
for (const char *c = which; *c != 0; c++) {
size_t where_item = s.find(*c);
if (where_item != llvm::StringRef::npos) {
where = where_item;
return true;
}
}
where = llvm::StringRef::npos;
return false;
}
static bool UnpackTerminatedSubstring(const llvm::StringRef &s,
const char start, const char stop,
llvm::StringRef &dest) {
size_t pos_of_start = s.find(start);
if (pos_of_start == llvm::StringRef::npos)
return false;
size_t pos_of_stop = s.rfind(stop);
if (pos_of_stop == llvm::StringRef::npos)
return false;
size_t token_count = 1;
size_t idx = pos_of_start + 1;
while (idx < s.size()) {
if (s[idx] == start)
++token_count;
if (s[idx] == stop) {
if (token_count == 1) {
dest = s.slice(pos_of_start, idx + 1);
return true;
}
}
idx++;
}
return false;
}
static bool UnpackQualifiedName(const llvm::StringRef &s, llvm::StringRef &decl,
llvm::StringRef &basename, bool &was_operator) {
size_t pos_of_dot = s.rfind('.');
if (pos_of_dot == llvm::StringRef::npos)
return false;
decl = s.substr(0, pos_of_dot);
basename = s.substr(pos_of_dot + 1);
size_t idx_of_operator;
was_operator = StringHasAnyOf(basename, {"@infix", "@prefix", "@postfix"},
idx_of_operator);
if (was_operator)
basename = basename.substr(0, idx_of_operator - 1);
return !decl.empty() && !basename.empty();
}
static bool ParseLocalDeclName(const swift::Demangle::NodePointer &node,
StreamString &identifier,
swift::Demangle::Node::Kind &parent_kind,
swift::Demangle::Node::Kind &kind) {
swift::Demangle::Node::iterator end = node->end();
for (swift::Demangle::Node::iterator pos = node->begin(); pos != end; ++pos) {
swift::Demangle::NodePointer child = *pos;
swift::Demangle::Node::Kind child_kind = child->getKind();
switch (child_kind) {
case swift::Demangle::Node::Kind::Number:
break;
default:
if (child->hasText()) {
identifier.PutCString(child->getText());
return true;
}
break;
}
}
return false;
}
static bool ParseFunction(const swift::Demangle::NodePointer &node,
StreamString &identifier,
swift::Demangle::Node::Kind &parent_kind,
swift::Demangle::Node::Kind &kind) {
swift::Demangle::Node::iterator end = node->end();
swift::Demangle::Node::iterator pos = node->begin();
// First child is the function's scope
parent_kind = (*pos)->getKind();
++pos;
// Second child is either the type (no identifier)
if (pos != end) {
switch ((*pos)->getKind()) {
case swift::Demangle::Node::Kind::Type:
break;
case swift::Demangle::Node::Kind::LocalDeclName:
if (ParseLocalDeclName(*pos, identifier, parent_kind, kind))
return true;
else
return false;
break;
default:
case swift::Demangle::Node::Kind::InfixOperator:
case swift::Demangle::Node::Kind::PostfixOperator:
case swift::Demangle::Node::Kind::PrefixOperator:
case swift::Demangle::Node::Kind::Identifier:
if ((*pos)->hasText())
identifier.PutCString((*pos)->getText());
return true;
}
}
return false;
}
static bool ParseGlobal(const swift::Demangle::NodePointer &node,
StreamString &identifier,
swift::Demangle::Node::Kind &parent_kind,
swift::Demangle::Node::Kind &kind) {
swift::Demangle::Node::iterator end = node->end();
for (swift::Demangle::Node::iterator pos = node->begin(); pos != end; ++pos) {
swift::Demangle::NodePointer child = *pos;
if (child) {
kind = child->getKind();
switch (child->getKind()) {
case swift::Demangle::Node::Kind::Allocator:
identifier.PutCString("__allocating_init");
ParseFunction(child, identifier, parent_kind, kind);
return true;
case swift::Demangle::Node::Kind::Constructor:
identifier.PutCString("init");
ParseFunction(child, identifier, parent_kind, kind);
return true;
case swift::Demangle::Node::Kind::Deallocator:
identifier.PutCString("__deallocating_deinit");
ParseFunction(child, identifier, parent_kind, kind);
return true;
case swift::Demangle::Node::Kind::Destructor:
identifier.PutCString("deinit");
ParseFunction(child, identifier, parent_kind, kind);
return true;
case swift::Demangle::Node::Kind::Getter:
case swift::Demangle::Node::Kind::Setter:
case swift::Demangle::Node::Kind::Function:
return ParseFunction(child, identifier, parent_kind, kind);
// Ignore these, they decorate a function at the same level, but don't
// contain any text
case swift::Demangle::Node::Kind::ObjCAttribute:
break;
default:
return false;
}
}
}
return false;
}
bool SwiftLanguageRuntime::MethodName::ExtractFunctionBasenameFromMangled(
const ConstString &mangled, ConstString &basename, bool &is_method) {
bool success = false;
swift::Demangle::Node::Kind kind = swift::Demangle::Node::Kind::Global;
swift::Demangle::Node::Kind parent_kind = swift::Demangle::Node::Kind::Global;
if (mangled) {
const char *mangled_cstr = mangled.GetCString();
const size_t mangled_cstr_len = mangled.GetLength();
if (mangled_cstr_len > 3) {
llvm::StringRef mangled_ref(mangled_cstr, mangled_cstr_len);
// Only demangle swift functions
// This is a no-op right now for the new mangling, because you
// have to demangle the whole name to figure this out anyway.
// I'm leaving the test here in case we actually need to do this
// only to functions.
swift::Demangle::Context demangle_ctx;
swift::Demangle::NodePointer node =
demangle_ctx.demangleSymbolAsNode(mangled_ref);
StreamString identifier;
if (node) {
switch (node->getKind()) {
case swift::Demangle::Node::Kind::Global:
success = ParseGlobal(node, identifier, parent_kind, kind);
break;
default:
break;
}
if (!identifier.GetString().empty()) {
basename = ConstString(identifier.GetString());
}
}
}
}
if (success) {
switch (kind) {
case swift::Demangle::Node::Kind::Allocator:
case swift::Demangle::Node::Kind::Constructor:
case swift::Demangle::Node::Kind::Deallocator:
case swift::Demangle::Node::Kind::Destructor:
is_method = true;
break;
case swift::Demangle::Node::Kind::Getter:
case swift::Demangle::Node::Kind::Setter:
// don't handle getters and setters right now...
return false;
case swift::Demangle::Node::Kind::Function:
switch (parent_kind) {
case swift::Demangle::Node::Kind::BoundGenericClass:
case swift::Demangle::Node::Kind::BoundGenericEnum:
case swift::Demangle::Node::Kind::BoundGenericStructure:
case swift::Demangle::Node::Kind::Class:
case swift::Demangle::Node::Kind::Enum:
case swift::Demangle::Node::Kind::Structure:
is_method = true;
break;
default:
break;
}
break;
default:
break;
}
}
return success;
}
void SwiftLanguageRuntime::MethodName::Parse() {
if (!m_parsed && m_full) {
// ConstString mangled;
// m_full.GetMangledCounterpart(mangled);
// printf ("\n parsing = '%s'\n", m_full.GetCString());
// if (mangled)
// printf (" mangled = '%s'\n", mangled.GetCString());
m_parse_error = false;
m_parsed = true;
llvm::StringRef full(m_full.GetCString());
bool was_operator = false;
if (full.find("::") != llvm::StringRef::npos) {
// :: is not an allowed operator in Swift (func ::(...) { fails to
// compile)
// but it's a very legitimate token in C++ - as a defense, reject anything
// with a :: in it as invalid Swift
m_parse_error = true;
return;
}
if (StringHasAllOf(full, ".:()")) {
const size_t open_paren = full.find(" (");
llvm::StringRef funcname = full.substr(0, open_paren);
UnpackQualifiedName(funcname, m_context, m_basename, was_operator);
if (was_operator)
m_type = eTypeOperator;
// check for obvious constructor/destructor cases
else if (m_basename.equals("__deallocating_destructor"))
m_type = eTypeDeallocator;
else if (m_basename.equals("__allocating_constructor"))
m_type = eTypeAllocator;
else if (m_basename.equals("init"))
m_type = eTypeConstructor;
else if (m_basename.equals("destructor"))
m_type = eTypeDestructor;
else
m_type = eTypeUnknownMethod;
const size_t idx_of_colon =
full.find(':', open_paren == llvm::StringRef::npos ? 0 : open_paren);
full = full.substr(idx_of_colon + 2);
if (full.empty())
return;
if (full[0] == '<') {
if (UnpackTerminatedSubstring(full, '<', '>', m_template_args)) {
full = full.substr(m_template_args.size());
} else {
m_parse_error = true;
return;
}
}
if (full.empty())
return;
if (full[0] == '(') {
if (UnpackTerminatedSubstring(full, '(', ')', m_metatype_ref)) {
full = full.substr(m_template_args.size());
if (full[0] == '<') {
if (UnpackTerminatedSubstring(full, '<', '>', m_template_args)) {
full = full.substr(m_template_args.size());
} else {
m_parse_error = true;
return;
}
}
} else {
m_parse_error = true;
return;
}
}
if (full.empty())
return;
if (full[0] == '(') {
if (UnpackTerminatedSubstring(full, '(', ')', m_arguments)) {
full = full.substr(m_template_args.size());
} else {
m_parse_error = true;
return;
}
}
if (full.empty())
return;
size_t idx_of_ret = full.find("->");
if (idx_of_ret == llvm::StringRef::npos) {
full = full.substr(idx_of_ret);
if (full.empty()) {
m_parse_error = true;
return;
}
if (full[0] == ' ')
full = full.substr(1);
m_return_type = full;
}
} else if (full.find('.') != llvm::StringRef::npos) {
// this is probably just a full name (module.type.func)
UnpackQualifiedName(full, m_context, m_basename, was_operator);
if (was_operator)
m_type = eTypeOperator;
else
m_type = eTypeUnknownMethod;
} else {
// this is most probably just a basename
m_basename = full;
m_type = eTypeUnknownMethod;
}
}
}
llvm::StringRef SwiftLanguageRuntime::MethodName::GetBasename() {
if (!m_parsed)
Parse();
return m_basename;
}
const CompilerType &SwiftLanguageRuntime::GetBoxMetadataType() {
if (m_box_metadata_type.IsValid())
return m_box_metadata_type;
static ConstString g_type_name("__lldb_autogen_boxmetadata");
const bool is_packed = false;
if (ClangASTContext *ast_ctx =
GetProcess()->GetTarget().GetScratchClangASTContext()) {
CompilerType voidstar =
ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType();
CompilerType uint32 = ClangASTContext::GetIntTypeFromBitSize(
ast_ctx->getASTContext(), 32, false);
m_box_metadata_type = ast_ctx->GetOrCreateStructForIdentifier(
g_type_name, {{"kind", voidstar}, {"offset", uint32}}, is_packed);
}
return m_box_metadata_type;
}
std::shared_ptr<swift::remote::MemoryReader>
SwiftLanguageRuntime::GetMemoryReader() {
class MemoryReader : public swift::remote::MemoryReader {
public:
MemoryReader(Process *p, size_t max_read_amount = 50 * 1024)
: m_process(p) {
lldbassert(m_process && "MemoryReader requires a valid Process");
m_max_read_amount = max_read_amount;
}
virtual ~MemoryReader() = default;
uint8_t getPointerSize() override {
return m_process->GetAddressByteSize();
}
uint8_t getSizeSize() override {
return getPointerSize(); // FIXME: sizeof(size_t)
}
swift::remote::RemoteAddress
getSymbolAddress(const std::string &name) override {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES));
if (name.empty())
return swift::remote::RemoteAddress(nullptr);
if (log)
log->Printf("[MemoryReader] asked to retrieve address of symbol %s",
name.c_str());
ConstString name_cs(name.c_str(), name.size());
SymbolContextList sc_list;
if (m_process->GetTarget().GetImages().FindSymbolsWithNameAndType(
name_cs, lldb::eSymbolTypeAny, sc_list)) {
SymbolContext sym_ctx;
// Remove undefined symbols from the list:
size_t num_sc_matches = sc_list.GetSize();
if (num_sc_matches > 1) {
SymbolContextList tmp_sc_list(sc_list);
sc_list.Clear();
for (size_t idx = 0; idx < num_sc_matches; idx++) {
tmp_sc_list.GetContextAtIndex(idx, sym_ctx);
if (sym_ctx.symbol &&
sym_ctx.symbol->GetType() != lldb::eSymbolTypeUndefined) {
sc_list.Append(sym_ctx);
}
}
}
if (sc_list.GetSize() == 1 && sc_list.GetContextAtIndex(0, sym_ctx)) {
if (sym_ctx.symbol) {
auto load_addr =
sym_ctx.symbol->GetLoadAddress(&m_process->GetTarget());
if (log)
log->Printf("[MemoryReader] symbol resolved to 0x%" PRIx64,
load_addr);
return swift::remote::RemoteAddress(load_addr);
}
}
}
if (log)
log->Printf("[MemoryReader] symbol resolution failed");
return swift::remote::RemoteAddress(nullptr);
}
bool readBytes(swift::remote::RemoteAddress address, uint8_t *dest,
uint64_t size) override {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES));
if (log)
log->Printf("[MemoryReader] asked to read %" PRIu64
" bytes at address 0x%" PRIx64,
size, address.getAddressData());
if (size > m_max_read_amount) {
if (log)
log->Printf(
"[MemoryReader] memory read exceeds maximum allowed size");
return false;
}
Target &target(m_process->GetTarget());
Address addr(address.getAddressData());
Status error;
if (size > target.ReadMemory(addr, false, dest, size, error)) {
if (log)
log->Printf(
"[MemoryReader] memory read returned fewer bytes than asked for");
return false;
}
if (error.Fail()) {
if (log)
log->Printf("[MemoryReader] memory read returned error: %s",
error.AsCString());
return false;
}
if (log) {
StreamString stream;
for (uint64_t i = 0; i < size; i++) {
stream.PutHex8(dest[i]);
stream.PutChar(' ');
}
log->Printf("[MemoryReader] memory read returned data: %s",
stream.GetData());
}
return true;
}
bool readString(swift::remote::RemoteAddress address,
std::string &dest) override {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES));
if (log)
log->Printf(
"[MemoryReader] asked to read string data at address 0x%" PRIx64,
address.getAddressData());
std::vector<char> storage(m_max_read_amount, 0);
Target &target(m_process->GetTarget());
Address addr(address.getAddressData());
Status error;
target.ReadCStringFromMemory(addr, &storage[0], storage.size(), error);
if (error.Success()) {
dest.assign(&storage[0]);
if (log)
log->Printf("[MemoryReader] memory read returned data: %s",
dest.c_str());
return true;
} else {
if (log)
log->Printf("[MemoryReader] memory read returned error: %s",
error.AsCString());
return false;
}
}
private:
Process *m_process;
size_t m_max_read_amount;
};
if (!m_memory_reader_sp)
m_memory_reader_sp.reset(new MemoryReader(GetProcess()));
return m_memory_reader_sp;
}
SwiftASTContext *SwiftLanguageRuntime::GetScratchSwiftASTContext() {
Status error;
return m_process->GetTarget().GetScratchSwiftASTContext(error);
}
SwiftLanguageRuntime::MemberVariableOffsetResolver::
MemberVariableOffsetResolver(swift::ASTContext *ast_ctx,
SwiftLanguageRuntime *runtime,
swift::TypeBase *type)
: m_swift_ast(ast_ctx), m_swift_runtime(runtime), m_offsets() {
lldbassert(m_swift_ast &&
"MemberVariableOffsetResolver requires a swift::ASTContext");
lldbassert(m_swift_runtime &&
"MemberVariableOffsetResolver requires a SwiftLanguageRuntime");
lldbassert(type && "MemberVariableOffsetResolver requires a swift::Type");
m_swift_type = type;
m_remote_ast.reset(new swift::remoteAST::RemoteASTContext(
*ast_ctx, m_swift_runtime->GetMemoryReader()));
}
llvm::Optional<uint64_t>
SwiftLanguageRuntime::MemberVariableOffsetResolver::ResolveOffset(
ValueObject *valobj, ConstString ivar_name, Status *error) {
if (error)
error->Clear();
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES));
if (log)
log->Printf(
"[MemberVariableOffsetResolver] asked to resolve offset for ivar %s",
ivar_name.AsCString());
auto iter = m_offsets.find(ivar_name.AsCString()), end = m_offsets.end();
if (iter != end)
return iter->second;
auto optmeta = swift::remote::RemoteAddress(nullptr);
const swift::TypeKind type_kind = m_swift_type->getKind();
switch (type_kind) {
case swift::TypeKind::Class:
case swift::TypeKind::BoundGenericClass: {
if (log)
log->Printf("[MemberVariableOffsetResolver] type is a class - trying to "
"get metadata for valueobject %s",
(valobj ? valobj->GetName().AsCString() : "<null>"));
// retrieve the metadata for class types as this is where we get the maximum
// benefit
if (valobj) {
lldb::addr_t value = valobj->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
if (value == 0 || value == LLDB_INVALID_ADDRESS)
break;
Status error;
lldb::addr_t meta_ptr =
m_swift_runtime->GetProcess()->ReadPointerFromMemory(value, error);
if (error.Fail() || meta_ptr == 0 || meta_ptr == LLDB_INVALID_ADDRESS)
break;
if (auto objc_runtime = m_swift_runtime->GetObjCRuntime()) {
if (objc_runtime->GetRuntimeVersion() ==
ObjCLanguageRuntime::ObjCRuntimeVersions::eAppleObjC_V2) {
meta_ptr =
((AppleObjCRuntimeV2 *)objc_runtime)->GetPointerISA(meta_ptr);
}
}
optmeta = swift::remote::RemoteAddress(meta_ptr);
}
if (log)
log->Printf("[MemberVariableOffsetResolver] optmeta = 0x%" PRIx64,
optmeta.getAddressData());
} break;
default: {
if (log)
log->Printf("[MemberVariableOffsetResolver] type is not a class - no "
"metadata needed");
} break;
}
swift::remoteAST::Result<uint64_t> result = m_remote_ast->getOffsetOfMember(
m_swift_type, optmeta, ivar_name.GetStringRef());
if (result) {
if (log)
log->Printf("[MemberVariableOffsetResolver] offset discovered = %" PRIu64,
(uint64_t)result.getValue());
m_offsets.emplace(ivar_name.AsCString(), result.getValue());
return result.getValue();
} else {
const auto &failure = result.getFailure();
if (error)
error->SetErrorStringWithFormat("error in resolving type offset: %s",
failure.render().c_str());
if (log)
log->Printf("[MemberVariableOffsetResolver] failure: %s",
failure.render().c_str());
return llvm::Optional<uint64_t>();
}
}
SwiftLanguageRuntime::MetadataPromise::MetadataPromise(
swift::ASTContext *ast_ctx, SwiftLanguageRuntime *runtime,
lldb::addr_t location)
: m_swift_ast(ast_ctx), m_swift_runtime(runtime),
m_metadata_location(location) {
lldbassert(m_swift_ast && "MetadataPromise requires a swift::ASTContext");
lldbassert(m_swift_runtime &&
"MetadataPromise requires a SwiftLanguageRuntime");
m_remote_ast.reset(new swift::remoteAST::RemoteASTContext(
*ast_ctx, m_swift_runtime->GetMemoryReader()));
}
CompilerType
SwiftLanguageRuntime::MetadataPromise::FulfillTypePromise(Status *error) {
if (error)
error->Clear();
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES));
if (log)
log->Printf("[MetadataPromise] asked to fulfill type promise at location "
"0x%" PRIx64,
m_metadata_location);
if (m_compiler_type.hasValue())
return m_compiler_type.getValue();
swift::remoteAST::Result<swift::Type> result =
m_remote_ast->getTypeForRemoteTypeMetadata(
swift::remote::RemoteAddress(m_metadata_location));
if (result) {
m_compiler_type = CompilerType(m_swift_ast, result.getValue().getPointer());
if (log)
log->Printf("[MetadataPromise] result is type %s",
m_compiler_type->GetTypeName().AsCString());
return m_compiler_type.getValue();
} else {
const auto &failure = result.getFailure();
if (error)
error->SetErrorStringWithFormat("error in resolving type: %s",
failure.render().c_str());
if (log)
log->Printf("[MetadataPromise] failure: %s", failure.render().c_str());
return (m_compiler_type = CompilerType()).getValue();
}
}
llvm::Optional<swift::MetadataKind>
SwiftLanguageRuntime::MetadataPromise::FulfillKindPromise(Status *error) {
if (error)
error->Clear();
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES));
if (log)
log->Printf("[MetadataPromise] asked to fulfill kind promise at location "
"0x%" PRIx64,
m_metadata_location);
if (m_metadata_kind.hasValue())
return m_metadata_kind;
swift::remoteAST::Result<swift::MetadataKind> result =
m_remote_ast->getKindForRemoteTypeMetadata(
swift::remote::RemoteAddress(m_metadata_location));
if (result) {
m_metadata_kind = result.getValue();
if (log)
log->Printf("[MetadataPromise] result is kind %u", result.getValue());
return m_metadata_kind;
} else {
const auto &failure = result.getFailure();
if (error)
error->SetErrorStringWithFormat("error in resolving type: %s",
failure.render().c_str());
if (log)
log->Printf("[MetadataPromise] failure: %s", failure.render().c_str());
return m_metadata_kind;
}
}
bool SwiftLanguageRuntime::MetadataPromise::IsStaticallyDetermined() {
if (llvm::Optional<swift::MetadataKind> kind_promise = FulfillKindPromise()) {
switch (kind_promise.getValue()) {
case swift::MetadataKind::Class:
case swift::MetadataKind::Existential:
case swift::MetadataKind::ObjCClassWrapper:
return false;
default:
return true;
}
}
return true;
}
static inline swift::Type GetSwiftType(const CompilerType &type) {
return swift::Type(
reinterpret_cast<swift::TypeBase *>(type.GetOpaqueQualType()));
}
SwiftLanguageRuntime::MetadataPromiseSP
SwiftLanguageRuntime::GetMetadataPromise(lldb::addr_t addr,
SwiftASTContext *swift_ast_ctx) {
if (!swift_ast_ctx)
swift_ast_ctx = GetScratchSwiftASTContext();
if (!swift_ast_ctx || swift_ast_ctx->HasFatalErrors())
return nullptr;
if (addr == 0 || addr == LLDB_INVALID_ADDRESS)
return nullptr;
if (auto objc_runtime = GetObjCRuntime()) {
if (objc_runtime->GetRuntimeVersion() ==
ObjCLanguageRuntime::ObjCRuntimeVersions::eAppleObjC_V2) {
addr = ((AppleObjCRuntimeV2 *)objc_runtime)->GetPointerISA(addr);
}
}
typename decltype(m_promises_map)::key_type key{
swift_ast_ctx->GetASTContext(), addr};
auto iter = m_promises_map.find(key), end = m_promises_map.end();
if (iter != end)
return iter->second;
MetadataPromiseSP promise_sp(
new MetadataPromise(std::get<0>(key), this, std::get<1>(key)));
m_promises_map.emplace(key, promise_sp);
return promise_sp;
}
SwiftLanguageRuntime::MemberVariableOffsetResolverSP
SwiftLanguageRuntime::GetMemberVariableOffsetResolver(
CompilerType compiler_type) {
if (!compiler_type.IsValid())
return nullptr;
SwiftASTContext *swift_ast_ctx =
llvm::dyn_cast_or_null<SwiftASTContext>(compiler_type.GetTypeSystem());
if (!swift_ast_ctx || swift_ast_ctx->HasFatalErrors())
return nullptr;
swift::TypeBase *swift_type = reinterpret_cast<swift::TypeBase *>(
compiler_type.GetCanonicalType().GetOpaqueQualType());
typename decltype(m_resolvers_map)::key_type key{
swift_ast_ctx->GetASTContext(), swift_type};
auto iter = m_resolvers_map.find(key), end = m_resolvers_map.end();
if (iter != end)
return iter->second;
MemberVariableOffsetResolverSP resolver_sp(new MemberVariableOffsetResolver(
std::get<0>(key), this, std::get<1>(key)));
m_resolvers_map.emplace(key, resolver_sp);
return resolver_sp;
}
static size_t BaseClassDepth(ValueObject &in_value) {
ValueObject *ptr = &in_value;
size_t depth = 0;
while (ptr->IsBaseClass()) {
depth++;
ptr = ptr->GetParent();
}
return depth;
}
bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Class(
ValueObject &in_value, lldb::DynamicValueType use_dynamic,
TypeAndOrName &class_type_or_name, Address &address) {
CompilerType value_type(in_value.GetCompilerType());
AddressType address_type;
lldb::addr_t class_metadata_ptr = in_value.GetPointerValue(&address_type);
if (auto objc_runtime = GetObjCRuntime()) {
if (objc_runtime->IsTaggedPointer(class_metadata_ptr)) {
Value::ValueType value_type;
return objc_runtime->GetDynamicTypeAndAddress(
in_value, use_dynamic, class_type_or_name, address, value_type,
/* allow_swift = */ true);
}
}
if (class_metadata_ptr == LLDB_INVALID_ADDRESS || class_metadata_ptr == 0)
return false;
address.SetRawAddress(class_metadata_ptr);
size_t base_depth = BaseClassDepth(in_value);
lldb::addr_t class_instance_location;
if (in_value.IsBaseClass())
class_instance_location = in_value.GetPointerValue();
else
class_instance_location = in_value.GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
if (class_instance_location == LLDB_INVALID_ADDRESS)
return false;
Status error;
lldb::addr_t class_metadata_location =
m_process->ReadPointerFromMemory(class_instance_location, error);
if (error.Fail() || class_metadata_location == 0 ||
class_metadata_location == LLDB_INVALID_ADDRESS)
return false;
SwiftASTContext *swift_ast_ctx = llvm::dyn_cast_or_null<SwiftASTContext>(
in_value.GetCompilerType().GetTypeSystem());
MetadataPromiseSP promise_sp(
GetMetadataPromise(class_metadata_location, swift_ast_ctx));
if (!promise_sp)
return false;
CompilerType class_type(promise_sp->FulfillTypePromise());
if (!class_type)
return false;
while (base_depth > 0) {
class_type = class_type.GetDirectBaseClassAtIndex(0, nullptr);
assert(class_type && "failed to get base class");
base_depth--;
}
class_type_or_name.SetCompilerType(class_type);
if (error.Fail())
return false;
return class_type_or_name.GetCompilerType().IsValid();
}
SwiftLanguageRuntime::SwiftErrorDescriptor::SwiftErrorDescriptor()
: m_kind(Kind::eNotAnError) {}
bool SwiftLanguageRuntime::IsValidErrorValue(
ValueObject &in_value, SwiftErrorDescriptor *out_error_descriptor) {
// see GetDynamicTypeAndAddress_ErrorType for details
CompilerType var_type(in_value.GetStaticValue()->GetCompilerType());
SwiftASTContext::ProtocolInfo protocol_info;
if (!SwiftASTContext::GetProtocolTypeInfo(var_type, protocol_info))
return false;
if (!protocol_info.m_is_errortype)
return false;
static ConstString g_instance_type_child_name("instance_type");
ValueObjectSP instance_type_sp(
in_value.GetStaticValue()->GetChildMemberWithName(
g_instance_type_child_name, true));
if (!instance_type_sp)
return false;
lldb::addr_t metadata_location = instance_type_sp->GetValueAsUnsigned(0);
if (metadata_location == 0 || metadata_location == LLDB_INVALID_ADDRESS)
return false;
SetupSwiftError();
if (m_SwiftNativeNSErrorISA.hasValue()) {
if (auto objc_runtime = GetObjCRuntime()) {
if (auto descriptor =
objc_runtime->GetClassDescriptor(*instance_type_sp)) {
if (descriptor->GetISA() != m_SwiftNativeNSErrorISA.getValue()) {
// not a _SwiftNativeNSError - but statically typed as ErrorType
// return true here
if (out_error_descriptor) {
*out_error_descriptor = SwiftErrorDescriptor();
out_error_descriptor->m_kind = SwiftErrorDescriptor::Kind::eBridged;
out_error_descriptor->m_bridged.instance_ptr_value =
instance_type_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
}
return true;
}
}
}
}
if (GetObjCRuntime()) {
// this is a swift native error but it can be bridged to ObjC
// so it needs to be layout compatible
size_t ptr_size = m_process->GetAddressByteSize();
size_t metadata_offset =
ptr_size + 4 + (ptr_size == 8 ? 4 : 0); // CFRuntimeBase
metadata_offset += ptr_size + ptr_size + ptr_size; // CFIndex + 2*CFRef
metadata_location += metadata_offset;
Status error;
lldb::addr_t metadata_ptr_value =
m_process->ReadPointerFromMemory(metadata_location, error);
if (metadata_ptr_value == 0 || metadata_ptr_value == LLDB_INVALID_ADDRESS ||
error.Fail())
return false;
if (out_error_descriptor) {
*out_error_descriptor = SwiftErrorDescriptor();
out_error_descriptor->m_kind =
SwiftErrorDescriptor::Kind::eSwiftBridgeableNative;
out_error_descriptor->m_bridgeable_native.metadata_location =
metadata_location;
out_error_descriptor->m_bridgeable_native.metadata_ptr_value =
metadata_ptr_value;
}
} else {
// this is a swift native error and it has no way to be bridged to ObjC
// so it adopts a more compact layout
Status error;
size_t ptr_size = m_process->GetAddressByteSize();
size_t metadata_offset = 2 * ptr_size;
metadata_location += metadata_offset;
lldb::addr_t metadata_ptr_value =
m_process->ReadPointerFromMemory(metadata_location, error);
if (metadata_ptr_value == 0 || metadata_ptr_value == LLDB_INVALID_ADDRESS ||
error.Fail())
return false;
lldb::addr_t witness_table_location = metadata_location + ptr_size;
lldb::addr_t witness_table_ptr_value =
m_process->ReadPointerFromMemory(witness_table_location, error);
if (witness_table_ptr_value == 0 ||
witness_table_ptr_value == LLDB_INVALID_ADDRESS || error.Fail())
return false;
lldb::addr_t payload_location = witness_table_location + ptr_size;
if (out_error_descriptor) {
*out_error_descriptor = SwiftErrorDescriptor();
out_error_descriptor->m_kind =
SwiftErrorDescriptor::Kind::eSwiftPureNative;
out_error_descriptor->m_pure_native.metadata_location =
metadata_ptr_value;
out_error_descriptor->m_pure_native.witness_table_location =
witness_table_ptr_value;
out_error_descriptor->m_pure_native.payload_ptr = payload_location;
}
}
return true;
}
bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_ErrorType(
ValueObject &in_value, lldb::DynamicValueType use_dynamic,
TypeAndOrName &class_type_or_name, Address &address) {
// layout of error type
// pointer to -------> SwiftError {
// --------------
// CFRuntimeBase
// CFIndex
// CFStringRef
// CFDictionaryRef
// --------------
// Metadata
// WitnessTable
// hashable Metadata
// hashable WitnessTable
// --------------
// tail allocated actual object data *
// }
// * for a struct, it's the inline data
// * for a class, it's the inline pointer-to-the-data (aka, the swift class
// instance)
SwiftErrorDescriptor error_descriptor;
if (!IsValidErrorValue(in_value, &error_descriptor))
return false;
Status error;
CompilerType var_type(in_value.GetStaticValue()->GetCompilerType());
size_t ptr_size = m_process->GetAddressByteSize();
SwiftASTContext *swift_ast_ctx =
llvm::dyn_cast_or_null<SwiftASTContext>(var_type.GetTypeSystem());
if (!swift_ast_ctx)
return false;
switch (error_descriptor.m_kind) {
case SwiftErrorDescriptor::Kind::eNotAnError:
return false;
case SwiftErrorDescriptor::Kind::eSwiftBridgeableNative: {
MetadataPromiseSP promise_sp(GetMetadataPromise(
error_descriptor.m_bridgeable_native.metadata_ptr_value,
swift_ast_ctx));
if (!promise_sp)
return false;
error_descriptor.m_bridgeable_native.metadata_location += 4 * ptr_size;
if (!promise_sp->IsStaticallyDetermined()) {
// figure out the actual dynamic type via the metadata at the "isa"
// pointer
error_descriptor.m_bridgeable_native.metadata_location =
m_process->ReadPointerFromMemory(
error_descriptor.m_bridgeable_native.metadata_location, error);
if (error_descriptor.m_bridgeable_native.metadata_location == 0 ||
error_descriptor.m_bridgeable_native.metadata_location ==
LLDB_INVALID_ADDRESS ||
error.Fail())
return false;
error_descriptor.m_bridgeable_native.metadata_ptr_value =
m_process->ReadPointerFromMemory(
error_descriptor.m_bridgeable_native.metadata_location, error);
if (error_descriptor.m_bridgeable_native.metadata_ptr_value == 0 ||
error_descriptor.m_bridgeable_native.metadata_ptr_value ==
LLDB_INVALID_ADDRESS ||
error.Fail())
return false;
promise_sp = GetMetadataPromise(
error_descriptor.m_bridgeable_native.metadata_ptr_value,
swift_ast_ctx);
if (!promise_sp || !promise_sp->FulfillTypePromise()) {
// this could still be a random ObjC object
if (auto objc_runtime = GetObjCRuntime()) {
DataExtractor extractor(
&error_descriptor.m_bridgeable_native.metadata_location,
sizeof(error_descriptor.m_bridgeable_native.metadata_location),
GetProcess()->GetByteOrder(), GetProcess()->GetAddressByteSize());
ExecutionContext exe_ctx(GetProcess());
auto scratch_ast =
GetProcess()->GetTarget().GetScratchClangASTContext();
if (scratch_ast) {
auto valobj_sp = ValueObject::CreateValueObjectFromData(
in_value.GetName().AsCString(), extractor, exe_ctx,
scratch_ast->GetBasicType(eBasicTypeObjCID));
if (valobj_sp) {
Value::ValueType value_type;
if (objc_runtime->GetDynamicTypeAndAddress(
*valobj_sp, use_dynamic, class_type_or_name, address,
value_type)) {
address.SetLoadAddress(
error_descriptor.m_bridgeable_native.metadata_location,
&GetProcess()->GetTarget());
if (!class_type_or_name.GetCompilerType().IsPointerType()) {
// the language runtimes do not return pointer-to-types when
// doing dynamic type resolution
// what usually happens is that the static type has
// pointer-like traits that ValueObjectDynamic
// then preserves in the dynamic value - since the static type
// here is a Swift protocol object
// the dynamic type won't know to pointerize. But we truly
// need an ObjCObjectPointer here or else
// type printing WILL be confused. Hence, make the pointer
// type ourselves if we didn't get one already
class_type_or_name.SetCompilerType(
class_type_or_name.GetCompilerType().GetPointerType());
}
return true;
}
}
}
}
return false;
}
}
if (!promise_sp)
return false;
address.SetLoadAddress(
error_descriptor.m_bridgeable_native.metadata_location,
&m_process->GetTarget());
CompilerType metadata_type(promise_sp->FulfillTypePromise());
if (metadata_type.IsValid() && error.Success()) {
class_type_or_name.SetCompilerType(metadata_type);
return true;
}
} break;
case SwiftErrorDescriptor::Kind::eBridged: {
if (error_descriptor.m_bridged.instance_ptr_value != 0 &&
error_descriptor.m_bridged.instance_ptr_value != LLDB_INVALID_ADDRESS) {
Status error_type_lookup_error;
if (CompilerType error_type =
swift_ast_ctx->GetNSErrorType(error_type_lookup_error)) {
class_type_or_name.SetCompilerType(error_type);
address.SetRawAddress(error_descriptor.m_bridged.instance_ptr_value);
return true;
}
}
} break;
case SwiftErrorDescriptor::Kind::eSwiftPureNative: {
Status error;
if (MetadataPromiseSP promise_sp = GetMetadataPromise(
error_descriptor.m_pure_native.metadata_location, swift_ast_ctx)) {
if (promise_sp->IsStaticallyDetermined()) {
if (CompilerType compiler_type = promise_sp->FulfillTypePromise()) {
class_type_or_name.SetCompilerType(compiler_type);
address.SetRawAddress(error_descriptor.m_pure_native.payload_ptr);
return true;
}
} else {
error_descriptor.m_pure_native.metadata_location =
m_process->ReadPointerFromMemory(
error_descriptor.m_pure_native.payload_ptr, error);
if (error_descriptor.m_pure_native.metadata_location == 0 ||
error_descriptor.m_pure_native.metadata_location ==
LLDB_INVALID_ADDRESS ||
error.Fail())
return false;
error_descriptor.m_pure_native.payload_ptr =
error_descriptor.m_pure_native.metadata_location;
error_descriptor.m_pure_native.metadata_location =
m_process->ReadPointerFromMemory(
error_descriptor.m_pure_native.payload_ptr, error);
if (MetadataPromiseSP promise_sp = GetMetadataPromise(
error_descriptor.m_pure_native.metadata_location,
swift_ast_ctx)) {
if (CompilerType compiler_type = promise_sp->FulfillTypePromise()) {
class_type_or_name.SetCompilerType(compiler_type);
address.SetRawAddress(error_descriptor.m_pure_native.payload_ptr);
return true;
}
}
}
}
} break;
}
return false;
}
bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Protocol(
ValueObject &in_value, lldb::DynamicValueType use_dynamic,
TypeAndOrName &class_type_or_name, Address &address) {
CompilerType var_type(in_value.GetCompilerType());
SwiftASTContext::ProtocolInfo protocol_info;
if (!SwiftASTContext::GetProtocolTypeInfo(var_type, protocol_info))
return false;
if (protocol_info.m_is_errortype)
return GetDynamicTypeAndAddress_ErrorType(in_value, use_dynamic,
class_type_or_name, address);
MetadataPromiseSP promise_sp;
static ConstString g_instance_type_child_name("instance_type");
ValueObjectSP instance_type_sp(
in_value.GetStaticValue()->GetChildMemberWithName(
g_instance_type_child_name, true));
if (!instance_type_sp)
return false;
ValueObjectSP payload0_sp(
in_value.GetStaticValue()->GetChildAtIndex(0, true));
if (!payload0_sp)
return false;
// @objc protocols are automatically class-only, and there is no
// static/dynamic to deal with
bool is_class = protocol_info.m_is_objc || protocol_info.m_is_class_only ||
protocol_info.m_is_anyobject;
if (!is_class) {
promise_sp = GetMetadataPromise(instance_type_sp->GetValueAsUnsigned(0));
if (!promise_sp)
return false;
if (promise_sp->FulfillKindPromise().hasValue() &&
promise_sp->FulfillKindPromise().getValue() ==
swift::MetadataKind::Class)
is_class = true;
}
if (is_class) {
if (GetDynamicTypeAndAddress_Class(*payload0_sp, use_dynamic,
class_type_or_name, address))
return true;
// only for @objc protocols, try to fallback to the ObjC runtime as a source
// of type information
// this is not exactly a great solution and we need to be careful with how
// we use the results of this
// computation, but assuming some care, at least data formatters will work
if (!protocol_info.m_is_objc)
return false;
auto objc_runtime = GetObjCRuntime();
if (!objc_runtime)
return false;
auto descriptor_sp = objc_runtime->GetClassDescriptor(*payload0_sp);
if (!descriptor_sp)
return false;
std::vector<clang::NamedDecl *> decls;
DeclVendor *vendor = objc_runtime->GetDeclVendor();
if (!vendor)
return false;
vendor->FindDecls(descriptor_sp->GetClassName(), true, 1, decls);
if (decls.size() == 0)
return false;
CompilerType type = ClangASTContext::GetTypeForDecl(decls[0]);
if (!type.IsValid())
return false;
lldb::addr_t class_metadata_ptr = payload0_sp->GetAddressOf();
if (class_metadata_ptr == LLDB_INVALID_ADDRESS || class_metadata_ptr == 0)
return false;
address.SetRawAddress(class_metadata_ptr);
class_type_or_name.SetCompilerType(type.GetPointerType());
return class_type_or_name.GetCompilerType().IsValid();
}
if (promise_sp->FulfillKindPromise().hasValue() &&
(promise_sp->FulfillKindPromise().getValue() ==
swift::MetadataKind::Struct ||
promise_sp->FulfillKindPromise().getValue() ==
swift::MetadataKind::Enum ||
promise_sp->FulfillKindPromise().getValue() ==
swift::MetadataKind::Tuple)) {
Status error;
class_type_or_name.SetCompilerType(promise_sp->FulfillTypePromise());
if (error.Fail())
return false;
// the choices made here affect dynamic type resolution
// for an inline protocol object, e.g.:
// (P) $R1 = {
// (Builtin.RawPointer) payload_data_0 = 0x0000000000000001
// (Builtin.RawPointer) payload_data_1 = 0x0000000000000002
// (Builtin.RawPointer) payload_data_2 = 0x0000000000000000
// (Builtin.RawPointer) instance_type = 0x000000010054c2f8
// (Builtin.RawPointer) protocol_witness_0 = 0x000000010054c100
// }
// pick &payload_data_0
// for a pointed-to protocol object, e.g.:
// (Q) $R2 = {
// (Builtin.RawPointer) payload_data_0 = 0x00000001006079b0
// (Builtin.RawPointer) payload_data_1 = 0x0000000000000000
// (Builtin.RawPointer) payload_data_2 = 0x0000000000000000
// (Builtin.RawPointer) instance_type = 0x000000010054c648
// (Builtin.RawPointer) protocol_witness_0 = 0x000000010054c7b0
// }
// pick the value of payload_data_0
switch (SwiftASTContext::GetAllocationStrategy(
class_type_or_name.GetCompilerType())) {
case SwiftASTContext::TypeAllocationStrategy::eInline:
// FIXME: we should not have to do this - but we are getting confused
// w.r.t.
// frozen-dried vs. live versions of objects, so hack around it for now
if (in_value.GetValue().GetValueAddressType() == eAddressTypeHost)
address.SetRawAddress(in_value.GetValue().GetScalar().ULongLong());
else
address.SetRawAddress(in_value.GetAddressOf());
return true;
case SwiftASTContext::TypeAllocationStrategy::ePointer:
address.SetRawAddress(payload0_sp->GetValueAsUnsigned(0));
return true;
default:
// TODO we don't know how to deal with the dynamic case quite yet
return false;
}
}
return false;
}
bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Promise(
ValueObject &in_value, MetadataPromiseSP promise_sp,
lldb::DynamicValueType use_dynamic, TypeAndOrName &class_type_or_name,
Address &address) {
if (!promise_sp)
return false;
CompilerType var_type(in_value.GetCompilerType());
Status error;
if (!promise_sp->FulfillKindPromise())
return false;
switch (promise_sp->FulfillKindPromise().getValue()) {
case swift::MetadataKind::Class: {
CompilerType dyn_type(promise_sp->FulfillTypePromise());
if (!dyn_type.IsValid())
return false;
class_type_or_name.SetCompilerType(dyn_type);
lldb::addr_t val_ptr_addr = in_value.GetPointerValue();
val_ptr_addr = GetProcess()->ReadPointerFromMemory(val_ptr_addr, error);
address.SetLoadAddress(val_ptr_addr, &m_process->GetTarget());
return true;
} break;
case swift::MetadataKind::Struct:
case swift::MetadataKind::Tuple: {
CompilerType dyn_type(promise_sp->FulfillTypePromise());
if (!dyn_type.IsValid())
return false;
class_type_or_name.SetCompilerType(dyn_type);
lldb::addr_t val_ptr_addr = in_value.GetPointerValue();
address.SetLoadAddress(val_ptr_addr, &m_process->GetTarget());
return true;
} break;
case swift::MetadataKind::Enum: {
CompilerType dyn_type(promise_sp->FulfillTypePromise());
if (!dyn_type.IsValid())
return false;
class_type_or_name.SetCompilerType(dyn_type);
lldb::addr_t val_ptr_addr = in_value.GetPointerValue();
{
auto swift_type = GetSwiftType(dyn_type);
if (swift_type->getOptionalObjectType())
val_ptr_addr = GetProcess()->ReadPointerFromMemory(val_ptr_addr, error);
}
address.SetLoadAddress(val_ptr_addr, &m_process->GetTarget());
return true;
} break;
case swift::MetadataKind::Existential: {
SwiftASTContext *swift_ast_ctx =
llvm::dyn_cast_or_null<SwiftASTContext>(var_type.GetTypeSystem());
CompilerType protocol_type(promise_sp->FulfillTypePromise());
if (swift_ast_ctx->IsErrorType(protocol_type)) {
if (swift_ast_ctx) {
Status error;
// the offset
size_t ptr_size = m_process->GetAddressByteSize();
size_t metadata_offset = ptr_size + 4 + (ptr_size == 8 ? 4 : 0);
metadata_offset += ptr_size + ptr_size + ptr_size;
lldb::addr_t archetype_ptr_value = in_value.GetValueAsUnsigned(0);
lldb::addr_t base_errortype_ptr =
m_process->ReadPointerFromMemory(archetype_ptr_value, error);
lldb::addr_t static_metadata_ptrptr =
base_errortype_ptr + metadata_offset;
lldb::addr_t static_metadata_ptr =
m_process->ReadPointerFromMemory(static_metadata_ptrptr, error);
MetadataPromiseSP promise_sp(
GetMetadataPromise(static_metadata_ptr, swift_ast_ctx));
if (promise_sp) {
lldb::addr_t load_addr = static_metadata_ptrptr + 2 * ptr_size;
if (promise_sp->FulfillKindPromise() &&
promise_sp->FulfillKindPromise().getValue() ==
swift::MetadataKind::Class) {
load_addr = m_process->ReadPointerFromMemory(load_addr, error);
lldb::addr_t dynamic_metadata_location =
m_process->ReadPointerFromMemory(load_addr, error);
promise_sp =
GetMetadataPromise(dynamic_metadata_location, swift_ast_ctx);
}
CompilerType clang_type(promise_sp->FulfillTypePromise());
if (clang_type.IsValid() && load_addr != 0 &&
load_addr != LLDB_INVALID_ADDRESS) {
class_type_or_name.SetCompilerType(clang_type);
address.SetLoadAddress(load_addr, &m_process->GetTarget());
return true;
}
}
}
} else {
Status error;
lldb::addr_t ptr_to_instance_type = in_value.GetValueAsUnsigned(0) +
(3 * m_process->GetAddressByteSize());
lldb::addr_t metadata_of_impl_addr =
m_process->ReadPointerFromMemory(ptr_to_instance_type, error);
if (error.Fail() || metadata_of_impl_addr == 0 ||
metadata_of_impl_addr == LLDB_INVALID_ADDRESS)
return false;
MetadataPromiseSP promise_of_impl_sp(
GetMetadataPromise(metadata_of_impl_addr, swift_ast_ctx));
if (GetDynamicTypeAndAddress_Promise(in_value, promise_of_impl_sp,
use_dynamic, class_type_or_name,
address)) {
lldb::addr_t load_addr = in_value.GetValueAsUnsigned(0);
if (promise_of_impl_sp->FulfillKindPromise() &&
promise_of_impl_sp->FulfillKindPromise().getValue() ==
swift::MetadataKind::Class) {
load_addr = m_process->ReadPointerFromMemory(load_addr, error);
if (error.Fail() || load_addr == 0 ||
load_addr == LLDB_INVALID_ADDRESS)
return false;
} else if (promise_of_impl_sp->FulfillKindPromise() &&
(promise_of_impl_sp->FulfillKindPromise().getValue() ==
swift::MetadataKind::Enum ||
promise_of_impl_sp->FulfillKindPromise().getValue() ==
swift::MetadataKind::Struct)) {
} else
lldbassert(false && "class, enum and struct are the only protocol "
"implementor types I know about");
address.SetLoadAddress(load_addr, &m_process->GetTarget());
return true;
}
}
} break;
default:
break;
}
return false;
}
SwiftLanguageRuntime::MetadataPromiseSP
SwiftLanguageRuntime::GetPromiseForTypeNameAndFrame(const char *type_name,
StackFrame *frame) {
if (!frame || !type_name || !type_name[0])
return nullptr;
SwiftASTContext *swift_ast_ctx = nullptr;
const SymbolContext &sc(frame->GetSymbolContext(eSymbolContextFunction));
if (sc.function)
swift_ast_ctx = llvm::dyn_cast_or_null<SwiftASTContext>(
sc.function->GetCompilerType().GetTypeSystem());
StreamString type_metadata_ptr_var_name;
type_metadata_ptr_var_name.Printf("$swift.type.%s", type_name);
VariableList *var_list = frame->GetVariableList(false);
if (!var_list)
return nullptr;
VariableSP var_sp(var_list->FindVariable(
ConstString(type_metadata_ptr_var_name.GetData())));
if (!var_sp)
return nullptr;
ValueObjectSP metadata_ptr_var_sp(
frame->GetValueObjectForFrameVariable(var_sp, lldb::eNoDynamicValues));
if (!metadata_ptr_var_sp ||
metadata_ptr_var_sp->UpdateValueIfNeeded() == false)
return nullptr;
lldb::addr_t metadata_location(metadata_ptr_var_sp->GetValueAsUnsigned(0));
if (metadata_location == 0 || metadata_location == LLDB_INVALID_ADDRESS)
return nullptr;
return GetMetadataPromise(metadata_location, swift_ast_ctx);
}
CompilerType
SwiftLanguageRuntime::DoArchetypeBindingForType(StackFrame &stack_frame,
CompilerType base_type) {
SwiftASTContext *ast_context =
llvm::dyn_cast_or_null<SwiftASTContext>(base_type.GetTypeSystem());
lldbassert(ast_context && "null AST Context");
if (!ast_context)
return base_type;
if (base_type.GetTypeInfo() & lldb::eTypeIsSwift) {
swift::Type target_swift_type(GetSwiftType(base_type));
target_swift_type = target_swift_type.transform(
[this, &stack_frame,
ast_context](swift::Type candidate_type) -> swift::Type {
if (swift::ArchetypeType *candidate_archetype =
llvm::dyn_cast_or_null<swift::ArchetypeType>(
candidate_type.getPointer())) {
ConstString candidate_name(candidate_archetype->getFullName());
CompilerType concrete_type = this->GetConcreteType(
&stack_frame, candidate_name);
Status import_error;
CompilerType target_concrete_type =
ast_context->ImportType(concrete_type, import_error);
if (target_concrete_type.IsValid())
return swift::Type(GetSwiftType(target_concrete_type));
else
return candidate_type;
} else
return candidate_type;
});
return CompilerType(ast_context->GetASTContext(),
target_swift_type.getPointer());
}
return base_type;
}
bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Archetype(
ValueObject &in_value, lldb::DynamicValueType use_dynamic,
TypeAndOrName &class_type_or_name, Address &address) {
const char *type_name(in_value.GetTypeName().GetCString());
StackFrame *frame(in_value.GetFrameSP().get());
MetadataPromiseSP promise_sp(GetPromiseForTypeNameAndFrame(type_name, frame));
if (!promise_sp)
return false;
if (!GetDynamicTypeAndAddress_Promise(in_value, promise_sp, use_dynamic,
class_type_or_name, address))
return false;
if (promise_sp->FulfillKindPromise() &&
promise_sp->FulfillKindPromise().getValue() ==
swift::MetadataKind::Class) {
// when an archetype represents a class, it will represent the static type
// of the class
// but the dynamic type might be different
Status error;
lldb::addr_t addr_of_meta = address.GetLoadAddress(&m_process->GetTarget());
addr_of_meta = m_process->ReadPointerFromMemory(addr_of_meta, error);
if (addr_of_meta == LLDB_INVALID_ADDRESS || addr_of_meta == 0 ||
error.Fail())
return true; // my gut says we should fail here, but we seemed to be on a
// good track before..
MetadataPromiseSP actual_type_promise(GetMetadataPromise(addr_of_meta));
if (actual_type_promise && actual_type_promise.get() != promise_sp.get()) {
CompilerType static_type(class_type_or_name.GetCompilerType());
class_type_or_name.SetCompilerType(
actual_type_promise->FulfillTypePromise());
if (error.Fail() ||
class_type_or_name.GetCompilerType().IsValid() == false)
class_type_or_name.SetCompilerType(static_type);
}
}
return true;
}
bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Tuple(
ValueObject &in_value, lldb::DynamicValueType use_dynamic,
TypeAndOrName &class_type_or_name, Address &address) {
std::vector<CompilerType> dyn_types;
for (size_t idx = 0; idx < in_value.GetNumChildren(); idx++) {
ValueObjectSP child_sp(in_value.GetChildAtIndex(idx, true));
TypeAndOrName type_and_or_name;
Address address;
Value::ValueType value_type;
if (GetDynamicTypeAndAddress(*child_sp.get(), use_dynamic, type_and_or_name,
address, value_type) == false)
dyn_types.push_back(child_sp->GetCompilerType());
else
dyn_types.push_back(type_and_or_name.GetCompilerType());
}
SwiftASTContext *swift_ast_ctx = llvm::dyn_cast_or_null<SwiftASTContext>(
in_value.GetCompilerType().GetTypeSystem());
CompilerType dyn_tuple_type(swift_ast_ctx->CreateTupleType(dyn_types));
class_type_or_name.SetCompilerType(dyn_tuple_type);
lldb::addr_t tuple_address = in_value.GetPointerValue();
Status error;
tuple_address = m_process->ReadPointerFromMemory(tuple_address, error);
if (error.Fail() || tuple_address == 0 ||
tuple_address == LLDB_INVALID_ADDRESS)
return false;
address.SetLoadAddress(tuple_address, in_value.GetTargetSP().get());
return true;
}
bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Struct(
ValueObject &in_value, lldb::DynamicValueType use_dynamic,
TypeAndOrName &class_type_or_name, Address &address) {
// struct can't inherit from each other, but they can be generic, in which
// case
// we need to turn MyStruct<U> into MyStruct<$swift.type.U>
std::vector<CompilerType> generic_args;
lldb_private::StackFrame *frame =
in_value.GetExecutionContextRef().GetFrameSP().get();
if (!frame)
return false;
// this will be a BoundGenericStruct, bound to archetypes
CompilerType struct_type(in_value.GetCompilerType());
CompilerType resolved_type(DoArchetypeBindingForType(*frame, struct_type));
if (!resolved_type)
return false;
class_type_or_name.SetCompilerType(resolved_type);
lldb::addr_t struct_address = in_value.GetPointerValue();
if (0 == struct_address || LLDB_INVALID_ADDRESS == struct_address)
struct_address = in_value.GetAddressOf(true, nullptr);
if (0 == struct_address || LLDB_INVALID_ADDRESS == struct_address) {
if (false == SwiftASTContext::IsPossibleZeroSizeType(
class_type_or_name.GetCompilerType()))
return false;
}
address.SetLoadAddress(struct_address, in_value.GetTargetSP().get());
return true;
}
bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Enum(
ValueObject &in_value, lldb::DynamicValueType use_dynamic,
TypeAndOrName &class_type_or_name, Address &address) {
// enums can't inherit from each other, but they can be generic, in which case
// we need to turn MyEnum<U> into MyEnum<$swift.type.U>
std::vector<CompilerType> generic_args;
lldb_private::StackFrame *frame =
in_value.GetExecutionContextRef().GetFrameSP().get();
if (!frame)
return false;
// this will be a BoundGenericEnum, bound to archetypes
CompilerType enum_type(in_value.GetCompilerType());
CompilerType resolved_type(DoArchetypeBindingForType(*frame, enum_type));
if (!resolved_type)
return false;
class_type_or_name.SetCompilerType(resolved_type);
lldb::addr_t enum_address = in_value.GetPointerValue();
if (0 == enum_address || LLDB_INVALID_ADDRESS == enum_address)
enum_address = in_value.GetAddressOf(true, nullptr);
if (0 == enum_address || LLDB_INVALID_ADDRESS == enum_address) {
if (false == SwiftASTContext::IsPossibleZeroSizeType(
class_type_or_name.GetCompilerType()))
return false;
}
address.SetLoadAddress(enum_address, in_value.GetTargetSP().get());
return true;
}
bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_IndirectEnumCase(
ValueObject &in_value, lldb::DynamicValueType use_dynamic,
TypeAndOrName &class_type_or_name, Address &address) {
static ConstString g_offset("offset");
DataExtractor data;
Status error;
if (in_value.GetParent() && in_value.GetParent()->GetData(data, error) &&
error.Success()) {
bool has_payload;
bool is_indirect;
CompilerType payload_type;
if (SwiftASTContext::GetSelectedEnumCase(
in_value.GetParent()->GetCompilerType(), data, nullptr,
&has_payload, &payload_type, &is_indirect)) {
if (has_payload && is_indirect && payload_type)
class_type_or_name.SetCompilerType(payload_type);
lldb::addr_t box_addr = in_value.GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
if (box_addr != LLDB_INVALID_ADDRESS) {
box_addr = MaskMaybeBridgedPointer(box_addr);
lldb::addr_t box_location =
m_process->ReadPointerFromMemory(box_addr, error);
if (box_location != LLDB_INVALID_ADDRESS) {
box_location = MaskMaybeBridgedPointer(box_location);
ProcessStructReader reader(m_process, box_location,
GetBoxMetadataType());
uint32_t offset = reader.GetField<uint32_t>(g_offset);
lldb::addr_t box_value = box_addr + offset;
// try to read one byte at the box value
m_process->ReadUnsignedIntegerFromMemory(box_value, 1, 0, error);
if (error
.Fail()) // and if that fails, then we're off in no man's land
return false;
Flags type_info(payload_type.GetTypeInfo());
if (type_info.AllSet(eTypeIsSwift | eTypeIsClass)) {
lldb::addr_t old_box_value = box_value;
box_value = m_process->ReadPointerFromMemory(box_value, error);
if (box_value != LLDB_INVALID_ADDRESS) {
DataExtractor data(&box_value, m_process->GetAddressByteSize(),
m_process->GetByteOrder(),
m_process->GetAddressByteSize());
ValueObjectSP valobj_sp(ValueObject::CreateValueObjectFromData(
"_", data, *m_process, payload_type));
if (valobj_sp) {
Value::ValueType value_type;
if (GetDynamicTypeAndAddress(*valobj_sp, use_dynamic,
class_type_or_name, address,
value_type)) {
address.SetRawAddress(old_box_value);
return true;
}
}
}
} else if (type_info.AllSet(eTypeIsSwift | eTypeIsProtocol)) {
SwiftASTContext::ProtocolInfo protocol_info;
if (SwiftASTContext::GetProtocolTypeInfo(payload_type,
protocol_info)) {
auto ptr_size = m_process->GetAddressByteSize();
std::vector<uint8_t> buffer(
ptr_size * protocol_info.m_num_storage_words, 0);
for (uint32_t idx = 0; idx < protocol_info.m_num_storage_words;
idx++) {
lldb::addr_t word = m_process->ReadUnsignedIntegerFromMemory(
box_value + idx * ptr_size, ptr_size, 0, error);
if (error.Fail())
return false;
memcpy(&buffer[idx * ptr_size], &word, ptr_size);
}
DataExtractor data(&buffer[0], buffer.size(),
m_process->GetByteOrder(),
m_process->GetAddressByteSize());
ValueObjectSP valobj_sp(ValueObject::CreateValueObjectFromData(
"_", data, *m_process, payload_type));
if (valobj_sp) {
Value::ValueType value_type;
if (GetDynamicTypeAndAddress(*valobj_sp, use_dynamic,
class_type_or_name, address,
value_type)) {
address.SetRawAddress(box_value);
return true;
}
}
}
} else {
// this is most likely a statically known type
address.SetLoadAddress(box_value, &m_process->GetTarget());
return true;
}
}
}
}
}
return false;
}
// Dynamic type resolution tends to want to generate scalar data - but there are
// caveats
// Per original comment here
// "Our address is the location of the dynamic type stored in memory. It isn't
// a load address,
// because we aren't pointing to the LOCATION that stores the pointer to us,
// we're pointing to us..."
// See inlined comments for exceptions to this general rule.
Value::ValueType SwiftLanguageRuntime::GetValueType(
Value::ValueType static_value_type, const CompilerType &static_type,
const CompilerType &dynamic_type, bool is_indirect_enum_case) {
Flags static_type_flags(static_type.GetTypeInfo());
Flags dynamic_type_flags(dynamic_type.GetTypeInfo());
if (dynamic_type_flags.AllSet(eTypeIsSwift)) {
// for a protocol object where does the dynamic data live if the target
// object is a struct? (for a class, it's easy)
if (static_type_flags.AllSet(eTypeIsSwift | eTypeIsProtocol) &&
dynamic_type_flags.AnySet(eTypeIsStructUnion | eTypeIsEnumeration)) {
SwiftASTContext *swift_ast_ctx =
llvm::dyn_cast_or_null<SwiftASTContext>(static_type.GetTypeSystem());
if (swift_ast_ctx && swift_ast_ctx->IsErrorType(static_type)) {
// ErrorType values are always a pointer
return Value::eValueTypeLoadAddress;
}
switch (SwiftASTContext::GetAllocationStrategy(dynamic_type)) {
case SwiftASTContext::TypeAllocationStrategy::eDynamic:
case SwiftASTContext::TypeAllocationStrategy::eUnknown:
break;
case SwiftASTContext::TypeAllocationStrategy::eInline: // inline data;
// same as the
// static data
return static_value_type;
case SwiftASTContext::TypeAllocationStrategy::ePointer: // pointed-to; in
// the target
return Value::eValueTypeLoadAddress;
}
}
if (static_type_flags.AllSet(eTypeIsSwift | eTypeIsArchetype)) {
// if I am handling a non-pointer Swift type obtained from an archetype,
// then the runtime vends the location
// of the object, not the object per se (since the object is not a pointer
// itself, this is way easier to achieve)
// hence, it's a load address, not a scalar containing a pointer as for
// ObjC classes
if (dynamic_type_flags.AllClear(eTypeIsPointer | eTypeIsReference |
eTypeInstanceIsPointer))
return Value::eValueTypeLoadAddress;
}
if (static_type_flags.AllSet(eTypeIsSwift | eTypeIsPointer) &&
static_type_flags.AllClear(eTypeIsArchetype)) {
if (is_indirect_enum_case || static_type_flags.AllClear(eTypeIsBuiltIn))
return Value::eValueTypeLoadAddress;
}
}
if (static_type_flags.AllSet(eTypeIsSwift) &&
dynamic_type_flags.AllSet(eTypeIsSwift) &&
dynamic_type_flags.AllClear(eTypeIsPointer | eTypeInstanceIsPointer))
return static_value_type;
else
return Value::eValueTypeScalar;
}
static bool IsIndirectEnumCase(ValueObject &valobj) {
return (valobj.GetLanguageFlags() &
SwiftASTContext::LanguageFlags::eIsIndirectEnumCase) ==
SwiftASTContext::LanguageFlags::eIsIndirectEnumCase;
}
bool SwiftLanguageRuntime::GetDynamicTypeAndAddress(
ValueObject &in_value, lldb::DynamicValueType use_dynamic,
TypeAndOrName &class_type_or_name, Address &address,
Value::ValueType &value_type) {
class_type_or_name.Clear();
if (SwiftASTContext *swift_ast = llvm::dyn_cast_or_null<SwiftASTContext>(
in_value.GetCompilerType().GetTypeSystem())) {
if (swift_ast->HasFatalErrors() || !swift_ast->GetClangImporter()) {
return false;
}
} else {
return false;
}
if (use_dynamic == lldb::eNoDynamicValues || !CouldHaveDynamicValue(in_value))
return false;
bool success = false;
const bool is_indirect_enum_case = IsIndirectEnumCase(in_value);
if (is_indirect_enum_case)
success = GetDynamicTypeAndAddress_IndirectEnumCase(
in_value, use_dynamic, class_type_or_name, address);
else {
CompilerType var_type(in_value.GetCompilerType());
Flags type_info(var_type.GetTypeInfo());
if (type_info.AnySet(eTypeIsSwift)) {
if (type_info.AnySet(eTypeIsClass))
success = GetDynamicTypeAndAddress_Class(in_value, use_dynamic,
class_type_or_name, address);
else if (type_info.AnySet(eTypeIsEnumeration))
success = GetDynamicTypeAndAddress_Enum(in_value, use_dynamic,
class_type_or_name, address);
else if (type_info.AnySet(eTypeIsProtocol))
success = GetDynamicTypeAndAddress_Protocol(
in_value, use_dynamic, class_type_or_name, address);
else if (type_info.AnySet(eTypeIsArchetype))
success = GetDynamicTypeAndAddress_Archetype(
in_value, use_dynamic, class_type_or_name, address);
else if (type_info.AnySet(eTypeIsTuple))
success = GetDynamicTypeAndAddress_Tuple(in_value, use_dynamic,
class_type_or_name, address);
else if (type_info.AnySet(eTypeIsStructUnion))
success = GetDynamicTypeAndAddress_Struct(in_value, use_dynamic,
class_type_or_name, address);
else if (type_info.AllSet(eTypeIsBuiltIn | eTypeIsPointer |
eTypeHasValue))
success = GetDynamicTypeAndAddress_Class(in_value, use_dynamic,
class_type_or_name, address);
}
}
if (success) {
value_type = GetValueType(
in_value.GetValue().GetValueType(), in_value.GetCompilerType(),
class_type_or_name.GetCompilerType(), is_indirect_enum_case);
}
return success;
}
TypeAndOrName
SwiftLanguageRuntime::FixUpDynamicType(const TypeAndOrName &type_and_or_name,
ValueObject &static_value) {
TypeAndOrName ret(type_and_or_name);
bool should_be_made_into_ref = false;
bool should_be_made_into_ptr = false;
Flags type_flags(static_value.GetCompilerType().GetTypeInfo());
Flags type_andor_name_flags(type_and_or_name.GetCompilerType().GetTypeInfo());
// if the static type is a pointer or reference, so should the dynamic type
// caveat: if the static type is a Swift class instance, the dynamic type
// could either be a Swift type (no need to change anything), or an ObjC type
// in which case it needs to be made into a pointer
if (type_flags.AnySet(eTypeIsPointer))
should_be_made_into_ptr =
(type_flags.AllClear(eTypeIsArchetype | eTypeIsBuiltIn) &&
!IsIndirectEnumCase(static_value));
else if (type_flags.AnySet(eTypeInstanceIsPointer))
should_be_made_into_ptr = !type_andor_name_flags.AllSet(eTypeIsSwift);
else if (type_flags.AnySet(eTypeIsReference))
should_be_made_into_ref = true;
else if (type_flags.AllSet(eTypeIsSwift | eTypeIsProtocol))
should_be_made_into_ptr =
type_and_or_name.GetCompilerType().IsRuntimeGeneratedType() &&
!type_and_or_name.GetCompilerType().IsPointerType();
if (type_and_or_name.HasType()) {
// The type will always be the type of the dynamic object. If our parent's
// type was a pointer,
// then our type should be a pointer to the type of the dynamic object. If
// a reference, then the original type
// should be okay...
CompilerType orig_type = type_and_or_name.GetCompilerType();
CompilerType corrected_type = orig_type;
if (should_be_made_into_ptr)
corrected_type = orig_type.GetPointerType();
else if (should_be_made_into_ref)
corrected_type = orig_type.GetLValueReferenceType();
ret.SetCompilerType(corrected_type);
} else /*if (m_dynamic_type_info.HasName())*/
{
// If we are here we need to adjust our dynamic type name to include the
// correct & or * symbol
std::string corrected_name(type_and_or_name.GetName().GetCString());
if (should_be_made_into_ptr)
corrected_name.append(" *");
else if (should_be_made_into_ref)
corrected_name.append(" &");
// the parent type should be a correctly pointer'ed or referenc'ed type
ret.SetCompilerType(static_value.GetCompilerType());
ret.SetName(corrected_name.c_str());
}
return ret;
}
bool SwiftLanguageRuntime::IsRuntimeSupportValue(ValueObject &valobj) {
static llvm::StringRef g_dollar_swift_type("$swift.type.");
ConstString valobj_name(valobj.GetName());
llvm::StringRef valobj_name_sr(valobj_name.GetStringRef());
if (valobj_name_sr.startswith(g_dollar_swift_type))
return true;
static llvm::StringRef g_globalinit("globalinit_");
static ConstString g_builtin_word("Builtin.Word");
static ConstString g__argc("_argc");
static ConstString g__unsafeArgv("_unsafeArgv");
static ConstString g_dollar_error("$error");
static ConstString g_tmp_closure("$tmpClosure");
ConstString valobj_type_name(valobj.GetTypeName());
if (valobj_name_sr.startswith(g_globalinit) &&
valobj_type_name == g_builtin_word)
return true;
if (valobj_name == g__argc || valobj_name == g__unsafeArgv ||
valobj_name == g_dollar_error || valobj_name == g_tmp_closure)
return true;
return false;
}
bool SwiftLanguageRuntime::CouldHaveDynamicValue(ValueObject &in_value) {
// if (in_value.IsDynamic())
// return false;
if (IsIndirectEnumCase(in_value))
return true;
CompilerType var_type(in_value.GetCompilerType());
Flags var_type_flags(var_type.GetTypeInfo());
if (var_type_flags.AllSet(eTypeIsSwift | eTypeInstanceIsPointer)) {
// Swift class instances are actually pointers, but base class instances
// are inlined at offset 0 in the class data. If we just let base classes
// be dynamic, it would cause an infinite recursion. So we would usually
// disable it
// But if the base class is a generic type we still need to bind it, and
// that is
// a good job for dynamic types to perform
if (in_value.IsBaseClass()) {
CompilerType base_type(in_value.GetCompilerType());
if (SwiftASTContext::IsFullyRealized(base_type))
return false;
}
return true;
}
return var_type.IsPossibleDynamicType(nullptr, false, false, true);
}
CompilerType
SwiftLanguageRuntime::GetConcreteType(ExecutionContextScope *exe_scope,
ConstString abstract_type_name) {
if (!exe_scope)
return CompilerType();
StackFrame *frame(exe_scope->CalculateStackFrame().get());
if (!frame)
return CompilerType();
MetadataPromiseSP promise_sp(
GetPromiseForTypeNameAndFrame(abstract_type_name.GetCString(), frame));
if (!promise_sp)
return CompilerType();
return promise_sp->FulfillTypePromise();
}
namespace {
enum class ThunkKind
{
Unknown = 0,
AllocatingInit,
PartialApply,
ObjCAttribute,
Reabstraction,
ProtocolConformance,
};
enum class ThunkAction
{
Unknown = 0,
GetThunkTarget,
StepIntoConformance,
StepThrough
};
}
static ThunkKind
GetThunkKind(llvm::StringRef symbol_name)
{
swift::Demangle::Node::Kind kind;
swift::Demangle::Context demangle_ctx;
if (!demangle_ctx.isThunkSymbol(symbol_name))
return ThunkKind::Unknown;
swift::Demangle::NodePointer nodes = demangle_ctx.demangleSymbolAsNode(symbol_name);
size_t num_global_children = nodes->getNumChildren();
if (num_global_children == 0)
return ThunkKind::Unknown;
if (nodes->getKind() != swift::Demangle::Node::Kind::Global)
return ThunkKind::Unknown;
if (nodes->getNumChildren() == 0)
return ThunkKind::Unknown;
swift::Demangle::NodePointer node_ptr = nodes->getFirstChild();
kind = node_ptr->getKind();
switch (kind)
{
case swift::Demangle::Node::Kind::ObjCAttribute:
return ThunkKind::ObjCAttribute;
break;
case swift::Demangle::Node::Kind::ProtocolWitness:
if (node_ptr->getNumChildren() == 0)
return ThunkKind::Unknown;
if (node_ptr->getFirstChild()->getKind()
== swift::Demangle::Node::Kind::ProtocolConformance)
return ThunkKind::ProtocolConformance;
break;
case swift::Demangle::Node::Kind::ReabstractionThunkHelper:
return ThunkKind::Reabstraction;
case swift::Demangle::Node::Kind::PartialApplyForwarder:
return ThunkKind::PartialApply;
case swift::Demangle::Node::Kind::Allocator:
if (node_ptr->getNumChildren() == 0)
return ThunkKind::Unknown;
if (node_ptr->getFirstChild()->getKind()
== swift::Demangle::Node::Kind::Class)
return ThunkKind::AllocatingInit;
break;
default:
break;
}
return ThunkKind::Unknown;
}
static const char *GetThunkKindName (ThunkKind kind)
{
switch (kind)
{
case ThunkKind::Unknown:
return "Unknown";
case ThunkKind::AllocatingInit:
return "StepThrough";
case ThunkKind::PartialApply:
return "GetThunkTarget";
case ThunkKind::ObjCAttribute:
return "GetThunkTarget";
case ThunkKind::Reabstraction:
return "GetThunkTarget";
case ThunkKind::ProtocolConformance:
return "StepIntoConformance";
}
}
static ThunkAction
GetThunkAction (ThunkKind kind)
{
switch (kind)
{
case ThunkKind::Unknown:
return ThunkAction::Unknown;
case ThunkKind::AllocatingInit:
return ThunkAction::StepThrough;
case ThunkKind::PartialApply:
return ThunkAction::GetThunkTarget;
case ThunkKind::ObjCAttribute:
return ThunkAction::GetThunkTarget;
case ThunkKind::Reabstraction:
return ThunkAction::StepThrough;
case ThunkKind::ProtocolConformance:
return ThunkAction::StepIntoConformance;
}
}
bool SwiftLanguageRuntime::GetTargetOfPartialApply(SymbolContext &curr_sc,
ConstString &apply_name,
SymbolContext &sc) {
if (!curr_sc.module_sp)
return false;
SymbolContextList sc_list;
swift::Demangle::Context demangle_ctx;
// Make sure this is a partial apply:
std::string apply_target = demangle_ctx.getThunkTarget(apply_name.GetStringRef());
if (!apply_target.empty()) {
size_t num_symbols = curr_sc.module_sp->FindFunctions(
ConstString(apply_target), NULL, eFunctionNameTypeFull, true, false, false, sc_list);
if (num_symbols == 0)
return false;
CompileUnit *curr_cu = curr_sc.comp_unit;
size_t num_found = 0;
for (size_t i = 0; i < num_symbols; i++) {
SymbolContext tmp_sc;
if (sc_list.GetContextAtIndex(i, tmp_sc)) {
if (tmp_sc.comp_unit && curr_cu && tmp_sc.comp_unit == curr_cu) {
sc = tmp_sc;
num_found++;
} else if (curr_sc.module_sp == tmp_sc.module_sp) {
sc = tmp_sc;
num_found++;
}
}
}
if (num_found == 1)
return true;
else {
sc.Clear(false);
return false;
}
} else {
return false;
}
}
bool SwiftLanguageRuntime::IsSymbolARuntimeThunk(const Symbol &symbol) {
llvm::StringRef symbol_name = symbol.GetMangled().GetMangledName().GetStringRef();
if (symbol_name.empty())
return false;
swift::Demangle::Context demangle_ctx;
return demangle_ctx.isThunkSymbol(symbol_name);
}
lldb::ThreadPlanSP
SwiftLanguageRuntime::GetStepThroughTrampolinePlan(Thread &thread,
bool stop_others) {
// Here are the trampolines we have at present.
// 1) The thunks from protocol invocations to the call in the actual object
// implementing the protocol.
// 2) Thunks for going from Swift ObjC classes to their actual method
// invocations
// 3) Thunks that retain captured objects in closure invocations.
ThreadPlanSP new_thread_plan_sp;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
StackFrameSP stack_sp = thread.GetStackFrameAtIndex(0);
if (!stack_sp)
return new_thread_plan_sp;
SymbolContext sc = stack_sp->GetSymbolContext(eSymbolContextEverything);
Symbol *symbol = sc.symbol;
// Note, I don't really need to consult IsSymbolARuntimeThunk here, but it
// is fast to do and
// keeps this list and the one in IsSymbolARuntimeThunk in sync.
if (!symbol || !IsSymbolARuntimeThunk(*symbol))
return new_thread_plan_sp;
// Only do this if you are at the beginning of the thunk function:
lldb::addr_t cur_addr = thread.GetRegisterContext()->GetPC();
lldb::addr_t symbol_addr = symbol->GetAddress().GetLoadAddress(
&thread.GetProcess()->GetTarget());
if (symbol_addr != cur_addr)
return new_thread_plan_sp;
Address target_address;
ConstString symbol_mangled_name = symbol->GetMangled().GetMangledName();
const char *symbol_name = symbol_mangled_name.AsCString();
ThunkKind thunk_kind = GetThunkKind(symbol_mangled_name.GetStringRef());
ThunkAction thunk_action = GetThunkAction(thunk_kind);
switch (thunk_action)
{
case ThunkAction::Unknown:
return new_thread_plan_sp;
case ThunkAction::GetThunkTarget:
{
swift::Demangle::Context demangle_ctx;
std::string thunk_target = demangle_ctx.getThunkTarget(symbol_name);
if (thunk_target.empty())
{
if (log)
log->Printf("Stepped to thunk \"%s\" (kind: %s) but could not "
"find the thunk target. ",
symbol_name,
GetThunkKindName(thunk_kind));
return new_thread_plan_sp;
}
if (log)
log->Printf("Stepped to thunk \"%s\" (kind: %s) stepping to target: \"%s\".",
symbol_name, GetThunkKindName(thunk_kind), thunk_target.c_str());
ModuleList modules = thread.GetProcess()->GetTarget().GetImages();
SymbolContextList sc_list;
modules.FindFunctionSymbols(ConstString(thunk_target),
eFunctionNameTypeFull, sc_list);
if (sc_list.GetSize() == 1) {
SymbolContext sc;
sc_list.GetContextAtIndex(0, sc);
if (sc.symbol)
target_address = sc.symbol->GetAddress();
}
}
break;
case ThunkAction::StepIntoConformance:
{
// The TTW symbols encode the protocol conformance requirements and it
// is possible to go to
// the AST and get it to replay the logic that it used to determine
// what to dispatch to.
// But that ties us too closely to the logic of the compiler, and
// these thunks are quite
// simple, they just do a little retaining, and then call the correct
// function.
// So for simplicity's sake, I'm just going to get the base name of
// the function
// this protocol thunk is preparing to call, then step into through
// the thunk, stopping if I end up
// in a frame with that function name.
swift::Demangle::Context demangle_ctx;
swift::Demangle::NodePointer demangled_nodes =
demangle_ctx.demangleSymbolAsNode(symbol_mangled_name.GetStringRef());
// Now find the ProtocolWitness node in the demangled result.
swift::Demangle::NodePointer witness_node = demangled_nodes;
bool found_witness_node = false;
while (witness_node) {
if (witness_node->getKind() ==
swift::Demangle::Node::Kind::ProtocolWitness) {
found_witness_node = true;
break;
}
witness_node = witness_node->getFirstChild();
}
if (!found_witness_node) {
if (log)
log->Printf("Stepped into witness thunk \"%s\" but could not "
"find the ProtocolWitness node in the demangled "
"nodes.",
symbol_name);
return new_thread_plan_sp;
}
size_t num_children = witness_node->getNumChildren();
if (num_children < 2) {
if (log)
log->Printf("Stepped into witness thunk \"%s\" but the "
"ProtocolWitness node doesn't have enough nodes.",
symbol_name);
return new_thread_plan_sp;
}
swift::Demangle::NodePointer function_node =
witness_node->getChild(1);
if (function_node == nullptr ||
function_node->getKind() !=
swift::Demangle::Node::Kind::Function) {
if (log)
log->Printf("Stepped into witness thunk \"%s\" but could not "
"find the function in the ProtocolWitness node.",
symbol_name);
return new_thread_plan_sp;
}
// Okay, now find the name of this function.
num_children = function_node->getNumChildren();
swift::Demangle::NodePointer name_node(nullptr);
for (size_t i = 0; i < num_children; i++) {
if (function_node->getChild(i)->getKind() ==
swift::Demangle::Node::Kind::Identifier) {
name_node = function_node->getChild(i);
break;
}
}
if (!name_node) {
if (log)
log->Printf("Stepped into witness thunk \"%s\" but could not "
"find the Function name in the function node.",
symbol_name);
return new_thread_plan_sp;
}
std::string function_name(name_node->getText());
if (function_name.empty()) {
if (log)
log->Printf("Stepped into witness thunk \"%s\" but the Function "
"name was empty.",
symbol_name);
return new_thread_plan_sp;
}
// We have to get the address range of the thunk symbol, and make a
// "step through range stepping in"
AddressRange sym_addr_range(sc.symbol->GetAddress(),
sc.symbol->GetByteSize());
new_thread_plan_sp.reset(new ThreadPlanStepInRange(
thread, sym_addr_range, sc, function_name.c_str(),
eOnlyDuringStepping, eLazyBoolNo, eLazyBoolNo));
return new_thread_plan_sp;
}
break;
case ThunkAction::StepThrough:
{
if (log)
log->Printf("Stepping through thunk: %s kind: %s",
symbol_name, GetThunkKindName(thunk_kind));
AddressRange sym_addr_range(sc.symbol->GetAddress(),
sc.symbol->GetByteSize());
new_thread_plan_sp.reset(new ThreadPlanStepInRange(
thread, sym_addr_range, sc, nullptr, eOnlyDuringStepping,
eLazyBoolNo, eLazyBoolNo));
return new_thread_plan_sp;
}
break;
}
if (target_address.IsValid()) {
new_thread_plan_sp.reset(
new ThreadPlanRunToAddress(thread, target_address, stop_others));
}
return new_thread_plan_sp;
}
void SwiftLanguageRuntime::FindFunctionPointersInCall(
StackFrame &frame, std::vector<Address> &addresses, bool debug_only,
bool resolve_thunks) {
// Extract the mangled name from the stack frame, and realize the function
// type in the Target's SwiftASTContext.
// Then walk the arguments looking for function pointers. If we find one in
// the FIRST argument, we can fetch
// the pointer value and return that.
// FIXME: when we can ask swift/llvm for the location of function arguments,
// then we can do this for all the
// function pointer arguments we find.
SymbolContext sc = frame.GetSymbolContext(eSymbolContextSymbol);
if (sc.symbol) {
Mangled mangled_name = sc.symbol->GetMangled();
if (mangled_name.GuessLanguage() == lldb::eLanguageTypeSwift) {
Status error;
Target &target = frame.GetThread()->GetProcess()->GetTarget();
SwiftASTContext *swift_ast = target.GetScratchSwiftASTContext(error);
if (swift_ast) {
CompilerType function_type = swift_ast->GetTypeFromMangledTypename(
mangled_name.GetMangledName().AsCString(), error);
if (error.Success()) {
if (function_type.IsFunctionType()) {
// FIXME: For now we only check the first argument since we don't
// know how to find the values
// of arguments further in the argument list.
// int num_arguments = function_type.GetFunctionArgumentCount();
// for (int i = 0; i < num_arguments; i++)
for (int i = 0; i < 1; i++) {
CompilerType argument_type =
function_type.GetFunctionArgumentTypeAtIndex(i);
if (argument_type.IsFunctionPointerType()) {
// We found a function pointer argument. Try to track down its
// value. This is a hack
// for now, we really should ask swift/llvm how to find the
// argument(s) given the
// Swift decl for this function, and then look those up in the
// frame.
ABISP abi_sp(frame.GetThread()->GetProcess()->GetABI());
ValueList argument_values;
Value input_value;
CompilerType clang_void_ptr_type =
target.GetScratchClangASTContext()
->GetBasicType(eBasicTypeVoid)
.GetPointerType();
input_value.SetValueType(Value::eValueTypeScalar);
input_value.SetCompilerType(clang_void_ptr_type);
argument_values.PushValue(input_value);
bool success = abi_sp->GetArgumentValues(
*(frame.GetThread().get()), argument_values);
if (success) {
// Now get a pointer value from the zeroth argument.
Status error;
DataExtractor data;
ExecutionContext exe_ctx;
frame.CalculateExecutionContext(exe_ctx);
error = argument_values.GetValueAtIndex(0)->GetValueAsData(
&exe_ctx, data, 0, NULL);
lldb::offset_t offset = 0;
lldb::addr_t fn_ptr_addr = data.GetPointer(&offset);
Address fn_ptr_address;
fn_ptr_address.SetLoadAddress(fn_ptr_addr, &target);
// Now check to see if this has debug info:
bool add_it = true;
if (resolve_thunks) {
SymbolContext sc;
fn_ptr_address.CalculateSymbolContext(
&sc, eSymbolContextEverything);
if (sc.comp_unit && sc.symbol) {
ConstString symbol_name =
sc.symbol->GetMangled().GetMangledName();
if (symbol_name) {
SymbolContext target_context;
if (GetTargetOfPartialApply(sc, symbol_name,
target_context)) {
if (target_context.symbol)
fn_ptr_address =
target_context.symbol->GetAddress();
else if (target_context.function)
fn_ptr_address =
target_context.function->GetAddressRange()
.GetBaseAddress();
}
}
}
}
if (debug_only) {
LineEntry line_entry;
fn_ptr_address.CalculateSymbolContextLineEntry(line_entry);
if (!line_entry.IsValid())
add_it = false;
}
if (add_it)
addresses.push_back(fn_ptr_address);
}
}
}
}
}
}
}
}
}
//------------------------------------------------------------------
// Exception breakpoint Precondition class for Swift:
//------------------------------------------------------------------
void SwiftLanguageRuntime::SwiftExceptionPrecondition::AddTypeName(
const char *class_name) {
m_type_names.insert(class_name);
}
void SwiftLanguageRuntime::SwiftExceptionPrecondition::AddEnumSpec(
const char *enum_name, const char *element_name) {
std::unordered_map<std::string, std::vector<std::string>>::value_type
new_value(enum_name, std::vector<std::string>());
auto result = m_enum_spec.emplace(new_value);
result.first->second.push_back(element_name);
}
SwiftLanguageRuntime::SwiftExceptionPrecondition::SwiftExceptionPrecondition() {
}
ValueObjectSP
SwiftLanguageRuntime::CalculateErrorValueObjectFromValue(
Value &value, ConstString name, bool persistent)
{
ValueObjectSP error_valobj_sp;
Status error;
SwiftASTContext *ast_context =
m_process->GetTarget().GetScratchSwiftASTContext(error);
if (!ast_context || error.Fail())
return error_valobj_sp;
CompilerType swift_error_proto_type = ast_context->GetErrorType();
value.SetCompilerType(swift_error_proto_type);
error_valobj_sp = ValueObjectConstResult::Create(
m_process, value, name);
if (error_valobj_sp && error_valobj_sp->GetError().Success()) {
error_valobj_sp = error_valobj_sp->GetQualifiedRepresentationIfAvailable(
lldb::eDynamicCanRunTarget, true);
if (!IsValidErrorValue(*(error_valobj_sp.get()))) {
error_valobj_sp.reset();
}
}
if (persistent && error_valobj_sp) {
PersistentExpressionState *persistent_state =
m_process->GetTarget().GetPersistentExpressionStateForLanguage(
eLanguageTypeSwift);
ConstString persistent_variable_name(
persistent_state->GetNextPersistentVariableName(true));
lldb::ValueObjectSP const_valobj_sp;
// Check in case our value is already a constant value
if (error_valobj_sp->GetIsConstant()) {
const_valobj_sp = error_valobj_sp;
const_valobj_sp->SetName(persistent_variable_name);
} else
const_valobj_sp =
error_valobj_sp->CreateConstantValue(persistent_variable_name);
lldb::ValueObjectSP live_valobj_sp = error_valobj_sp;
error_valobj_sp = const_valobj_sp;
ExpressionVariableSP clang_expr_variable_sp(
persistent_state->CreatePersistentVariable(error_valobj_sp));
clang_expr_variable_sp->m_live_sp = live_valobj_sp;
clang_expr_variable_sp->m_flags |=
ClangExpressionVariable::EVIsProgramReference;
error_valobj_sp = clang_expr_variable_sp->GetValueObject();
}
return error_valobj_sp;
}
ValueObjectSP SwiftLanguageRuntime::CalculateErrorValueFromFirstArgument(
StackFrameSP frame_sp, ConstString variable_name) {
ProcessSP process_sp(frame_sp->GetThread()->GetProcess());
ABISP abi_sp(process_sp->GetABI());
ValueList argument_values;
Value input_value;
Status error;
Target *target = frame_sp->CalculateTarget().get();
ValueObjectSP error_valobj_sp;
ClangASTContext *clang_ast_context = target->GetScratchClangASTContext();
CompilerType clang_void_ptr_type =
clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
input_value.SetValueType(Value::eValueTypeScalar);
input_value.SetCompilerType(clang_void_ptr_type);
argument_values.PushValue(input_value);
bool success = abi_sp->GetArgumentValues(*(frame_sp->GetThread().get()),
argument_values);
if (success) {
ExecutionContext exe_ctx;
frame_sp->CalculateExecutionContext(exe_ctx);
DataExtractor data;
SwiftASTContext *ast_context = target->GetScratchSwiftASTContext(error);
if (!ast_context || error.Fail())
return error_valobj_sp;
CompilerType swift_error_proto_type = ast_context->GetErrorType();
if (swift_error_proto_type.IsValid()) {
Value *arg0 = argument_values.GetValueAtIndex(0);
Status extract_error = arg0->GetValueAsData(&exe_ctx, data, 0, nullptr);
if (extract_error.Success()) {
error_valobj_sp = ValueObjectConstResult::Create(
frame_sp.get(), swift_error_proto_type, variable_name, data);
if (error_valobj_sp->GetError().Fail()) {
// If we couldn't make the error ValueObject, then we will always
// stop.
// FIXME: Some logging here would be good.
return error_valobj_sp;
}
error_valobj_sp =
error_valobj_sp->GetQualifiedRepresentationIfAvailable(
lldb::eDynamicCanRunTarget, true);
}
}
}
return error_valobj_sp;
}
void SwiftLanguageRuntime::RegisterGlobalError(Target &target, ConstString name,
lldb::addr_t addr) {
Status ast_context_error;
SwiftASTContext *ast_context =
target.GetScratchSwiftASTContext(ast_context_error);
if (ast_context_error.Success() && ast_context &&
!ast_context->HasFatalErrors()) {
SwiftPersistentExpressionState *persistent_state =
llvm::cast<SwiftPersistentExpressionState>(
target.GetPersistentExpressionStateForLanguage(
lldb::eLanguageTypeSwift));
std::string module_name = "$__lldb_module_for_";
module_name.append(&name.GetCString()[1]);
Status module_creation_error;
swift::ModuleDecl *module_decl = ast_context->CreateModule(
ConstString(module_name), module_creation_error);
if (module_creation_error.Success() && module_decl) {
const bool is_static = false;
const auto specifier = swift::VarDecl::Specifier::Let;
const bool is_capture_list = false;
swift::VarDecl *var_decl = new (*ast_context->GetASTContext())
swift::VarDecl(is_static, specifier, is_capture_list, swift::SourceLoc(),
ast_context->GetIdentifier(name.GetCString()),
GetSwiftType(ast_context->GetErrorType()),
module_decl);
var_decl->setInterfaceType(var_decl->getType());
var_decl->setDebuggerVar(true);
persistent_state->RegisterSwiftPersistentDecl(var_decl);
ConstString mangled_name;
{
swift::Mangle::ASTMangler mangler(true);
mangled_name = ConstString(mangler.mangleGlobalVariableFull(var_decl));
}
lldb::addr_t symbol_addr;
{
ProcessSP process_sp(target.GetProcessSP());
Status alloc_error;
symbol_addr = process_sp->AllocateMemory(
process_sp->GetAddressByteSize(),
lldb::ePermissionsWritable | lldb::ePermissionsReadable,
alloc_error);
if (alloc_error.Success() && symbol_addr != LLDB_INVALID_ADDRESS) {
Status write_error;
process_sp->WritePointerToMemory(symbol_addr, addr, write_error);
if (write_error.Success()) {
persistent_state->RegisterSymbol(mangled_name, symbol_addr);
}
}
}
}
}
}
bool SwiftLanguageRuntime::SwiftExceptionPrecondition::EvaluatePrecondition(
StoppointCallbackContext &context) {
if (!m_type_names.empty()) {
StackFrameSP frame_sp = context.exe_ctx_ref.GetFrameSP();
if (!frame_sp)
return true;
ValueObjectSP error_valobj_sp = CalculateErrorValueFromFirstArgument(
frame_sp, ConstString("__swift_error_var"));
if (!error_valobj_sp || error_valobj_sp->GetError().Fail())
return true;
// This shouldn't fail, since at worst it will return me the object I just
// successfully got.
std::string full_error_name(
error_valobj_sp->GetCompilerType().GetTypeName().AsCString());
size_t last_dot_pos = full_error_name.rfind('.');
std::string type_name_base;
if (last_dot_pos == std::string::npos)
type_name_base = full_error_name;
else {
if (last_dot_pos + 1 <= full_error_name.size())
type_name_base =
full_error_name.substr(last_dot_pos + 1, full_error_name.size());
}
// The type name will be the module and then the type. If the match name
// has a dot, we require a complete
// match against the type, if the type name has no dot, we match it against
// the base.
for (std::string name : m_type_names) {
if (name.rfind('.') != std::string::npos) {
if (name == full_error_name)
return true;
} else {
if (name == type_name_base)
return true;
}
}
return false;
}
return true;
}
void SwiftLanguageRuntime::SwiftExceptionPrecondition::GetDescription(
Stream &stream, lldb::DescriptionLevel level) {
if (level == eDescriptionLevelFull || level == eDescriptionLevelVerbose) {
if (m_type_names.size() > 0) {
stream.Printf("\nType Filters:");
for (std::string name : m_type_names) {
stream.Printf(" %s", name.c_str());
}
stream.Printf("\n");
}
}
}
Status SwiftLanguageRuntime::SwiftExceptionPrecondition::ConfigurePrecondition(
Args &args) {
Status error;
std::vector<std::string> object_typenames;
args.GetOptionValuesAsStrings("exception-typename", object_typenames);
for (auto type_name : object_typenames)
AddTypeName(type_name.c_str());
return error;
}
void SwiftLanguageRuntime::AddToLibraryNegativeCache(const char *library_name) {
std::lock_guard<std::mutex> locker(m_negative_cache_mutex);
m_library_negative_cache.insert(library_name);
}
bool SwiftLanguageRuntime::IsInLibraryNegativeCache(const char *library_name) {
std::lock_guard<std::mutex> locker(m_negative_cache_mutex);
return m_library_negative_cache.count(library_name) == 1;
}
lldb::addr_t
SwiftLanguageRuntime::MaskMaybeBridgedPointer(lldb::addr_t addr,
lldb::addr_t *masked_bits) {
if (!m_process)
return addr;
const ArchSpec &arch_spec(m_process->GetTarget().GetArchitecture());
ArchSpec::Core core_kind = arch_spec.GetCore();
bool is_arm = false;
bool is_intel = false;
bool is_32 = false;
bool is_64 = false;
if (core_kind == ArchSpec::Core::eCore_arm_arm64) {
is_arm = is_64 = true;
} else if (core_kind >= ArchSpec::Core::kCore_arm_first &&
core_kind <= ArchSpec::Core::kCore_arm_last) {
is_arm = true;
} else if (core_kind >= ArchSpec::Core::kCore_x86_64_first &&
core_kind <= ArchSpec::Core::kCore_x86_64_last) {
is_intel = true;
} else if (core_kind >= ArchSpec::Core::kCore_x86_32_first &&
core_kind <= ArchSpec::Core::kCore_x86_32_last) {
is_intel = true;
} else {
// this is a really random CPU core to be running on - just get out fast
return addr;
}
switch (arch_spec.GetAddressByteSize()) {
case 4:
is_32 = true;
break;
case 8:
is_64 = true;
break;
default:
// this is a really random pointer size to be running on - just get out fast
return addr;
}
lldb::addr_t mask = 0;
if (is_arm && is_64)
mask = SWIFT_ABI_ARM64_SWIFT_SPARE_BITS_MASK;
if (is_arm && is_32)
mask = SWIFT_ABI_ARM_SWIFT_SPARE_BITS_MASK;
if (is_intel && is_64)
mask = SWIFT_ABI_X86_64_SWIFT_SPARE_BITS_MASK;
if (is_intel && is_32)
mask = SWIFT_ABI_I386_SWIFT_SPARE_BITS_MASK;
if (masked_bits)
*masked_bits = addr & mask;
return addr & ~mask;
}
lldb::addr_t
SwiftLanguageRuntime::MaybeMaskNonTrivialReferencePointer(
lldb::addr_t addr,
SwiftASTContext::NonTriviallyManagedReferenceStrategy strategy) {
if (addr == 0)
return addr;
AppleObjCRuntime *objc_runtime = GetObjCRuntime();
if (objc_runtime) {
// tagged pointers don't perform any masking
if (objc_runtime->IsTaggedPointer(addr))
return addr;
}
if (!m_process)
return addr;
const ArchSpec &arch_spec(m_process->GetTarget().GetArchitecture());
ArchSpec::Core core_kind = arch_spec.GetCore();
bool is_arm = false;
bool is_intel = false;
bool is_32 = false;
bool is_64 = false;
if (core_kind == ArchSpec::Core::eCore_arm_arm64) {
is_arm = is_64 = true;
} else if (core_kind >= ArchSpec::Core::kCore_arm_first &&
core_kind <= ArchSpec::Core::kCore_arm_last) {
is_arm = true;
} else if (core_kind >= ArchSpec::Core::kCore_x86_64_first &&
core_kind <= ArchSpec::Core::kCore_x86_64_last) {
is_intel = true;
} else if (core_kind >= ArchSpec::Core::kCore_x86_32_first &&
core_kind <= ArchSpec::Core::kCore_x86_32_last) {
is_intel = true;
} else {
// this is a really random CPU core to be running on - just get out fast
return addr;
}
switch (arch_spec.GetAddressByteSize()) {
case 4:
is_32 = true;
break;
case 8:
is_64 = true;
break;
default:
// this is a really random pointer size to be running on - just get out fast
return addr;
}
lldb::addr_t mask = 0;
if (strategy == SwiftASTContext::NonTriviallyManagedReferenceStrategy::eWeak) {
bool is_indirect = true;
// On non-objc platforms, the weak reference pointer always pointed to a
// runtime structure.
// For ObjC platforms, the masked value determines whether it is indirect.
uint32_t value = 0;
if (objc_runtime)
{
if (is_intel) {
if (is_64) {
mask = SWIFT_ABI_X86_64_OBJC_WEAK_REFERENCE_MARKER_MASK;
value = SWIFT_ABI_X86_64_OBJC_WEAK_REFERENCE_MARKER_VALUE;
} else {
mask = SWIFT_ABI_I386_OBJC_WEAK_REFERENCE_MARKER_MASK;
value = SWIFT_ABI_I386_OBJC_WEAK_REFERENCE_MARKER_VALUE;
}
} else if (is_arm) {
if (is_64) {
mask = SWIFT_ABI_ARM64_OBJC_WEAK_REFERENCE_MARKER_MASK;
value = SWIFT_ABI_ARM64_OBJC_WEAK_REFERENCE_MARKER_VALUE;
} else {
mask = SWIFT_ABI_ARM_OBJC_WEAK_REFERENCE_MARKER_MASK;
value = SWIFT_ABI_ARM_OBJC_WEAK_REFERENCE_MARKER_VALUE;
}
}
} else {
// This name is a little confusing. The "DEFAULT" marking in System.h
// is supposed to mean: the value for non-ObjC platforms. So
// DEFAULT_OBJC here actually means "non-ObjC".
mask = SWIFT_ABI_DEFAULT_OBJC_WEAK_REFERENCE_MARKER_MASK;
value = SWIFT_ABI_DEFAULT_OBJC_WEAK_REFERENCE_MARKER_VALUE;
}
is_indirect = ((addr & mask) == value);
if (!is_indirect)
return addr;
// The masked value of address is a pointer to the runtime structure.
// The first field of the structure is the actual pointer.
Process *process = GetProcess();
Status error;
lldb::addr_t masked_addr = addr & ~mask;
lldb::addr_t isa_addr = process->ReadPointerFromMemory(masked_addr, error);
if (error.Fail())
{
// FIXME: do some logging here.
return addr;
}
return isa_addr;
} else {
if (is_arm && is_64)
mask = SWIFT_ABI_ARM64_OBJC_NUM_RESERVED_LOW_BITS;
else if (is_intel && is_64)
mask = SWIFT_ABI_X86_64_OBJC_NUM_RESERVED_LOW_BITS;
else
mask = SWIFT_ABI_DEFAULT_OBJC_NUM_RESERVED_LOW_BITS;
mask = (1 << mask) | (1 << (mask + 1));
return addr & ~mask;
}
return addr;
}
ConstString SwiftLanguageRuntime::GetErrorBackstopName() {
return ConstString("swift_errorInMain");
}
ConstString SwiftLanguageRuntime::GetStandardLibraryBaseName() {
static ConstString g_swiftCore("swiftCore");
return g_swiftCore;
}
ConstString SwiftLanguageRuntime::GetStandardLibraryName() {
PlatformSP platform_sp(m_process->GetTarget().GetPlatform());
if (platform_sp)
return platform_sp->GetFullNameForDylib(GetStandardLibraryBaseName());
return GetStandardLibraryBaseName();
}
bool SwiftLanguageRuntime::GetReferenceCounts(ValueObject &valobj,
size_t &strong, size_t &weak) {
CompilerType compiler_type(valobj.GetCompilerType());
Flags type_flags(compiler_type.GetTypeInfo());
if (llvm::isa<SwiftASTContext>(compiler_type.GetTypeSystem()) &&
type_flags.AllSet(eTypeInstanceIsPointer)) {
lldb::addr_t ptr_value = valobj.GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
if (ptr_value == LLDB_INVALID_ADDRESS)
return false;
ptr_value += GetProcess()->GetAddressByteSize();
Status error;
strong =
GetProcess()->ReadUnsignedIntegerFromMemory(ptr_value, 4, 0, error) >>
2;
if (error.Fail())
return false;
weak = GetProcess()->ReadUnsignedIntegerFromMemory(ptr_value + 4, 4, 0,
error) >>
2;
if (error.Fail())
return false;
return true;
}
return false;
}
class ProjectionSyntheticChildren : public SyntheticChildren {
public:
struct FieldProjection {
ConstString name;
CompilerType type;
int32_t byte_offset;
FieldProjection(CompilerType parent_type, ExecutionContext *exe_ctx,
size_t idx) {
const bool transparent_pointers = false;
const bool omit_empty_base_classes = true;
const bool ignore_array_bounds = false;
bool child_is_base_class = false;
bool child_is_deref_of_parent = false;
std::string child_name;
uint32_t child_byte_size;
uint32_t child_bitfield_bit_size;
uint32_t child_bitfield_bit_offset;
uint64_t language_flags;
type = parent_type.GetChildCompilerTypeAtIndex(
exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
ignore_array_bounds, child_name, child_byte_size, byte_offset,
child_bitfield_bit_size, child_bitfield_bit_offset,
child_is_base_class, child_is_deref_of_parent, nullptr,
language_flags);
if (child_is_base_class)
type.Clear(); // invalidate - base classes are dealt with outside of the
// projection
else
name.SetCStringWithLength(child_name.c_str(), child_name.size());
}
bool IsValid() { return !name.IsEmpty() && type.IsValid(); }
explicit operator bool() { return IsValid(); }
};
struct TypeProjection {
std::vector<FieldProjection> field_projections;
ConstString type_name;
};
typedef std::unique_ptr<TypeProjection> TypeProjectionUP;
bool IsScripted() { return false; }
std::string GetDescription() { return "projection synthetic children"; }
ProjectionSyntheticChildren(const Flags &flags, TypeProjectionUP &&projection)
: SyntheticChildren(flags), m_projection(std::move(projection)) {}
protected:
TypeProjectionUP m_projection;
class ProjectionFrontEndProvider : public SyntheticChildrenFrontEnd {
public:
ProjectionFrontEndProvider(ValueObject &backend,
TypeProjectionUP &projection)
: SyntheticChildrenFrontEnd(backend), m_num_bases(0),
m_projection(projection.get()) {
lldbassert(m_projection && "need a valid projection");
CompilerType type(backend.GetCompilerType());
m_num_bases = type.GetNumDirectBaseClasses();
}
size_t CalculateNumChildren() override {
return m_projection->field_projections.size() + m_num_bases;
}
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
if (idx < m_num_bases) {
if (ValueObjectSP base_object_sp =
m_backend.GetChildAtIndex(idx, true)) {
CompilerType base_type(base_object_sp->GetCompilerType());
ConstString base_type_name(base_type.GetTypeName());
if (base_type_name.IsEmpty() ||
!SwiftLanguageRuntime::IsSwiftClassName(base_type_name.GetCString()))
return base_object_sp;
base_object_sp = m_backend.GetSyntheticBase(
0, base_type, true,
Mangled(base_type_name, true)
.GetDemangledName(lldb::eLanguageTypeSwift));
return base_object_sp;
} else
return nullptr;
}
idx -= m_num_bases;
if (idx < m_projection->field_projections.size()) {
auto &projection(m_projection->field_projections.at(idx));
return m_backend.GetSyntheticChildAtOffset(
projection.byte_offset, projection.type, true, projection.name);
}
return nullptr;
}
size_t GetIndexOfChildWithName(const ConstString &name) override {
for (size_t idx = 0; idx < m_projection->field_projections.size();
idx++) {
if (m_projection->field_projections.at(idx).name == name)
return idx;
}
return UINT32_MAX;
}
bool Update() override { return false; }
bool MightHaveChildren() override { return true; }
ConstString GetSyntheticTypeName() override {
return m_projection->type_name;
}
private:
size_t m_num_bases;
TypeProjectionUP::element_type *m_projection;
};
public:
SyntheticChildrenFrontEnd::AutoPointer GetFrontEnd(ValueObject &backend) {
return SyntheticChildrenFrontEnd::AutoPointer(
new ProjectionFrontEndProvider(backend, m_projection));
}
};
lldb::SyntheticChildrenSP
SwiftLanguageRuntime::GetBridgedSyntheticChildProvider(ValueObject &valobj) {
const char *type_name(valobj.GetCompilerType().GetTypeName().AsCString());
if (type_name && *type_name) {
auto iter = m_bridged_synthetics_map.find(type_name),
end = m_bridged_synthetics_map.end();
if (iter != end)
return iter->second;
}
ProjectionSyntheticChildren::TypeProjectionUP type_projection(
new ProjectionSyntheticChildren::TypeProjectionUP::element_type());
if (SwiftASTContext *swift_ast_ctx = GetScratchSwiftASTContext()) {
Status error;
CompilerType swift_type =
swift_ast_ctx->GetTypeFromMangledTypename(type_name, error);
if (swift_type.IsValid()) {
ExecutionContext exe_ctx(GetProcess());
bool any_projected = false;
for (size_t idx = 0; idx < swift_type.GetNumChildren(true); idx++) {
// if a projection fails, keep going - we have offsets here, so it
// should be OK to skip some members
if (auto projection = ProjectionSyntheticChildren::FieldProjection(
swift_type, &exe_ctx, idx)) {
any_projected = true;
type_projection->field_projections.push_back(projection);
}
}
if (any_projected) {
type_projection->type_name = swift_type.GetDisplayTypeName();
SyntheticChildrenSP synth_sp =
SyntheticChildrenSP(new ProjectionSyntheticChildren(
SyntheticChildren::Flags(), std::move(type_projection)));
return (m_bridged_synthetics_map[type_name] = synth_sp);
}
}
}
return nullptr;
}
void SwiftLanguageRuntime::WillStartExecutingUserExpression() {
std::lock_guard<std::mutex> lock(m_active_user_expr_mutex);
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
if (m_active_user_expr_count == 0 &&
m_dynamic_exclusivity_flag_addr) {
// We're executing the first user expression. Toggle the flag.
Status error;
TypeSystem *type_system =
m_process->GetTarget().GetScratchTypeSystemForLanguage(
&error,
eLanguageTypeC_plus_plus);
if (error.Fail()) {
if (log)
log->Printf("SwiftLanguageRuntime: Unable to get pointer to type "
"system: %s", error.AsCString());
return;
}
ConstString BoolName("bool");
size_t bool_size =
type_system->GetBuiltinTypeByName(BoolName).GetByteSize(nullptr);
Scalar original_value;
m_process->ReadScalarIntegerFromMemory(*m_dynamic_exclusivity_flag_addr,
bool_size, false, original_value,
error);
m_original_dynamic_exclusivity_flag_state = original_value.UInt() != 0;
if (error.Fail()) {
if (log)
log->Printf("SwiftLanguageRuntime: Unable to read "
"disableExclusivityChecking flag state: %s",
error.AsCString());
} else {
Scalar new_value(1U);
m_process->WriteScalarToMemory(*m_dynamic_exclusivity_flag_addr,
new_value, bool_size, error);
if (error.Fail()) {
if (log)
log->Printf("SwiftLanguageRuntime: Unable to set "
"disableExclusivityChecking flag state: %s",
error.AsCString());
} else {
if (log)
log->Printf("SwiftLanguageRuntime: Changed "
"disableExclusivityChecking flag state from %u to 1",
m_original_dynamic_exclusivity_flag_state);
}
}
}
++m_active_user_expr_count;
if (log)
log->Printf("SwiftLanguageRuntime: starting user expression. "
"Number active: %u", m_active_user_expr_count);
}
void SwiftLanguageRuntime::DidFinishExecutingUserExpression() {
std::lock_guard<std::mutex> lock(m_active_user_expr_mutex);
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
--m_active_user_expr_count;
if (log)
log->Printf("SwiftLanguageRuntime: finished user expression. "
"Number active: %u", m_active_user_expr_count);
if (m_active_user_expr_count == 0 &&
m_dynamic_exclusivity_flag_addr) {
Status error;
TypeSystem *type_system =
m_process->GetTarget().GetScratchTypeSystemForLanguage(
&error,
eLanguageTypeC_plus_plus);
if (error.Fail()) {
if (log)
log->Printf("SwiftLanguageRuntime: Unable to get pointer to type "
"system: %s", error.AsCString());
return;
}
ConstString BoolName("bool");
size_t bool_size =
type_system->GetBuiltinTypeByName(BoolName).GetByteSize(nullptr);
Scalar original_value(m_original_dynamic_exclusivity_flag_state ? 1U : 0U);
m_process->WriteScalarToMemory(*m_dynamic_exclusivity_flag_addr,
original_value, bool_size, error);
if (error.Fail()) {
if (log)
log->Printf("SwiftLanguageRuntime: Unable to reset "
"disableExclusivityChecking flag state: %s",
error.AsCString());
} else {
if (log)
log->Printf("SwiftLanguageRuntime: Changed "
"disableExclusivityChecking flag state back to %u",
m_original_dynamic_exclusivity_flag_state);
}
}
}
llvm::Optional<Value> SwiftLanguageRuntime::GetErrorReturnLocationAfterReturn(
lldb::StackFrameSP frame_sp)
{
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
llvm::Optional<Value> error_val;
llvm::StringRef error_reg_name;
ArchSpec arch_spec(GetTargetRef().GetArchitecture());
switch (arch_spec.GetMachine()) {
case llvm::Triple::ArchType::arm:
error_reg_name = "r6";
break;
case llvm::Triple::ArchType::aarch64:
error_reg_name = "x19";
break;
case llvm::Triple::ArchType::x86_64:
error_reg_name = "r12";
break;
default:
break;
}
if (error_reg_name.empty())
return error_val;
RegisterContextSP reg_ctx = frame_sp->GetRegisterContext();
const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName(error_reg_name);
lldbassert(reg_info && "didn't get the right register name for swift error register");
if (!reg_info)
return error_val;
RegisterValue reg_value;
if (!reg_ctx->ReadRegister(reg_info, reg_value))
{
// Do some logging here.
return error_val;
}
lldb::addr_t error_addr = reg_value.GetAsUInt64();
if (error_addr == 0)
return error_val;
Value val;
if (reg_value.GetScalarValue(val.GetScalar())) {
val.SetValueType(Value::eValueTypeScalar);
val.SetContext(Value::eContextTypeRegisterInfo,
const_cast<RegisterInfo *>(reg_info));
error_val = val;
}
// if (log)
// log->Printf("Found return address: 0x%" PRIu64 " from register %s.",
// return_addr,
// error_reg_name.str().c_str());
return error_val;
}
llvm::Optional<Value> SwiftLanguageRuntime::GetErrorReturnLocationBeforeReturn(
lldb::StackFrameSP frame_sp, bool &need_to_check_after_return) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
llvm::Optional<Value> error_val;
if (!frame_sp)
{
need_to_check_after_return = false;
return error_val;
}
// For Architectures where the error isn't returned in a register,
// there's a magic variable that points to the value. Check that first:
ConstString error_location_name("$error");
VariableListSP variables_sp = frame_sp->GetInScopeVariableList(false);
VariableSP error_loc_var_sp = variables_sp->FindVariable(
error_location_name, eValueTypeVariableArgument);
if (error_loc_var_sp) {
need_to_check_after_return = false;
ValueObjectSP error_loc_val_sp = frame_sp->GetValueObjectForFrameVariable(
error_loc_var_sp, eNoDynamicValues);
if (error_loc_val_sp && error_loc_val_sp->GetError().Success())
error_val = error_loc_val_sp->GetValue();
// if (log)
// log->Printf("Found return address: 0x%" PRIu64 " from error variable.", return_addr);
return error_val;
}
// Otherwise, see if we know which register it lives in from the calling convention.
// This should probably go in the ABI plugin not here, but the Swift ABI can change with
// swiftlang versions and that would make it awkward in the ABI.
Function *func = frame_sp->GetSymbolContext(eSymbolContextFunction).function;
if (!func)
{
need_to_check_after_return = false;
return error_val;
}
need_to_check_after_return = func->CanThrow();
return error_val;
}
//------------------------------------------------------------------
// Static Functions
//------------------------------------------------------------------
LanguageRuntime *
SwiftLanguageRuntime::CreateInstance(Process *process,
lldb::LanguageType language) {
if (language == eLanguageTypeSwift)
return new SwiftLanguageRuntime(process);
else
return NULL;
}
lldb::BreakpointResolverSP
SwiftLanguageRuntime::CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp,
bool throw_bp) {
BreakpointResolverSP resolver_sp;
if (throw_bp)
resolver_sp.reset(new BreakpointResolverName(
bkpt, "swift_willThrow", eFunctionNameTypeBase, eLanguageTypeUnknown,
Breakpoint::Exact, 0, eLazyBoolNo));
// FIXME: We don't do catch breakpoints for ObjC yet.
// Should there be some way for the runtime to specify what it can do in this
// regard?
return resolver_sp;
}
static const char *
SwiftDemangleNodeKindToCString(const swift::Demangle::Node::Kind node_kind) {
#define NODE(e) \
case swift::Demangle::Node::Kind::e: \
return #e;
switch (node_kind) {
#include "swift/Demangling/DemangleNodes.def"
}
return "swift::Demangle::Node::Kind::???";
#undef NODE
}
static OptionDefinition g_swift_demangle_options[] = {
// clang-format off
{LLDB_OPT_SET_1, false, "expand", 'e', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Whether LLDB should print the demangled tree"},
// clang-format on
};
class CommandObjectSwift_Demangle : public CommandObjectParsed {
public:
CommandObjectSwift_Demangle(CommandInterpreter &interpreter)
: CommandObjectParsed(interpreter, "demangle",
"Demangle a Swift mangled name",
"language swift demangle"),
m_options() {}
~CommandObjectSwift_Demangle() {}
virtual Options *GetOptions() { return &m_options; }
class CommandOptions : public Options {
public:
CommandOptions() : Options(), m_expand(false, false) {
OptionParsingStarting(nullptr);
}
virtual ~CommandOptions() {}
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
ExecutionContext *execution_context) override {
Status error;
const int short_option = m_getopt_table[option_idx].val;
switch (short_option) {
case 'e':
m_expand.SetCurrentValue(true);
break;
default:
error.SetErrorStringWithFormat("invalid short option character '%c'",
short_option);
break;
}
return error;
}
void OptionParsingStarting(ExecutionContext *execution_context) override {
m_expand.Clear();
}
llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_swift_demangle_options);
}
// Options table: Required for subclasses of Options.
OptionValueBoolean m_expand;
};
protected:
void PrintNode(swift::Demangle::NodePointer node_ptr, Stream &stream,
int depth = 0) {
if (!node_ptr)
return;
std::string indent(2 * depth, ' ');
stream.Printf("%s", indent.c_str());
stream.Printf("kind=%s",
SwiftDemangleNodeKindToCString(node_ptr->getKind()));
if (node_ptr->hasText()) {
std::string Text = node_ptr->getText();
stream.Printf(", text=\"%s\"", Text.c_str());
}
if (node_ptr->hasIndex())
stream.Printf(", index=%" PRIu64, node_ptr->getIndex());
stream.Printf("\n");
for (auto &&child : *node_ptr) {
PrintNode(child, stream, depth + 1);
}
}
bool DoExecute(Args &command, CommandReturnObject &result) {
for (size_t i = 0; i < command.GetArgumentCount(); i++) {
const char *arg = command.GetArgumentAtIndex(i);
if (arg && *arg) {
swift::Demangle::Context demangle_ctx;
auto node_ptr = demangle_ctx.demangleSymbolAsNode(llvm::StringRef(arg));
if (node_ptr) {
if (m_options.m_expand) {
PrintNode(node_ptr, result.GetOutputStream());
}
result.GetOutputStream().Printf(
"%s ---> %s\n", arg,
swift::Demangle::nodeToString(node_ptr).c_str());
}
}
}
result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
return true;
}
CommandOptions m_options;
};
class CommandObjectSwift_RefCount : public CommandObjectRaw {
public:
CommandObjectSwift_RefCount(CommandInterpreter &interpreter)
: CommandObjectRaw(interpreter, "refcount",
"Inspect the reference count data for a Swift object",
"language swift refcount",
eCommandProcessMustBePaused | eCommandRequiresFrame) {}
~CommandObjectSwift_RefCount() {}
virtual Options *GetOptions() { return nullptr; }
protected:
bool DoExecute(const char *command, CommandReturnObject &result) {
ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
StackFrameSP frame_sp(exe_ctx.GetFrameSP());
EvaluateExpressionOptions options;
options.SetLanguage(lldb::eLanguageTypeSwift);
options.SetResultIsInternal(true);
options.SetUseDynamic();
ValueObjectSP result_valobj_sp;
if (exe_ctx.GetTargetSP()->EvaluateExpression(command, frame_sp.get(),
result_valobj_sp) ==
eExpressionCompleted) {
if (result_valobj_sp) {
if (result_valobj_sp->GetError().Fail()) {
result.SetStatus(lldb::eReturnStatusFailed);
result.AppendError(result_valobj_sp->GetError().AsCString());
return false;
}
result_valobj_sp =
result_valobj_sp->GetQualifiedRepresentationIfAvailable(
lldb::eDynamicCanRunTarget, true);
CompilerType result_type(result_valobj_sp->GetCompilerType());
if (result_type.GetTypeInfo() & lldb::eTypeInstanceIsPointer) {
size_t strong = 0, weak = 0;
if (!exe_ctx.GetProcessSP()
->GetSwiftLanguageRuntime()
->GetReferenceCounts(*result_valobj_sp.get(), strong,
weak)) {
result.AppendError("refcount not available");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
} else {
result.AppendMessageWithFormat(
"refcount data: (strong = %zu, weak = %zu)\n", strong, weak);
result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
return true;
}
} else {
result.AppendError("refcount only available for class types");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
}
}
result.SetStatus(lldb::eReturnStatusFailed);
if (result_valobj_sp && result_valobj_sp->GetError().Fail())
result.AppendError(result_valobj_sp->GetError().AsCString());
return false;
}
};
class CommandObjectMultiwordSwift : public CommandObjectMultiword {
public:
CommandObjectMultiwordSwift(CommandInterpreter &interpreter)
: CommandObjectMultiword(
interpreter, "swift",
"A set of commands for operating on the Swift Language Runtime.",
"swift <subcommand> [<subcommand-options>]") {
LoadSubCommand("demangle", CommandObjectSP(new CommandObjectSwift_Demangle(
interpreter)));
LoadSubCommand("refcount", CommandObjectSP(new CommandObjectSwift_RefCount(
interpreter)));
}
virtual ~CommandObjectMultiwordSwift() {}
};
void SwiftLanguageRuntime::Initialize() {
PluginManager::RegisterPlugin(
GetPluginNameStatic(), "Language runtime for the Swift language",
CreateInstance,
[](CommandInterpreter &interpreter) -> lldb::CommandObjectSP {
return CommandObjectSP(new CommandObjectMultiwordSwift(interpreter));
});
}
void SwiftLanguageRuntime::Terminate() {
PluginManager::UnregisterPlugin(CreateInstance);
}
lldb_private::ConstString SwiftLanguageRuntime::GetPluginNameStatic() {
static ConstString g_name("swift");
return g_name;
}
//------------------------------------------------------------------
// PluginInterface protocol
//------------------------------------------------------------------
lldb_private::ConstString SwiftLanguageRuntime::GetPluginName() {
return GetPluginNameStatic();
}
uint32_t SwiftLanguageRuntime::GetPluginVersion() { return 1; }