diff options
Diffstat (limited to 'lldb/source/Plugins/LanguageRuntime')
30 files changed, 16292 insertions, 0 deletions
diff --git a/lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.cpp b/lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.cpp new file mode 100644 index 000000000000..f38014505a8b --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.cpp @@ -0,0 +1,353 @@ +//===-- CPPLanguageRuntime.cpp +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <string.h> + +#include <memory> + +#include "CPPLanguageRuntime.h" + +#include "llvm/ADT/StringRef.h" + +#include "lldb/Symbol/Block.h" +#include "lldb/Symbol/Variable.h" +#include "lldb/Symbol/VariableList.h" + +#include "lldb/Core/PluginManager.h" +#include "lldb/Core/UniqueCStringMap.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Target/ABI.h" +#include "lldb/Target/ExecutionContext.h" +#include "lldb/Target/RegisterContext.h" +#include "lldb/Target/SectionLoadList.h" +#include "lldb/Target/StackFrame.h" +#include "lldb/Target/ThreadPlanRunToAddress.h" +#include "lldb/Target/ThreadPlanStepInRange.h" + +using namespace lldb; +using namespace lldb_private; + +static ConstString g_this = ConstString("this"); + +char CPPLanguageRuntime::ID = 0; + +// Destructor +CPPLanguageRuntime::~CPPLanguageRuntime() {} + +CPPLanguageRuntime::CPPLanguageRuntime(Process *process) + : LanguageRuntime(process) {} + +bool CPPLanguageRuntime::IsWhitelistedRuntimeValue(ConstString name) { + return name == g_this; +} + +bool CPPLanguageRuntime::GetObjectDescription(Stream &str, + ValueObject &object) { + // C++ has no generic way to do this. + return false; +} + +bool CPPLanguageRuntime::GetObjectDescription( + Stream &str, Value &value, ExecutionContextScope *exe_scope) { + // C++ has no generic way to do this. + return false; +} + +CPPLanguageRuntime::LibCppStdFunctionCallableInfo +CPPLanguageRuntime::FindLibCppStdFunctionCallableInfo( + lldb::ValueObjectSP &valobj_sp) { + LibCppStdFunctionCallableInfo optional_info; + + if (!valobj_sp) + return optional_info; + + // Member __f_ has type __base*, the contents of which will hold: + // 1) a vtable entry which may hold type information needed to discover the + // lambda being called + // 2) possibly hold a pointer to the callable object + // e.g. + // + // (lldb) frame var -R f_display + // (std::__1::function<void (int)>) f_display = { + // __buf_ = { + // … + // } + // __f_ = 0x00007ffeefbffa00 + // } + // (lldb) memory read -fA 0x00007ffeefbffa00 + // 0x7ffeefbffa00: ... `vtable for std::__1::__function::__func<void (*) ... + // 0x7ffeefbffa08: ... `print_num(int) at std_function_cppreference_exam ... + // + // We will be handling five cases below, std::function is wrapping: + // + // 1) a lambda we know at compile time. We will obtain the name of the lambda + // from the first template pameter from __func's vtable. We will look up + // the lambda's operator()() and obtain the line table entry. + // 2) a lambda we know at runtime. A pointer to the lambdas __invoke method + // will be stored after the vtable. We will obtain the lambdas name from + // this entry and lookup operator()() and obtain the line table entry. + // 3) a callable object via operator()(). We will obtain the name of the + // object from the first template parameter from __func's vtable. We will + // look up the objectc operator()() and obtain the line table entry. + // 4) a member function. A pointer to the function will stored after the + // we will obtain the name from this pointer. + // 5) a free function. A pointer to the function will stored after the vtable + // we will obtain the name from this pointer. + ValueObjectSP member__f_( + valobj_sp->GetChildMemberWithName(ConstString("__f_"), true)); + + if (member__f_) { + ValueObjectSP sub_member__f_( + member__f_->GetChildMemberWithName(ConstString("__f_"), true)); + + if (sub_member__f_) + member__f_ = sub_member__f_; + } + + lldb::addr_t member__f_pointer_value = member__f_->GetValueAsUnsigned(0); + + optional_info.member__f_pointer_value = member__f_pointer_value; + + ExecutionContext exe_ctx(valobj_sp->GetExecutionContextRef()); + Process *process = exe_ctx.GetProcessPtr(); + + if (process == nullptr) + return optional_info; + + uint32_t address_size = process->GetAddressByteSize(); + Status status; + + // First item pointed to by __f_ should be the pointer to the vtable for + // a __base object. + lldb::addr_t vtable_address = + process->ReadPointerFromMemory(member__f_pointer_value, status); + + if (status.Fail()) + return optional_info; + + lldb::addr_t address_after_vtable = member__f_pointer_value + address_size; + // As commened above we may not have a function pointer but if we do we will + // need it. + lldb::addr_t possible_function_address = + process->ReadPointerFromMemory(address_after_vtable, status); + + if (status.Fail()) + return optional_info; + + Target &target = process->GetTarget(); + + if (target.GetSectionLoadList().IsEmpty()) + return optional_info; + + Address vtable_addr_resolved; + SymbolContext sc; + Symbol *symbol; + + if (!target.GetSectionLoadList().ResolveLoadAddress(vtable_address, + vtable_addr_resolved)) + return optional_info; + + target.GetImages().ResolveSymbolContextForAddress( + vtable_addr_resolved, eSymbolContextEverything, sc); + symbol = sc.symbol; + + if (symbol == nullptr) + return optional_info; + + llvm::StringRef vtable_name(symbol->GetName().GetCString()); + bool found_expected_start_string = + vtable_name.startswith("vtable for std::__1::__function::__func<"); + + if (!found_expected_start_string) + return optional_info; + + // Given case 1 or 3 we have a vtable name, we are want to extract the first + // template parameter + // + // ... __func<main::$_0, std::__1::allocator<main::$_0> ... + // ^^^^^^^^^ + // + // We do this by find the first < and , and extracting in between. + // + // This covers the case of the lambda known at compile time. + size_t first_open_angle_bracket = vtable_name.find('<') + 1; + size_t first_comma = vtable_name.find(','); + + llvm::StringRef first_template_parameter = + vtable_name.slice(first_open_angle_bracket, first_comma); + + Address function_address_resolved; + + // Setup for cases 2, 4 and 5 we have a pointer to a function after the + // vtable. We will use a process of elimination to drop through each case + // and obtain the data we need. + if (target.GetSectionLoadList().ResolveLoadAddress( + possible_function_address, function_address_resolved)) { + target.GetImages().ResolveSymbolContextForAddress( + function_address_resolved, eSymbolContextEverything, sc); + symbol = sc.symbol; + } + + auto get_name = [&first_template_parameter, &symbol]() { + // Given case 1: + // + // main::$_0 + // + // we want to append ::operator()() + if (first_template_parameter.contains("$_")) + return llvm::Regex::escape(first_template_parameter.str()) + + R"(::operator\(\)\(.*\))"; + + if (symbol != nullptr && + symbol->GetName().GetStringRef().contains("__invoke")) { + + llvm::StringRef symbol_name = symbol->GetName().GetStringRef(); + size_t pos2 = symbol_name.find_last_of(':'); + + // Given case 2: + // + // main::$_1::__invoke(...) + // + // We want to slice off __invoke(...) and append operator()() + std::string lambda_operator = + llvm::Regex::escape(symbol_name.slice(0, pos2 + 1).str()) + + R"(operator\(\)\(.*\))"; + + return lambda_operator; + } + + // Case 3 + return first_template_parameter.str() + R"(::operator\(\)\(.*\))"; + ; + }; + + std::string func_to_match = get_name(); + + SymbolContextList scl; + + target.GetImages().FindSymbolsMatchingRegExAndType( + RegularExpression{R"(^)" + func_to_match}, eSymbolTypeAny, scl); + + // Case 1,2 or 3 + if (scl.GetSize() >= 1) { + SymbolContext sc2 = scl[0]; + + AddressRange range; + sc2.GetAddressRange(eSymbolContextEverything, 0, false, range); + + Address address = range.GetBaseAddress(); + + Address addr; + if (target.ResolveLoadAddress(address.GetCallableLoadAddress(&target), + addr)) { + LineEntry line_entry; + addr.CalculateSymbolContextLineEntry(line_entry); + + if (first_template_parameter.contains("$_") || + (symbol != nullptr && + symbol->GetName().GetStringRef().contains("__invoke"))) { + // Case 1 and 2 + optional_info.callable_case = LibCppStdFunctionCallableCase::Lambda; + } else { + // Case 3 + optional_info.callable_case = + LibCppStdFunctionCallableCase::CallableObject; + } + + optional_info.callable_symbol = *symbol; + optional_info.callable_line_entry = line_entry; + optional_info.callable_address = addr; + return optional_info; + } + } + + // Case 4 or 5 + if (symbol && !symbol->GetName().GetStringRef().startswith("vtable for")) { + optional_info.callable_case = + LibCppStdFunctionCallableCase::FreeOrMemberFunction; + optional_info.callable_address = function_address_resolved; + optional_info.callable_symbol = *symbol; + + return optional_info; + } + + return optional_info; +} + +lldb::ThreadPlanSP +CPPLanguageRuntime::GetStepThroughTrampolinePlan(Thread &thread, + bool stop_others) { + ThreadPlanSP ret_plan_sp; + + lldb::addr_t curr_pc = thread.GetRegisterContext()->GetPC(); + + TargetSP target_sp(thread.CalculateTarget()); + + if (target_sp->GetSectionLoadList().IsEmpty()) + return ret_plan_sp; + + Address pc_addr_resolved; + SymbolContext sc; + Symbol *symbol; + + if (!target_sp->GetSectionLoadList().ResolveLoadAddress(curr_pc, + pc_addr_resolved)) + return ret_plan_sp; + + target_sp->GetImages().ResolveSymbolContextForAddress( + pc_addr_resolved, eSymbolContextEverything, sc); + symbol = sc.symbol; + + if (symbol == nullptr) + return ret_plan_sp; + + llvm::StringRef function_name(symbol->GetName().GetCString()); + + // Handling the case where we are attempting to step into std::function. + // The behavior will be that we will attempt to obtain the wrapped + // callable via FindLibCppStdFunctionCallableInfo() and if we find it we + // will return a ThreadPlanRunToAddress to the callable. Therefore we will + // step into the wrapped callable. + // + bool found_expected_start_string = + function_name.startswith("std::__1::function<"); + + if (!found_expected_start_string) + return ret_plan_sp; + + AddressRange range_of_curr_func; + sc.GetAddressRange(eSymbolContextEverything, 0, false, range_of_curr_func); + + StackFrameSP frame = thread.GetStackFrameAtIndex(0); + + if (frame) { + ValueObjectSP value_sp = frame->FindVariable(g_this); + + CPPLanguageRuntime::LibCppStdFunctionCallableInfo callable_info = + FindLibCppStdFunctionCallableInfo(value_sp); + + if (callable_info.callable_case != LibCppStdFunctionCallableCase::Invalid && + value_sp->GetValueIsValid()) { + // We found the std::function wrapped callable and we have its address. + // We now create a ThreadPlan to run to the callable. + ret_plan_sp = std::make_shared<ThreadPlanRunToAddress>( + thread, callable_info.callable_address, stop_others); + return ret_plan_sp; + } else { + // We are in std::function but we could not obtain the callable. + // We create a ThreadPlan to keep stepping through using the address range + // of the current function. + ret_plan_sp = std::make_shared<ThreadPlanStepInRange>( + thread, range_of_curr_func, sc, eOnlyThisThread, eLazyBoolYes, + eLazyBoolYes); + return ret_plan_sp; + } + } + + return ret_plan_sp; +} diff --git a/lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h b/lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h new file mode 100644 index 000000000000..28526361efc4 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h @@ -0,0 +1,90 @@ +//===-- CPPLanguageRuntime.h +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_CPPLanguageRuntime_h_ +#define liblldb_CPPLanguageRuntime_h_ + +#include <vector> +#include "lldb/Core/PluginInterface.h" +#include "lldb/Target/LanguageRuntime.h" +#include "lldb/lldb-private.h" + +namespace lldb_private { + +class CPPLanguageRuntime : public LanguageRuntime { +public: + enum class LibCppStdFunctionCallableCase { + Lambda = 0, + CallableObject, + FreeOrMemberFunction, + Invalid + }; + + struct LibCppStdFunctionCallableInfo { + Symbol callable_symbol; + Address callable_address; + LineEntry callable_line_entry; + lldb::addr_t member__f_pointer_value = 0u; + LibCppStdFunctionCallableCase callable_case = + LibCppStdFunctionCallableCase::Invalid; + }; + + LibCppStdFunctionCallableInfo + FindLibCppStdFunctionCallableInfo(lldb::ValueObjectSP &valobj_sp); + + ~CPPLanguageRuntime() override; + + static char ID; + + bool isA(const void *ClassID) const override { + return ClassID == &ID || LanguageRuntime::isA(ClassID); + } + + static bool classof(const LanguageRuntime *runtime) { + return runtime->isA(&ID); + } + + lldb::LanguageType GetLanguageType() const override { + return lldb::eLanguageTypeC_plus_plus; + } + + static CPPLanguageRuntime *Get(Process &process) { + return llvm::cast_or_null<CPPLanguageRuntime>( + process.GetLanguageRuntime(lldb::eLanguageTypeC_plus_plus)); + } + + bool GetObjectDescription(Stream &str, ValueObject &object) override; + + bool GetObjectDescription(Stream &str, Value &value, + ExecutionContextScope *exe_scope) override; + + /// Obtain a ThreadPlan to get us into C++ constructs such as std::function. + /// + /// \param[in] thread + /// Curent thrad of execution. + /// + /// \param[in] stop_others + /// True if other threads should pause during execution. + /// + /// \return + /// A ThreadPlan Shared pointer + lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread, + bool stop_others) override; + + bool IsWhitelistedRuntimeValue(ConstString name) override; +protected: + // Classes that inherit from CPPLanguageRuntime can see and modify these + CPPLanguageRuntime(Process *process); + +private: + DISALLOW_COPY_AND_ASSIGN(CPPLanguageRuntime); +}; + +} // namespace lldb_private + +#endif // liblldb_CPPLanguageRuntime_h_ diff --git a/lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp b/lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp new file mode 100644 index 000000000000..02e62a263286 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp @@ -0,0 +1,610 @@ +//===-- ItaniumABILanguageRuntime.cpp --------------------------------------*- +//C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "ItaniumABILanguageRuntime.h" + +#include "lldb/Breakpoint/BreakpointLocation.h" +#include "lldb/Core/Mangled.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Core/ValueObjectMemory.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/Expression/DiagnosticManager.h" +#include "lldb/Expression/FunctionCaller.h" +#include "lldb/Interpreter/CommandObject.h" +#include "lldb/Interpreter/CommandObjectMultiword.h" +#include "lldb/Interpreter/CommandReturnObject.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Symbol/Symbol.h" +#include "lldb/Symbol/SymbolFile.h" +#include "lldb/Symbol/TypeList.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/RegisterContext.h" +#include "lldb/Target/SectionLoadList.h" +#include "lldb/Target/StopInfo.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/Thread.h" +#include "lldb/Utility/ConstString.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Scalar.h" +#include "lldb/Utility/Status.h" + +#include <vector> + +using namespace lldb; +using namespace lldb_private; + +static const char *vtable_demangled_prefix = "vtable for "; + +char ItaniumABILanguageRuntime::ID = 0; + +bool ItaniumABILanguageRuntime::CouldHaveDynamicValue(ValueObject &in_value) { + const bool check_cxx = true; + const bool check_objc = false; + return in_value.GetCompilerType().IsPossibleDynamicType(nullptr, check_cxx, + check_objc); +} + +TypeAndOrName ItaniumABILanguageRuntime::GetTypeInfoFromVTableAddress( + ValueObject &in_value, lldb::addr_t original_ptr, + lldb::addr_t vtable_load_addr) { + if (m_process && vtable_load_addr != LLDB_INVALID_ADDRESS) { + // Find the symbol that contains the "vtable_load_addr" address + Address vtable_addr; + Target &target = m_process->GetTarget(); + if (!target.GetSectionLoadList().IsEmpty()) { + if (target.GetSectionLoadList().ResolveLoadAddress(vtable_load_addr, + vtable_addr)) { + // See if we have cached info for this type already + TypeAndOrName type_info = GetDynamicTypeInfo(vtable_addr); + if (type_info) + return type_info; + + SymbolContext sc; + target.GetImages().ResolveSymbolContextForAddress( + vtable_addr, eSymbolContextSymbol, sc); + Symbol *symbol = sc.symbol; + if (symbol != nullptr) { + const char *name = + symbol->GetMangled() + .GetDemangledName(lldb::eLanguageTypeC_plus_plus) + .AsCString(); + if (name && strstr(name, vtable_demangled_prefix) == name) { + Log *log( + lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT)); + LLDB_LOGF(log, + "0x%16.16" PRIx64 + ": static-type = '%s' has vtable symbol '%s'\n", + original_ptr, in_value.GetTypeName().GetCString(), name); + // We are a C++ class, that's good. Get the class name and look it + // up: + const char *class_name = name + strlen(vtable_demangled_prefix); + // We know the class name is absolute, so tell FindTypes that by + // prefixing it with the root namespace: + std::string lookup_name("::"); + lookup_name.append(class_name); + + type_info.SetName(class_name); + const bool exact_match = true; + TypeList class_types; + + // First look in the module that the vtable symbol came from and + // look for a single exact match. + llvm::DenseSet<SymbolFile *> searched_symbol_files; + if (sc.module_sp) + sc.module_sp->FindTypes(ConstString(lookup_name), exact_match, 1, + searched_symbol_files, class_types); + + // If we didn't find a symbol, then move on to the entire module + // list in the target and get as many unique matches as possible + if (class_types.Empty()) + target.GetImages().FindTypes(nullptr, ConstString(lookup_name), + exact_match, UINT32_MAX, + searched_symbol_files, class_types); + + lldb::TypeSP type_sp; + if (class_types.Empty()) { + LLDB_LOGF(log, "0x%16.16" PRIx64 ": is not dynamic\n", + original_ptr); + return TypeAndOrName(); + } + if (class_types.GetSize() == 1) { + type_sp = class_types.GetTypeAtIndex(0); + if (type_sp) { + if (ClangASTContext::IsCXXClassType( + type_sp->GetForwardCompilerType())) { + LLDB_LOGF( + log, + "0x%16.16" PRIx64 + ": static-type = '%s' has dynamic type: uid={0x%" PRIx64 + "}, type-name='%s'\n", + original_ptr, in_value.GetTypeName().AsCString(), + type_sp->GetID(), type_sp->GetName().GetCString()); + type_info.SetTypeSP(type_sp); + } + } + } else { + size_t i; + if (log) { + for (i = 0; i < class_types.GetSize(); i++) { + type_sp = class_types.GetTypeAtIndex(i); + if (type_sp) { + LLDB_LOGF( + log, + "0x%16.16" PRIx64 + ": static-type = '%s' has multiple matching dynamic " + "types: uid={0x%" PRIx64 "}, type-name='%s'\n", + original_ptr, in_value.GetTypeName().AsCString(), + type_sp->GetID(), type_sp->GetName().GetCString()); + } + } + } + + for (i = 0; i < class_types.GetSize(); i++) { + type_sp = class_types.GetTypeAtIndex(i); + if (type_sp) { + if (ClangASTContext::IsCXXClassType( + type_sp->GetForwardCompilerType())) { + LLDB_LOGF( + log, + "0x%16.16" PRIx64 ": static-type = '%s' has multiple " + "matching dynamic types, picking " + "this one: uid={0x%" PRIx64 "}, type-name='%s'\n", + original_ptr, in_value.GetTypeName().AsCString(), + type_sp->GetID(), type_sp->GetName().GetCString()); + type_info.SetTypeSP(type_sp); + } + } + } + + if (log) { + LLDB_LOGF(log, + "0x%16.16" PRIx64 + ": static-type = '%s' has multiple matching dynamic " + "types, didn't find a C++ match\n", + original_ptr, in_value.GetTypeName().AsCString()); + } + } + if (type_info) + SetDynamicTypeInfo(vtable_addr, type_info); + return type_info; + } + } + } + } + } + return TypeAndOrName(); +} + +bool ItaniumABILanguageRuntime::GetDynamicTypeAndAddress( + ValueObject &in_value, lldb::DynamicValueType use_dynamic, + TypeAndOrName &class_type_or_name, Address &dynamic_address, + Value::ValueType &value_type) { + // For Itanium, if the type has a vtable pointer in the object, it will be at + // offset 0 in the object. That will point to the "address point" within the + // vtable (not the beginning of the vtable.) We can then look up the symbol + // containing this "address point" and that symbol's name demangled will + // contain the full class name. The second pointer above the "address point" + // is the "offset_to_top". We'll use that to get the start of the value + // object which holds the dynamic type. + // + + class_type_or_name.Clear(); + value_type = Value::ValueType::eValueTypeScalar; + + // Only a pointer or reference type can have a different dynamic and static + // type: + if (!CouldHaveDynamicValue(in_value)) + return false; + + // First job, pull out the address at 0 offset from the object. + AddressType address_type; + lldb::addr_t original_ptr = in_value.GetPointerValue(&address_type); + if (original_ptr == LLDB_INVALID_ADDRESS) + return false; + + ExecutionContext exe_ctx(in_value.GetExecutionContextRef()); + + Process *process = exe_ctx.GetProcessPtr(); + + if (process == nullptr) + return false; + + Status error; + const lldb::addr_t vtable_address_point = + process->ReadPointerFromMemory(original_ptr, error); + + if (!error.Success() || vtable_address_point == LLDB_INVALID_ADDRESS) + return false; + + class_type_or_name = GetTypeInfoFromVTableAddress(in_value, original_ptr, + vtable_address_point); + + if (!class_type_or_name) + return false; + + CompilerType type = class_type_or_name.GetCompilerType(); + // There can only be one type with a given name, so we've just found + // duplicate definitions, and this one will do as well as any other. We + // don't consider something to have a dynamic type if it is the same as + // the static type. So compare against the value we were handed. + if (!type) + return true; + + if (ClangASTContext::AreTypesSame(in_value.GetCompilerType(), type)) { + // The dynamic type we found was the same type, so we don't have a + // dynamic type here... + return false; + } + + // The offset_to_top is two pointers above the vtable pointer. + const uint32_t addr_byte_size = process->GetAddressByteSize(); + const lldb::addr_t offset_to_top_location = + vtable_address_point - 2 * addr_byte_size; + // Watch for underflow, offset_to_top_location should be less than + // vtable_address_point + if (offset_to_top_location >= vtable_address_point) + return false; + const int64_t offset_to_top = process->ReadSignedIntegerFromMemory( + offset_to_top_location, addr_byte_size, INT64_MIN, error); + + if (offset_to_top == INT64_MIN) + return false; + // So the dynamic type is a value that starts at offset_to_top above + // the original address. + lldb::addr_t dynamic_addr = original_ptr + offset_to_top; + if (!process->GetTarget().GetSectionLoadList().ResolveLoadAddress( + dynamic_addr, dynamic_address)) { + dynamic_address.SetRawAddress(dynamic_addr); + } + return true; +} + +TypeAndOrName ItaniumABILanguageRuntime::FixUpDynamicType( + const TypeAndOrName &type_and_or_name, ValueObject &static_value) { + CompilerType static_type(static_value.GetCompilerType()); + Flags static_type_flags(static_type.GetTypeInfo()); + + TypeAndOrName ret(type_and_or_name); + 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 (static_type_flags.AllSet(eTypeIsPointer)) + corrected_type = orig_type.GetPointerType(); + else if (static_type_flags.AllSet(eTypeIsReference)) + corrected_type = orig_type.GetLValueReferenceType(); + ret.SetCompilerType(corrected_type); + } else { + // 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 (static_type_flags.AllSet(eTypeIsPointer)) + corrected_name.append(" *"); + else if (static_type_flags.AllSet(eTypeIsReference)) + corrected_name.append(" &"); + // the parent type should be a correctly pointer'ed or referenc'ed type + ret.SetCompilerType(static_type); + ret.SetName(corrected_name.c_str()); + } + return ret; +} + +// Static Functions +LanguageRuntime * +ItaniumABILanguageRuntime::CreateInstance(Process *process, + lldb::LanguageType language) { + // FIXME: We have to check the process and make sure we actually know that + // this process supports + // the Itanium ABI. + if (language == eLanguageTypeC_plus_plus || + language == eLanguageTypeC_plus_plus_03 || + language == eLanguageTypeC_plus_plus_11 || + language == eLanguageTypeC_plus_plus_14) + return new ItaniumABILanguageRuntime(process); + else + return nullptr; +} + +class CommandObjectMultiwordItaniumABI_Demangle : public CommandObjectParsed { +public: + CommandObjectMultiwordItaniumABI_Demangle(CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "demangle", + "Demangle a C++ mangled name.", + "language cplusplus demangle") { + CommandArgumentEntry arg; + CommandArgumentData index_arg; + + // Define the first (and only) variant of this arg. + index_arg.arg_type = eArgTypeSymbol; + index_arg.arg_repetition = eArgRepeatPlus; + + // There is only one variant this argument could be; put it into the + // argument entry. + arg.push_back(index_arg); + + // Push the data for the first argument into the m_arguments vector. + m_arguments.push_back(arg); + } + + ~CommandObjectMultiwordItaniumABI_Demangle() override = default; + +protected: + bool DoExecute(Args &command, CommandReturnObject &result) override { + bool demangled_any = false; + bool error_any = false; + for (auto &entry : command.entries()) { + if (entry.ref().empty()) + continue; + + // the actual Mangled class should be strict about this, but on the + // command line if you're copying mangled names out of 'nm' on Darwin, + // they will come out with an extra underscore - be willing to strip this + // on behalf of the user. This is the moral equivalent of the -_/-n + // options to c++filt + auto name = entry.ref(); + if (name.startswith("__Z")) + name = name.drop_front(); + + Mangled mangled(name); + if (mangled.GuessLanguage() == lldb::eLanguageTypeC_plus_plus) { + ConstString demangled( + mangled.GetDisplayDemangledName(lldb::eLanguageTypeC_plus_plus)); + demangled_any = true; + result.AppendMessageWithFormat("%s ---> %s\n", entry.c_str(), + demangled.GetCString()); + } else { + error_any = true; + result.AppendErrorWithFormat("%s is not a valid C++ mangled name\n", + entry.ref().str().c_str()); + } + } + + result.SetStatus( + error_any ? lldb::eReturnStatusFailed + : (demangled_any ? lldb::eReturnStatusSuccessFinishResult + : lldb::eReturnStatusSuccessFinishNoResult)); + return result.Succeeded(); + } +}; + +class CommandObjectMultiwordItaniumABI : public CommandObjectMultiword { +public: + CommandObjectMultiwordItaniumABI(CommandInterpreter &interpreter) + : CommandObjectMultiword( + interpreter, "cplusplus", + "Commands for operating on the C++ language runtime.", + "cplusplus <subcommand> [<subcommand-options>]") { + LoadSubCommand( + "demangle", + CommandObjectSP( + new CommandObjectMultiwordItaniumABI_Demangle(interpreter))); + } + + ~CommandObjectMultiwordItaniumABI() override = default; +}; + +void ItaniumABILanguageRuntime::Initialize() { + PluginManager::RegisterPlugin( + GetPluginNameStatic(), "Itanium ABI for the C++ language", CreateInstance, + [](CommandInterpreter &interpreter) -> lldb::CommandObjectSP { + return CommandObjectSP( + new CommandObjectMultiwordItaniumABI(interpreter)); + }); +} + +void ItaniumABILanguageRuntime::Terminate() { + PluginManager::UnregisterPlugin(CreateInstance); +} + +lldb_private::ConstString ItaniumABILanguageRuntime::GetPluginNameStatic() { + static ConstString g_name("itanium"); + return g_name; +} + +// PluginInterface protocol +lldb_private::ConstString ItaniumABILanguageRuntime::GetPluginName() { + return GetPluginNameStatic(); +} + +uint32_t ItaniumABILanguageRuntime::GetPluginVersion() { return 1; } + +BreakpointResolverSP ItaniumABILanguageRuntime::CreateExceptionResolver( + Breakpoint *bkpt, bool catch_bp, bool throw_bp) { + return CreateExceptionResolver(bkpt, catch_bp, throw_bp, false); +} + +BreakpointResolverSP ItaniumABILanguageRuntime::CreateExceptionResolver( + Breakpoint *bkpt, bool catch_bp, bool throw_bp, bool for_expressions) { + // One complication here is that most users DON'T want to stop at + // __cxa_allocate_expression, but until we can do anything better with + // predicting unwinding the expression parser does. So we have two forms of + // the exception breakpoints, one for expressions that leaves out + // __cxa_allocate_exception, and one that includes it. The + // SetExceptionBreakpoints does the latter, the CreateExceptionBreakpoint in + // the runtime the former. + static const char *g_catch_name = "__cxa_begin_catch"; + static const char *g_throw_name1 = "__cxa_throw"; + static const char *g_throw_name2 = "__cxa_rethrow"; + static const char *g_exception_throw_name = "__cxa_allocate_exception"; + std::vector<const char *> exception_names; + exception_names.reserve(4); + if (catch_bp) + exception_names.push_back(g_catch_name); + + if (throw_bp) { + exception_names.push_back(g_throw_name1); + exception_names.push_back(g_throw_name2); + } + + if (for_expressions) + exception_names.push_back(g_exception_throw_name); + + BreakpointResolverSP resolver_sp(new BreakpointResolverName( + bkpt, exception_names.data(), exception_names.size(), + eFunctionNameTypeBase, eLanguageTypeUnknown, 0, eLazyBoolNo)); + + return resolver_sp; +} + +lldb::SearchFilterSP ItaniumABILanguageRuntime::CreateExceptionSearchFilter() { + Target &target = m_process->GetTarget(); + + FileSpecList filter_modules; + if (target.GetArchitecture().GetTriple().getVendor() == llvm::Triple::Apple) { + // Limit the number of modules that are searched for these breakpoints for + // Apple binaries. + filter_modules.EmplaceBack("libc++abi.dylib"); + filter_modules.EmplaceBack("libSystem.B.dylib"); + } + return target.GetSearchFilterForModuleList(&filter_modules); +} + +lldb::BreakpointSP ItaniumABILanguageRuntime::CreateExceptionBreakpoint( + bool catch_bp, bool throw_bp, bool for_expressions, bool is_internal) { + Target &target = m_process->GetTarget(); + FileSpecList filter_modules; + BreakpointResolverSP exception_resolver_sp = + CreateExceptionResolver(nullptr, catch_bp, throw_bp, for_expressions); + SearchFilterSP filter_sp(CreateExceptionSearchFilter()); + const bool hardware = false; + const bool resolve_indirect_functions = false; + return target.CreateBreakpoint(filter_sp, exception_resolver_sp, is_internal, + hardware, resolve_indirect_functions); +} + +void ItaniumABILanguageRuntime::SetExceptionBreakpoints() { + if (!m_process) + return; + + const bool catch_bp = false; + const bool throw_bp = true; + const bool is_internal = true; + const bool for_expressions = true; + + // For the exception breakpoints set by the Expression parser, we'll be a + // little more aggressive and stop at exception allocation as well. + + if (m_cxx_exception_bp_sp) { + m_cxx_exception_bp_sp->SetEnabled(true); + } else { + m_cxx_exception_bp_sp = CreateExceptionBreakpoint( + catch_bp, throw_bp, for_expressions, is_internal); + if (m_cxx_exception_bp_sp) + m_cxx_exception_bp_sp->SetBreakpointKind("c++ exception"); + } +} + +void ItaniumABILanguageRuntime::ClearExceptionBreakpoints() { + if (!m_process) + return; + + if (m_cxx_exception_bp_sp) { + m_cxx_exception_bp_sp->SetEnabled(false); + } +} + +bool ItaniumABILanguageRuntime::ExceptionBreakpointsAreSet() { + return m_cxx_exception_bp_sp && m_cxx_exception_bp_sp->IsEnabled(); +} + +bool ItaniumABILanguageRuntime::ExceptionBreakpointsExplainStop( + lldb::StopInfoSP stop_reason) { + if (!m_process) + return false; + + if (!stop_reason || stop_reason->GetStopReason() != eStopReasonBreakpoint) + return false; + + uint64_t break_site_id = stop_reason->GetValue(); + return m_process->GetBreakpointSiteList().BreakpointSiteContainsBreakpoint( + break_site_id, m_cxx_exception_bp_sp->GetID()); +} + +ValueObjectSP ItaniumABILanguageRuntime::GetExceptionObjectForThread( + ThreadSP thread_sp) { + if (!thread_sp->SafeToCallFunctions()) + return {}; + + ClangASTContext *clang_ast_context = + m_process->GetTarget().GetScratchClangASTContext(); + CompilerType voidstar = + clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType(); + + DiagnosticManager diagnostics; + ExecutionContext exe_ctx; + EvaluateExpressionOptions options; + + options.SetUnwindOnError(true); + options.SetIgnoreBreakpoints(true); + options.SetStopOthers(true); + options.SetTimeout(m_process->GetUtilityExpressionTimeout()); + options.SetTryAllThreads(false); + thread_sp->CalculateExecutionContext(exe_ctx); + + const ModuleList &modules = m_process->GetTarget().GetImages(); + SymbolContextList contexts; + SymbolContext context; + + modules.FindSymbolsWithNameAndType( + ConstString("__cxa_current_exception_type"), eSymbolTypeCode, contexts); + contexts.GetContextAtIndex(0, context); + Address addr = context.symbol->GetAddress(); + + Status error; + FunctionCaller *function_caller = + m_process->GetTarget().GetFunctionCallerForLanguage( + eLanguageTypeC, voidstar, addr, ValueList(), "caller", error); + + ExpressionResults func_call_ret; + Value results; + func_call_ret = function_caller->ExecuteFunction(exe_ctx, nullptr, options, + diagnostics, results); + if (func_call_ret != eExpressionCompleted || !error.Success()) { + return ValueObjectSP(); + } + + size_t ptr_size = m_process->GetAddressByteSize(); + addr_t result_ptr = results.GetScalar().ULongLong(LLDB_INVALID_ADDRESS); + addr_t exception_addr = + m_process->ReadPointerFromMemory(result_ptr - ptr_size, error); + + if (!error.Success()) { + return ValueObjectSP(); + } + + lldb_private::formatters::InferiorSizedWord exception_isw(exception_addr, + *m_process); + ValueObjectSP exception = ValueObject::CreateValueObjectFromData( + "exception", exception_isw.GetAsData(m_process->GetByteOrder()), exe_ctx, + voidstar); + exception = exception->GetDynamicValue(eDynamicDontRunTarget); + + return exception; +} + +TypeAndOrName ItaniumABILanguageRuntime::GetDynamicTypeInfo( + const lldb_private::Address &vtable_addr) { + std::lock_guard<std::mutex> locker(m_dynamic_type_map_mutex); + DynamicTypeCache::const_iterator pos = m_dynamic_type_map.find(vtable_addr); + if (pos == m_dynamic_type_map.end()) + return TypeAndOrName(); + else + return pos->second; +} + +void ItaniumABILanguageRuntime::SetDynamicTypeInfo( + const lldb_private::Address &vtable_addr, const TypeAndOrName &type_info) { + std::lock_guard<std::mutex> locker(m_dynamic_type_map_mutex); + m_dynamic_type_map[vtable_addr] = type_info; +} diff --git a/lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h b/lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h new file mode 100644 index 000000000000..97cc81b8681f --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h @@ -0,0 +1,117 @@ +//===-- ItaniumABILanguageRuntime.h -----------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_ItaniumABILanguageRuntime_h_ +#define liblldb_ItaniumABILanguageRuntime_h_ + +#include <map> +#include <mutex> +#include <vector> + +#include "lldb/Breakpoint/BreakpointResolver.h" +#include "lldb/Core/Value.h" +#include "lldb/Symbol/Type.h" +#include "lldb/Target/LanguageRuntime.h" +#include "lldb/lldb-private.h" + +#include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h" + +namespace lldb_private { + +class ItaniumABILanguageRuntime : public lldb_private::CPPLanguageRuntime { +public: + ~ItaniumABILanguageRuntime() override = default; + + // Static Functions + static void Initialize(); + + static void Terminate(); + + static lldb_private::LanguageRuntime * + CreateInstance(Process *process, lldb::LanguageType language); + + static lldb_private::ConstString GetPluginNameStatic(); + + static char ID; + + bool isA(const void *ClassID) const override { + return ClassID == &ID || CPPLanguageRuntime::isA(ClassID); + } + + static bool classof(const LanguageRuntime *runtime) { + return runtime->isA(&ID); + } + + bool GetDynamicTypeAndAddress(ValueObject &in_value, + lldb::DynamicValueType use_dynamic, + TypeAndOrName &class_type_or_name, + Address &address, + Value::ValueType &value_type) override; + + TypeAndOrName FixUpDynamicType(const TypeAndOrName &type_and_or_name, + ValueObject &static_value) override; + + bool CouldHaveDynamicValue(ValueObject &in_value) override; + + void SetExceptionBreakpoints() override; + + void ClearExceptionBreakpoints() override; + + bool ExceptionBreakpointsAreSet() override; + + bool ExceptionBreakpointsExplainStop(lldb::StopInfoSP stop_reason) override; + + lldb::BreakpointResolverSP CreateExceptionResolver(Breakpoint *bkpt, + bool catch_bp, + bool throw_bp) override; + + lldb::SearchFilterSP CreateExceptionSearchFilter() override; + + lldb::ValueObjectSP GetExceptionObjectForThread( + lldb::ThreadSP thread_sp) override; + + // PluginInterface protocol + lldb_private::ConstString GetPluginName() override; + + uint32_t GetPluginVersion() override; + +protected: + lldb::BreakpointResolverSP CreateExceptionResolver(Breakpoint *bkpt, + bool catch_bp, + bool throw_bp, + bool for_expressions); + + lldb::BreakpointSP CreateExceptionBreakpoint(bool catch_bp, bool throw_bp, + bool for_expressions, + bool is_internal); + +private: + typedef std::map<lldb_private::Address, TypeAndOrName> DynamicTypeCache; + + ItaniumABILanguageRuntime(Process *process) + : // Call CreateInstance instead. + lldb_private::CPPLanguageRuntime(process), m_cxx_exception_bp_sp(), + m_dynamic_type_map(), m_dynamic_type_map_mutex() {} + + lldb::BreakpointSP m_cxx_exception_bp_sp; + DynamicTypeCache m_dynamic_type_map; + std::mutex m_dynamic_type_map_mutex; + + TypeAndOrName GetTypeInfoFromVTableAddress(ValueObject &in_value, + lldb::addr_t original_ptr, + lldb::addr_t vtable_addr); + + TypeAndOrName GetDynamicTypeInfo(const lldb_private::Address &vtable_addr); + + void SetDynamicTypeInfo(const lldb_private::Address &vtable_addr, + const TypeAndOrName &type_info); +}; + +} // namespace lldb_private + +#endif // liblldb_ItaniumABILanguageRuntime_h_ diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.cpp b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.cpp new file mode 100644 index 000000000000..93aa07f89165 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.cpp @@ -0,0 +1,541 @@ +//===-- AppleObjCClassDescriptorV2.cpp -----------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "AppleObjCClassDescriptorV2.h" + +#include "lldb/Expression/FunctionCaller.h" +#include "lldb/Utility/Log.h" + +using namespace lldb; +using namespace lldb_private; + +bool ClassDescriptorV2::Read_objc_class( + Process *process, std::unique_ptr<objc_class_t> &objc_class) const { + objc_class.reset(new objc_class_t); + + bool ret = objc_class->Read(process, m_objc_class_ptr); + + if (!ret) + objc_class.reset(); + + return ret; +} + +static lldb::addr_t GetClassDataMask(Process *process) { + switch (process->GetAddressByteSize()) { + case 4: + return 0xfffffffcUL; + case 8: + return 0x00007ffffffffff8UL; + default: + break; + } + + return LLDB_INVALID_ADDRESS; +} + +bool ClassDescriptorV2::objc_class_t::Read(Process *process, + lldb::addr_t addr) { + size_t ptr_size = process->GetAddressByteSize(); + + size_t objc_class_size = ptr_size // uintptr_t isa; + + ptr_size // Class superclass; + + ptr_size // void *cache; + + ptr_size // IMP *vtable; + + ptr_size; // uintptr_t data_NEVER_USE; + + DataBufferHeap objc_class_buf(objc_class_size, '\0'); + Status error; + + process->ReadMemory(addr, objc_class_buf.GetBytes(), objc_class_size, error); + if (error.Fail()) { + return false; + } + + DataExtractor extractor(objc_class_buf.GetBytes(), objc_class_size, + process->GetByteOrder(), + process->GetAddressByteSize()); + + lldb::offset_t cursor = 0; + + m_isa = extractor.GetAddress_unchecked(&cursor); // uintptr_t isa; + m_superclass = extractor.GetAddress_unchecked(&cursor); // Class superclass; + m_cache_ptr = extractor.GetAddress_unchecked(&cursor); // void *cache; + m_vtable_ptr = extractor.GetAddress_unchecked(&cursor); // IMP *vtable; + lldb::addr_t data_NEVER_USE = + extractor.GetAddress_unchecked(&cursor); // uintptr_t data_NEVER_USE; + + m_flags = (uint8_t)(data_NEVER_USE & (lldb::addr_t)3); + m_data_ptr = data_NEVER_USE & GetClassDataMask(process); + + return true; +} + +bool ClassDescriptorV2::class_rw_t::Read(Process *process, lldb::addr_t addr) { + size_t ptr_size = process->GetAddressByteSize(); + + size_t size = sizeof(uint32_t) // uint32_t flags; + + sizeof(uint32_t) // uint32_t version; + + ptr_size // const class_ro_t *ro; + + ptr_size // union { method_list_t **method_lists; + // method_list_t *method_list; }; + + ptr_size // struct chained_property_list *properties; + + ptr_size // const protocol_list_t **protocols; + + ptr_size // Class firstSubclass; + + ptr_size; // Class nextSiblingClass; + + DataBufferHeap buffer(size, '\0'); + Status error; + + process->ReadMemory(addr, buffer.GetBytes(), size, error); + if (error.Fail()) { + return false; + } + + DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(), + process->GetAddressByteSize()); + + lldb::offset_t cursor = 0; + + m_flags = extractor.GetU32_unchecked(&cursor); + m_version = extractor.GetU32_unchecked(&cursor); + m_ro_ptr = extractor.GetAddress_unchecked(&cursor); + m_method_list_ptr = extractor.GetAddress_unchecked(&cursor); + m_properties_ptr = extractor.GetAddress_unchecked(&cursor); + m_firstSubclass = extractor.GetAddress_unchecked(&cursor); + m_nextSiblingClass = extractor.GetAddress_unchecked(&cursor); + + return true; +} + +bool ClassDescriptorV2::class_ro_t::Read(Process *process, lldb::addr_t addr) { + size_t ptr_size = process->GetAddressByteSize(); + + size_t size = sizeof(uint32_t) // uint32_t flags; + + sizeof(uint32_t) // uint32_t instanceStart; + + sizeof(uint32_t) // uint32_t instanceSize; + + (ptr_size == 8 ? sizeof(uint32_t) + : 0) // uint32_t reserved; // __LP64__ only + + ptr_size // const uint8_t *ivarLayout; + + ptr_size // const char *name; + + ptr_size // const method_list_t *baseMethods; + + ptr_size // const protocol_list_t *baseProtocols; + + ptr_size // const ivar_list_t *ivars; + + ptr_size // const uint8_t *weakIvarLayout; + + ptr_size; // const property_list_t *baseProperties; + + DataBufferHeap buffer(size, '\0'); + Status error; + + process->ReadMemory(addr, buffer.GetBytes(), size, error); + if (error.Fail()) { + return false; + } + + DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(), + process->GetAddressByteSize()); + + lldb::offset_t cursor = 0; + + m_flags = extractor.GetU32_unchecked(&cursor); + m_instanceStart = extractor.GetU32_unchecked(&cursor); + m_instanceSize = extractor.GetU32_unchecked(&cursor); + if (ptr_size == 8) + m_reserved = extractor.GetU32_unchecked(&cursor); + else + m_reserved = 0; + m_ivarLayout_ptr = extractor.GetAddress_unchecked(&cursor); + m_name_ptr = extractor.GetAddress_unchecked(&cursor); + m_baseMethods_ptr = extractor.GetAddress_unchecked(&cursor); + m_baseProtocols_ptr = extractor.GetAddress_unchecked(&cursor); + m_ivars_ptr = extractor.GetAddress_unchecked(&cursor); + m_weakIvarLayout_ptr = extractor.GetAddress_unchecked(&cursor); + m_baseProperties_ptr = extractor.GetAddress_unchecked(&cursor); + + DataBufferHeap name_buf(1024, '\0'); + + process->ReadCStringFromMemory(m_name_ptr, (char *)name_buf.GetBytes(), + name_buf.GetByteSize(), error); + + if (error.Fail()) { + return false; + } + + m_name.assign((char *)name_buf.GetBytes()); + + return true; +} + +bool ClassDescriptorV2::Read_class_row( + Process *process, const objc_class_t &objc_class, + std::unique_ptr<class_ro_t> &class_ro, + std::unique_ptr<class_rw_t> &class_rw) const { + class_ro.reset(); + class_rw.reset(); + + Status error; + uint32_t class_row_t_flags = process->ReadUnsignedIntegerFromMemory( + objc_class.m_data_ptr, sizeof(uint32_t), 0, error); + if (!error.Success()) + return false; + + if (class_row_t_flags & RW_REALIZED) { + class_rw.reset(new class_rw_t); + + if (!class_rw->Read(process, objc_class.m_data_ptr)) { + class_rw.reset(); + return false; + } + + class_ro.reset(new class_ro_t); + + if (!class_ro->Read(process, class_rw->m_ro_ptr)) { + class_rw.reset(); + class_ro.reset(); + return false; + } + } else { + class_ro.reset(new class_ro_t); + + if (!class_ro->Read(process, objc_class.m_data_ptr)) { + class_ro.reset(); + return false; + } + } + + return true; +} + +bool ClassDescriptorV2::method_list_t::Read(Process *process, + lldb::addr_t addr) { + size_t size = sizeof(uint32_t) // uint32_t entsize_NEVER_USE; + + sizeof(uint32_t); // uint32_t count; + + DataBufferHeap buffer(size, '\0'); + Status error; + + process->ReadMemory(addr, buffer.GetBytes(), size, error); + if (error.Fail()) { + return false; + } + + DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(), + process->GetAddressByteSize()); + + lldb::offset_t cursor = 0; + + m_entsize = extractor.GetU32_unchecked(&cursor) & ~(uint32_t)3; + m_count = extractor.GetU32_unchecked(&cursor); + m_first_ptr = addr + cursor; + + return true; +} + +bool ClassDescriptorV2::method_t::Read(Process *process, lldb::addr_t addr) { + size_t size = GetSize(process); + + DataBufferHeap buffer(size, '\0'); + Status error; + + process->ReadMemory(addr, buffer.GetBytes(), size, error); + if (error.Fail()) { + return false; + } + + DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(), + process->GetAddressByteSize()); + + lldb::offset_t cursor = 0; + + m_name_ptr = extractor.GetAddress_unchecked(&cursor); + m_types_ptr = extractor.GetAddress_unchecked(&cursor); + m_imp_ptr = extractor.GetAddress_unchecked(&cursor); + + process->ReadCStringFromMemory(m_name_ptr, m_name, error); + if (error.Fail()) { + return false; + } + + process->ReadCStringFromMemory(m_types_ptr, m_types, error); + return !error.Fail(); +} + +bool ClassDescriptorV2::ivar_list_t::Read(Process *process, lldb::addr_t addr) { + size_t size = sizeof(uint32_t) // uint32_t entsize; + + sizeof(uint32_t); // uint32_t count; + + DataBufferHeap buffer(size, '\0'); + Status error; + + process->ReadMemory(addr, buffer.GetBytes(), size, error); + if (error.Fail()) { + return false; + } + + DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(), + process->GetAddressByteSize()); + + lldb::offset_t cursor = 0; + + m_entsize = extractor.GetU32_unchecked(&cursor); + m_count = extractor.GetU32_unchecked(&cursor); + m_first_ptr = addr + cursor; + + return true; +} + +bool ClassDescriptorV2::ivar_t::Read(Process *process, lldb::addr_t addr) { + size_t size = GetSize(process); + + DataBufferHeap buffer(size, '\0'); + Status error; + + process->ReadMemory(addr, buffer.GetBytes(), size, error); + if (error.Fail()) { + return false; + } + + DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(), + process->GetAddressByteSize()); + + lldb::offset_t cursor = 0; + + m_offset_ptr = extractor.GetAddress_unchecked(&cursor); + m_name_ptr = extractor.GetAddress_unchecked(&cursor); + m_type_ptr = extractor.GetAddress_unchecked(&cursor); + m_alignment = extractor.GetU32_unchecked(&cursor); + m_size = extractor.GetU32_unchecked(&cursor); + + process->ReadCStringFromMemory(m_name_ptr, m_name, error); + if (error.Fail()) { + return false; + } + + process->ReadCStringFromMemory(m_type_ptr, m_type, error); + return !error.Fail(); +} + +bool ClassDescriptorV2::Describe( + std::function<void(ObjCLanguageRuntime::ObjCISA)> const &superclass_func, + std::function<bool(const char *, const char *)> const &instance_method_func, + std::function<bool(const char *, const char *)> const &class_method_func, + std::function<bool(const char *, const char *, lldb::addr_t, + uint64_t)> const &ivar_func) const { + lldb_private::Process *process = m_runtime.GetProcess(); + + std::unique_ptr<objc_class_t> objc_class; + std::unique_ptr<class_ro_t> class_ro; + std::unique_ptr<class_rw_t> class_rw; + + if (!Read_objc_class(process, objc_class)) + return false; + if (!Read_class_row(process, *objc_class, class_ro, class_rw)) + return false; + + static ConstString NSObject_name("NSObject"); + + if (m_name != NSObject_name && superclass_func) + superclass_func(objc_class->m_superclass); + + if (instance_method_func) { + std::unique_ptr<method_list_t> base_method_list; + + base_method_list.reset(new method_list_t); + if (!base_method_list->Read(process, class_ro->m_baseMethods_ptr)) + return false; + + if (base_method_list->m_entsize != method_t::GetSize(process)) + return false; + + std::unique_ptr<method_t> method; + method.reset(new method_t); + + for (uint32_t i = 0, e = base_method_list->m_count; i < e; ++i) { + method->Read(process, base_method_list->m_first_ptr + + (i * base_method_list->m_entsize)); + + if (instance_method_func(method->m_name.c_str(), method->m_types.c_str())) + break; + } + } + + if (class_method_func) { + AppleObjCRuntime::ClassDescriptorSP metaclass(GetMetaclass()); + + // We don't care about the metaclass's superclass, or its class methods. + // Its instance methods are our class methods. + + if (metaclass) { + metaclass->Describe( + std::function<void(ObjCLanguageRuntime::ObjCISA)>(nullptr), + class_method_func, + std::function<bool(const char *, const char *)>(nullptr), + std::function<bool(const char *, const char *, lldb::addr_t, + uint64_t)>(nullptr)); + } + } + + if (ivar_func) { + if (class_ro->m_ivars_ptr != 0) { + ivar_list_t ivar_list; + if (!ivar_list.Read(process, class_ro->m_ivars_ptr)) + return false; + + if (ivar_list.m_entsize != ivar_t::GetSize(process)) + return false; + + ivar_t ivar; + + for (uint32_t i = 0, e = ivar_list.m_count; i < e; ++i) { + ivar.Read(process, ivar_list.m_first_ptr + (i * ivar_list.m_entsize)); + + if (ivar_func(ivar.m_name.c_str(), ivar.m_type.c_str(), + ivar.m_offset_ptr, ivar.m_size)) + break; + } + } + } + + return true; +} + +ConstString ClassDescriptorV2::GetClassName() { + if (!m_name) { + lldb_private::Process *process = m_runtime.GetProcess(); + + if (process) { + std::unique_ptr<objc_class_t> objc_class; + std::unique_ptr<class_ro_t> class_ro; + std::unique_ptr<class_rw_t> class_rw; + + if (!Read_objc_class(process, objc_class)) + return m_name; + if (!Read_class_row(process, *objc_class, class_ro, class_rw)) + return m_name; + + m_name = ConstString(class_ro->m_name.c_str()); + } + } + return m_name; +} + +ObjCLanguageRuntime::ClassDescriptorSP ClassDescriptorV2::GetSuperclass() { + lldb_private::Process *process = m_runtime.GetProcess(); + + if (!process) + return ObjCLanguageRuntime::ClassDescriptorSP(); + + std::unique_ptr<objc_class_t> objc_class; + + if (!Read_objc_class(process, objc_class)) + return ObjCLanguageRuntime::ClassDescriptorSP(); + + return m_runtime.ObjCLanguageRuntime::GetClassDescriptorFromISA( + objc_class->m_superclass); +} + +ObjCLanguageRuntime::ClassDescriptorSP ClassDescriptorV2::GetMetaclass() const { + lldb_private::Process *process = m_runtime.GetProcess(); + + if (!process) + return ObjCLanguageRuntime::ClassDescriptorSP(); + + std::unique_ptr<objc_class_t> objc_class; + + if (!Read_objc_class(process, objc_class)) + return ObjCLanguageRuntime::ClassDescriptorSP(); + + lldb::addr_t candidate_isa = m_runtime.GetPointerISA(objc_class->m_isa); + + return ObjCLanguageRuntime::ClassDescriptorSP( + new ClassDescriptorV2(m_runtime, candidate_isa, nullptr)); +} + +uint64_t ClassDescriptorV2::GetInstanceSize() { + lldb_private::Process *process = m_runtime.GetProcess(); + + if (process) { + std::unique_ptr<objc_class_t> objc_class; + std::unique_ptr<class_ro_t> class_ro; + std::unique_ptr<class_rw_t> class_rw; + + if (!Read_objc_class(process, objc_class)) + return 0; + if (!Read_class_row(process, *objc_class, class_ro, class_rw)) + return 0; + + return class_ro->m_instanceSize; + } + + return 0; +} + +ClassDescriptorV2::iVarsStorage::iVarsStorage() + : m_filled(false), m_ivars(), m_mutex() {} + +size_t ClassDescriptorV2::iVarsStorage::size() { return m_ivars.size(); } + +ClassDescriptorV2::iVarDescriptor &ClassDescriptorV2::iVarsStorage:: +operator[](size_t idx) { + return m_ivars[idx]; +} + +void ClassDescriptorV2::iVarsStorage::fill(AppleObjCRuntimeV2 &runtime, + ClassDescriptorV2 &descriptor) { + if (m_filled) + return; + std::lock_guard<std::recursive_mutex> guard(m_mutex); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES)); + LLDB_LOGV(log, "class_name = {0}", descriptor.GetClassName()); + m_filled = true; + ObjCLanguageRuntime::EncodingToTypeSP encoding_to_type_sp( + runtime.GetEncodingToType()); + Process *process(runtime.GetProcess()); + if (!encoding_to_type_sp) + return; + descriptor.Describe(nullptr, nullptr, nullptr, [this, process, + encoding_to_type_sp, + log](const char *name, + const char *type, + lldb::addr_t offset_ptr, + uint64_t size) -> bool { + const bool for_expression = false; + const bool stop_loop = false; + LLDB_LOGV(log, "name = {0}, encoding = {1}, offset_ptr = {2:x}, size = {3}", + name, type, offset_ptr, size); + CompilerType ivar_type = + encoding_to_type_sp->RealizeType(type, for_expression); + if (ivar_type) { + LLDB_LOGV(log, + "name = {0}, encoding = {1}, offset_ptr = {2:x}, size = " + "{3}, type_size = {4}", + name, type, offset_ptr, size, + ivar_type.GetByteSize(nullptr).getValueOr(0)); + Scalar offset_scalar; + Status error; + const int offset_ptr_size = 4; + const bool is_signed = false; + size_t read = process->ReadScalarIntegerFromMemory( + offset_ptr, offset_ptr_size, is_signed, offset_scalar, error); + if (error.Success() && 4 == read) { + LLDB_LOGV(log, "offset_ptr = {0:x} --> {1}", offset_ptr, + offset_scalar.SInt()); + m_ivars.push_back( + {ConstString(name), ivar_type, size, offset_scalar.SInt()}); + } else + LLDB_LOGV(log, "offset_ptr = {0:x} --> read fail, read = %{1}", + offset_ptr, read); + } + return stop_loop; + }); +} + +void ClassDescriptorV2::GetIVarInformation() { + m_ivars_storage.fill(m_runtime, *this); +} diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.h b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.h new file mode 100644 index 000000000000..b8ba9dbb65f4 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.h @@ -0,0 +1,331 @@ +//===-- AppleObjCClassDescriptorV2.h ----------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_AppleObjCClassDescriptorV2_h_ +#define liblldb_AppleObjCClassDescriptorV2_h_ + +#include <mutex> + +#include "AppleObjCRuntimeV2.h" +#include "lldb/lldb-private.h" + +#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h" + +namespace lldb_private { + +class ClassDescriptorV2 : public ObjCLanguageRuntime::ClassDescriptor { +public: + friend class lldb_private::AppleObjCRuntimeV2; + + ~ClassDescriptorV2() override = default; + + ConstString GetClassName() override; + + ObjCLanguageRuntime::ClassDescriptorSP GetSuperclass() override; + + ObjCLanguageRuntime::ClassDescriptorSP GetMetaclass() const override; + + bool IsValid() override { + return true; // any Objective-C v2 runtime class descriptor we vend is valid + } + + // a custom descriptor is used for tagged pointers + bool GetTaggedPointerInfo(uint64_t *info_bits = nullptr, + uint64_t *value_bits = nullptr, + uint64_t *payload = nullptr) override { + return false; + } + + uint64_t GetInstanceSize() override; + + ObjCLanguageRuntime::ObjCISA GetISA() override { return m_objc_class_ptr; } + + bool Describe( + std::function<void(ObjCLanguageRuntime::ObjCISA)> const &superclass_func, + std::function<bool(const char *, const char *)> const + &instance_method_func, + std::function<bool(const char *, const char *)> const &class_method_func, + std::function<bool(const char *, const char *, lldb::addr_t, + uint64_t)> const &ivar_func) const override; + + size_t GetNumIVars() override { + GetIVarInformation(); + return m_ivars_storage.size(); + } + + iVarDescriptor GetIVarAtIndex(size_t idx) override { + if (idx >= GetNumIVars()) + return iVarDescriptor(); + return m_ivars_storage[idx]; + } + +protected: + void GetIVarInformation(); + +private: + static const uint32_t RW_REALIZED = (1 << 31); + + struct objc_class_t { + ObjCLanguageRuntime::ObjCISA m_isa; // The class's metaclass. + ObjCLanguageRuntime::ObjCISA m_superclass; + lldb::addr_t m_cache_ptr; + lldb::addr_t m_vtable_ptr; + lldb::addr_t m_data_ptr; + uint8_t m_flags; + + objc_class_t() + : m_isa(0), m_superclass(0), m_cache_ptr(0), m_vtable_ptr(0), + m_data_ptr(0), m_flags(0) {} + + void Clear() { + m_isa = 0; + m_superclass = 0; + m_cache_ptr = 0; + m_vtable_ptr = 0; + m_data_ptr = 0; + m_flags = 0; + } + + bool Read(Process *process, lldb::addr_t addr); + }; + + struct class_ro_t { + uint32_t m_flags; + uint32_t m_instanceStart; + uint32_t m_instanceSize; + uint32_t m_reserved; + + lldb::addr_t m_ivarLayout_ptr; + lldb::addr_t m_name_ptr; + lldb::addr_t m_baseMethods_ptr; + lldb::addr_t m_baseProtocols_ptr; + lldb::addr_t m_ivars_ptr; + + lldb::addr_t m_weakIvarLayout_ptr; + lldb::addr_t m_baseProperties_ptr; + + std::string m_name; + + bool Read(Process *process, lldb::addr_t addr); + }; + + struct class_rw_t { + uint32_t m_flags; + uint32_t m_version; + + lldb::addr_t m_ro_ptr; + union { + lldb::addr_t m_method_list_ptr; + lldb::addr_t m_method_lists_ptr; + }; + lldb::addr_t m_properties_ptr; + lldb::addr_t m_protocols_ptr; + + ObjCLanguageRuntime::ObjCISA m_firstSubclass; + ObjCLanguageRuntime::ObjCISA m_nextSiblingClass; + + bool Read(Process *process, lldb::addr_t addr); + }; + + struct method_list_t { + uint32_t m_entsize; + uint32_t m_count; + lldb::addr_t m_first_ptr; + + bool Read(Process *process, lldb::addr_t addr); + }; + + struct method_t { + lldb::addr_t m_name_ptr; + lldb::addr_t m_types_ptr; + lldb::addr_t m_imp_ptr; + + std::string m_name; + std::string m_types; + + static size_t GetSize(Process *process) { + size_t ptr_size = process->GetAddressByteSize(); + + return ptr_size // SEL name; + + ptr_size // const char *types; + + ptr_size; // IMP imp; + } + + bool Read(Process *process, lldb::addr_t addr); + }; + + struct ivar_list_t { + uint32_t m_entsize; + uint32_t m_count; + lldb::addr_t m_first_ptr; + + bool Read(Process *process, lldb::addr_t addr); + }; + + struct ivar_t { + lldb::addr_t m_offset_ptr; + lldb::addr_t m_name_ptr; + lldb::addr_t m_type_ptr; + uint32_t m_alignment; + uint32_t m_size; + + std::string m_name; + std::string m_type; + + static size_t GetSize(Process *process) { + size_t ptr_size = process->GetAddressByteSize(); + + return ptr_size // uintptr_t *offset; + + ptr_size // const char *name; + + ptr_size // const char *type; + + sizeof(uint32_t) // uint32_t alignment; + + sizeof(uint32_t); // uint32_t size; + } + + bool Read(Process *process, lldb::addr_t addr); + }; + + class iVarsStorage { + public: + iVarsStorage(); + + size_t size(); + + iVarDescriptor &operator[](size_t idx); + + void fill(AppleObjCRuntimeV2 &runtime, ClassDescriptorV2 &descriptor); + + private: + bool m_filled; + std::vector<iVarDescriptor> m_ivars; + std::recursive_mutex m_mutex; + }; + + // The constructor should only be invoked by the runtime as it builds its + // caches + // or populates them. A ClassDescriptorV2 should only ever exist in a cache. + ClassDescriptorV2(AppleObjCRuntimeV2 &runtime, + ObjCLanguageRuntime::ObjCISA isa, const char *name) + : m_runtime(runtime), m_objc_class_ptr(isa), m_name(name), + m_ivars_storage() {} + + bool Read_objc_class(Process *process, + std::unique_ptr<objc_class_t> &objc_class) const; + + bool Read_class_row(Process *process, const objc_class_t &objc_class, + std::unique_ptr<class_ro_t> &class_ro, + std::unique_ptr<class_rw_t> &class_rw) const; + + AppleObjCRuntimeV2 + &m_runtime; // The runtime, so we can read information lazily. + lldb::addr_t m_objc_class_ptr; // The address of the objc_class_t. (I.e., + // objects of this class type have this as + // their ISA) + ConstString m_name; // May be NULL + iVarsStorage m_ivars_storage; +}; + +// tagged pointer descriptor +class ClassDescriptorV2Tagged : public ObjCLanguageRuntime::ClassDescriptor { +public: + ClassDescriptorV2Tagged(ConstString class_name, uint64_t payload) { + m_name = class_name; + if (!m_name) { + m_valid = false; + return; + } + m_valid = true; + m_payload = payload; + m_info_bits = (m_payload & 0xF0ULL) >> 4; + m_value_bits = (m_payload & ~0x0000000000000000FFULL) >> 8; + } + + ClassDescriptorV2Tagged( + ObjCLanguageRuntime::ClassDescriptorSP actual_class_sp, + uint64_t payload) { + if (!actual_class_sp) { + m_valid = false; + return; + } + m_name = actual_class_sp->GetClassName(); + if (!m_name) { + m_valid = false; + return; + } + m_valid = true; + m_payload = payload; + m_info_bits = (m_payload & 0x0FULL); + m_value_bits = (m_payload & ~0x0FULL) >> 4; + } + + ~ClassDescriptorV2Tagged() override = default; + + ConstString GetClassName() override { return m_name; } + + ObjCLanguageRuntime::ClassDescriptorSP GetSuperclass() override { + // tagged pointers can represent a class that has a superclass, but since + // that information is not + // stored in the object itself, we would have to query the runtime to + // discover the hierarchy + // for the time being, we skip this step in the interest of static discovery + return ObjCLanguageRuntime::ClassDescriptorSP(); + } + + ObjCLanguageRuntime::ClassDescriptorSP GetMetaclass() const override { + return ObjCLanguageRuntime::ClassDescriptorSP(); + } + + bool IsValid() override { return m_valid; } + + bool IsKVO() override { + return false; // tagged pointers are not KVO'ed + } + + bool IsCFType() override { + return false; // tagged pointers are not CF objects + } + + bool GetTaggedPointerInfo(uint64_t *info_bits = nullptr, + uint64_t *value_bits = nullptr, + uint64_t *payload = nullptr) override { + if (info_bits) + *info_bits = GetInfoBits(); + if (value_bits) + *value_bits = GetValueBits(); + if (payload) + *payload = GetPayload(); + return true; + } + + uint64_t GetInstanceSize() override { + return (IsValid() ? m_pointer_size : 0); + } + + ObjCLanguageRuntime::ObjCISA GetISA() override { + return 0; // tagged pointers have no ISA + } + + // these calls are not part of any formal tagged pointers specification + virtual uint64_t GetValueBits() { return (IsValid() ? m_value_bits : 0); } + + virtual uint64_t GetInfoBits() { return (IsValid() ? m_info_bits : 0); } + + virtual uint64_t GetPayload() { return (IsValid() ? m_payload : 0); } + +private: + ConstString m_name; + uint8_t m_pointer_size; + bool m_valid; + uint64_t m_info_bits; + uint64_t m_value_bits; + uint64_t m_payload; +}; + +} // namespace lldb_private + +#endif // liblldb_AppleObjCClassDescriptorV2_h_ diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.cpp b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.cpp new file mode 100644 index 000000000000..1f27a4f0b3ed --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.cpp @@ -0,0 +1,663 @@ +//===-- AppleObjCDeclVendor.cpp ---------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "AppleObjCDeclVendor.h" + +#include "Plugins/ExpressionParser/Clang/ASTDumper.h" +#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h" +#include "lldb/Core/Module.h" +#include "lldb/Symbol/ClangExternalASTSourceCommon.h" +#include "lldb/Symbol/ClangUtil.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/Target.h" +#include "lldb/Utility/Log.h" + +#include "clang/AST/ASTContext.h" +#include "clang/AST/DeclObjC.h" + + +using namespace lldb_private; + +class lldb_private::AppleObjCExternalASTSource + : public ClangExternalASTSourceCommon { +public: + AppleObjCExternalASTSource(AppleObjCDeclVendor &decl_vendor) + : m_decl_vendor(decl_vendor) {} + + bool FindExternalVisibleDeclsByName(const clang::DeclContext *decl_ctx, + clang::DeclarationName name) override { + static unsigned int invocation_id = 0; + unsigned int current_id = invocation_id++; + + Log *log(GetLogIfAllCategoriesSet( + LIBLLDB_LOG_EXPRESSIONS)); // FIXME - a more appropriate log channel? + + if (log) { + LLDB_LOGF(log, + "AppleObjCExternalASTSource::FindExternalVisibleDeclsByName[%" + "u] on (ASTContext*)%p Looking for %s in (%sDecl*)%p", + current_id, + static_cast<void *>(&decl_ctx->getParentASTContext()), + name.getAsString().c_str(), decl_ctx->getDeclKindName(), + static_cast<const void *>(decl_ctx)); + } + + do { + const clang::ObjCInterfaceDecl *interface_decl = + llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl_ctx); + + if (!interface_decl) + break; + + clang::ObjCInterfaceDecl *non_const_interface_decl = + const_cast<clang::ObjCInterfaceDecl *>(interface_decl); + + if (!m_decl_vendor.FinishDecl(non_const_interface_decl)) + break; + + clang::DeclContext::lookup_result result = + non_const_interface_decl->lookup(name); + + return (result.size() != 0); + } while (false); + + SetNoExternalVisibleDeclsForName(decl_ctx, name); + return false; + } + + void CompleteType(clang::TagDecl *tag_decl) override { + static unsigned int invocation_id = 0; + unsigned int current_id = invocation_id++; + + Log *log(GetLogIfAllCategoriesSet( + LIBLLDB_LOG_EXPRESSIONS)); // FIXME - a more appropriate log channel? + + if (log) { + LLDB_LOGF(log, + "AppleObjCExternalASTSource::CompleteType[%u] on " + "(ASTContext*)%p Completing (TagDecl*)%p named %s", + current_id, static_cast<void *>(&tag_decl->getASTContext()), + static_cast<void *>(tag_decl), + tag_decl->getName().str().c_str()); + + LLDB_LOGF(log, " AOEAS::CT[%u] Before:", current_id); + ASTDumper dumper((clang::Decl *)tag_decl); + dumper.ToLog(log, " [CT] "); + } + + if (log) { + LLDB_LOGF(log, " AOEAS::CT[%u] After:", current_id); + ASTDumper dumper((clang::Decl *)tag_decl); + dumper.ToLog(log, " [CT] "); + } + return; + } + + void CompleteType(clang::ObjCInterfaceDecl *interface_decl) override { + static unsigned int invocation_id = 0; + unsigned int current_id = invocation_id++; + + Log *log(GetLogIfAllCategoriesSet( + LIBLLDB_LOG_EXPRESSIONS)); // FIXME - a more appropriate log channel? + + if (log) { + LLDB_LOGF(log, + "AppleObjCExternalASTSource::CompleteType[%u] on " + "(ASTContext*)%p Completing (ObjCInterfaceDecl*)%p named %s", + current_id, + static_cast<void *>(&interface_decl->getASTContext()), + static_cast<void *>(interface_decl), + interface_decl->getName().str().c_str()); + + LLDB_LOGF(log, " AOEAS::CT[%u] Before:", current_id); + ASTDumper dumper((clang::Decl *)interface_decl); + dumper.ToLog(log, " [CT] "); + } + + m_decl_vendor.FinishDecl(interface_decl); + + if (log) { + LLDB_LOGF(log, " [CT] After:"); + ASTDumper dumper((clang::Decl *)interface_decl); + dumper.ToLog(log, " [CT] "); + } + return; + } + + bool layoutRecordType( + const clang::RecordDecl *Record, uint64_t &Size, uint64_t &Alignment, + llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets, + llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> + &BaseOffsets, + llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> + &VirtualBaseOffsets) override { + return false; + } + + void StartTranslationUnit(clang::ASTConsumer *Consumer) override { + clang::TranslationUnitDecl *translation_unit_decl = + m_decl_vendor.m_ast_ctx.getASTContext()->getTranslationUnitDecl(); + translation_unit_decl->setHasExternalVisibleStorage(); + translation_unit_decl->setHasExternalLexicalStorage(); + } + +private: + AppleObjCDeclVendor &m_decl_vendor; +}; + +AppleObjCDeclVendor::AppleObjCDeclVendor(ObjCLanguageRuntime &runtime) + : ClangDeclVendor(eAppleObjCDeclVendor), m_runtime(runtime), + m_ast_ctx(runtime.GetProcess() + ->GetTarget() + .GetArchitecture() + .GetTriple() + .getTriple() + .c_str()), + m_type_realizer_sp(m_runtime.GetEncodingToType()) { + m_external_source = new AppleObjCExternalASTSource(*this); + llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> external_source_owning_ptr( + m_external_source); + m_ast_ctx.getASTContext()->setExternalSource(external_source_owning_ptr); +} + +clang::ObjCInterfaceDecl * +AppleObjCDeclVendor::GetDeclForISA(ObjCLanguageRuntime::ObjCISA isa) { + ISAToInterfaceMap::const_iterator iter = m_isa_to_interface.find(isa); + + if (iter != m_isa_to_interface.end()) + return iter->second; + + clang::ASTContext *ast_ctx = m_ast_ctx.getASTContext(); + + ObjCLanguageRuntime::ClassDescriptorSP descriptor = + m_runtime.GetClassDescriptorFromISA(isa); + + if (!descriptor) + return nullptr; + + ConstString name(descriptor->GetClassName()); + + clang::IdentifierInfo &identifier_info = + ast_ctx->Idents.get(name.GetStringRef()); + + clang::ObjCInterfaceDecl *new_iface_decl = clang::ObjCInterfaceDecl::Create( + *ast_ctx, ast_ctx->getTranslationUnitDecl(), clang::SourceLocation(), + &identifier_info, nullptr, nullptr); + + ClangASTMetadata meta_data; + meta_data.SetISAPtr(isa); + m_external_source->SetMetadata(new_iface_decl, meta_data); + + new_iface_decl->setHasExternalVisibleStorage(); + new_iface_decl->setHasExternalLexicalStorage(); + + ast_ctx->getTranslationUnitDecl()->addDecl(new_iface_decl); + + m_isa_to_interface[isa] = new_iface_decl; + + return new_iface_decl; +} + +class ObjCRuntimeMethodType { +public: + ObjCRuntimeMethodType(const char *types) : m_is_valid(false) { + const char *cursor = types; + enum ParserState { Start = 0, InType, InPos } state = Start; + const char *type = nullptr; + int brace_depth = 0; + + uint32_t stepsLeft = 256; + + while (true) { + if (--stepsLeft == 0) { + m_is_valid = false; + return; + } + + switch (state) { + case Start: { + switch (*cursor) { + default: + state = InType; + type = cursor; + break; + case '\0': + m_is_valid = true; + return; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + m_is_valid = false; + return; + } + } break; + case InType: { + switch (*cursor) { + default: + ++cursor; + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (!brace_depth) { + state = InPos; + if (type) { + m_type_vector.push_back(std::string(type, (cursor - type))); + } else { + m_is_valid = false; + return; + } + type = nullptr; + } else { + ++cursor; + } + break; + case '[': + case '{': + case '(': + ++brace_depth; + ++cursor; + break; + case ']': + case '}': + case ')': + if (!brace_depth) { + m_is_valid = false; + return; + } + --brace_depth; + ++cursor; + break; + case '\0': + m_is_valid = false; + return; + } + } break; + case InPos: { + switch (*cursor) { + default: + state = InType; + type = cursor; + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + ++cursor; + break; + case '\0': + m_is_valid = true; + return; + } + } break; + } + } + } + + clang::ObjCMethodDecl * + BuildMethod(clang::ObjCInterfaceDecl *interface_decl, const char *name, + bool instance, + ObjCLanguageRuntime::EncodingToTypeSP type_realizer_sp) { + if (!m_is_valid || m_type_vector.size() < 3) + return nullptr; + + clang::ASTContext &ast_ctx(interface_decl->getASTContext()); + + const bool isInstance = instance; + const bool isVariadic = false; + const bool isSynthesized = false; + const bool isImplicitlyDeclared = true; + const bool isDefined = false; + const clang::ObjCMethodDecl::ImplementationControl impControl = + clang::ObjCMethodDecl::None; + const bool HasRelatedResultType = false; + const bool for_expression = true; + + std::vector<clang::IdentifierInfo *> selector_components; + + const char *name_cursor = name; + bool is_zero_argument = true; + + while (*name_cursor != '\0') { + const char *colon_loc = strchr(name_cursor, ':'); + if (!colon_loc) { + selector_components.push_back( + &ast_ctx.Idents.get(llvm::StringRef(name_cursor))); + break; + } else { + is_zero_argument = false; + selector_components.push_back(&ast_ctx.Idents.get( + llvm::StringRef(name_cursor, colon_loc - name_cursor))); + name_cursor = colon_loc + 1; + } + } + + clang::IdentifierInfo **identifier_infos = selector_components.data(); + if (!identifier_infos) { + return nullptr; + } + + clang::Selector sel = ast_ctx.Selectors.getSelector( + is_zero_argument ? 0 : selector_components.size(), + identifier_infos); + + clang::QualType ret_type = + ClangUtil::GetQualType(type_realizer_sp->RealizeType( + interface_decl->getASTContext(), m_type_vector[0].c_str(), + for_expression)); + + if (ret_type.isNull()) + return nullptr; + + clang::ObjCMethodDecl *ret = clang::ObjCMethodDecl::Create( + ast_ctx, clang::SourceLocation(), clang::SourceLocation(), sel, + ret_type, nullptr, interface_decl, isInstance, isVariadic, + isSynthesized, isImplicitlyDeclared, isDefined, impControl, + HasRelatedResultType); + + std::vector<clang::ParmVarDecl *> parm_vars; + + for (size_t ai = 3, ae = m_type_vector.size(); ai != ae; ++ai) { + const bool for_expression = true; + clang::QualType arg_type = + ClangUtil::GetQualType(type_realizer_sp->RealizeType( + ast_ctx, m_type_vector[ai].c_str(), for_expression)); + + if (arg_type.isNull()) + return nullptr; // well, we just wasted a bunch of time. Wish we could + // delete the stuff we'd just made! + + parm_vars.push_back(clang::ParmVarDecl::Create( + ast_ctx, ret, clang::SourceLocation(), clang::SourceLocation(), + nullptr, arg_type, nullptr, clang::SC_None, nullptr)); + } + + ret->setMethodParams(ast_ctx, + llvm::ArrayRef<clang::ParmVarDecl *>(parm_vars), + llvm::ArrayRef<clang::SourceLocation>()); + + return ret; + } + + explicit operator bool() { return m_is_valid; } + + size_t GetNumTypes() { return m_type_vector.size(); } + + const char *GetTypeAtIndex(size_t idx) { return m_type_vector[idx].c_str(); } + +private: + typedef std::vector<std::string> TypeVector; + + TypeVector m_type_vector; + bool m_is_valid; +}; + +bool AppleObjCDeclVendor::FinishDecl(clang::ObjCInterfaceDecl *interface_decl) { + Log *log(GetLogIfAllCategoriesSet( + LIBLLDB_LOG_EXPRESSIONS)); // FIXME - a more appropriate log channel? + + ClangASTMetadata *metadata = m_external_source->GetMetadata(interface_decl); + ObjCLanguageRuntime::ObjCISA objc_isa = 0; + if (metadata) + objc_isa = metadata->GetISAPtr(); + + if (!objc_isa) + return false; + + if (!interface_decl->hasExternalVisibleStorage()) + return true; + + interface_decl->startDefinition(); + + interface_decl->setHasExternalVisibleStorage(false); + interface_decl->setHasExternalLexicalStorage(false); + + ObjCLanguageRuntime::ClassDescriptorSP descriptor = + m_runtime.GetClassDescriptorFromISA(objc_isa); + + if (!descriptor) + return false; + + auto superclass_func = [interface_decl, + this](ObjCLanguageRuntime::ObjCISA isa) { + clang::ObjCInterfaceDecl *superclass_decl = GetDeclForISA(isa); + + if (!superclass_decl) + return; + + FinishDecl(superclass_decl); + clang::ASTContext *context = m_ast_ctx.getASTContext(); + interface_decl->setSuperClass(context->getTrivialTypeSourceInfo( + context->getObjCInterfaceType(superclass_decl))); + }; + + auto instance_method_func = + [log, interface_decl, this](const char *name, const char *types) -> bool { + if (!name || !types) + return false; // skip this one + + ObjCRuntimeMethodType method_type(types); + + clang::ObjCMethodDecl *method_decl = + method_type.BuildMethod(interface_decl, name, true, m_type_realizer_sp); + + LLDB_LOGF(log, "[ AOTV::FD] Instance method [%s] [%s]", name, types); + + if (method_decl) + interface_decl->addDecl(method_decl); + + return false; + }; + + auto class_method_func = [log, interface_decl, + this](const char *name, const char *types) -> bool { + if (!name || !types) + return false; // skip this one + + ObjCRuntimeMethodType method_type(types); + + clang::ObjCMethodDecl *method_decl = method_type.BuildMethod( + interface_decl, name, false, m_type_realizer_sp); + + LLDB_LOGF(log, "[ AOTV::FD] Class method [%s] [%s]", name, types); + + if (method_decl) + interface_decl->addDecl(method_decl); + + return false; + }; + + auto ivar_func = [log, interface_decl, + this](const char *name, const char *type, + lldb::addr_t offset_ptr, uint64_t size) -> bool { + if (!name || !type) + return false; + + const bool for_expression = false; + + LLDB_LOGF(log, + "[ AOTV::FD] Instance variable [%s] [%s], offset at %" PRIx64, + name, type, offset_ptr); + + CompilerType ivar_type = m_runtime.GetEncodingToType()->RealizeType( + m_ast_ctx, type, for_expression); + + if (ivar_type.IsValid()) { + clang::TypeSourceInfo *const type_source_info = nullptr; + const bool is_synthesized = false; + clang::ObjCIvarDecl *ivar_decl = clang::ObjCIvarDecl::Create( + *m_ast_ctx.getASTContext(), interface_decl, clang::SourceLocation(), + clang::SourceLocation(), &m_ast_ctx.getASTContext()->Idents.get(name), + ClangUtil::GetQualType(ivar_type), + type_source_info, // TypeSourceInfo * + clang::ObjCIvarDecl::Public, nullptr, is_synthesized); + + if (ivar_decl) { + interface_decl->addDecl(ivar_decl); + } + } + + return false; + }; + + if (log) { + ASTDumper method_dumper((clang::Decl *)interface_decl); + + LLDB_LOGF(log, + "[AppleObjCDeclVendor::FinishDecl] Finishing Objective-C " + "interface for %s", + descriptor->GetClassName().AsCString()); + } + + if (!descriptor->Describe(superclass_func, instance_method_func, + class_method_func, ivar_func)) + return false; + + if (log) { + ASTDumper method_dumper((clang::Decl *)interface_decl); + + LLDB_LOGF( + log, + "[AppleObjCDeclVendor::FinishDecl] Finished Objective-C interface"); + + method_dumper.ToLog(log, " [AOTV::FD] "); + } + + return true; +} + +uint32_t +AppleObjCDeclVendor::FindDecls(ConstString name, bool append, + uint32_t max_matches, + std::vector<clang::NamedDecl *> &decls) { + static unsigned int invocation_id = 0; + unsigned int current_id = invocation_id++; + + Log *log(GetLogIfAllCategoriesSet( + LIBLLDB_LOG_EXPRESSIONS)); // FIXME - a more appropriate log channel? + + LLDB_LOGF(log, "AppleObjCDeclVendor::FindDecls [%u] ('%s', %s, %u, )", + current_id, (const char *)name.AsCString(), + append ? "true" : "false", max_matches); + + if (!append) + decls.clear(); + + uint32_t ret = 0; + + do { + // See if the type is already in our ASTContext. + + clang::ASTContext *ast_ctx = m_ast_ctx.getASTContext(); + + clang::IdentifierInfo &identifier_info = + ast_ctx->Idents.get(name.GetStringRef()); + clang::DeclarationName decl_name = + ast_ctx->DeclarationNames.getIdentifier(&identifier_info); + + clang::DeclContext::lookup_result lookup_result = + ast_ctx->getTranslationUnitDecl()->lookup(decl_name); + + if (!lookup_result.empty()) { + if (clang::ObjCInterfaceDecl *result_iface_decl = + llvm::dyn_cast<clang::ObjCInterfaceDecl>(lookup_result[0])) { + if (log) { + clang::QualType result_iface_type = + ast_ctx->getObjCInterfaceType(result_iface_decl); + ASTDumper dumper(result_iface_type); + + uint64_t isa_value = LLDB_INVALID_ADDRESS; + ClangASTMetadata *metadata = + m_external_source->GetMetadata(result_iface_decl); + if (metadata) + isa_value = metadata->GetISAPtr(); + + LLDB_LOGF(log, + "AOCTV::FT [%u] Found %s (isa 0x%" PRIx64 + ") in the ASTContext", + current_id, dumper.GetCString(), isa_value); + } + + decls.push_back(result_iface_decl); + ret++; + break; + } else { + LLDB_LOGF(log, + "AOCTV::FT [%u] There's something in the ASTContext, but " + "it's not something we know about", + current_id); + break; + } + } else if (log) { + LLDB_LOGF(log, "AOCTV::FT [%u] Couldn't find %s in the ASTContext", + current_id, name.AsCString()); + } + + // It's not. If it exists, we have to put it into our ASTContext. + + ObjCLanguageRuntime::ObjCISA isa = m_runtime.GetISA(name); + + if (!isa) { + LLDB_LOGF(log, "AOCTV::FT [%u] Couldn't find the isa", current_id); + + break; + } + + clang::ObjCInterfaceDecl *iface_decl = GetDeclForISA(isa); + + if (!iface_decl) { + LLDB_LOGF(log, + "AOCTV::FT [%u] Couldn't get the Objective-C interface for " + "isa 0x%" PRIx64, + current_id, (uint64_t)isa); + + break; + } + + if (log) { + clang::QualType new_iface_type = + ast_ctx->getObjCInterfaceType(iface_decl); + ASTDumper dumper(new_iface_type); + LLDB_LOGF(log, "AOCTV::FT [%u] Created %s (isa 0x%" PRIx64 ")", + current_id, dumper.GetCString(), (uint64_t)isa); + } + + decls.push_back(iface_decl); + ret++; + break; + } while (false); + + return ret; +} + +clang::ExternalASTMerger::ImporterSource +AppleObjCDeclVendor::GetImporterSource() { + return clang::ExternalASTMerger::ImporterSource(*m_ast_ctx.getASTContext(), + *m_ast_ctx.getFileManager(), + m_ast_ctx.GetOriginMap()); +} diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.h b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.h new file mode 100644 index 000000000000..99ca4b748709 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.h @@ -0,0 +1,55 @@ +//===-- AppleObjCDeclVendor.h -----------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_AppleObjCDeclVendor_h_ +#define liblldb_AppleObjCDeclVendor_h_ + +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/lldb-private.h" + +#include "Plugins/ExpressionParser/Clang/ClangDeclVendor.h" +#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h" + +namespace lldb_private { + +class AppleObjCExternalASTSource; + +class AppleObjCDeclVendor : public ClangDeclVendor { +public: + AppleObjCDeclVendor(ObjCLanguageRuntime &runtime); + + static bool classof(const DeclVendor *vendor) { + return vendor->GetKind() == eAppleObjCDeclVendor; + } + + uint32_t FindDecls(ConstString name, bool append, uint32_t max_matches, + std::vector<clang::NamedDecl *> &decls) override; + + clang::ExternalASTMerger::ImporterSource GetImporterSource() override; + + friend class AppleObjCExternalASTSource; + +private: + clang::ObjCInterfaceDecl *GetDeclForISA(ObjCLanguageRuntime::ObjCISA isa); + bool FinishDecl(clang::ObjCInterfaceDecl *decl); + + ObjCLanguageRuntime &m_runtime; + ClangASTContext m_ast_ctx; + ObjCLanguageRuntime::EncodingToTypeSP m_type_realizer_sp; + AppleObjCExternalASTSource *m_external_source; + + typedef llvm::DenseMap<ObjCLanguageRuntime::ObjCISA, + clang::ObjCInterfaceDecl *> + ISAToInterfaceMap; + + ISAToInterfaceMap m_isa_to_interface; +}; + +} // namespace lldb_private + +#endif // liblldb_AppleObjCDeclVendor_h_ diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp new file mode 100644 index 000000000000..8ca9ad7b843a --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp @@ -0,0 +1,588 @@ +//===-- AppleObjCRuntime.cpp -------------------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "AppleObjCRuntime.h" +#include "AppleObjCTrampolineHandler.h" + +#include "clang/AST/Type.h" + +#include "lldb/Breakpoint/BreakpointLocation.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/ModuleList.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/Core/Section.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/Expression/DiagnosticManager.h" +#include "lldb/Expression/FunctionCaller.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Symbol/ObjectFile.h" +#include "lldb/Target/ExecutionContext.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/RegisterContext.h" +#include "lldb/Target/StopInfo.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/Thread.h" +#include "lldb/Utility/ConstString.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Scalar.h" +#include "lldb/Utility/Status.h" +#include "lldb/Utility/StreamString.h" + +#include "Plugins/Process/Utility/HistoryThread.h" +#include "Plugins/Language/ObjC/NSString.h" +#include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h" + +#include <vector> + +using namespace lldb; +using namespace lldb_private; + +char AppleObjCRuntime::ID = 0; + +AppleObjCRuntime::~AppleObjCRuntime() {} + +AppleObjCRuntime::AppleObjCRuntime(Process *process) + : ObjCLanguageRuntime(process), m_read_objc_library(false), + m_objc_trampoline_handler_up(), m_Foundation_major() { + ReadObjCLibraryIfNeeded(process->GetTarget().GetImages()); +} + +bool AppleObjCRuntime::GetObjectDescription(Stream &str, ValueObject &valobj) { + CompilerType compiler_type(valobj.GetCompilerType()); + bool is_signed; + // ObjC objects can only be pointers (or numbers that actually represents + // pointers but haven't been typecast, because reasons..) + if (!compiler_type.IsIntegerType(is_signed) && !compiler_type.IsPointerType()) + return false; + + // Make the argument list: we pass one arg, the address of our pointer, to + // the print function. + Value val; + + if (!valobj.ResolveValue(val.GetScalar())) + return false; + + // Value Objects may not have a process in their ExecutionContextRef. But we + // need to have one in the ref we pass down to eventually call description. + // Get it from the target if it isn't present. + ExecutionContext exe_ctx; + if (valobj.GetProcessSP()) { + exe_ctx = ExecutionContext(valobj.GetExecutionContextRef()); + } else { + exe_ctx.SetContext(valobj.GetTargetSP(), true); + if (!exe_ctx.HasProcessScope()) + return false; + } + return GetObjectDescription(str, val, exe_ctx.GetBestExecutionContextScope()); +} +bool AppleObjCRuntime::GetObjectDescription(Stream &strm, Value &value, + ExecutionContextScope *exe_scope) { + if (!m_read_objc_library) + return false; + + ExecutionContext exe_ctx; + exe_scope->CalculateExecutionContext(exe_ctx); + Process *process = exe_ctx.GetProcessPtr(); + if (!process) + return false; + + // We need other parts of the exe_ctx, but the processes have to match. + assert(m_process == process); + + // Get the function address for the print function. + const Address *function_address = GetPrintForDebuggerAddr(); + if (!function_address) + return false; + + Target *target = exe_ctx.GetTargetPtr(); + CompilerType compiler_type = value.GetCompilerType(); + if (compiler_type) { + if (!ClangASTContext::IsObjCObjectPointerType(compiler_type)) { + strm.Printf("Value doesn't point to an ObjC object.\n"); + return false; + } + } else { + // If it is not a pointer, see if we can make it into a pointer. + ClangASTContext *ast_context = target->GetScratchClangASTContext(); + CompilerType opaque_type = ast_context->GetBasicType(eBasicTypeObjCID); + if (!opaque_type) + opaque_type = ast_context->GetBasicType(eBasicTypeVoid).GetPointerType(); + // value.SetContext(Value::eContextTypeClangType, opaque_type_ptr); + value.SetCompilerType(opaque_type); + } + + ValueList arg_value_list; + arg_value_list.PushValue(value); + + // This is the return value: + ClangASTContext *ast_context = target->GetScratchClangASTContext(); + + CompilerType return_compiler_type = ast_context->GetCStringType(true); + Value ret; + // ret.SetContext(Value::eContextTypeClangType, return_compiler_type); + ret.SetCompilerType(return_compiler_type); + + if (exe_ctx.GetFramePtr() == nullptr) { + Thread *thread = exe_ctx.GetThreadPtr(); + if (thread == nullptr) { + exe_ctx.SetThreadSP(process->GetThreadList().GetSelectedThread()); + thread = exe_ctx.GetThreadPtr(); + } + if (thread) { + exe_ctx.SetFrameSP(thread->GetSelectedFrame()); + } + } + + // Now we're ready to call the function: + + DiagnosticManager diagnostics; + lldb::addr_t wrapper_struct_addr = LLDB_INVALID_ADDRESS; + + if (!m_print_object_caller_up) { + Status error; + m_print_object_caller_up.reset( + exe_scope->CalculateTarget()->GetFunctionCallerForLanguage( + eLanguageTypeObjC, return_compiler_type, *function_address, + arg_value_list, "objc-object-description", error)); + if (error.Fail()) { + m_print_object_caller_up.reset(); + strm.Printf("Could not get function runner to call print for debugger " + "function: %s.", + error.AsCString()); + return false; + } + m_print_object_caller_up->InsertFunction(exe_ctx, wrapper_struct_addr, + diagnostics); + } else { + m_print_object_caller_up->WriteFunctionArguments( + exe_ctx, wrapper_struct_addr, arg_value_list, diagnostics); + } + + EvaluateExpressionOptions options; + options.SetUnwindOnError(true); + options.SetTryAllThreads(true); + options.SetStopOthers(true); + options.SetIgnoreBreakpoints(true); + options.SetTimeout(process->GetUtilityExpressionTimeout()); + options.SetIsForUtilityExpr(true); + + ExpressionResults results = m_print_object_caller_up->ExecuteFunction( + exe_ctx, &wrapper_struct_addr, options, diagnostics, ret); + if (results != eExpressionCompleted) { + strm.Printf("Error evaluating Print Object function: %d.\n", results); + return false; + } + + addr_t result_ptr = ret.GetScalar().ULongLong(LLDB_INVALID_ADDRESS); + + char buf[512]; + size_t cstr_len = 0; + size_t full_buffer_len = sizeof(buf) - 1; + size_t curr_len = full_buffer_len; + while (curr_len == full_buffer_len) { + Status error; + curr_len = process->ReadCStringFromMemory(result_ptr + cstr_len, buf, + sizeof(buf), error); + strm.Write(buf, curr_len); + cstr_len += curr_len; + } + return cstr_len > 0; +} + +lldb::ModuleSP AppleObjCRuntime::GetObjCModule() { + ModuleSP module_sp(m_objc_module_wp.lock()); + if (module_sp) + return module_sp; + + Process *process = GetProcess(); + if (process) { + const ModuleList &modules = process->GetTarget().GetImages(); + for (uint32_t idx = 0; idx < modules.GetSize(); idx++) { + module_sp = modules.GetModuleAtIndex(idx); + if (AppleObjCRuntime::AppleIsModuleObjCLibrary(module_sp)) { + m_objc_module_wp = module_sp; + return module_sp; + } + } + } + return ModuleSP(); +} + +Address *AppleObjCRuntime::GetPrintForDebuggerAddr() { + if (!m_PrintForDebugger_addr) { + const ModuleList &modules = m_process->GetTarget().GetImages(); + + SymbolContextList contexts; + SymbolContext context; + + modules.FindSymbolsWithNameAndType(ConstString("_NSPrintForDebugger"), + eSymbolTypeCode, contexts); + if (contexts.IsEmpty()) { + modules.FindSymbolsWithNameAndType(ConstString("_CFPrintForDebugger"), + eSymbolTypeCode, contexts); + if (contexts.IsEmpty()) + return nullptr; + } + + contexts.GetContextAtIndex(0, context); + + m_PrintForDebugger_addr.reset(new Address(context.symbol->GetAddress())); + } + + return m_PrintForDebugger_addr.get(); +} + +bool AppleObjCRuntime::CouldHaveDynamicValue(ValueObject &in_value) { + return in_value.GetCompilerType().IsPossibleDynamicType( + nullptr, + false, // do not check C++ + true); // check ObjC +} + +bool AppleObjCRuntime::GetDynamicTypeAndAddress( + ValueObject &in_value, lldb::DynamicValueType use_dynamic, + TypeAndOrName &class_type_or_name, Address &address, + Value::ValueType &value_type) { + return false; +} + +TypeAndOrName +AppleObjCRuntime::FixUpDynamicType(const TypeAndOrName &type_and_or_name, + ValueObject &static_value) { + CompilerType static_type(static_value.GetCompilerType()); + Flags static_type_flags(static_type.GetTypeInfo()); + + TypeAndOrName ret(type_and_or_name); + 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 (static_type_flags.AllSet(eTypeIsPointer)) + corrected_type = orig_type.GetPointerType(); + ret.SetCompilerType(corrected_type); + } else { + // 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 (static_type_flags.AllSet(eTypeIsPointer)) + corrected_name.append(" *"); + // the parent type should be a correctly pointer'ed or referenc'ed type + ret.SetCompilerType(static_type); + ret.SetName(corrected_name.c_str()); + } + return ret; +} + +bool AppleObjCRuntime::AppleIsModuleObjCLibrary(const ModuleSP &module_sp) { + if (module_sp) { + const FileSpec &module_file_spec = module_sp->GetFileSpec(); + static ConstString ObjCName("libobjc.A.dylib"); + + if (module_file_spec) { + if (module_file_spec.GetFilename() == ObjCName) + return true; + } + } + return false; +} + +// we use the version of Foundation to make assumptions about the ObjC runtime +// on a target +uint32_t AppleObjCRuntime::GetFoundationVersion() { + if (!m_Foundation_major.hasValue()) { + const ModuleList &modules = m_process->GetTarget().GetImages(); + for (uint32_t idx = 0; idx < modules.GetSize(); idx++) { + lldb::ModuleSP module_sp = modules.GetModuleAtIndex(idx); + if (!module_sp) + continue; + if (strcmp(module_sp->GetFileSpec().GetFilename().AsCString(""), + "Foundation") == 0) { + m_Foundation_major = module_sp->GetVersion().getMajor(); + return *m_Foundation_major; + } + } + return LLDB_INVALID_MODULE_VERSION; + } else + return m_Foundation_major.getValue(); +} + +void AppleObjCRuntime::GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true, + lldb::addr_t &cf_false) { + cf_true = cf_false = LLDB_INVALID_ADDRESS; +} + +bool AppleObjCRuntime::IsModuleObjCLibrary(const ModuleSP &module_sp) { + return AppleIsModuleObjCLibrary(module_sp); +} + +bool AppleObjCRuntime::ReadObjCLibrary(const ModuleSP &module_sp) { + // Maybe check here and if we have a handler already, and the UUID of this + // module is the same as the one in the current module, then we don't have to + // reread it? + m_objc_trampoline_handler_up.reset( + new AppleObjCTrampolineHandler(m_process->shared_from_this(), module_sp)); + if (m_objc_trampoline_handler_up != nullptr) { + m_read_objc_library = true; + return true; + } else + return false; +} + +ThreadPlanSP AppleObjCRuntime::GetStepThroughTrampolinePlan(Thread &thread, + bool stop_others) { + ThreadPlanSP thread_plan_sp; + if (m_objc_trampoline_handler_up) + thread_plan_sp = m_objc_trampoline_handler_up->GetStepThroughDispatchPlan( + thread, stop_others); + return thread_plan_sp; +} + +// Static Functions +ObjCLanguageRuntime::ObjCRuntimeVersions +AppleObjCRuntime::GetObjCVersion(Process *process, ModuleSP &objc_module_sp) { + if (!process) + return ObjCRuntimeVersions::eObjC_VersionUnknown; + + Target &target = process->GetTarget(); + if (target.GetArchitecture().GetTriple().getVendor() != + llvm::Triple::VendorType::Apple) + return ObjCRuntimeVersions::eObjC_VersionUnknown; + + const ModuleList &target_modules = target.GetImages(); + std::lock_guard<std::recursive_mutex> gaurd(target_modules.GetMutex()); + + size_t num_images = target_modules.GetSize(); + for (size_t i = 0; i < num_images; i++) { + ModuleSP module_sp = target_modules.GetModuleAtIndexUnlocked(i); + // One tricky bit here is that we might get called as part of the initial + // module loading, but before all the pre-run libraries get winnowed from + // the module list. So there might actually be an old and incorrect ObjC + // library sitting around in the list, and we don't want to look at that. + // That's why we call IsLoadedInTarget. + + if (AppleIsModuleObjCLibrary(module_sp) && + module_sp->IsLoadedInTarget(&target)) { + objc_module_sp = module_sp; + ObjectFile *ofile = module_sp->GetObjectFile(); + if (!ofile) + return ObjCRuntimeVersions::eObjC_VersionUnknown; + + SectionList *sections = module_sp->GetSectionList(); + if (!sections) + return ObjCRuntimeVersions::eObjC_VersionUnknown; + SectionSP v1_telltale_section_sp = + sections->FindSectionByName(ConstString("__OBJC")); + if (v1_telltale_section_sp) { + return ObjCRuntimeVersions::eAppleObjC_V1; + } + return ObjCRuntimeVersions::eAppleObjC_V2; + } + } + + return ObjCRuntimeVersions::eObjC_VersionUnknown; +} + +void AppleObjCRuntime::SetExceptionBreakpoints() { + const bool catch_bp = false; + const bool throw_bp = true; + const bool is_internal = true; + + if (!m_objc_exception_bp_sp) { + m_objc_exception_bp_sp = LanguageRuntime::CreateExceptionBreakpoint( + m_process->GetTarget(), GetLanguageType(), catch_bp, throw_bp, + is_internal); + if (m_objc_exception_bp_sp) + m_objc_exception_bp_sp->SetBreakpointKind("ObjC exception"); + } else + m_objc_exception_bp_sp->SetEnabled(true); +} + +void AppleObjCRuntime::ClearExceptionBreakpoints() { + if (!m_process) + return; + + if (m_objc_exception_bp_sp.get()) { + m_objc_exception_bp_sp->SetEnabled(false); + } +} + +bool AppleObjCRuntime::ExceptionBreakpointsAreSet() { + return m_objc_exception_bp_sp && m_objc_exception_bp_sp->IsEnabled(); +} + +bool AppleObjCRuntime::ExceptionBreakpointsExplainStop( + lldb::StopInfoSP stop_reason) { + if (!m_process) + return false; + + if (!stop_reason || stop_reason->GetStopReason() != eStopReasonBreakpoint) + return false; + + uint64_t break_site_id = stop_reason->GetValue(); + return m_process->GetBreakpointSiteList().BreakpointSiteContainsBreakpoint( + break_site_id, m_objc_exception_bp_sp->GetID()); +} + +bool AppleObjCRuntime::CalculateHasNewLiteralsAndIndexing() { + if (!m_process) + return false; + + Target &target(m_process->GetTarget()); + + static ConstString s_method_signature( + "-[NSDictionary objectForKeyedSubscript:]"); + static ConstString s_arclite_method_signature( + "__arclite_objectForKeyedSubscript"); + + SymbolContextList sc_list; + + target.GetImages().FindSymbolsWithNameAndType(s_method_signature, + eSymbolTypeCode, sc_list); + if (sc_list.IsEmpty()) + target.GetImages().FindSymbolsWithNameAndType(s_arclite_method_signature, + eSymbolTypeCode, sc_list); + return !sc_list.IsEmpty(); +} + +lldb::SearchFilterSP AppleObjCRuntime::CreateExceptionSearchFilter() { + Target &target = m_process->GetTarget(); + + FileSpecList filter_modules; + if (target.GetArchitecture().GetTriple().getVendor() == llvm::Triple::Apple) { + filter_modules.Append(std::get<0>(GetExceptionThrowLocation())); + } + return target.GetSearchFilterForModuleList(&filter_modules); +} + +ValueObjectSP AppleObjCRuntime::GetExceptionObjectForThread( + ThreadSP thread_sp) { + auto *cpp_runtime = m_process->GetLanguageRuntime(eLanguageTypeC_plus_plus); + if (!cpp_runtime) return ValueObjectSP(); + auto cpp_exception = cpp_runtime->GetExceptionObjectForThread(thread_sp); + if (!cpp_exception) return ValueObjectSP(); + + auto descriptor = GetClassDescriptor(*cpp_exception); + if (!descriptor || !descriptor->IsValid()) return ValueObjectSP(); + + while (descriptor) { + ConstString class_name(descriptor->GetClassName()); + if (class_name == "NSException") + return cpp_exception; + descriptor = descriptor->GetSuperclass(); + } + + return ValueObjectSP(); +} + +ThreadSP AppleObjCRuntime::GetBacktraceThreadFromException( + lldb::ValueObjectSP exception_sp) { + ValueObjectSP reserved_dict = + exception_sp->GetChildMemberWithName(ConstString("reserved"), true); + if (!reserved_dict) return ThreadSP(); + + reserved_dict = reserved_dict->GetSyntheticValue(); + if (!reserved_dict) return ThreadSP(); + + CompilerType objc_id = + exception_sp->GetTargetSP()->GetScratchClangASTContext()->GetBasicType( + lldb::eBasicTypeObjCID); + ValueObjectSP return_addresses; + + auto objc_object_from_address = [&exception_sp, &objc_id](uint64_t addr, + const char *name) { + Value value(addr); + value.SetCompilerType(objc_id); + auto object = ValueObjectConstResult::Create( + exception_sp->GetTargetSP().get(), value, ConstString(name)); + object = object->GetDynamicValue(eDynamicDontRunTarget); + return object; + }; + + for (size_t idx = 0; idx < reserved_dict->GetNumChildren(); idx++) { + ValueObjectSP dict_entry = reserved_dict->GetChildAtIndex(idx, true); + + DataExtractor data; + data.SetAddressByteSize(dict_entry->GetProcessSP()->GetAddressByteSize()); + Status error; + dict_entry->GetData(data, error); + if (error.Fail()) return ThreadSP(); + + lldb::offset_t data_offset = 0; + auto dict_entry_key = data.GetPointer(&data_offset); + auto dict_entry_value = data.GetPointer(&data_offset); + + auto key_nsstring = objc_object_from_address(dict_entry_key, "key"); + StreamString key_summary; + if (lldb_private::formatters::NSStringSummaryProvider( + *key_nsstring, key_summary, TypeSummaryOptions()) && + !key_summary.Empty()) { + if (key_summary.GetString() == "\"callStackReturnAddresses\"") { + return_addresses = objc_object_from_address(dict_entry_value, + "callStackReturnAddresses"); + break; + } + } + } + + if (!return_addresses) return ThreadSP(); + auto frames_value = + return_addresses->GetChildMemberWithName(ConstString("_frames"), true); + addr_t frames_addr = frames_value->GetValueAsUnsigned(0); + auto count_value = + return_addresses->GetChildMemberWithName(ConstString("_cnt"), true); + size_t count = count_value->GetValueAsUnsigned(0); + auto ignore_value = + return_addresses->GetChildMemberWithName(ConstString("_ignore"), true); + size_t ignore = ignore_value->GetValueAsUnsigned(0); + + size_t ptr_size = m_process->GetAddressByteSize(); + std::vector<lldb::addr_t> pcs; + for (size_t idx = 0; idx < count; idx++) { + Status error; + addr_t pc = m_process->ReadPointerFromMemory( + frames_addr + (ignore + idx) * ptr_size, error); + pcs.push_back(pc); + } + + if (pcs.empty()) return ThreadSP(); + + ThreadSP new_thread_sp(new HistoryThread(*m_process, 0, pcs)); + m_process->GetExtendedThreadList().AddThread(new_thread_sp); + return new_thread_sp; +} + +std::tuple<FileSpec, ConstString> +AppleObjCRuntime::GetExceptionThrowLocation() { + return std::make_tuple( + FileSpec("libobjc.A.dylib"), ConstString("objc_exception_throw")); +} + +void AppleObjCRuntime::ReadObjCLibraryIfNeeded(const ModuleList &module_list) { + if (!HasReadObjCLibrary()) { + std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex()); + + size_t num_modules = module_list.GetSize(); + for (size_t i = 0; i < num_modules; i++) { + auto mod = module_list.GetModuleAtIndex(i); + if (IsModuleObjCLibrary(mod)) { + ReadObjCLibrary(mod); + break; + } + } + } +} + +void AppleObjCRuntime::ModulesDidLoad(const ModuleList &module_list) { + ReadObjCLibraryIfNeeded(module_list); +} diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h new file mode 100644 index 000000000000..79ac53e1e440 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h @@ -0,0 +1,131 @@ +//===-- AppleObjCRuntime.h --------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_AppleObjCRuntime_h_ +#define liblldb_AppleObjCRuntime_h_ + +#include "llvm/ADT/Optional.h" + +#include "AppleObjCTrampolineHandler.h" +#include "AppleThreadPlanStepThroughObjCTrampoline.h" +#include "lldb/Target/LanguageRuntime.h" +#include "lldb/lldb-private.h" + +#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h" + +namespace lldb_private { + +class AppleObjCRuntime : public lldb_private::ObjCLanguageRuntime { +public: + ~AppleObjCRuntime() override; + + // Static Functions + // Note there is no CreateInstance, Initialize & Terminate functions here, + // because + // you can't make an instance of this generic runtime. + + static char ID; + + bool isA(const void *ClassID) const override { + return ClassID == &ID || ObjCLanguageRuntime::isA(ClassID); + } + + static bool classof(const LanguageRuntime *runtime) { + return runtime->isA(&ID); + } + + // These are generic runtime functions: + bool GetObjectDescription(Stream &str, Value &value, + ExecutionContextScope *exe_scope) override; + + bool GetObjectDescription(Stream &str, ValueObject &object) override; + + bool CouldHaveDynamicValue(ValueObject &in_value) override; + + bool GetDynamicTypeAndAddress(ValueObject &in_value, + lldb::DynamicValueType use_dynamic, + TypeAndOrName &class_type_or_name, + Address &address, + Value::ValueType &value_type) override; + + TypeAndOrName FixUpDynamicType(const TypeAndOrName &type_and_or_name, + ValueObject &static_value) override; + + // These are the ObjC specific functions. + + bool IsModuleObjCLibrary(const lldb::ModuleSP &module_sp) override; + + bool ReadObjCLibrary(const lldb::ModuleSP &module_sp) override; + + bool HasReadObjCLibrary() override { return m_read_objc_library; } + + lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread, + bool stop_others) override; + + // Get the "libobjc.A.dylib" module from the current target if we can find + // it, also cache it once it is found to ensure quick lookups. + lldb::ModuleSP GetObjCModule(); + + // Sync up with the target + + void ModulesDidLoad(const ModuleList &module_list) override; + + void SetExceptionBreakpoints() override; + + void ClearExceptionBreakpoints() override; + + bool ExceptionBreakpointsAreSet() override; + + bool ExceptionBreakpointsExplainStop(lldb::StopInfoSP stop_reason) override; + + lldb::SearchFilterSP CreateExceptionSearchFilter() override; + + static std::tuple<FileSpec, ConstString> GetExceptionThrowLocation(); + + lldb::ValueObjectSP GetExceptionObjectForThread( + lldb::ThreadSP thread_sp) override; + + lldb::ThreadSP GetBacktraceThreadFromException( + lldb::ValueObjectSP thread_sp) override; + + uint32_t GetFoundationVersion(); + + virtual void GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true, + lldb::addr_t &cf_false); + + virtual bool IsTaggedPointer (lldb::addr_t addr) { return false; } + +protected: + // Call CreateInstance instead. + AppleObjCRuntime(Process *process); + + bool CalculateHasNewLiteralsAndIndexing() override; + + static bool AppleIsModuleObjCLibrary(const lldb::ModuleSP &module_sp); + + static ObjCRuntimeVersions GetObjCVersion(Process *process, + lldb::ModuleSP &objc_module_sp); + + void ReadObjCLibraryIfNeeded(const ModuleList &module_list); + + Address *GetPrintForDebuggerAddr(); + + std::unique_ptr<Address> m_PrintForDebugger_addr; + bool m_read_objc_library; + std::unique_ptr<lldb_private::AppleObjCTrampolineHandler> + m_objc_trampoline_handler_up; + lldb::BreakpointSP m_objc_exception_bp_sp; + lldb::ModuleWP m_objc_module_wp; + std::unique_ptr<FunctionCaller> m_print_object_caller_up; + + llvm::Optional<uint32_t> m_Foundation_major; +}; + +} // namespace lldb_private + +#endif // liblldb_AppleObjCRuntime_h_ diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp new file mode 100644 index 000000000000..88bfe2ce0203 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp @@ -0,0 +1,445 @@ +//===-- AppleObjCRuntimeV1.cpp --------------------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "AppleObjCRuntimeV1.h" +#include "AppleObjCDeclVendor.h" +#include "AppleObjCTrampolineHandler.h" + +#include "clang/AST/Type.h" + +#include "lldb/Breakpoint/BreakpointLocation.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/Expression/FunctionCaller.h" +#include "lldb/Expression/UtilityFunction.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Symbol/Symbol.h" +#include "lldb/Target/ExecutionContext.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/RegisterContext.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/Thread.h" +#include "lldb/Utility/ConstString.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Scalar.h" +#include "lldb/Utility/Status.h" +#include "lldb/Utility/StreamString.h" + +#include <memory> +#include <vector> + +using namespace lldb; +using namespace lldb_private; + +char AppleObjCRuntimeV1::ID = 0; + +AppleObjCRuntimeV1::AppleObjCRuntimeV1(Process *process) + : AppleObjCRuntime(process), m_hash_signature(), + m_isa_hash_table_ptr(LLDB_INVALID_ADDRESS) {} + +// for V1 runtime we just try to return a class name as that is the minimum +// level of support required for the data formatters to work +bool AppleObjCRuntimeV1::GetDynamicTypeAndAddress( + ValueObject &in_value, lldb::DynamicValueType use_dynamic, + TypeAndOrName &class_type_or_name, Address &address, + Value::ValueType &value_type) { + class_type_or_name.Clear(); + value_type = Value::ValueType::eValueTypeScalar; + if (CouldHaveDynamicValue(in_value)) { + auto class_descriptor(GetClassDescriptor(in_value)); + if (class_descriptor && class_descriptor->IsValid() && + class_descriptor->GetClassName()) { + const addr_t object_ptr = in_value.GetPointerValue(); + address.SetRawAddress(object_ptr); + class_type_or_name.SetName(class_descriptor->GetClassName()); + } + } + return !class_type_or_name.IsEmpty(); +} + +// Static Functions +lldb_private::LanguageRuntime * +AppleObjCRuntimeV1::CreateInstance(Process *process, + lldb::LanguageType language) { + // FIXME: This should be a MacOS or iOS process, and we need to look for the + // OBJC section to make + // sure we aren't using the V1 runtime. + if (language == eLanguageTypeObjC) { + ModuleSP objc_module_sp; + + if (AppleObjCRuntime::GetObjCVersion(process, objc_module_sp) == + ObjCRuntimeVersions::eAppleObjC_V1) + return new AppleObjCRuntimeV1(process); + else + return nullptr; + } else + return nullptr; +} + +void AppleObjCRuntimeV1::Initialize() { + PluginManager::RegisterPlugin( + GetPluginNameStatic(), "Apple Objective-C Language Runtime - Version 1", + CreateInstance, + /*command_callback = */ nullptr, GetBreakpointExceptionPrecondition); +} + +void AppleObjCRuntimeV1::Terminate() { + PluginManager::UnregisterPlugin(CreateInstance); +} + +lldb_private::ConstString AppleObjCRuntimeV1::GetPluginNameStatic() { + static ConstString g_name("apple-objc-v1"); + return g_name; +} + +// PluginInterface protocol +ConstString AppleObjCRuntimeV1::GetPluginName() { + return GetPluginNameStatic(); +} + +uint32_t AppleObjCRuntimeV1::GetPluginVersion() { return 1; } + +BreakpointResolverSP +AppleObjCRuntimeV1::CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, + bool throw_bp) { + BreakpointResolverSP resolver_sp; + + if (throw_bp) + resolver_sp = std::make_shared<BreakpointResolverName>( + bkpt, std::get<1>(GetExceptionThrowLocation()).AsCString(), + eFunctionNameTypeBase, eLanguageTypeUnknown, Breakpoint::Exact, 0, + eLazyBoolNo); + // FIXME: don't do catch yet. + return resolver_sp; +} + +struct BufStruct { + char contents[2048]; +}; + +UtilityFunction *AppleObjCRuntimeV1::CreateObjectChecker(const char *name) { + std::unique_ptr<BufStruct> buf(new BufStruct); + + int strformatsize = snprintf(&buf->contents[0], sizeof(buf->contents), + "struct __objc_class " + " \n" + "{ " + " \n" + " struct __objc_class *isa; " + " \n" + " struct __objc_class *super_class; " + " \n" + " const char *name; " + " \n" + " // rest of struct elided because unused " + " \n" + "}; " + " \n" + " " + " \n" + "struct __objc_object " + " \n" + "{ " + " \n" + " struct __objc_class *isa; " + " \n" + "}; " + " \n" + " " + " \n" + "extern \"C\" void " + " \n" + "%s(void *$__lldb_arg_obj, void *$__lldb_arg_selector) " + " \n" + "{ " + " \n" + " struct __objc_object *obj = (struct " + "__objc_object*)$__lldb_arg_obj; \n" + " if ($__lldb_arg_obj == (void *)0) " + " \n" + " return; // nil is ok " + " (int)strlen(obj->isa->name); " + " \n" + "} " + " \n", + name); + assert(strformatsize < (int)sizeof(buf->contents)); + (void)strformatsize; + + Status error; + return GetTargetRef().GetUtilityFunctionForLanguage( + buf->contents, eLanguageTypeObjC, name, error); +} + +AppleObjCRuntimeV1::ClassDescriptorV1::ClassDescriptorV1( + ValueObject &isa_pointer) { + Initialize(isa_pointer.GetValueAsUnsigned(0), isa_pointer.GetProcessSP()); +} + +AppleObjCRuntimeV1::ClassDescriptorV1::ClassDescriptorV1( + ObjCISA isa, lldb::ProcessSP process_sp) { + Initialize(isa, process_sp); +} + +void AppleObjCRuntimeV1::ClassDescriptorV1::Initialize( + ObjCISA isa, lldb::ProcessSP process_sp) { + if (!isa || !process_sp) { + m_valid = false; + return; + } + + m_valid = true; + + Status error; + + m_isa = process_sp->ReadPointerFromMemory(isa, error); + + if (error.Fail()) { + m_valid = false; + return; + } + + uint32_t ptr_size = process_sp->GetAddressByteSize(); + + if (!IsPointerValid(m_isa, ptr_size)) { + m_valid = false; + return; + } + + m_parent_isa = process_sp->ReadPointerFromMemory(m_isa + ptr_size, error); + + if (error.Fail()) { + m_valid = false; + return; + } + + if (!IsPointerValid(m_parent_isa, ptr_size, true)) { + m_valid = false; + return; + } + + lldb::addr_t name_ptr = + process_sp->ReadPointerFromMemory(m_isa + 2 * ptr_size, error); + + if (error.Fail()) { + m_valid = false; + return; + } + + lldb::DataBufferSP buffer_sp(new DataBufferHeap(1024, 0)); + + size_t count = process_sp->ReadCStringFromMemory( + name_ptr, (char *)buffer_sp->GetBytes(), 1024, error); + + if (error.Fail()) { + m_valid = false; + return; + } + + if (count) + m_name = ConstString((char *)buffer_sp->GetBytes()); + else + m_name = ConstString(); + + m_instance_size = process_sp->ReadUnsignedIntegerFromMemory( + m_isa + 5 * ptr_size, ptr_size, 0, error); + + if (error.Fail()) { + m_valid = false; + return; + } + + m_process_wp = lldb::ProcessWP(process_sp); +} + +AppleObjCRuntime::ClassDescriptorSP +AppleObjCRuntimeV1::ClassDescriptorV1::GetSuperclass() { + if (!m_valid) + return AppleObjCRuntime::ClassDescriptorSP(); + ProcessSP process_sp = m_process_wp.lock(); + if (!process_sp) + return AppleObjCRuntime::ClassDescriptorSP(); + return ObjCLanguageRuntime::ClassDescriptorSP( + new AppleObjCRuntimeV1::ClassDescriptorV1(m_parent_isa, process_sp)); +} + +AppleObjCRuntime::ClassDescriptorSP +AppleObjCRuntimeV1::ClassDescriptorV1::GetMetaclass() const { + return ClassDescriptorSP(); +} + +bool AppleObjCRuntimeV1::ClassDescriptorV1::Describe( + std::function<void(ObjCLanguageRuntime::ObjCISA)> const &superclass_func, + std::function<bool(const char *, const char *)> const &instance_method_func, + std::function<bool(const char *, const char *)> const &class_method_func, + std::function<bool(const char *, const char *, lldb::addr_t, + uint64_t)> const &ivar_func) const { + return false; +} + +lldb::addr_t AppleObjCRuntimeV1::GetTaggedPointerObfuscator() { + return 0; +} + +lldb::addr_t AppleObjCRuntimeV1::GetISAHashTablePointer() { + if (m_isa_hash_table_ptr == LLDB_INVALID_ADDRESS) { + ModuleSP objc_module_sp(GetObjCModule()); + + if (!objc_module_sp) + return LLDB_INVALID_ADDRESS; + + static ConstString g_objc_debug_class_hash("_objc_debug_class_hash"); + + const Symbol *symbol = objc_module_sp->FindFirstSymbolWithNameAndType( + g_objc_debug_class_hash, lldb::eSymbolTypeData); + if (symbol && symbol->ValueIsAddress()) { + Process *process = GetProcess(); + if (process) { + + lldb::addr_t objc_debug_class_hash_addr = + symbol->GetAddressRef().GetLoadAddress(&process->GetTarget()); + + if (objc_debug_class_hash_addr != LLDB_INVALID_ADDRESS) { + Status error; + lldb::addr_t objc_debug_class_hash_ptr = + process->ReadPointerFromMemory(objc_debug_class_hash_addr, error); + if (objc_debug_class_hash_ptr != 0 && + objc_debug_class_hash_ptr != LLDB_INVALID_ADDRESS) { + m_isa_hash_table_ptr = objc_debug_class_hash_ptr; + } + } + } + } + } + return m_isa_hash_table_ptr; +} + +void AppleObjCRuntimeV1::UpdateISAToDescriptorMapIfNeeded() { + // TODO: implement HashTableSignature... + Process *process = GetProcess(); + + if (process) { + // Update the process stop ID that indicates the last time we updated the + // map, whether it was successful or not. + m_isa_to_descriptor_stop_id = process->GetStopID(); + + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); + + ProcessSP process_sp = process->shared_from_this(); + + ModuleSP objc_module_sp(GetObjCModule()); + + if (!objc_module_sp) + return; + + uint32_t isa_count = 0; + + lldb::addr_t hash_table_ptr = GetISAHashTablePointer(); + if (hash_table_ptr != LLDB_INVALID_ADDRESS) { + // Read the NXHashTable struct: + // + // typedef struct { + // const NXHashTablePrototype *prototype; + // unsigned count; + // unsigned nbBuckets; + // void *buckets; + // const void *info; + // } NXHashTable; + + Status error; + DataBufferHeap buffer(1024, 0); + if (process->ReadMemory(hash_table_ptr, buffer.GetBytes(), 20, error) == + 20) { + const uint32_t addr_size = m_process->GetAddressByteSize(); + const ByteOrder byte_order = m_process->GetByteOrder(); + DataExtractor data(buffer.GetBytes(), buffer.GetByteSize(), byte_order, + addr_size); + lldb::offset_t offset = addr_size; // Skip prototype + const uint32_t count = data.GetU32(&offset); + const uint32_t num_buckets = data.GetU32(&offset); + const addr_t buckets_ptr = data.GetPointer(&offset); + if (m_hash_signature.NeedsUpdate(count, num_buckets, buckets_ptr)) { + m_hash_signature.UpdateSignature(count, num_buckets, buckets_ptr); + + const uint32_t data_size = num_buckets * 2 * sizeof(uint32_t); + buffer.SetByteSize(data_size); + + if (process->ReadMemory(buckets_ptr, buffer.GetBytes(), data_size, + error) == data_size) { + data.SetData(buffer.GetBytes(), buffer.GetByteSize(), byte_order); + offset = 0; + for (uint32_t bucket_idx = 0; bucket_idx < num_buckets; + ++bucket_idx) { + const uint32_t bucket_isa_count = data.GetU32(&offset); + const lldb::addr_t bucket_data = data.GetU32(&offset); + + if (bucket_isa_count == 0) + continue; + + isa_count += bucket_isa_count; + + ObjCISA isa; + if (bucket_isa_count == 1) { + // When we only have one entry in the bucket, the bucket data + // is the "isa" + isa = bucket_data; + if (isa) { + if (!ISAIsCached(isa)) { + ClassDescriptorSP descriptor_sp( + new ClassDescriptorV1(isa, process_sp)); + + if (log && log->GetVerbose()) + LLDB_LOGF(log, + "AppleObjCRuntimeV1 added (ObjCISA)0x%" PRIx64 + " from _objc_debug_class_hash to " + "isa->descriptor cache", + isa); + + AddClass(isa, descriptor_sp); + } + } + } else { + // When we have more than one entry in the bucket, the bucket + // data is a pointer to an array of "isa" values + addr_t isa_addr = bucket_data; + for (uint32_t isa_idx = 0; isa_idx < bucket_isa_count; + ++isa_idx, isa_addr += addr_size) { + isa = m_process->ReadPointerFromMemory(isa_addr, error); + + if (isa && isa != LLDB_INVALID_ADDRESS) { + if (!ISAIsCached(isa)) { + ClassDescriptorSP descriptor_sp( + new ClassDescriptorV1(isa, process_sp)); + + if (log && log->GetVerbose()) + LLDB_LOGF( + log, + "AppleObjCRuntimeV1 added (ObjCISA)0x%" PRIx64 + " from _objc_debug_class_hash to isa->descriptor " + "cache", + isa); + + AddClass(isa, descriptor_sp); + } + } + } + } + } + } + } + } + } + } else { + m_isa_to_descriptor_stop_id = UINT32_MAX; + } +} + +DeclVendor *AppleObjCRuntimeV1::GetDeclVendor() { + return nullptr; +} diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h new file mode 100644 index 000000000000..6fdae63d4126 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h @@ -0,0 +1,156 @@ +//===-- AppleObjCRuntimeV1.h ------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_AppleObjCRuntimeV1_h_ +#define liblldb_AppleObjCRuntimeV1_h_ + +#include "AppleObjCRuntime.h" +#include "lldb/lldb-private.h" + +#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h" + +namespace lldb_private { + +class AppleObjCRuntimeV1 : public AppleObjCRuntime { +public: + ~AppleObjCRuntimeV1() override = default; + + // Static Functions + static void Initialize(); + + static void Terminate(); + + static lldb_private::LanguageRuntime * + CreateInstance(Process *process, lldb::LanguageType language); + + static lldb_private::ConstString GetPluginNameStatic(); + + static char ID; + + bool isA(const void *ClassID) const override { + return ClassID == &ID || AppleObjCRuntime::isA(ClassID); + } + + static bool classof(const LanguageRuntime *runtime) { + return runtime->isA(&ID); + } + + lldb::addr_t GetTaggedPointerObfuscator(); + + class ClassDescriptorV1 : public ObjCLanguageRuntime::ClassDescriptor { + public: + ClassDescriptorV1(ValueObject &isa_pointer); + ClassDescriptorV1(ObjCISA isa, lldb::ProcessSP process_sp); + + ~ClassDescriptorV1() override = default; + + ConstString GetClassName() override { return m_name; } + + ClassDescriptorSP GetSuperclass() override; + + ClassDescriptorSP GetMetaclass() const override; + + bool IsValid() override { return m_valid; } + + // v1 does not support tagged pointers + bool GetTaggedPointerInfo(uint64_t *info_bits = nullptr, + uint64_t *value_bits = nullptr, + uint64_t *payload = nullptr) override { + return false; + } + + uint64_t GetInstanceSize() override { return m_instance_size; } + + ObjCISA GetISA() override { return m_isa; } + + bool + Describe(std::function<void(ObjCLanguageRuntime::ObjCISA)> const + &superclass_func, + std::function<bool(const char *, const char *)> const + &instance_method_func, + std::function<bool(const char *, const char *)> const + &class_method_func, + std::function<bool(const char *, const char *, lldb::addr_t, + uint64_t)> const &ivar_func) const override; + + protected: + void Initialize(ObjCISA isa, lldb::ProcessSP process_sp); + + private: + ConstString m_name; + ObjCISA m_isa; + ObjCISA m_parent_isa; + bool m_valid; + lldb::ProcessWP m_process_wp; + uint64_t m_instance_size; + }; + + // These are generic runtime functions: + bool GetDynamicTypeAndAddress(ValueObject &in_value, + lldb::DynamicValueType use_dynamic, + TypeAndOrName &class_type_or_name, + Address &address, + Value::ValueType &value_type) override; + + UtilityFunction *CreateObjectChecker(const char *) override; + + // PluginInterface protocol + ConstString GetPluginName() override; + + uint32_t GetPluginVersion() override; + + ObjCRuntimeVersions GetRuntimeVersion() const override { + return ObjCRuntimeVersions::eAppleObjC_V1; + } + + void UpdateISAToDescriptorMapIfNeeded() override; + + DeclVendor *GetDeclVendor() override; + +protected: + lldb::BreakpointResolverSP CreateExceptionResolver(Breakpoint *bkpt, + bool catch_bp, + bool throw_bp) override; + + class HashTableSignature { + public: + HashTableSignature() + : m_count(0), m_num_buckets(0), m_buckets_ptr(LLDB_INVALID_ADDRESS) {} + + bool NeedsUpdate(uint32_t count, uint32_t num_buckets, + lldb::addr_t buckets_ptr) { + return m_count != count || m_num_buckets != num_buckets || + m_buckets_ptr != buckets_ptr; + } + + void UpdateSignature(uint32_t count, uint32_t num_buckets, + lldb::addr_t buckets_ptr) { + m_count = count; + m_num_buckets = num_buckets; + m_buckets_ptr = buckets_ptr; + } + + protected: + uint32_t m_count; + uint32_t m_num_buckets; + lldb::addr_t m_buckets_ptr; + }; + + lldb::addr_t GetISAHashTablePointer(); + + HashTableSignature m_hash_signature; + lldb::addr_t m_isa_hash_table_ptr; + std::unique_ptr<DeclVendor> m_decl_vendor_up; + +private: + AppleObjCRuntimeV1(Process *process); +}; + +} // namespace lldb_private + +#endif // liblldb_AppleObjCRuntimeV1_h_ diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp new file mode 100644 index 000000000000..9bdbef393e39 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp @@ -0,0 +1,2730 @@ +//===-- AppleObjCRuntimeV2.cpp ----------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <stdint.h> + +#include <memory> +#include <string> +#include <vector> + +#include "clang/AST/ASTContext.h" +#include "clang/AST/DeclObjC.h" + +#include "lldb/Core/ClangForward.h" +#include "lldb/Host/OptionParser.h" +#include "lldb/Symbol/CompilerType.h" +#include "lldb/lldb-enumerations.h" + +#include "lldb/Core/ClangForward.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/Core/Section.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/Core/ValueObjectVariable.h" +#include "lldb/Expression/DiagnosticManager.h" +#include "lldb/Expression/FunctionCaller.h" +#include "lldb/Expression/UtilityFunction.h" +#include "lldb/Interpreter/CommandObject.h" +#include "lldb/Interpreter/CommandObjectMultiword.h" +#include "lldb/Interpreter/CommandReturnObject.h" +#include "lldb/Interpreter/OptionArgParser.h" +#include "lldb/Interpreter/OptionValueBoolean.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Symbol/ObjectFile.h" +#include "lldb/Symbol/Symbol.h" +#include "lldb/Symbol/TypeList.h" +#include "lldb/Symbol/VariableList.h" +#include "lldb/Target/ABI.h" +#include "lldb/Target/ExecutionContext.h" +#include "lldb/Target/Platform.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/RegisterContext.h" +#include "lldb/Target/StackFrameRecognizer.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/Thread.h" +#include "lldb/Utility/ConstString.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Scalar.h" +#include "lldb/Utility/Status.h" +#include "lldb/Utility/Stream.h" +#include "lldb/Utility/StreamString.h" +#include "lldb/Utility/Timer.h" + +#include "AppleObjCClassDescriptorV2.h" +#include "AppleObjCDeclVendor.h" +#include "AppleObjCRuntimeV2.h" +#include "AppleObjCTrampolineHandler.h" +#include "AppleObjCTypeEncodingParser.h" + +#include "clang/AST/ASTContext.h" +#include "clang/AST/DeclObjC.h" + +#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h" + +#include <vector> + +using namespace lldb; +using namespace lldb_private; + +char AppleObjCRuntimeV2::ID = 0; + +static const char *g_get_dynamic_class_info_name = + "__lldb_apple_objc_v2_get_dynamic_class_info"; +// Testing using the new C++11 raw string literals. If this breaks GCC then we +// will need to revert to the code above... +static const char *g_get_dynamic_class_info_body = R"( + +extern "C" +{ + size_t strlen(const char *); + char *strncpy (char * s1, const char * s2, size_t n); + int printf(const char * format, ...); +} +#define DEBUG_PRINTF(fmt, ...) if (should_log) printf(fmt, ## __VA_ARGS__) + +typedef struct _NXMapTable { + void *prototype; + unsigned num_classes; + unsigned num_buckets_minus_one; + void *buckets; +} NXMapTable; + +#define NX_MAPNOTAKEY ((void *)(-1)) + +typedef struct BucketInfo +{ + const char *name_ptr; + Class isa; +} BucketInfo; + +struct ClassInfo +{ + Class isa; + uint32_t hash; +} __attribute__((__packed__)); + +uint32_t +__lldb_apple_objc_v2_get_dynamic_class_info (void *gdb_objc_realized_classes_ptr, + void *class_infos_ptr, + uint32_t class_infos_byte_size, + uint32_t should_log) +{ + DEBUG_PRINTF ("gdb_objc_realized_classes_ptr = %p\n", gdb_objc_realized_classes_ptr); + DEBUG_PRINTF ("class_infos_ptr = %p\n", class_infos_ptr); + DEBUG_PRINTF ("class_infos_byte_size = %u\n", class_infos_byte_size); + const NXMapTable *grc = (const NXMapTable *)gdb_objc_realized_classes_ptr; + if (grc) + { + const unsigned num_classes = grc->num_classes; + if (class_infos_ptr) + { + const size_t max_class_infos = class_infos_byte_size/sizeof(ClassInfo); + ClassInfo *class_infos = (ClassInfo *)class_infos_ptr; + BucketInfo *buckets = (BucketInfo *)grc->buckets; + + uint32_t idx = 0; + for (unsigned i=0; i<=grc->num_buckets_minus_one; ++i) + { + if (buckets[i].name_ptr != NX_MAPNOTAKEY) + { + if (idx < max_class_infos) + { + const char *s = buckets[i].name_ptr; + uint32_t h = 5381; + for (unsigned char c = *s; c; c = *++s) + h = ((h << 5) + h) + c; + class_infos[idx].hash = h; + class_infos[idx].isa = buckets[i].isa; + } + ++idx; + } + } + if (idx < max_class_infos) + { + class_infos[idx].isa = NULL; + class_infos[idx].hash = 0; + } + } + return num_classes; + } + return 0; +} + +)"; + +// We'll substitute in class_getName or class_getNameRaw depending +// on which is present. +static const char *g_shared_cache_class_name_funcptr = R"( +extern "C" +{ + const char *%s(void *objc_class); + const char *(*class_name_lookup_func)(void *) = %s; +} +)"; + +static const char *g_get_shared_cache_class_info_name = + "__lldb_apple_objc_v2_get_shared_cache_class_info"; +// Testing using the new C++11 raw string literals. If this breaks GCC then we +// will need to revert to the code above... +static const char *g_get_shared_cache_class_info_body = R"( + +extern "C" +{ + size_t strlen(const char *); + char *strncpy (char * s1, const char * s2, size_t n); + int printf(const char * format, ...); +} + +#define DEBUG_PRINTF(fmt, ...) if (should_log) printf(fmt, ## __VA_ARGS__) + + +struct objc_classheader_t { + int32_t clsOffset; + int32_t hiOffset; +}; + +struct objc_clsopt_t { + uint32_t capacity; + uint32_t occupied; + uint32_t shift; + uint32_t mask; + uint32_t zero; + uint32_t unused; + uint64_t salt; + uint32_t scramble[256]; + uint8_t tab[0]; // tab[mask+1] + // uint8_t checkbytes[capacity]; + // int32_t offset[capacity]; + // objc_classheader_t clsOffsets[capacity]; + // uint32_t duplicateCount; + // objc_classheader_t duplicateOffsets[duplicateCount]; +}; + +struct objc_opt_t { + uint32_t version; + int32_t selopt_offset; + int32_t headeropt_offset; + int32_t clsopt_offset; +}; + +struct objc_opt_v14_t { + uint32_t version; + uint32_t flags; + int32_t selopt_offset; + int32_t headeropt_offset; + int32_t clsopt_offset; +}; + +struct ClassInfo +{ + Class isa; + uint32_t hash; +} __attribute__((__packed__)); + +uint32_t +__lldb_apple_objc_v2_get_shared_cache_class_info (void *objc_opt_ro_ptr, + void *class_infos_ptr, + uint32_t class_infos_byte_size, + uint32_t should_log) +{ + uint32_t idx = 0; + DEBUG_PRINTF ("objc_opt_ro_ptr = %p\n", objc_opt_ro_ptr); + DEBUG_PRINTF ("class_infos_ptr = %p\n", class_infos_ptr); + DEBUG_PRINTF ("class_infos_byte_size = %u (%llu class infos)\n", class_infos_byte_size, (uint64_t)(class_infos_byte_size/sizeof(ClassInfo))); + if (objc_opt_ro_ptr) + { + const objc_opt_t *objc_opt = (objc_opt_t *)objc_opt_ro_ptr; + const objc_opt_v14_t* objc_opt_v14 = (objc_opt_v14_t*)objc_opt_ro_ptr; + const bool is_v14_format = objc_opt->version >= 14; + if (is_v14_format) + { + DEBUG_PRINTF ("objc_opt->version = %u\n", objc_opt_v14->version); + DEBUG_PRINTF ("objc_opt->flags = %u\n", objc_opt_v14->flags); + DEBUG_PRINTF ("objc_opt->selopt_offset = %d\n", objc_opt_v14->selopt_offset); + DEBUG_PRINTF ("objc_opt->headeropt_offset = %d\n", objc_opt_v14->headeropt_offset); + DEBUG_PRINTF ("objc_opt->clsopt_offset = %d\n", objc_opt_v14->clsopt_offset); + } + else + { + DEBUG_PRINTF ("objc_opt->version = %u\n", objc_opt->version); + DEBUG_PRINTF ("objc_opt->selopt_offset = %d\n", objc_opt->selopt_offset); + DEBUG_PRINTF ("objc_opt->headeropt_offset = %d\n", objc_opt->headeropt_offset); + DEBUG_PRINTF ("objc_opt->clsopt_offset = %d\n", objc_opt->clsopt_offset); + } + if (objc_opt->version == 12 || objc_opt->version == 13 || objc_opt->version == 14 || objc_opt->version == 15) + { + const objc_clsopt_t* clsopt = NULL; + if (is_v14_format) + clsopt = (const objc_clsopt_t*)((uint8_t *)objc_opt_v14 + objc_opt_v14->clsopt_offset); + else + clsopt = (const objc_clsopt_t*)((uint8_t *)objc_opt + objc_opt->clsopt_offset); + const size_t max_class_infos = class_infos_byte_size/sizeof(ClassInfo); + DEBUG_PRINTF("max_class_infos = %llu\n", (uint64_t)max_class_infos); + ClassInfo *class_infos = (ClassInfo *)class_infos_ptr; + int32_t invalidEntryOffset = 0; + // this is safe to do because the version field order is invariant + if (objc_opt->version == 12) + invalidEntryOffset = 16; + const uint8_t *checkbytes = &clsopt->tab[clsopt->mask+1]; + const int32_t *offsets = (const int32_t *)(checkbytes + clsopt->capacity); + const objc_classheader_t *classOffsets = (const objc_classheader_t *)(offsets + clsopt->capacity); + DEBUG_PRINTF ("clsopt->capacity = %u\n", clsopt->capacity); + DEBUG_PRINTF ("clsopt->mask = 0x%8.8x\n", clsopt->mask); + DEBUG_PRINTF ("classOffsets = %p\n", classOffsets); + DEBUG_PRINTF("invalidEntryOffset = %d\n", invalidEntryOffset); + for (uint32_t i=0; i<clsopt->capacity; ++i) + { + const int32_t clsOffset = classOffsets[i].clsOffset; + DEBUG_PRINTF("clsOffset[%u] = %u\n", i, clsOffset); + if (clsOffset & 1) + { + DEBUG_PRINTF("clsOffset & 1\n"); + continue; // duplicate + } + else if (clsOffset == invalidEntryOffset) + { + DEBUG_PRINTF("clsOffset == invalidEntryOffset\n"); + continue; // invalid offset + } + + if (class_infos && idx < max_class_infos) + { + class_infos[idx].isa = (Class)((uint8_t *)clsopt + clsOffset); + const char *name = class_name_lookup_func (class_infos[idx].isa); + DEBUG_PRINTF ("[%u] isa = %8p %s\n", idx, class_infos[idx].isa, name); + // Hash the class name so we don't have to read it + const char *s = name; + uint32_t h = 5381; + for (unsigned char c = *s; c; c = *++s) + { + // class_getName demangles swift names and the hash must + // be calculated on the mangled name. hash==0 means lldb + // will fetch the mangled name and compute the hash in + // ParseClassInfoArray. + if (c == '.') + { + h = 0; + break; + } + h = ((h << 5) + h) + c; + } + class_infos[idx].hash = h; + } + else + { + DEBUG_PRINTF("not(class_infos && idx < max_class_infos)\n"); + } + ++idx; + } + + const uint32_t *duplicate_count_ptr = (uint32_t *)&classOffsets[clsopt->capacity]; + const uint32_t duplicate_count = *duplicate_count_ptr; + const objc_classheader_t *duplicateClassOffsets = (const objc_classheader_t *)(&duplicate_count_ptr[1]); + DEBUG_PRINTF ("duplicate_count = %u\n", duplicate_count); + DEBUG_PRINTF ("duplicateClassOffsets = %p\n", duplicateClassOffsets); + for (uint32_t i=0; i<duplicate_count; ++i) + { + const int32_t clsOffset = duplicateClassOffsets[i].clsOffset; + if (clsOffset & 1) + continue; // duplicate + else if (clsOffset == invalidEntryOffset) + continue; // invalid offset + + if (class_infos && idx < max_class_infos) + { + class_infos[idx].isa = (Class)((uint8_t *)clsopt + clsOffset); + const char *name = class_name_lookup_func (class_infos[idx].isa); + DEBUG_PRINTF ("[%u] isa = %8p %s\n", idx, class_infos[idx].isa, name); + // Hash the class name so we don't have to read it + const char *s = name; + uint32_t h = 5381; + for (unsigned char c = *s; c; c = *++s) + { + // class_getName demangles swift names and the hash must + // be calculated on the mangled name. hash==0 means lldb + // will fetch the mangled name and compute the hash in + // ParseClassInfoArray. + if (c == '.') + { + h = 0; + break; + } + h = ((h << 5) + h) + c; + } + class_infos[idx].hash = h; + } + ++idx; + } + } + DEBUG_PRINTF ("%u class_infos\n", idx); + DEBUG_PRINTF ("done\n"); + } + return idx; +} + + +)"; + +static uint64_t +ExtractRuntimeGlobalSymbol(Process *process, ConstString name, + const ModuleSP &module_sp, Status &error, + bool read_value = true, uint8_t byte_size = 0, + uint64_t default_value = LLDB_INVALID_ADDRESS, + SymbolType sym_type = lldb::eSymbolTypeData) { + if (!process) { + error.SetErrorString("no process"); + return default_value; + } + if (!module_sp) { + error.SetErrorString("no module"); + return default_value; + } + if (!byte_size) + byte_size = process->GetAddressByteSize(); + const Symbol *symbol = + module_sp->FindFirstSymbolWithNameAndType(name, lldb::eSymbolTypeData); + if (symbol && symbol->ValueIsAddress()) { + lldb::addr_t symbol_load_addr = + symbol->GetAddressRef().GetLoadAddress(&process->GetTarget()); + if (symbol_load_addr != LLDB_INVALID_ADDRESS) { + if (read_value) + return process->ReadUnsignedIntegerFromMemory( + symbol_load_addr, byte_size, default_value, error); + else + return symbol_load_addr; + } else { + error.SetErrorString("symbol address invalid"); + return default_value; + } + } else { + error.SetErrorString("no symbol"); + return default_value; + } +} + +static void RegisterObjCExceptionRecognizer(); + +AppleObjCRuntimeV2::AppleObjCRuntimeV2(Process *process, + const ModuleSP &objc_module_sp) + : AppleObjCRuntime(process), m_get_class_info_code(), + m_get_class_info_args(LLDB_INVALID_ADDRESS), + m_get_class_info_args_mutex(), m_get_shared_cache_class_info_code(), + m_get_shared_cache_class_info_args(LLDB_INVALID_ADDRESS), + m_get_shared_cache_class_info_args_mutex(), m_decl_vendor_up(), + m_tagged_pointer_obfuscator(LLDB_INVALID_ADDRESS), + m_isa_hash_table_ptr(LLDB_INVALID_ADDRESS), m_hash_signature(), + m_has_object_getClass(false), m_loaded_objc_opt(false), + m_non_pointer_isa_cache_up( + NonPointerISACache::CreateInstance(*this, objc_module_sp)), + m_tagged_pointer_vendor_up( + TaggedPointerVendorV2::CreateInstance(*this, objc_module_sp)), + m_encoding_to_type_sp(), m_noclasses_warning_emitted(false), + m_CFBoolean_values() { + static const ConstString g_gdb_object_getClass("gdb_object_getClass"); + m_has_object_getClass = + (objc_module_sp->FindFirstSymbolWithNameAndType( + g_gdb_object_getClass, eSymbolTypeCode) != nullptr); + RegisterObjCExceptionRecognizer(); +} + +bool AppleObjCRuntimeV2::GetDynamicTypeAndAddress( + ValueObject &in_value, lldb::DynamicValueType use_dynamic, + TypeAndOrName &class_type_or_name, Address &address, + Value::ValueType &value_type) { + // We should never get here with a null process... + assert(m_process != nullptr); + + // The Runtime is attached to a particular process, you shouldn't pass in a + // value from another process. Note, however, the process might be NULL (e.g. + // if the value was made with SBTarget::EvaluateExpression...) in which case + // it is sufficient if the target's match: + + Process *process = in_value.GetProcessSP().get(); + if (process) + assert(process == m_process); + else + assert(in_value.GetTargetSP().get() == m_process->CalculateTarget().get()); + + class_type_or_name.Clear(); + value_type = Value::ValueType::eValueTypeScalar; + + // Make sure we can have a dynamic value before starting... + if (CouldHaveDynamicValue(in_value)) { + // First job, pull out the address at 0 offset from the object That will + // be the ISA pointer. + ClassDescriptorSP objc_class_sp(GetNonKVOClassDescriptor(in_value)); + if (objc_class_sp) { + const addr_t object_ptr = in_value.GetPointerValue(); + address.SetRawAddress(object_ptr); + + ConstString class_name(objc_class_sp->GetClassName()); + class_type_or_name.SetName(class_name); + TypeSP type_sp(objc_class_sp->GetType()); + if (type_sp) + class_type_or_name.SetTypeSP(type_sp); + else { + type_sp = LookupInCompleteClassCache(class_name); + if (type_sp) { + objc_class_sp->SetType(type_sp); + class_type_or_name.SetTypeSP(type_sp); + } else { + // try to go for a CompilerType at least + if (auto *vendor = GetDeclVendor()) { + auto types = vendor->FindTypes(class_name, /*max_matches*/ 1); + if (!types.empty()) + class_type_or_name.SetCompilerType(types.front()); + } + } + } + } + } + return !class_type_or_name.IsEmpty(); +} + +// Static Functions +LanguageRuntime *AppleObjCRuntimeV2::CreateInstance(Process *process, + LanguageType language) { + // FIXME: This should be a MacOS or iOS process, and we need to look for the + // OBJC section to make + // sure we aren't using the V1 runtime. + if (language == eLanguageTypeObjC) { + ModuleSP objc_module_sp; + + if (AppleObjCRuntime::GetObjCVersion(process, objc_module_sp) == + ObjCRuntimeVersions::eAppleObjC_V2) + return new AppleObjCRuntimeV2(process, objc_module_sp); + else + return nullptr; + } else + return nullptr; +} + +static constexpr OptionDefinition g_objc_classtable_dump_options[] = { + {LLDB_OPT_SET_ALL, false, "verbose", 'v', OptionParser::eNoArgument, + nullptr, {}, 0, eArgTypeNone, + "Print ivar and method information in detail"}}; + +class CommandObjectObjC_ClassTable_Dump : public CommandObjectParsed { +public: + class CommandOptions : public Options { + public: + CommandOptions() : Options(), m_verbose(false, false) {} + + ~CommandOptions() override = default; + + 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 'v': + m_verbose.SetCurrentValue(true); + m_verbose.SetOptionWasSet(); + break; + + default: + error.SetErrorStringWithFormat("unrecognized short option '%c'", + short_option); + break; + } + + return error; + } + + void OptionParsingStarting(ExecutionContext *execution_context) override { + m_verbose.Clear(); + } + + llvm::ArrayRef<OptionDefinition> GetDefinitions() override { + return llvm::makeArrayRef(g_objc_classtable_dump_options); + } + + OptionValueBoolean m_verbose; + }; + + CommandObjectObjC_ClassTable_Dump(CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "dump", "Dump information on Objective-C classes " + "known to the current process.", + "language objc class-table dump", + eCommandRequiresProcess | eCommandProcessMustBeLaunched | + eCommandProcessMustBePaused), + m_options() { + CommandArgumentEntry arg; + CommandArgumentData index_arg; + + // Define the first (and only) variant of this arg. + index_arg.arg_type = eArgTypeRegularExpression; + index_arg.arg_repetition = eArgRepeatOptional; + + // There is only one variant this argument could be; put it into the + // argument entry. + arg.push_back(index_arg); + + // Push the data for the first argument into the m_arguments vector. + m_arguments.push_back(arg); + } + + ~CommandObjectObjC_ClassTable_Dump() override = default; + + Options *GetOptions() override { return &m_options; } + +protected: + bool DoExecute(Args &command, CommandReturnObject &result) override { + std::unique_ptr<RegularExpression> regex_up; + switch (command.GetArgumentCount()) { + case 0: + break; + case 1: { + regex_up.reset(new RegularExpression( + llvm::StringRef::withNullAsEmpty(command.GetArgumentAtIndex(0)))); + if (!regex_up->IsValid()) { + result.AppendError( + "invalid argument - please provide a valid regular expression"); + result.SetStatus(lldb::eReturnStatusFailed); + return false; + } + break; + } + default: { + result.AppendError("please provide 0 or 1 arguments"); + result.SetStatus(lldb::eReturnStatusFailed); + return false; + } + } + + Process *process = m_exe_ctx.GetProcessPtr(); + ObjCLanguageRuntime *objc_runtime = ObjCLanguageRuntime::Get(*process); + if (objc_runtime) { + auto iterators_pair = objc_runtime->GetDescriptorIteratorPair(); + auto iterator = iterators_pair.first; + auto &std_out = result.GetOutputStream(); + for (; iterator != iterators_pair.second; iterator++) { + if (iterator->second) { + const char *class_name = + iterator->second->GetClassName().AsCString("<unknown>"); + if (regex_up && class_name && + !regex_up->Execute(llvm::StringRef(class_name))) + continue; + std_out.Printf("isa = 0x%" PRIx64, iterator->first); + std_out.Printf(" name = %s", class_name); + std_out.Printf(" instance size = %" PRIu64, + iterator->second->GetInstanceSize()); + std_out.Printf(" num ivars = %" PRIuPTR, + (uintptr_t)iterator->second->GetNumIVars()); + if (auto superclass = iterator->second->GetSuperclass()) { + std_out.Printf(" superclass = %s", + superclass->GetClassName().AsCString("<unknown>")); + } + std_out.Printf("\n"); + if (m_options.m_verbose) { + for (size_t i = 0; i < iterator->second->GetNumIVars(); i++) { + auto ivar = iterator->second->GetIVarAtIndex(i); + std_out.Printf( + " ivar name = %s type = %s size = %" PRIu64 + " offset = %" PRId32 "\n", + ivar.m_name.AsCString("<unknown>"), + ivar.m_type.GetDisplayTypeName().AsCString("<unknown>"), + ivar.m_size, ivar.m_offset); + } + iterator->second->Describe( + nullptr, + [&std_out](const char *name, const char *type) -> bool { + std_out.Printf(" instance method name = %s type = %s\n", + name, type); + return false; + }, + [&std_out](const char *name, const char *type) -> bool { + std_out.Printf(" class method name = %s type = %s\n", name, + type); + return false; + }, + nullptr); + } + } else { + if (regex_up && !regex_up->Execute(llvm::StringRef())) + continue; + std_out.Printf("isa = 0x%" PRIx64 " has no associated class.\n", + iterator->first); + } + } + result.SetStatus(lldb::eReturnStatusSuccessFinishResult); + return true; + } else { + result.AppendError("current process has no Objective-C runtime loaded"); + result.SetStatus(lldb::eReturnStatusFailed); + return false; + } + } + + CommandOptions m_options; +}; + +class CommandObjectMultiwordObjC_TaggedPointer_Info + : public CommandObjectParsed { +public: + CommandObjectMultiwordObjC_TaggedPointer_Info(CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "info", "Dump information on a tagged pointer.", + "language objc tagged-pointer info", + eCommandRequiresProcess | eCommandProcessMustBeLaunched | + eCommandProcessMustBePaused) { + CommandArgumentEntry arg; + CommandArgumentData index_arg; + + // Define the first (and only) variant of this arg. + index_arg.arg_type = eArgTypeAddress; + index_arg.arg_repetition = eArgRepeatPlus; + + // There is only one variant this argument could be; put it into the + // argument entry. + arg.push_back(index_arg); + + // Push the data for the first argument into the m_arguments vector. + m_arguments.push_back(arg); + } + + ~CommandObjectMultiwordObjC_TaggedPointer_Info() override = default; + +protected: + bool DoExecute(Args &command, CommandReturnObject &result) override { + if (command.GetArgumentCount() == 0) { + result.AppendError("this command requires arguments"); + result.SetStatus(lldb::eReturnStatusFailed); + return false; + } + + Process *process = m_exe_ctx.GetProcessPtr(); + ExecutionContext exe_ctx(process); + ObjCLanguageRuntime *objc_runtime = ObjCLanguageRuntime::Get(*process); + if (objc_runtime) { + ObjCLanguageRuntime::TaggedPointerVendor *tagged_ptr_vendor = + objc_runtime->GetTaggedPointerVendor(); + if (tagged_ptr_vendor) { + for (size_t i = 0; i < command.GetArgumentCount(); i++) { + const char *arg_str = command.GetArgumentAtIndex(i); + if (!arg_str) + continue; + Status error; + lldb::addr_t arg_addr = OptionArgParser::ToAddress( + &exe_ctx, arg_str, LLDB_INVALID_ADDRESS, &error); + if (arg_addr == 0 || arg_addr == LLDB_INVALID_ADDRESS || error.Fail()) + continue; + auto descriptor_sp = tagged_ptr_vendor->GetClassDescriptor(arg_addr); + if (!descriptor_sp) + continue; + uint64_t info_bits = 0; + uint64_t value_bits = 0; + uint64_t payload = 0; + if (descriptor_sp->GetTaggedPointerInfo(&info_bits, &value_bits, + &payload)) { + result.GetOutputStream().Printf( + "0x%" PRIx64 " is tagged.\n\tpayload = 0x%" PRIx64 + "\n\tvalue = 0x%" PRIx64 "\n\tinfo bits = 0x%" PRIx64 + "\n\tclass = %s\n", + (uint64_t)arg_addr, payload, value_bits, info_bits, + descriptor_sp->GetClassName().AsCString("<unknown>")); + } else { + result.GetOutputStream().Printf("0x%" PRIx64 " is not tagged.\n", + (uint64_t)arg_addr); + } + } + } else { + result.AppendError("current process has no tagged pointer support"); + result.SetStatus(lldb::eReturnStatusFailed); + return false; + } + result.SetStatus(lldb::eReturnStatusSuccessFinishResult); + return true; + } else { + result.AppendError("current process has no Objective-C runtime loaded"); + result.SetStatus(lldb::eReturnStatusFailed); + return false; + } + } +}; + +class CommandObjectMultiwordObjC_ClassTable : public CommandObjectMultiword { +public: + CommandObjectMultiwordObjC_ClassTable(CommandInterpreter &interpreter) + : CommandObjectMultiword( + interpreter, "class-table", + "Commands for operating on the Objective-C class table.", + "class-table <subcommand> [<subcommand-options>]") { + LoadSubCommand( + "dump", + CommandObjectSP(new CommandObjectObjC_ClassTable_Dump(interpreter))); + } + + ~CommandObjectMultiwordObjC_ClassTable() override = default; +}; + +class CommandObjectMultiwordObjC_TaggedPointer : public CommandObjectMultiword { +public: + CommandObjectMultiwordObjC_TaggedPointer(CommandInterpreter &interpreter) + : CommandObjectMultiword( + interpreter, "tagged-pointer", + "Commands for operating on Objective-C tagged pointers.", + "class-table <subcommand> [<subcommand-options>]") { + LoadSubCommand( + "info", + CommandObjectSP( + new CommandObjectMultiwordObjC_TaggedPointer_Info(interpreter))); + } + + ~CommandObjectMultiwordObjC_TaggedPointer() override = default; +}; + +class CommandObjectMultiwordObjC : public CommandObjectMultiword { +public: + CommandObjectMultiwordObjC(CommandInterpreter &interpreter) + : CommandObjectMultiword( + interpreter, "objc", + "Commands for operating on the Objective-C language runtime.", + "objc <subcommand> [<subcommand-options>]") { + LoadSubCommand("class-table", + CommandObjectSP( + new CommandObjectMultiwordObjC_ClassTable(interpreter))); + LoadSubCommand("tagged-pointer", + CommandObjectSP(new CommandObjectMultiwordObjC_TaggedPointer( + interpreter))); + } + + ~CommandObjectMultiwordObjC() override = default; +}; + +void AppleObjCRuntimeV2::Initialize() { + PluginManager::RegisterPlugin( + GetPluginNameStatic(), "Apple Objective-C Language Runtime - Version 2", + CreateInstance, + [](CommandInterpreter &interpreter) -> lldb::CommandObjectSP { + return CommandObjectSP(new CommandObjectMultiwordObjC(interpreter)); + }, + GetBreakpointExceptionPrecondition); +} + +void AppleObjCRuntimeV2::Terminate() { + PluginManager::UnregisterPlugin(CreateInstance); +} + +lldb_private::ConstString AppleObjCRuntimeV2::GetPluginNameStatic() { + static ConstString g_name("apple-objc-v2"); + return g_name; +} + +// PluginInterface protocol +lldb_private::ConstString AppleObjCRuntimeV2::GetPluginName() { + return GetPluginNameStatic(); +} + +uint32_t AppleObjCRuntimeV2::GetPluginVersion() { return 1; } + +BreakpointResolverSP +AppleObjCRuntimeV2::CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, + bool throw_bp) { + BreakpointResolverSP resolver_sp; + + if (throw_bp) + resolver_sp = std::make_shared<BreakpointResolverName>( + bkpt, std::get<1>(GetExceptionThrowLocation()).AsCString(), + 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; +} + +UtilityFunction *AppleObjCRuntimeV2::CreateObjectChecker(const char *name) { + char check_function_code[2048]; + + int len = 0; + if (m_has_object_getClass) { + len = ::snprintf(check_function_code, sizeof(check_function_code), R"( + extern "C" void *gdb_object_getClass(void *); + extern "C" int printf(const char *format, ...); + extern "C" void + %s(void *$__lldb_arg_obj, void *$__lldb_arg_selector) { + if ($__lldb_arg_obj == (void *)0) + return; // nil is ok + if (!gdb_object_getClass($__lldb_arg_obj)) { + *((volatile int *)0) = 'ocgc'; + } else if ($__lldb_arg_selector != (void *)0) { + signed char $responds = (signed char) + [(id)$__lldb_arg_obj respondsToSelector: + (void *) $__lldb_arg_selector]; + if ($responds == (signed char) 0) + *((volatile int *)0) = 'ocgc'; + } + })", name); + } else { + len = ::snprintf(check_function_code, sizeof(check_function_code), R"( + extern "C" void *gdb_class_getClass(void *); + extern "C" int printf(const char *format, ...); + extern "C" void + %s(void *$__lldb_arg_obj, void *$__lldb_arg_selector) { + if ($__lldb_arg_obj == (void *)0) + return; // nil is ok + void **$isa_ptr = (void **)$__lldb_arg_obj; + if (*$isa_ptr == (void *)0 || + !gdb_class_getClass(*$isa_ptr)) + *((volatile int *)0) = 'ocgc'; + else if ($__lldb_arg_selector != (void *)0) { + signed char $responds = (signed char) + [(id)$__lldb_arg_obj respondsToSelector: + (void *) $__lldb_arg_selector]; + if ($responds == (signed char) 0) + *((volatile int *)0) = 'ocgc'; + } + })", name); + } + + assert(len < (int)sizeof(check_function_code)); + UNUSED_IF_ASSERT_DISABLED(len); + + Status error; + return GetTargetRef().GetUtilityFunctionForLanguage( + check_function_code, eLanguageTypeObjC, name, error); +} + +size_t AppleObjCRuntimeV2::GetByteOffsetForIvar(CompilerType &parent_ast_type, + const char *ivar_name) { + uint32_t ivar_offset = LLDB_INVALID_IVAR_OFFSET; + + const char *class_name = parent_ast_type.GetConstTypeName().AsCString(); + if (class_name && class_name[0] && ivar_name && ivar_name[0]) { + // Make the objective C V2 mangled name for the ivar offset from the class + // name and ivar name + std::string buffer("OBJC_IVAR_$_"); + buffer.append(class_name); + buffer.push_back('.'); + buffer.append(ivar_name); + ConstString ivar_const_str(buffer.c_str()); + + // Try to get the ivar offset address from the symbol table first using the + // name we created above + SymbolContextList sc_list; + Target &target = m_process->GetTarget(); + target.GetImages().FindSymbolsWithNameAndType(ivar_const_str, + eSymbolTypeObjCIVar, sc_list); + + addr_t ivar_offset_address = LLDB_INVALID_ADDRESS; + + Status error; + SymbolContext ivar_offset_symbol; + if (sc_list.GetSize() == 1 && + sc_list.GetContextAtIndex(0, ivar_offset_symbol)) { + if (ivar_offset_symbol.symbol) + ivar_offset_address = + ivar_offset_symbol.symbol->GetLoadAddress(&target); + } + + // If we didn't get the ivar offset address from the symbol table, fall + // back to getting it from the runtime + if (ivar_offset_address == LLDB_INVALID_ADDRESS) + ivar_offset_address = LookupRuntimeSymbol(ivar_const_str); + + if (ivar_offset_address != LLDB_INVALID_ADDRESS) + ivar_offset = m_process->ReadUnsignedIntegerFromMemory( + ivar_offset_address, 4, LLDB_INVALID_IVAR_OFFSET, error); + } + return ivar_offset; +} + +// tagged pointers are special not-a-real-pointer values that contain both type +// and value information this routine attempts to check with as little +// computational effort as possible whether something could possibly be a +// tagged pointer - false positives are possible but false negatives shouldn't +bool AppleObjCRuntimeV2::IsTaggedPointer(addr_t ptr) { + if (!m_tagged_pointer_vendor_up) + return false; + return m_tagged_pointer_vendor_up->IsPossibleTaggedPointer(ptr); +} + +class RemoteNXMapTable { +public: + RemoteNXMapTable() + : m_count(0), m_num_buckets_minus_one(0), + m_buckets_ptr(LLDB_INVALID_ADDRESS), m_process(nullptr), + m_end_iterator(*this, -1), m_load_addr(LLDB_INVALID_ADDRESS), + m_map_pair_size(0), m_invalid_key(0) {} + + void Dump() { + printf("RemoteNXMapTable.m_load_addr = 0x%" PRIx64 "\n", m_load_addr); + printf("RemoteNXMapTable.m_count = %u\n", m_count); + printf("RemoteNXMapTable.m_num_buckets_minus_one = %u\n", + m_num_buckets_minus_one); + printf("RemoteNXMapTable.m_buckets_ptr = 0x%" PRIX64 "\n", m_buckets_ptr); + } + + bool ParseHeader(Process *process, lldb::addr_t load_addr) { + m_process = process; + m_load_addr = load_addr; + m_map_pair_size = m_process->GetAddressByteSize() * 2; + m_invalid_key = + m_process->GetAddressByteSize() == 8 ? UINT64_MAX : UINT32_MAX; + Status err; + + // This currently holds true for all platforms we support, but we might + // need to change this to use get the actually byte size of "unsigned" from + // the target AST... + const uint32_t unsigned_byte_size = sizeof(uint32_t); + // Skip the prototype as we don't need it (const struct + // +NXMapTablePrototype *prototype) + + bool success = true; + if (load_addr == LLDB_INVALID_ADDRESS) + success = false; + else { + lldb::addr_t cursor = load_addr + m_process->GetAddressByteSize(); + + // unsigned count; + m_count = m_process->ReadUnsignedIntegerFromMemory( + cursor, unsigned_byte_size, 0, err); + if (m_count) { + cursor += unsigned_byte_size; + + // unsigned nbBucketsMinusOne; + m_num_buckets_minus_one = m_process->ReadUnsignedIntegerFromMemory( + cursor, unsigned_byte_size, 0, err); + cursor += unsigned_byte_size; + + // void *buckets; + m_buckets_ptr = m_process->ReadPointerFromMemory(cursor, err); + + success = m_count > 0 && m_buckets_ptr != LLDB_INVALID_ADDRESS; + } + } + + if (!success) { + m_count = 0; + m_num_buckets_minus_one = 0; + m_buckets_ptr = LLDB_INVALID_ADDRESS; + } + return success; + } + + // const_iterator mimics NXMapState and its code comes from NXInitMapState + // and NXNextMapState. + typedef std::pair<ConstString, ObjCLanguageRuntime::ObjCISA> element; + + friend class const_iterator; + class const_iterator { + public: + const_iterator(RemoteNXMapTable &parent, int index) + : m_parent(parent), m_index(index) { + AdvanceToValidIndex(); + } + + const_iterator(const const_iterator &rhs) + : m_parent(rhs.m_parent), m_index(rhs.m_index) { + // AdvanceToValidIndex() has been called by rhs already. + } + + const_iterator &operator=(const const_iterator &rhs) { + // AdvanceToValidIndex() has been called by rhs already. + assert(&m_parent == &rhs.m_parent); + m_index = rhs.m_index; + return *this; + } + + bool operator==(const const_iterator &rhs) const { + if (&m_parent != &rhs.m_parent) + return false; + if (m_index != rhs.m_index) + return false; + + return true; + } + + bool operator!=(const const_iterator &rhs) const { + return !(operator==(rhs)); + } + + const_iterator &operator++() { + AdvanceToValidIndex(); + return *this; + } + + const element operator*() const { + if (m_index == -1) { + // TODO find a way to make this an error, but not an assert + return element(); + } + + lldb::addr_t pairs_ptr = m_parent.m_buckets_ptr; + size_t map_pair_size = m_parent.m_map_pair_size; + lldb::addr_t pair_ptr = pairs_ptr + (m_index * map_pair_size); + + Status err; + + lldb::addr_t key = + m_parent.m_process->ReadPointerFromMemory(pair_ptr, err); + if (!err.Success()) + return element(); + lldb::addr_t value = m_parent.m_process->ReadPointerFromMemory( + pair_ptr + m_parent.m_process->GetAddressByteSize(), err); + if (!err.Success()) + return element(); + + std::string key_string; + + m_parent.m_process->ReadCStringFromMemory(key, key_string, err); + if (!err.Success()) + return element(); + + return element(ConstString(key_string.c_str()), + (ObjCLanguageRuntime::ObjCISA)value); + } + + private: + void AdvanceToValidIndex() { + if (m_index == -1) + return; + + const lldb::addr_t pairs_ptr = m_parent.m_buckets_ptr; + const size_t map_pair_size = m_parent.m_map_pair_size; + const lldb::addr_t invalid_key = m_parent.m_invalid_key; + Status err; + + while (m_index--) { + lldb::addr_t pair_ptr = pairs_ptr + (m_index * map_pair_size); + lldb::addr_t key = + m_parent.m_process->ReadPointerFromMemory(pair_ptr, err); + + if (!err.Success()) { + m_index = -1; + return; + } + + if (key != invalid_key) + return; + } + } + RemoteNXMapTable &m_parent; + int m_index; + }; + + const_iterator begin() { + return const_iterator(*this, m_num_buckets_minus_one + 1); + } + + const_iterator end() { return m_end_iterator; } + + uint32_t GetCount() const { return m_count; } + + uint32_t GetBucketCount() const { return m_num_buckets_minus_one; } + + lldb::addr_t GetBucketDataPointer() const { return m_buckets_ptr; } + + lldb::addr_t GetTableLoadAddress() const { return m_load_addr; } + +private: + // contents of _NXMapTable struct + uint32_t m_count; + uint32_t m_num_buckets_minus_one; + lldb::addr_t m_buckets_ptr; + lldb_private::Process *m_process; + const_iterator m_end_iterator; + lldb::addr_t m_load_addr; + size_t m_map_pair_size; + lldb::addr_t m_invalid_key; +}; + +AppleObjCRuntimeV2::HashTableSignature::HashTableSignature() + : m_count(0), m_num_buckets(0), m_buckets_ptr(0) {} + +void AppleObjCRuntimeV2::HashTableSignature::UpdateSignature( + const RemoteNXMapTable &hash_table) { + m_count = hash_table.GetCount(); + m_num_buckets = hash_table.GetBucketCount(); + m_buckets_ptr = hash_table.GetBucketDataPointer(); +} + +bool AppleObjCRuntimeV2::HashTableSignature::NeedsUpdate( + Process *process, AppleObjCRuntimeV2 *runtime, + RemoteNXMapTable &hash_table) { + if (!hash_table.ParseHeader(process, runtime->GetISAHashTablePointer())) { + return false; // Failed to parse the header, no need to update anything + } + + // Check with out current signature and return true if the count, number of + // buckets or the hash table address changes. + if (m_count == hash_table.GetCount() && + m_num_buckets == hash_table.GetBucketCount() && + m_buckets_ptr == hash_table.GetBucketDataPointer()) { + // Hash table hasn't changed + return false; + } + // Hash table data has changed, we need to update + return true; +} + +ObjCLanguageRuntime::ClassDescriptorSP +AppleObjCRuntimeV2::GetClassDescriptorFromISA(ObjCISA isa) { + ObjCLanguageRuntime::ClassDescriptorSP class_descriptor_sp; + if (m_non_pointer_isa_cache_up) + class_descriptor_sp = m_non_pointer_isa_cache_up->GetClassDescriptor(isa); + if (!class_descriptor_sp) + class_descriptor_sp = ObjCLanguageRuntime::GetClassDescriptorFromISA(isa); + return class_descriptor_sp; +} + +ObjCLanguageRuntime::ClassDescriptorSP +AppleObjCRuntimeV2::GetClassDescriptor(ValueObject &valobj) { + ClassDescriptorSP objc_class_sp; + if (valobj.IsBaseClass()) { + ValueObject *parent = valobj.GetParent(); + // if I am my own parent, bail out of here fast.. + if (parent && parent != &valobj) { + ClassDescriptorSP parent_descriptor_sp = GetClassDescriptor(*parent); + if (parent_descriptor_sp) + return parent_descriptor_sp->GetSuperclass(); + } + return nullptr; + } + // if we get an invalid VO (which might still happen when playing around with + // pointers returned by the expression parser, don't consider this a valid + // ObjC object) + if (valobj.GetCompilerType().IsValid()) { + addr_t isa_pointer = valobj.GetPointerValue(); + + // tagged pointer + if (IsTaggedPointer(isa_pointer)) { + return m_tagged_pointer_vendor_up->GetClassDescriptor(isa_pointer); + } else { + ExecutionContext exe_ctx(valobj.GetExecutionContextRef()); + + Process *process = exe_ctx.GetProcessPtr(); + if (process) { + Status error; + ObjCISA isa = process->ReadPointerFromMemory(isa_pointer, error); + if (isa != LLDB_INVALID_ADDRESS) { + objc_class_sp = GetClassDescriptorFromISA(isa); + if (isa && !objc_class_sp) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); + LLDB_LOGF(log, + "0x%" PRIx64 + ": AppleObjCRuntimeV2::GetClassDescriptor() ISA was " + "not in class descriptor cache 0x%" PRIx64, + isa_pointer, isa); + } + } + } + } + } + return objc_class_sp; +} + +lldb::addr_t AppleObjCRuntimeV2::GetTaggedPointerObfuscator() { + if (m_tagged_pointer_obfuscator != LLDB_INVALID_ADDRESS) + return m_tagged_pointer_obfuscator; + + + Process *process = GetProcess(); + ModuleSP objc_module_sp(GetObjCModule()); + + if (!objc_module_sp) + return LLDB_INVALID_ADDRESS; + + static ConstString g_gdb_objc_obfuscator("objc_debug_taggedpointer_obfuscator"); + + const Symbol *symbol = objc_module_sp->FindFirstSymbolWithNameAndType( + g_gdb_objc_obfuscator, lldb::eSymbolTypeAny); + if (symbol) { + lldb::addr_t g_gdb_obj_obfuscator_ptr = + symbol->GetLoadAddress(&process->GetTarget()); + + if (g_gdb_obj_obfuscator_ptr != LLDB_INVALID_ADDRESS) { + Status error; + m_tagged_pointer_obfuscator = process->ReadPointerFromMemory( + g_gdb_obj_obfuscator_ptr, error); + } + } + // If we don't have a correct value at this point, there must be no obfuscation. + if (m_tagged_pointer_obfuscator == LLDB_INVALID_ADDRESS) + m_tagged_pointer_obfuscator = 0; + + return m_tagged_pointer_obfuscator; +} + +lldb::addr_t AppleObjCRuntimeV2::GetISAHashTablePointer() { + if (m_isa_hash_table_ptr == LLDB_INVALID_ADDRESS) { + Process *process = GetProcess(); + + ModuleSP objc_module_sp(GetObjCModule()); + + if (!objc_module_sp) + return LLDB_INVALID_ADDRESS; + + static ConstString g_gdb_objc_realized_classes("gdb_objc_realized_classes"); + + const Symbol *symbol = objc_module_sp->FindFirstSymbolWithNameAndType( + g_gdb_objc_realized_classes, lldb::eSymbolTypeAny); + if (symbol) { + lldb::addr_t gdb_objc_realized_classes_ptr = + symbol->GetLoadAddress(&process->GetTarget()); + + if (gdb_objc_realized_classes_ptr != LLDB_INVALID_ADDRESS) { + Status error; + m_isa_hash_table_ptr = process->ReadPointerFromMemory( + gdb_objc_realized_classes_ptr, error); + } + } + } + return m_isa_hash_table_ptr; +} + +AppleObjCRuntimeV2::DescriptorMapUpdateResult +AppleObjCRuntimeV2::UpdateISAToDescriptorMapDynamic( + RemoteNXMapTable &hash_table) { + Process *process = GetProcess(); + + if (process == nullptr) + return DescriptorMapUpdateResult::Fail(); + + uint32_t num_class_infos = 0; + + Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_TYPES)); + + ExecutionContext exe_ctx; + + ThreadSP thread_sp = process->GetThreadList().GetExpressionExecutionThread(); + + if (!thread_sp) + return DescriptorMapUpdateResult::Fail(); + + thread_sp->CalculateExecutionContext(exe_ctx); + ClangASTContext *ast = process->GetTarget().GetScratchClangASTContext(); + + if (!ast) + return DescriptorMapUpdateResult::Fail(); + + Address function_address; + + DiagnosticManager diagnostics; + + const uint32_t addr_size = process->GetAddressByteSize(); + + Status err; + + // Read the total number of classes from the hash table + const uint32_t num_classes = hash_table.GetCount(); + if (num_classes == 0) { + LLDB_LOGF(log, "No dynamic classes found in gdb_objc_realized_classes."); + return DescriptorMapUpdateResult::Success(0); + } + + // Make some types for our arguments + CompilerType clang_uint32_t_type = + ast->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 32); + CompilerType clang_void_pointer_type = + ast->GetBasicType(eBasicTypeVoid).GetPointerType(); + + ValueList arguments; + FunctionCaller *get_class_info_function = nullptr; + + if (!m_get_class_info_code) { + Status error; + m_get_class_info_code.reset(GetTargetRef().GetUtilityFunctionForLanguage( + g_get_dynamic_class_info_body, eLanguageTypeObjC, + g_get_dynamic_class_info_name, error)); + if (error.Fail()) { + LLDB_LOGF(log, + "Failed to get Utility Function for implementation lookup: %s", + error.AsCString()); + m_get_class_info_code.reset(); + } else { + diagnostics.Clear(); + + if (!m_get_class_info_code->Install(diagnostics, exe_ctx)) { + if (log) { + LLDB_LOGF(log, "Failed to install implementation lookup"); + diagnostics.Dump(log); + } + m_get_class_info_code.reset(); + } + } + if (!m_get_class_info_code) + return DescriptorMapUpdateResult::Fail(); + + // Next make the runner function for our implementation utility function. + Value value; + value.SetValueType(Value::eValueTypeScalar); + value.SetCompilerType(clang_void_pointer_type); + arguments.PushValue(value); + arguments.PushValue(value); + + value.SetValueType(Value::eValueTypeScalar); + value.SetCompilerType(clang_uint32_t_type); + arguments.PushValue(value); + arguments.PushValue(value); + + get_class_info_function = m_get_class_info_code->MakeFunctionCaller( + clang_uint32_t_type, arguments, thread_sp, error); + + if (error.Fail()) { + LLDB_LOGF(log, + "Failed to make function caller for implementation lookup: %s.", + error.AsCString()); + return DescriptorMapUpdateResult::Fail(); + } + } else { + get_class_info_function = m_get_class_info_code->GetFunctionCaller(); + if (!get_class_info_function) { + if (log) { + LLDB_LOGF(log, "Failed to get implementation lookup function caller."); + diagnostics.Dump(log); + } + + return DescriptorMapUpdateResult::Fail(); + } + arguments = get_class_info_function->GetArgumentValues(); + } + + diagnostics.Clear(); + + const uint32_t class_info_byte_size = addr_size + 4; + const uint32_t class_infos_byte_size = num_classes * class_info_byte_size; + lldb::addr_t class_infos_addr = process->AllocateMemory( + class_infos_byte_size, ePermissionsReadable | ePermissionsWritable, err); + + if (class_infos_addr == LLDB_INVALID_ADDRESS) { + LLDB_LOGF(log, + "unable to allocate %" PRIu32 + " bytes in process for shared cache read", + class_infos_byte_size); + return DescriptorMapUpdateResult::Fail(); + } + + std::lock_guard<std::mutex> guard(m_get_class_info_args_mutex); + + // Fill in our function argument values + arguments.GetValueAtIndex(0)->GetScalar() = hash_table.GetTableLoadAddress(); + arguments.GetValueAtIndex(1)->GetScalar() = class_infos_addr; + arguments.GetValueAtIndex(2)->GetScalar() = class_infos_byte_size; + + // Only dump the runtime classes from the expression evaluation if the log is + // verbose: + Log *type_log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES); + bool dump_log = type_log && type_log->GetVerbose(); + + arguments.GetValueAtIndex(3)->GetScalar() = dump_log ? 1 : 0; + + bool success = false; + + diagnostics.Clear(); + + // Write our function arguments into the process so we can run our function + if (get_class_info_function->WriteFunctionArguments( + exe_ctx, m_get_class_info_args, arguments, diagnostics)) { + EvaluateExpressionOptions options; + options.SetUnwindOnError(true); + options.SetTryAllThreads(false); + options.SetStopOthers(true); + options.SetIgnoreBreakpoints(true); + options.SetTimeout(process->GetUtilityExpressionTimeout()); + options.SetIsForUtilityExpr(true); + + Value return_value; + return_value.SetValueType(Value::eValueTypeScalar); + // return_value.SetContext (Value::eContextTypeClangType, + // clang_uint32_t_type); + return_value.SetCompilerType(clang_uint32_t_type); + return_value.GetScalar() = 0; + + diagnostics.Clear(); + + // Run the function + ExpressionResults results = get_class_info_function->ExecuteFunction( + exe_ctx, &m_get_class_info_args, options, diagnostics, return_value); + + if (results == eExpressionCompleted) { + // The result is the number of ClassInfo structures that were filled in + num_class_infos = return_value.GetScalar().ULong(); + LLDB_LOGF(log, "Discovered %u ObjC classes\n", num_class_infos); + if (num_class_infos > 0) { + // Read the ClassInfo structures + DataBufferHeap buffer(num_class_infos * class_info_byte_size, 0); + if (process->ReadMemory(class_infos_addr, buffer.GetBytes(), + buffer.GetByteSize(), + err) == buffer.GetByteSize()) { + DataExtractor class_infos_data(buffer.GetBytes(), + buffer.GetByteSize(), + process->GetByteOrder(), addr_size); + ParseClassInfoArray(class_infos_data, num_class_infos); + } + } + success = true; + } else { + if (log) { + LLDB_LOGF(log, "Error evaluating our find class name function."); + diagnostics.Dump(log); + } + } + } else { + if (log) { + LLDB_LOGF(log, "Error writing function arguments."); + diagnostics.Dump(log); + } + } + + // Deallocate the memory we allocated for the ClassInfo array + process->DeallocateMemory(class_infos_addr); + + return DescriptorMapUpdateResult(success, num_class_infos); +} + +uint32_t AppleObjCRuntimeV2::ParseClassInfoArray(const DataExtractor &data, + uint32_t num_class_infos) { + // Parses an array of "num_class_infos" packed ClassInfo structures: + // + // struct ClassInfo + // { + // Class isa; + // uint32_t hash; + // } __attribute__((__packed__)); + + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES)); + bool should_log = log && log->GetVerbose(); + + uint32_t num_parsed = 0; + + // Iterate through all ClassInfo structures + lldb::offset_t offset = 0; + for (uint32_t i = 0; i < num_class_infos; ++i) { + ObjCISA isa = data.GetPointer(&offset); + + if (isa == 0) { + if (should_log) + LLDB_LOGF( + log, "AppleObjCRuntimeV2 found NULL isa, ignoring this class info"); + continue; + } + // Check if we already know about this ISA, if we do, the info will never + // change, so we can just skip it. + if (ISAIsCached(isa)) { + if (should_log) + LLDB_LOGF(log, + "AppleObjCRuntimeV2 found cached isa=0x%" PRIx64 + ", ignoring this class info", + isa); + offset += 4; + } else { + // Read the 32 bit hash for the class name + const uint32_t name_hash = data.GetU32(&offset); + ClassDescriptorSP descriptor_sp( + new ClassDescriptorV2(*this, isa, nullptr)); + + // The code in g_get_shared_cache_class_info_body sets the value of the hash + // to 0 to signal a demangled symbol. We use class_getName() in that code to + // find the class name, but this returns a demangled name for Swift symbols. + // For those symbols, recompute the hash here by reading their name from the + // runtime. + if (name_hash) + AddClass(isa, descriptor_sp, name_hash); + else + AddClass(isa, descriptor_sp, descriptor_sp->GetClassName().AsCString(nullptr)); + num_parsed++; + if (should_log) + LLDB_LOGF(log, + "AppleObjCRuntimeV2 added isa=0x%" PRIx64 + ", hash=0x%8.8x, name=%s", + isa, name_hash, + descriptor_sp->GetClassName().AsCString("<unknown>")); + } + } + if (should_log) + LLDB_LOGF(log, "AppleObjCRuntimeV2 parsed %" PRIu32 " class infos", + num_parsed); + return num_parsed; +} + +AppleObjCRuntimeV2::DescriptorMapUpdateResult +AppleObjCRuntimeV2::UpdateISAToDescriptorMapSharedCache() { + Process *process = GetProcess(); + + if (process == nullptr) + return DescriptorMapUpdateResult::Fail(); + + Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_TYPES)); + + ExecutionContext exe_ctx; + + ThreadSP thread_sp = process->GetThreadList().GetExpressionExecutionThread(); + + if (!thread_sp) + return DescriptorMapUpdateResult::Fail(); + + thread_sp->CalculateExecutionContext(exe_ctx); + ClangASTContext *ast = process->GetTarget().GetScratchClangASTContext(); + + if (!ast) + return DescriptorMapUpdateResult::Fail(); + + Address function_address; + + DiagnosticManager diagnostics; + + const uint32_t addr_size = process->GetAddressByteSize(); + + Status err; + + uint32_t num_class_infos = 0; + + const lldb::addr_t objc_opt_ptr = GetSharedCacheReadOnlyAddress(); + + if (objc_opt_ptr == LLDB_INVALID_ADDRESS) + return DescriptorMapUpdateResult::Fail(); + + const uint32_t num_classes = 128 * 1024; + + // Make some types for our arguments + CompilerType clang_uint32_t_type = + ast->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 32); + CompilerType clang_void_pointer_type = + ast->GetBasicType(eBasicTypeVoid).GetPointerType(); + + ValueList arguments; + FunctionCaller *get_shared_cache_class_info_function = nullptr; + + if (!m_get_shared_cache_class_info_code) { + Status error; + + // If the inferior objc.dylib has the class_getNameRaw function, + // use that in our jitted expression. Else fall back to the old + // class_getName. + static ConstString g_class_getName_symbol_name("class_getName"); + static ConstString g_class_getNameRaw_symbol_name("objc_debug_class_getNameRaw"); + ConstString class_name_getter_function_name = g_class_getName_symbol_name; + + ObjCLanguageRuntime *objc_runtime = ObjCLanguageRuntime::Get(*process); + if (objc_runtime) { + const ModuleList &images = process->GetTarget().GetImages(); + std::lock_guard<std::recursive_mutex> guard(images.GetMutex()); + for (size_t i = 0; i < images.GetSize(); ++i) { + lldb::ModuleSP mod_sp = images.GetModuleAtIndexUnlocked(i); + if (objc_runtime->IsModuleObjCLibrary(mod_sp)) { + const Symbol *symbol = + mod_sp->FindFirstSymbolWithNameAndType(g_class_getNameRaw_symbol_name, + lldb::eSymbolTypeCode); + if (symbol && + (symbol->ValueIsAddress() || symbol->GetAddressRef().IsValid())) { + class_name_getter_function_name = g_class_getNameRaw_symbol_name; + } + } + } + } + + // Substitute in the correct class_getName / class_getNameRaw function name, + // concatenate the two parts of our expression text. The format string + // has two %s's, so provide the name twice. + int prefix_string_size = snprintf (nullptr, 0, + g_shared_cache_class_name_funcptr, + class_name_getter_function_name.AsCString(), + class_name_getter_function_name.AsCString()); + + char *class_name_func_ptr_expr = (char*) malloc (prefix_string_size + 1); + snprintf (class_name_func_ptr_expr, prefix_string_size + 1, + g_shared_cache_class_name_funcptr, + class_name_getter_function_name.AsCString(), + class_name_getter_function_name.AsCString()); + std::string shared_class_expression = class_name_func_ptr_expr; + shared_class_expression += g_get_shared_cache_class_info_body; + free (class_name_func_ptr_expr); + + m_get_shared_cache_class_info_code.reset( + GetTargetRef().GetUtilityFunctionForLanguage( + shared_class_expression.c_str(), eLanguageTypeObjC, + g_get_shared_cache_class_info_name, error)); + if (error.Fail()) { + LLDB_LOGF(log, + "Failed to get Utility function for implementation lookup: %s.", + error.AsCString()); + m_get_shared_cache_class_info_code.reset(); + } else { + diagnostics.Clear(); + + if (!m_get_shared_cache_class_info_code->Install(diagnostics, exe_ctx)) { + if (log) { + LLDB_LOGF(log, "Failed to install implementation lookup."); + diagnostics.Dump(log); + } + m_get_shared_cache_class_info_code.reset(); + } + } + + if (!m_get_shared_cache_class_info_code) + return DescriptorMapUpdateResult::Fail(); + + // Next make the function caller for our implementation utility function. + Value value; + value.SetValueType(Value::eValueTypeScalar); + // value.SetContext (Value::eContextTypeClangType, clang_void_pointer_type); + value.SetCompilerType(clang_void_pointer_type); + arguments.PushValue(value); + arguments.PushValue(value); + + value.SetValueType(Value::eValueTypeScalar); + // value.SetContext (Value::eContextTypeClangType, clang_uint32_t_type); + value.SetCompilerType(clang_uint32_t_type); + arguments.PushValue(value); + arguments.PushValue(value); + + get_shared_cache_class_info_function = + m_get_shared_cache_class_info_code->MakeFunctionCaller( + clang_uint32_t_type, arguments, thread_sp, error); + + if (get_shared_cache_class_info_function == nullptr) + return DescriptorMapUpdateResult::Fail(); + + } else { + get_shared_cache_class_info_function = + m_get_shared_cache_class_info_code->GetFunctionCaller(); + if (get_shared_cache_class_info_function == nullptr) + return DescriptorMapUpdateResult::Fail(); + arguments = get_shared_cache_class_info_function->GetArgumentValues(); + } + + diagnostics.Clear(); + + const uint32_t class_info_byte_size = addr_size + 4; + const uint32_t class_infos_byte_size = num_classes * class_info_byte_size; + lldb::addr_t class_infos_addr = process->AllocateMemory( + class_infos_byte_size, ePermissionsReadable | ePermissionsWritable, err); + + if (class_infos_addr == LLDB_INVALID_ADDRESS) { + LLDB_LOGF(log, + "unable to allocate %" PRIu32 + " bytes in process for shared cache read", + class_infos_byte_size); + return DescriptorMapUpdateResult::Fail(); + } + + std::lock_guard<std::mutex> guard(m_get_shared_cache_class_info_args_mutex); + + // Fill in our function argument values + arguments.GetValueAtIndex(0)->GetScalar() = objc_opt_ptr; + arguments.GetValueAtIndex(1)->GetScalar() = class_infos_addr; + arguments.GetValueAtIndex(2)->GetScalar() = class_infos_byte_size; + // Only dump the runtime classes from the expression evaluation if the log is + // verbose: + Log *type_log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES); + bool dump_log = type_log && type_log->GetVerbose(); + + arguments.GetValueAtIndex(3)->GetScalar() = dump_log ? 1 : 0; + + bool success = false; + + diagnostics.Clear(); + + // Write our function arguments into the process so we can run our function + if (get_shared_cache_class_info_function->WriteFunctionArguments( + exe_ctx, m_get_shared_cache_class_info_args, arguments, + diagnostics)) { + EvaluateExpressionOptions options; + options.SetUnwindOnError(true); + options.SetTryAllThreads(false); + options.SetStopOthers(true); + options.SetIgnoreBreakpoints(true); + options.SetTimeout(process->GetUtilityExpressionTimeout()); + options.SetIsForUtilityExpr(true); + + Value return_value; + return_value.SetValueType(Value::eValueTypeScalar); + // return_value.SetContext (Value::eContextTypeClangType, + // clang_uint32_t_type); + return_value.SetCompilerType(clang_uint32_t_type); + return_value.GetScalar() = 0; + + diagnostics.Clear(); + + // Run the function + ExpressionResults results = + get_shared_cache_class_info_function->ExecuteFunction( + exe_ctx, &m_get_shared_cache_class_info_args, options, diagnostics, + return_value); + + if (results == eExpressionCompleted) { + // The result is the number of ClassInfo structures that were filled in + num_class_infos = return_value.GetScalar().ULong(); + LLDB_LOGF(log, "Discovered %u ObjC classes in shared cache\n", + num_class_infos); + assert(num_class_infos <= num_classes); + if (num_class_infos > 0) { + if (num_class_infos > num_classes) { + num_class_infos = num_classes; + + success = false; + } else { + success = true; + } + + // Read the ClassInfo structures + DataBufferHeap buffer(num_class_infos * class_info_byte_size, 0); + if (process->ReadMemory(class_infos_addr, buffer.GetBytes(), + buffer.GetByteSize(), + err) == buffer.GetByteSize()) { + DataExtractor class_infos_data(buffer.GetBytes(), + buffer.GetByteSize(), + process->GetByteOrder(), addr_size); + + ParseClassInfoArray(class_infos_data, num_class_infos); + } + } else { + success = true; + } + } else { + if (log) { + LLDB_LOGF(log, "Error evaluating our find class name function."); + diagnostics.Dump(log); + } + } + } else { + if (log) { + LLDB_LOGF(log, "Error writing function arguments."); + diagnostics.Dump(log); + } + } + + // Deallocate the memory we allocated for the ClassInfo array + process->DeallocateMemory(class_infos_addr); + + return DescriptorMapUpdateResult(success, num_class_infos); +} + +bool AppleObjCRuntimeV2::UpdateISAToDescriptorMapFromMemory( + RemoteNXMapTable &hash_table) { + Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_TYPES)); + + Process *process = GetProcess(); + + if (process == nullptr) + return false; + + uint32_t num_map_table_isas = 0; + + ModuleSP objc_module_sp(GetObjCModule()); + + if (objc_module_sp) { + for (RemoteNXMapTable::element elt : hash_table) { + ++num_map_table_isas; + + if (ISAIsCached(elt.second)) + continue; + + ClassDescriptorSP descriptor_sp = ClassDescriptorSP( + new ClassDescriptorV2(*this, elt.second, elt.first.AsCString())); + + if (log && log->GetVerbose()) + LLDB_LOGF(log, + "AppleObjCRuntimeV2 added (ObjCISA)0x%" PRIx64 + " (%s) from dynamic table to isa->descriptor cache", + elt.second, elt.first.AsCString()); + + AddClass(elt.second, descriptor_sp, elt.first.AsCString()); + } + } + + return num_map_table_isas > 0; +} + +lldb::addr_t AppleObjCRuntimeV2::GetSharedCacheReadOnlyAddress() { + Process *process = GetProcess(); + + if (process) { + ModuleSP objc_module_sp(GetObjCModule()); + + if (objc_module_sp) { + ObjectFile *objc_object = objc_module_sp->GetObjectFile(); + + if (objc_object) { + SectionList *section_list = objc_module_sp->GetSectionList(); + + if (section_list) { + SectionSP text_segment_sp( + section_list->FindSectionByName(ConstString("__TEXT"))); + + if (text_segment_sp) { + SectionSP objc_opt_section_sp( + text_segment_sp->GetChildren().FindSectionByName( + ConstString("__objc_opt_ro"))); + + if (objc_opt_section_sp) { + return objc_opt_section_sp->GetLoadBaseAddress( + &process->GetTarget()); + } + } + } + } + } + } + return LLDB_INVALID_ADDRESS; +} + +void AppleObjCRuntimeV2::UpdateISAToDescriptorMapIfNeeded() { + Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_TYPES)); + + static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); + Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION); + + // Else we need to check with our process to see when the map was updated. + Process *process = GetProcess(); + + if (process) { + RemoteNXMapTable hash_table; + + // Update the process stop ID that indicates the last time we updated the + // map, whether it was successful or not. + m_isa_to_descriptor_stop_id = process->GetStopID(); + + if (!m_hash_signature.NeedsUpdate(process, this, hash_table)) + return; + + m_hash_signature.UpdateSignature(hash_table); + + // Grab the dynamically loaded objc classes from the hash table in memory + DescriptorMapUpdateResult dynamic_update_result = + UpdateISAToDescriptorMapDynamic(hash_table); + + // Now get the objc classes that are baked into the Objective-C runtime in + // the shared cache, but only once per process as this data never changes + if (!m_loaded_objc_opt) { + // it is legitimately possible for the shared cache to be empty - in that + // case, the dynamic hash table will contain all the class information we + // need; the situation we're trying to detect is one where we aren't + // seeing class information from the runtime - in order to detect that + // vs. just the shared cache being empty or sparsely populated, we set an + // arbitrary (very low) threshold for the number of classes that we want + // to see in a "good" scenario - anything below that is suspicious + // (Foundation alone has thousands of classes) + const uint32_t num_classes_to_warn_at = 500; + + DescriptorMapUpdateResult shared_cache_update_result = + UpdateISAToDescriptorMapSharedCache(); + + LLDB_LOGF(log, + "attempted to read objc class data - results: " + "[dynamic_update]: ran: %s, count: %" PRIu32 + " [shared_cache_update]: ran: %s, count: %" PRIu32, + dynamic_update_result.m_update_ran ? "yes" : "no", + dynamic_update_result.m_num_found, + shared_cache_update_result.m_update_ran ? "yes" : "no", + shared_cache_update_result.m_num_found); + + // warn if: + // - we could not run either expression + // - we found fewer than num_classes_to_warn_at classes total + if ((!shared_cache_update_result.m_update_ran) || + (!dynamic_update_result.m_update_ran)) + WarnIfNoClassesCached( + SharedCacheWarningReason::eExpressionExecutionFailure); + else if (dynamic_update_result.m_num_found + + shared_cache_update_result.m_num_found < + num_classes_to_warn_at) + WarnIfNoClassesCached(SharedCacheWarningReason::eNotEnoughClassesRead); + else + m_loaded_objc_opt = true; + } + } else { + m_isa_to_descriptor_stop_id = UINT32_MAX; + } +} + +static bool DoesProcessHaveSharedCache(Process &process) { + PlatformSP platform_sp = process.GetTarget().GetPlatform(); + if (!platform_sp) + return true; // this should not happen + + ConstString platform_plugin_name = platform_sp->GetPluginName(); + if (platform_plugin_name) { + llvm::StringRef platform_plugin_name_sr = + platform_plugin_name.GetStringRef(); + if (platform_plugin_name_sr.endswith("-simulator")) + return false; + } + + return true; +} + +void AppleObjCRuntimeV2::WarnIfNoClassesCached( + SharedCacheWarningReason reason) { + if (m_noclasses_warning_emitted) + return; + + if (GetProcess() && !DoesProcessHaveSharedCache(*GetProcess())) { + // Simulators do not have the objc_opt_ro class table so don't actually + // complain to the user + m_noclasses_warning_emitted = true; + return; + } + + Debugger &debugger(GetProcess()->GetTarget().GetDebugger()); + if (auto stream = debugger.GetAsyncOutputStream()) { + switch (reason) { + case SharedCacheWarningReason::eNotEnoughClassesRead: + stream->PutCString("warning: could not find Objective-C class data in " + "the process. This may reduce the quality of type " + "information available.\n"); + m_noclasses_warning_emitted = true; + break; + case SharedCacheWarningReason::eExpressionExecutionFailure: + stream->PutCString("warning: could not execute support code to read " + "Objective-C class data in the process. This may " + "reduce the quality of type information available.\n"); + m_noclasses_warning_emitted = true; + break; + } + } +} + +ConstString +AppleObjCRuntimeV2::GetActualTypeName(ObjCLanguageRuntime::ObjCISA isa) { + if (isa == g_objc_Tagged_ISA) { + static const ConstString g_objc_tagged_isa_name("_lldb_Tagged_ObjC_ISA"); + return g_objc_tagged_isa_name; + } + if (isa == g_objc_Tagged_ISA_NSAtom) { + static const ConstString g_objc_tagged_isa_nsatom_name("NSAtom"); + return g_objc_tagged_isa_nsatom_name; + } + if (isa == g_objc_Tagged_ISA_NSNumber) { + static const ConstString g_objc_tagged_isa_nsnumber_name("NSNumber"); + return g_objc_tagged_isa_nsnumber_name; + } + if (isa == g_objc_Tagged_ISA_NSDateTS) { + static const ConstString g_objc_tagged_isa_nsdatets_name("NSDateTS"); + return g_objc_tagged_isa_nsdatets_name; + } + if (isa == g_objc_Tagged_ISA_NSManagedObject) { + static const ConstString g_objc_tagged_isa_nsmanagedobject_name( + "NSManagedObject"); + return g_objc_tagged_isa_nsmanagedobject_name; + } + if (isa == g_objc_Tagged_ISA_NSDate) { + static const ConstString g_objc_tagged_isa_nsdate_name("NSDate"); + return g_objc_tagged_isa_nsdate_name; + } + return ObjCLanguageRuntime::GetActualTypeName(isa); +} + +DeclVendor *AppleObjCRuntimeV2::GetDeclVendor() { + if (!m_decl_vendor_up) + m_decl_vendor_up.reset(new AppleObjCDeclVendor(*this)); + + return m_decl_vendor_up.get(); +} + +lldb::addr_t AppleObjCRuntimeV2::LookupRuntimeSymbol(ConstString name) { + lldb::addr_t ret = LLDB_INVALID_ADDRESS; + + const char *name_cstr = name.AsCString(); + + if (name_cstr) { + llvm::StringRef name_strref(name_cstr); + + llvm::StringRef ivar_prefix("OBJC_IVAR_$_"); + llvm::StringRef class_prefix("OBJC_CLASS_$_"); + + if (name_strref.startswith(ivar_prefix)) { + llvm::StringRef ivar_skipped_prefix = + name_strref.substr(ivar_prefix.size()); + std::pair<llvm::StringRef, llvm::StringRef> class_and_ivar = + ivar_skipped_prefix.split('.'); + + if (class_and_ivar.first.size() && class_and_ivar.second.size()) { + const ConstString class_name_cs(class_and_ivar.first); + ClassDescriptorSP descriptor = + ObjCLanguageRuntime::GetClassDescriptorFromClassName(class_name_cs); + + if (descriptor) { + const ConstString ivar_name_cs(class_and_ivar.second); + const char *ivar_name_cstr = ivar_name_cs.AsCString(); + + auto ivar_func = [&ret, ivar_name_cstr]( + const char *name, const char *type, lldb::addr_t offset_addr, + uint64_t size) -> lldb::addr_t { + if (!strcmp(name, ivar_name_cstr)) { + ret = offset_addr; + return true; + } + return false; + }; + + descriptor->Describe( + std::function<void(ObjCISA)>(nullptr), + std::function<bool(const char *, const char *)>(nullptr), + std::function<bool(const char *, const char *)>(nullptr), + ivar_func); + } + } + } else if (name_strref.startswith(class_prefix)) { + llvm::StringRef class_skipped_prefix = + name_strref.substr(class_prefix.size()); + const ConstString class_name_cs(class_skipped_prefix); + ClassDescriptorSP descriptor = + GetClassDescriptorFromClassName(class_name_cs); + + if (descriptor) + ret = descriptor->GetISA(); + } + } + + return ret; +} + +AppleObjCRuntimeV2::NonPointerISACache * +AppleObjCRuntimeV2::NonPointerISACache::CreateInstance( + AppleObjCRuntimeV2 &runtime, const lldb::ModuleSP &objc_module_sp) { + Process *process(runtime.GetProcess()); + + Status error; + + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES)); + + auto objc_debug_isa_magic_mask = ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_isa_magic_mask"), objc_module_sp, error); + if (error.Fail()) + return nullptr; + + auto objc_debug_isa_magic_value = ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_isa_magic_value"), objc_module_sp, + error); + if (error.Fail()) + return nullptr; + + auto objc_debug_isa_class_mask = ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_isa_class_mask"), objc_module_sp, error); + if (error.Fail()) + return nullptr; + + if (log) + log->PutCString("AOCRT::NPI: Found all the non-indexed ISA masks"); + + bool foundError = false; + auto objc_debug_indexed_isa_magic_mask = ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_indexed_isa_magic_mask"), objc_module_sp, + error); + foundError |= error.Fail(); + + auto objc_debug_indexed_isa_magic_value = ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_indexed_isa_magic_value"), + objc_module_sp, error); + foundError |= error.Fail(); + + auto objc_debug_indexed_isa_index_mask = ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_indexed_isa_index_mask"), objc_module_sp, + error); + foundError |= error.Fail(); + + auto objc_debug_indexed_isa_index_shift = ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_indexed_isa_index_shift"), + objc_module_sp, error); + foundError |= error.Fail(); + + auto objc_indexed_classes = + ExtractRuntimeGlobalSymbol(process, ConstString("objc_indexed_classes"), + objc_module_sp, error, false); + foundError |= error.Fail(); + + if (log) + log->PutCString("AOCRT::NPI: Found all the indexed ISA masks"); + + // we might want to have some rules to outlaw these other values (e.g if the + // mask is zero but the value is non-zero, ...) + + return new NonPointerISACache( + runtime, objc_module_sp, objc_debug_isa_class_mask, + objc_debug_isa_magic_mask, objc_debug_isa_magic_value, + objc_debug_indexed_isa_magic_mask, objc_debug_indexed_isa_magic_value, + objc_debug_indexed_isa_index_mask, objc_debug_indexed_isa_index_shift, + foundError ? 0 : objc_indexed_classes); +} + +AppleObjCRuntimeV2::TaggedPointerVendorV2 * +AppleObjCRuntimeV2::TaggedPointerVendorV2::CreateInstance( + AppleObjCRuntimeV2 &runtime, const lldb::ModuleSP &objc_module_sp) { + Process *process(runtime.GetProcess()); + + Status error; + + auto objc_debug_taggedpointer_mask = ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_taggedpointer_mask"), objc_module_sp, + error); + if (error.Fail()) + return new TaggedPointerVendorLegacy(runtime); + + auto objc_debug_taggedpointer_slot_shift = ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_taggedpointer_slot_shift"), + objc_module_sp, error, true, 4); + if (error.Fail()) + return new TaggedPointerVendorLegacy(runtime); + + auto objc_debug_taggedpointer_slot_mask = ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_taggedpointer_slot_mask"), + objc_module_sp, error, true, 4); + if (error.Fail()) + return new TaggedPointerVendorLegacy(runtime); + + auto objc_debug_taggedpointer_payload_lshift = ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_taggedpointer_payload_lshift"), + objc_module_sp, error, true, 4); + if (error.Fail()) + return new TaggedPointerVendorLegacy(runtime); + + auto objc_debug_taggedpointer_payload_rshift = ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_taggedpointer_payload_rshift"), + objc_module_sp, error, true, 4); + if (error.Fail()) + return new TaggedPointerVendorLegacy(runtime); + + auto objc_debug_taggedpointer_classes = ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_taggedpointer_classes"), objc_module_sp, + error, false); + if (error.Fail()) + return new TaggedPointerVendorLegacy(runtime); + + // try to detect the "extended tagged pointer" variables - if any are + // missing, use the non-extended vendor + do { + auto objc_debug_taggedpointer_ext_mask = ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_taggedpointer_ext_mask"), + objc_module_sp, error); + if (error.Fail()) + break; + + auto objc_debug_taggedpointer_ext_slot_shift = ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_taggedpointer_ext_slot_shift"), + objc_module_sp, error, true, 4); + if (error.Fail()) + break; + + auto objc_debug_taggedpointer_ext_slot_mask = ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_taggedpointer_ext_slot_mask"), + objc_module_sp, error, true, 4); + if (error.Fail()) + break; + + auto objc_debug_taggedpointer_ext_classes = ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_taggedpointer_ext_classes"), + objc_module_sp, error, false); + if (error.Fail()) + break; + + auto objc_debug_taggedpointer_ext_payload_lshift = + ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_taggedpointer_ext_payload_lshift"), + objc_module_sp, error, true, 4); + if (error.Fail()) + break; + + auto objc_debug_taggedpointer_ext_payload_rshift = + ExtractRuntimeGlobalSymbol( + process, ConstString("objc_debug_taggedpointer_ext_payload_rshift"), + objc_module_sp, error, true, 4); + if (error.Fail()) + break; + + return new TaggedPointerVendorExtended( + runtime, objc_debug_taggedpointer_mask, + objc_debug_taggedpointer_ext_mask, objc_debug_taggedpointer_slot_shift, + objc_debug_taggedpointer_ext_slot_shift, + objc_debug_taggedpointer_slot_mask, + objc_debug_taggedpointer_ext_slot_mask, + objc_debug_taggedpointer_payload_lshift, + objc_debug_taggedpointer_payload_rshift, + objc_debug_taggedpointer_ext_payload_lshift, + objc_debug_taggedpointer_ext_payload_rshift, + objc_debug_taggedpointer_classes, objc_debug_taggedpointer_ext_classes); + } while (false); + + // we might want to have some rules to outlaw these values (e.g if the + // table's address is zero) + + return new TaggedPointerVendorRuntimeAssisted( + runtime, objc_debug_taggedpointer_mask, + objc_debug_taggedpointer_slot_shift, objc_debug_taggedpointer_slot_mask, + objc_debug_taggedpointer_payload_lshift, + objc_debug_taggedpointer_payload_rshift, + objc_debug_taggedpointer_classes); +} + +bool AppleObjCRuntimeV2::TaggedPointerVendorLegacy::IsPossibleTaggedPointer( + lldb::addr_t ptr) { + return (ptr & 1); +} + +ObjCLanguageRuntime::ClassDescriptorSP +AppleObjCRuntimeV2::TaggedPointerVendorLegacy::GetClassDescriptor( + lldb::addr_t ptr) { + if (!IsPossibleTaggedPointer(ptr)) + return ObjCLanguageRuntime::ClassDescriptorSP(); + + uint32_t foundation_version = m_runtime.GetFoundationVersion(); + + if (foundation_version == LLDB_INVALID_MODULE_VERSION) + return ObjCLanguageRuntime::ClassDescriptorSP(); + + uint64_t class_bits = (ptr & 0xE) >> 1; + ConstString name; + + static ConstString g_NSAtom("NSAtom"); + static ConstString g_NSNumber("NSNumber"); + static ConstString g_NSDateTS("NSDateTS"); + static ConstString g_NSManagedObject("NSManagedObject"); + static ConstString g_NSDate("NSDate"); + + if (foundation_version >= 900) { + switch (class_bits) { + case 0: + name = g_NSAtom; + break; + case 3: + name = g_NSNumber; + break; + case 4: + name = g_NSDateTS; + break; + case 5: + name = g_NSManagedObject; + break; + case 6: + name = g_NSDate; + break; + default: + return ObjCLanguageRuntime::ClassDescriptorSP(); + } + } else { + switch (class_bits) { + case 1: + name = g_NSNumber; + break; + case 5: + name = g_NSManagedObject; + break; + case 6: + name = g_NSDate; + break; + case 7: + name = g_NSDateTS; + break; + default: + return ObjCLanguageRuntime::ClassDescriptorSP(); + } + } + + lldb::addr_t unobfuscated = ptr ^ m_runtime.GetTaggedPointerObfuscator(); + return ClassDescriptorSP(new ClassDescriptorV2Tagged(name, unobfuscated)); +} + +AppleObjCRuntimeV2::TaggedPointerVendorRuntimeAssisted:: + TaggedPointerVendorRuntimeAssisted( + AppleObjCRuntimeV2 &runtime, uint64_t objc_debug_taggedpointer_mask, + uint32_t objc_debug_taggedpointer_slot_shift, + uint32_t objc_debug_taggedpointer_slot_mask, + uint32_t objc_debug_taggedpointer_payload_lshift, + uint32_t objc_debug_taggedpointer_payload_rshift, + lldb::addr_t objc_debug_taggedpointer_classes) + : TaggedPointerVendorV2(runtime), m_cache(), + m_objc_debug_taggedpointer_mask(objc_debug_taggedpointer_mask), + m_objc_debug_taggedpointer_slot_shift( + objc_debug_taggedpointer_slot_shift), + m_objc_debug_taggedpointer_slot_mask(objc_debug_taggedpointer_slot_mask), + m_objc_debug_taggedpointer_payload_lshift( + objc_debug_taggedpointer_payload_lshift), + m_objc_debug_taggedpointer_payload_rshift( + objc_debug_taggedpointer_payload_rshift), + m_objc_debug_taggedpointer_classes(objc_debug_taggedpointer_classes) {} + +bool AppleObjCRuntimeV2::TaggedPointerVendorRuntimeAssisted:: + IsPossibleTaggedPointer(lldb::addr_t ptr) { + return (ptr & m_objc_debug_taggedpointer_mask) != 0; +} + +ObjCLanguageRuntime::ClassDescriptorSP +AppleObjCRuntimeV2::TaggedPointerVendorRuntimeAssisted::GetClassDescriptor( + lldb::addr_t ptr) { + ClassDescriptorSP actual_class_descriptor_sp; + uint64_t data_payload; + uint64_t unobfuscated = (ptr) ^ m_runtime.GetTaggedPointerObfuscator(); + + if (!IsPossibleTaggedPointer(unobfuscated)) + return ObjCLanguageRuntime::ClassDescriptorSP(); + + uintptr_t slot = (ptr >> m_objc_debug_taggedpointer_slot_shift) & + m_objc_debug_taggedpointer_slot_mask; + + CacheIterator iterator = m_cache.find(slot), end = m_cache.end(); + if (iterator != end) { + actual_class_descriptor_sp = iterator->second; + } else { + Process *process(m_runtime.GetProcess()); + uintptr_t slot_ptr = slot * process->GetAddressByteSize() + + m_objc_debug_taggedpointer_classes; + Status error; + uintptr_t slot_data = process->ReadPointerFromMemory(slot_ptr, error); + if (error.Fail() || slot_data == 0 || + slot_data == uintptr_t(LLDB_INVALID_ADDRESS)) + return nullptr; + actual_class_descriptor_sp = + m_runtime.GetClassDescriptorFromISA((ObjCISA)slot_data); + if (!actual_class_descriptor_sp) + return ObjCLanguageRuntime::ClassDescriptorSP(); + m_cache[slot] = actual_class_descriptor_sp; + } + + data_payload = + (((uint64_t)unobfuscated << m_objc_debug_taggedpointer_payload_lshift) >> + m_objc_debug_taggedpointer_payload_rshift); + + return ClassDescriptorSP( + new ClassDescriptorV2Tagged(actual_class_descriptor_sp, data_payload)); +} + +AppleObjCRuntimeV2::TaggedPointerVendorExtended::TaggedPointerVendorExtended( + AppleObjCRuntimeV2 &runtime, uint64_t objc_debug_taggedpointer_mask, + uint64_t objc_debug_taggedpointer_ext_mask, + uint32_t objc_debug_taggedpointer_slot_shift, + uint32_t objc_debug_taggedpointer_ext_slot_shift, + uint32_t objc_debug_taggedpointer_slot_mask, + uint32_t objc_debug_taggedpointer_ext_slot_mask, + uint32_t objc_debug_taggedpointer_payload_lshift, + uint32_t objc_debug_taggedpointer_payload_rshift, + uint32_t objc_debug_taggedpointer_ext_payload_lshift, + uint32_t objc_debug_taggedpointer_ext_payload_rshift, + lldb::addr_t objc_debug_taggedpointer_classes, + lldb::addr_t objc_debug_taggedpointer_ext_classes) + : TaggedPointerVendorRuntimeAssisted( + runtime, objc_debug_taggedpointer_mask, + objc_debug_taggedpointer_slot_shift, + objc_debug_taggedpointer_slot_mask, + objc_debug_taggedpointer_payload_lshift, + objc_debug_taggedpointer_payload_rshift, + objc_debug_taggedpointer_classes), + m_ext_cache(), + m_objc_debug_taggedpointer_ext_mask(objc_debug_taggedpointer_ext_mask), + m_objc_debug_taggedpointer_ext_slot_shift( + objc_debug_taggedpointer_ext_slot_shift), + m_objc_debug_taggedpointer_ext_slot_mask( + objc_debug_taggedpointer_ext_slot_mask), + m_objc_debug_taggedpointer_ext_payload_lshift( + objc_debug_taggedpointer_ext_payload_lshift), + m_objc_debug_taggedpointer_ext_payload_rshift( + objc_debug_taggedpointer_ext_payload_rshift), + m_objc_debug_taggedpointer_ext_classes( + objc_debug_taggedpointer_ext_classes) {} + +bool AppleObjCRuntimeV2::TaggedPointerVendorExtended:: + IsPossibleExtendedTaggedPointer(lldb::addr_t ptr) { + if (!IsPossibleTaggedPointer(ptr)) + return false; + + if (m_objc_debug_taggedpointer_ext_mask == 0) + return false; + + return ((ptr & m_objc_debug_taggedpointer_ext_mask) == + m_objc_debug_taggedpointer_ext_mask); +} + +ObjCLanguageRuntime::ClassDescriptorSP +AppleObjCRuntimeV2::TaggedPointerVendorExtended::GetClassDescriptor( + lldb::addr_t ptr) { + ClassDescriptorSP actual_class_descriptor_sp; + uint64_t data_payload; + uint64_t unobfuscated = (ptr) ^ m_runtime.GetTaggedPointerObfuscator(); + + if (!IsPossibleTaggedPointer(unobfuscated)) + return ObjCLanguageRuntime::ClassDescriptorSP(); + + if (!IsPossibleExtendedTaggedPointer(unobfuscated)) + return this->TaggedPointerVendorRuntimeAssisted::GetClassDescriptor(ptr); + + uintptr_t slot = (ptr >> m_objc_debug_taggedpointer_ext_slot_shift) & + m_objc_debug_taggedpointer_ext_slot_mask; + + CacheIterator iterator = m_ext_cache.find(slot), end = m_ext_cache.end(); + if (iterator != end) { + actual_class_descriptor_sp = iterator->second; + } else { + Process *process(m_runtime.GetProcess()); + uintptr_t slot_ptr = slot * process->GetAddressByteSize() + + m_objc_debug_taggedpointer_ext_classes; + Status error; + uintptr_t slot_data = process->ReadPointerFromMemory(slot_ptr, error); + if (error.Fail() || slot_data == 0 || + slot_data == uintptr_t(LLDB_INVALID_ADDRESS)) + return nullptr; + actual_class_descriptor_sp = + m_runtime.GetClassDescriptorFromISA((ObjCISA)slot_data); + if (!actual_class_descriptor_sp) + return ObjCLanguageRuntime::ClassDescriptorSP(); + m_ext_cache[slot] = actual_class_descriptor_sp; + } + + data_payload = + (((uint64_t)unobfuscated << m_objc_debug_taggedpointer_ext_payload_lshift) >> + m_objc_debug_taggedpointer_ext_payload_rshift); + + return ClassDescriptorSP( + new ClassDescriptorV2Tagged(actual_class_descriptor_sp, data_payload)); +} + +AppleObjCRuntimeV2::NonPointerISACache::NonPointerISACache( + AppleObjCRuntimeV2 &runtime, const ModuleSP &objc_module_sp, + uint64_t objc_debug_isa_class_mask, uint64_t objc_debug_isa_magic_mask, + uint64_t objc_debug_isa_magic_value, + uint64_t objc_debug_indexed_isa_magic_mask, + uint64_t objc_debug_indexed_isa_magic_value, + uint64_t objc_debug_indexed_isa_index_mask, + uint64_t objc_debug_indexed_isa_index_shift, + lldb::addr_t objc_indexed_classes) + : m_runtime(runtime), m_cache(), m_objc_module_wp(objc_module_sp), + m_objc_debug_isa_class_mask(objc_debug_isa_class_mask), + m_objc_debug_isa_magic_mask(objc_debug_isa_magic_mask), + m_objc_debug_isa_magic_value(objc_debug_isa_magic_value), + m_objc_debug_indexed_isa_magic_mask(objc_debug_indexed_isa_magic_mask), + m_objc_debug_indexed_isa_magic_value(objc_debug_indexed_isa_magic_value), + m_objc_debug_indexed_isa_index_mask(objc_debug_indexed_isa_index_mask), + m_objc_debug_indexed_isa_index_shift(objc_debug_indexed_isa_index_shift), + m_objc_indexed_classes(objc_indexed_classes), m_indexed_isa_cache() {} + +ObjCLanguageRuntime::ClassDescriptorSP +AppleObjCRuntimeV2::NonPointerISACache::GetClassDescriptor(ObjCISA isa) { + ObjCISA real_isa = 0; + if (!EvaluateNonPointerISA(isa, real_isa)) + return ObjCLanguageRuntime::ClassDescriptorSP(); + auto cache_iter = m_cache.find(real_isa); + if (cache_iter != m_cache.end()) + return cache_iter->second; + auto descriptor_sp = + m_runtime.ObjCLanguageRuntime::GetClassDescriptorFromISA(real_isa); + if (descriptor_sp) // cache only positive matches since the table might grow + m_cache[real_isa] = descriptor_sp; + return descriptor_sp; +} + +bool AppleObjCRuntimeV2::NonPointerISACache::EvaluateNonPointerISA( + ObjCISA isa, ObjCISA &ret_isa) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES)); + + LLDB_LOGF(log, "AOCRT::NPI Evalulate(isa = 0x%" PRIx64 ")", (uint64_t)isa); + + if ((isa & ~m_objc_debug_isa_class_mask) == 0) + return false; + + // If all of the indexed ISA variables are set, then its possible that this + // ISA is indexed, and we should first try to get its value using the index. + // Note, we check these variables first as the ObjC runtime will set at least + // one of their values to 0 if they aren't needed. + if (m_objc_debug_indexed_isa_magic_mask && + m_objc_debug_indexed_isa_magic_value && + m_objc_debug_indexed_isa_index_mask && + m_objc_debug_indexed_isa_index_shift && m_objc_indexed_classes) { + if ((isa & ~m_objc_debug_indexed_isa_index_mask) == 0) + return false; + + if ((isa & m_objc_debug_indexed_isa_magic_mask) == + m_objc_debug_indexed_isa_magic_value) { + // Magic bits are correct, so try extract the index. + uintptr_t index = (isa & m_objc_debug_indexed_isa_index_mask) >> + m_objc_debug_indexed_isa_index_shift; + // If the index is out of bounds of the length of the array then check if + // the array has been updated. If that is the case then we should try + // read the count again, and update the cache if the count has been + // updated. + if (index > m_indexed_isa_cache.size()) { + LLDB_LOGF(log, + "AOCRT::NPI (index = %" PRIu64 + ") exceeds cache (size = %" PRIu64 ")", + (uint64_t)index, (uint64_t)m_indexed_isa_cache.size()); + + Process *process(m_runtime.GetProcess()); + + ModuleSP objc_module_sp(m_objc_module_wp.lock()); + if (!objc_module_sp) + return false; + + Status error; + auto objc_indexed_classes_count = ExtractRuntimeGlobalSymbol( + process, ConstString("objc_indexed_classes_count"), objc_module_sp, + error); + if (error.Fail()) + return false; + + LLDB_LOGF(log, "AOCRT::NPI (new class count = %" PRIu64 ")", + (uint64_t)objc_indexed_classes_count); + + if (objc_indexed_classes_count > m_indexed_isa_cache.size()) { + // Read the class entries we don't have. We should just read all of + // them instead of just the one we need as then we can cache those we + // may need later. + auto num_new_classes = + objc_indexed_classes_count - m_indexed_isa_cache.size(); + const uint32_t addr_size = process->GetAddressByteSize(); + DataBufferHeap buffer(num_new_classes * addr_size, 0); + + lldb::addr_t last_read_class = + m_objc_indexed_classes + (m_indexed_isa_cache.size() * addr_size); + size_t bytes_read = process->ReadMemory( + last_read_class, buffer.GetBytes(), buffer.GetByteSize(), error); + if (error.Fail() || bytes_read != buffer.GetByteSize()) + return false; + + LLDB_LOGF(log, "AOCRT::NPI (read new classes count = %" PRIu64 ")", + (uint64_t)num_new_classes); + + // Append the new entries to the existing cache. + DataExtractor data(buffer.GetBytes(), buffer.GetByteSize(), + process->GetByteOrder(), + process->GetAddressByteSize()); + + lldb::offset_t offset = 0; + for (unsigned i = 0; i != num_new_classes; ++i) + m_indexed_isa_cache.push_back(data.GetPointer(&offset)); + } + } + + // If the index is still out of range then this isn't a pointer. + if (index > m_indexed_isa_cache.size()) + return false; + + LLDB_LOGF(log, "AOCRT::NPI Evalulate(ret_isa = 0x%" PRIx64 ")", + (uint64_t)m_indexed_isa_cache[index]); + + ret_isa = m_indexed_isa_cache[index]; + return (ret_isa != 0); // this is a pointer so 0 is not a valid value + } + + return false; + } + + // Definitely not an indexed ISA, so try to use a mask to extract the pointer + // from the ISA. + if ((isa & m_objc_debug_isa_magic_mask) == m_objc_debug_isa_magic_value) { + ret_isa = isa & m_objc_debug_isa_class_mask; + return (ret_isa != 0); // this is a pointer so 0 is not a valid value + } + return false; +} + +ObjCLanguageRuntime::EncodingToTypeSP AppleObjCRuntimeV2::GetEncodingToType() { + if (!m_encoding_to_type_sp) + m_encoding_to_type_sp = + std::make_shared<AppleObjCTypeEncodingParser>(*this); + return m_encoding_to_type_sp; +} + +lldb_private::AppleObjCRuntime::ObjCISA +AppleObjCRuntimeV2::GetPointerISA(ObjCISA isa) { + ObjCISA ret = isa; + + if (m_non_pointer_isa_cache_up) + m_non_pointer_isa_cache_up->EvaluateNonPointerISA(isa, ret); + + return ret; +} + +bool AppleObjCRuntimeV2::GetCFBooleanValuesIfNeeded() { + if (m_CFBoolean_values) + return true; + + static ConstString g_kCFBooleanFalse("__kCFBooleanFalse"); + static ConstString g_kCFBooleanTrue("__kCFBooleanTrue"); + + std::function<lldb::addr_t(ConstString)> get_symbol = + [this](ConstString sym) -> lldb::addr_t { + SymbolContextList sc_list; + GetProcess()->GetTarget().GetImages().FindSymbolsWithNameAndType( + sym, lldb::eSymbolTypeData, sc_list); + if (sc_list.GetSize() == 1) { + SymbolContext sc; + sc_list.GetContextAtIndex(0, sc); + if (sc.symbol) + return sc.symbol->GetLoadAddress(&GetProcess()->GetTarget()); + } + + return LLDB_INVALID_ADDRESS; + }; + + lldb::addr_t false_addr = get_symbol(g_kCFBooleanFalse); + lldb::addr_t true_addr = get_symbol(g_kCFBooleanTrue); + + return (m_CFBoolean_values = {false_addr, true_addr}).operator bool(); +} + +void AppleObjCRuntimeV2::GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true, + lldb::addr_t &cf_false) { + if (GetCFBooleanValuesIfNeeded()) { + cf_true = m_CFBoolean_values->second; + cf_false = m_CFBoolean_values->first; + } else + this->AppleObjCRuntime::GetValuesForGlobalCFBooleans(cf_true, cf_false); +} + +#pragma mark Frame recognizers + +class ObjCExceptionRecognizedStackFrame : public RecognizedStackFrame { + public: + ObjCExceptionRecognizedStackFrame(StackFrameSP frame_sp) { + ThreadSP thread_sp = frame_sp->GetThread(); + ProcessSP process_sp = thread_sp->GetProcess(); + + const lldb::ABISP &abi = process_sp->GetABI(); + if (!abi) return; + + CompilerType voidstar = process_sp->GetTarget() + .GetScratchClangASTContext() + ->GetBasicType(lldb::eBasicTypeVoid) + .GetPointerType(); + + ValueList args; + Value input_value; + input_value.SetCompilerType(voidstar); + args.PushValue(input_value); + + if (!abi->GetArgumentValues(*thread_sp, args)) return; + + addr_t exception_addr = args.GetValueAtIndex(0)->GetScalar().ULongLong(); + + Value value(exception_addr); + value.SetCompilerType(voidstar); + exception = ValueObjectConstResult::Create(frame_sp.get(), value, + ConstString("exception")); + exception = ValueObjectRecognizerSynthesizedValue::Create( + *exception, eValueTypeVariableArgument); + exception = exception->GetDynamicValue(eDynamicDontRunTarget); + + m_arguments = ValueObjectListSP(new ValueObjectList()); + m_arguments->Append(exception); + } + + ValueObjectSP exception; + + lldb::ValueObjectSP GetExceptionObject() override { return exception; } +}; + +class ObjCExceptionThrowFrameRecognizer : public StackFrameRecognizer { + lldb::RecognizedStackFrameSP + RecognizeFrame(lldb::StackFrameSP frame) override { + return lldb::RecognizedStackFrameSP( + new ObjCExceptionRecognizedStackFrame(frame)); + }; +}; + +static void RegisterObjCExceptionRecognizer() { + static llvm::once_flag g_once_flag; + llvm::call_once(g_once_flag, []() { + FileSpec module; + ConstString function; + std::tie(module, function) = AppleObjCRuntime::GetExceptionThrowLocation(); + StackFrameRecognizerManager::AddRecognizer( + StackFrameRecognizerSP(new ObjCExceptionThrowFrameRecognizer()), + module.GetFilename(), function, /*first_instruction_only*/ true); + }); +} diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h new file mode 100644 index 000000000000..a0fd39dc03b2 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h @@ -0,0 +1,342 @@ +//===-- AppleObjCRuntimeV2.h ------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_AppleObjCRuntimeV2_h_ +#define liblldb_AppleObjCRuntimeV2_h_ + +#include <map> +#include <memory> +#include <mutex> + +#include "AppleObjCRuntime.h" +#include "lldb/lldb-private.h" + +#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h" + +class RemoteNXMapTable; + +namespace lldb_private { + +class AppleObjCRuntimeV2 : public AppleObjCRuntime { +public: + ~AppleObjCRuntimeV2() override = default; + + // Static Functions + static void Initialize(); + + static void Terminate(); + + static lldb_private::LanguageRuntime * + CreateInstance(Process *process, lldb::LanguageType language); + + static lldb_private::ConstString GetPluginNameStatic(); + + static char ID; + + bool isA(const void *ClassID) const override { + return ClassID == &ID || AppleObjCRuntime::isA(ClassID); + } + + static bool classof(const LanguageRuntime *runtime) { + return runtime->isA(&ID); + } + + // These are generic runtime functions: + bool GetDynamicTypeAndAddress(ValueObject &in_value, + lldb::DynamicValueType use_dynamic, + TypeAndOrName &class_type_or_name, + Address &address, + Value::ValueType &value_type) override; + + UtilityFunction *CreateObjectChecker(const char *) override; + + // PluginInterface protocol + ConstString GetPluginName() override; + + uint32_t GetPluginVersion() override; + + ObjCRuntimeVersions GetRuntimeVersion() const override { + return ObjCRuntimeVersions::eAppleObjC_V2; + } + + size_t GetByteOffsetForIvar(CompilerType &parent_qual_type, + const char *ivar_name) override; + + void UpdateISAToDescriptorMapIfNeeded() override; + + ConstString GetActualTypeName(ObjCLanguageRuntime::ObjCISA isa) override; + + ClassDescriptorSP GetClassDescriptor(ValueObject &in_value) override; + + ClassDescriptorSP GetClassDescriptorFromISA(ObjCISA isa) override; + + DeclVendor *GetDeclVendor() override; + + lldb::addr_t LookupRuntimeSymbol(ConstString name) override; + + EncodingToTypeSP GetEncodingToType() override; + + bool IsTaggedPointer(lldb::addr_t ptr) override; + + TaggedPointerVendor *GetTaggedPointerVendor() override { + return m_tagged_pointer_vendor_up.get(); + } + + lldb::addr_t GetTaggedPointerObfuscator(); + + void GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true, + lldb::addr_t &cf_false) override; + + // none of these are valid ISAs - we use them to infer the type + // of tagged pointers - if we have something meaningful to say + // we report an actual type - otherwise, we just say tagged + // there is no connection between the values here and the tagged pointers map + static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA = 1; + static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSAtom = 2; + static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSNumber = 3; + static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSDateTS = 4; + static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSManagedObject = + 5; + static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSDate = 6; + +protected: + lldb::BreakpointResolverSP CreateExceptionResolver(Breakpoint *bkpt, + bool catch_bp, + bool throw_bp) override; + +private: + class HashTableSignature { + public: + HashTableSignature(); + + bool NeedsUpdate(Process *process, AppleObjCRuntimeV2 *runtime, + RemoteNXMapTable &hash_table); + + void UpdateSignature(const RemoteNXMapTable &hash_table); + + protected: + uint32_t m_count; + uint32_t m_num_buckets; + lldb::addr_t m_buckets_ptr; + }; + + class NonPointerISACache { + public: + static NonPointerISACache * + CreateInstance(AppleObjCRuntimeV2 &runtime, + const lldb::ModuleSP &objc_module_sp); + + ObjCLanguageRuntime::ClassDescriptorSP GetClassDescriptor(ObjCISA isa); + + private: + NonPointerISACache(AppleObjCRuntimeV2 &runtime, + const lldb::ModuleSP &objc_module_sp, + uint64_t objc_debug_isa_class_mask, + uint64_t objc_debug_isa_magic_mask, + uint64_t objc_debug_isa_magic_value, + uint64_t objc_debug_indexed_isa_magic_mask, + uint64_t objc_debug_indexed_isa_magic_value, + uint64_t objc_debug_indexed_isa_index_mask, + uint64_t objc_debug_indexed_isa_index_shift, + lldb::addr_t objc_indexed_classes); + + bool EvaluateNonPointerISA(ObjCISA isa, ObjCISA &ret_isa); + + AppleObjCRuntimeV2 &m_runtime; + std::map<ObjCISA, ObjCLanguageRuntime::ClassDescriptorSP> m_cache; + lldb::ModuleWP m_objc_module_wp; + uint64_t m_objc_debug_isa_class_mask; + uint64_t m_objc_debug_isa_magic_mask; + uint64_t m_objc_debug_isa_magic_value; + + uint64_t m_objc_debug_indexed_isa_magic_mask; + uint64_t m_objc_debug_indexed_isa_magic_value; + uint64_t m_objc_debug_indexed_isa_index_mask; + uint64_t m_objc_debug_indexed_isa_index_shift; + lldb::addr_t m_objc_indexed_classes; + + std::vector<lldb::addr_t> m_indexed_isa_cache; + + friend class AppleObjCRuntimeV2; + + DISALLOW_COPY_AND_ASSIGN(NonPointerISACache); + }; + + class TaggedPointerVendorV2 + : public ObjCLanguageRuntime::TaggedPointerVendor { + public: + ~TaggedPointerVendorV2() override = default; + + static TaggedPointerVendorV2 * + CreateInstance(AppleObjCRuntimeV2 &runtime, + const lldb::ModuleSP &objc_module_sp); + + protected: + AppleObjCRuntimeV2 &m_runtime; + + TaggedPointerVendorV2(AppleObjCRuntimeV2 &runtime) + : TaggedPointerVendor(), m_runtime(runtime) {} + + private: + DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendorV2); + }; + + class TaggedPointerVendorRuntimeAssisted : public TaggedPointerVendorV2 { + public: + bool IsPossibleTaggedPointer(lldb::addr_t ptr) override; + + ObjCLanguageRuntime::ClassDescriptorSP + GetClassDescriptor(lldb::addr_t ptr) override; + + protected: + TaggedPointerVendorRuntimeAssisted( + AppleObjCRuntimeV2 &runtime, uint64_t objc_debug_taggedpointer_mask, + uint32_t objc_debug_taggedpointer_slot_shift, + uint32_t objc_debug_taggedpointer_slot_mask, + uint32_t objc_debug_taggedpointer_payload_lshift, + uint32_t objc_debug_taggedpointer_payload_rshift, + lldb::addr_t objc_debug_taggedpointer_classes); + + typedef std::map<uint8_t, ObjCLanguageRuntime::ClassDescriptorSP> Cache; + typedef Cache::iterator CacheIterator; + Cache m_cache; + uint64_t m_objc_debug_taggedpointer_mask; + uint32_t m_objc_debug_taggedpointer_slot_shift; + uint32_t m_objc_debug_taggedpointer_slot_mask; + uint32_t m_objc_debug_taggedpointer_payload_lshift; + uint32_t m_objc_debug_taggedpointer_payload_rshift; + lldb::addr_t m_objc_debug_taggedpointer_classes; + + friend class AppleObjCRuntimeV2::TaggedPointerVendorV2; + + DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendorRuntimeAssisted); + }; + + class TaggedPointerVendorExtended + : public TaggedPointerVendorRuntimeAssisted { + public: + ObjCLanguageRuntime::ClassDescriptorSP + GetClassDescriptor(lldb::addr_t ptr) override; + + protected: + TaggedPointerVendorExtended( + AppleObjCRuntimeV2 &runtime, uint64_t objc_debug_taggedpointer_mask, + uint64_t objc_debug_taggedpointer_ext_mask, + uint32_t objc_debug_taggedpointer_slot_shift, + uint32_t objc_debug_taggedpointer_ext_slot_shift, + uint32_t objc_debug_taggedpointer_slot_mask, + uint32_t objc_debug_taggedpointer_ext_slot_mask, + uint32_t objc_debug_taggedpointer_payload_lshift, + uint32_t objc_debug_taggedpointer_payload_rshift, + uint32_t objc_debug_taggedpointer_ext_payload_lshift, + uint32_t objc_debug_taggedpointer_ext_payload_rshift, + lldb::addr_t objc_debug_taggedpointer_classes, + lldb::addr_t objc_debug_taggedpointer_ext_classes); + + bool IsPossibleExtendedTaggedPointer(lldb::addr_t ptr); + + typedef std::map<uint8_t, ObjCLanguageRuntime::ClassDescriptorSP> Cache; + typedef Cache::iterator CacheIterator; + Cache m_ext_cache; + uint64_t m_objc_debug_taggedpointer_ext_mask; + uint32_t m_objc_debug_taggedpointer_ext_slot_shift; + uint32_t m_objc_debug_taggedpointer_ext_slot_mask; + uint32_t m_objc_debug_taggedpointer_ext_payload_lshift; + uint32_t m_objc_debug_taggedpointer_ext_payload_rshift; + lldb::addr_t m_objc_debug_taggedpointer_ext_classes; + + friend class AppleObjCRuntimeV2::TaggedPointerVendorV2; + + DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendorExtended); + }; + + class TaggedPointerVendorLegacy : public TaggedPointerVendorV2 { + public: + bool IsPossibleTaggedPointer(lldb::addr_t ptr) override; + + ObjCLanguageRuntime::ClassDescriptorSP + GetClassDescriptor(lldb::addr_t ptr) override; + + protected: + TaggedPointerVendorLegacy(AppleObjCRuntimeV2 &runtime) + : TaggedPointerVendorV2(runtime) {} + + friend class AppleObjCRuntimeV2::TaggedPointerVendorV2; + + DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendorLegacy); + }; + + struct DescriptorMapUpdateResult { + bool m_update_ran; + uint32_t m_num_found; + + DescriptorMapUpdateResult(bool ran, uint32_t found) { + m_update_ran = ran; + m_num_found = found; + } + + static DescriptorMapUpdateResult Fail() { return {false, 0}; } + + static DescriptorMapUpdateResult Success(uint32_t found) { + return {true, found}; + } + }; + + AppleObjCRuntimeV2(Process *process, const lldb::ModuleSP &objc_module_sp); + + ObjCISA GetPointerISA(ObjCISA isa); + + lldb::addr_t GetISAHashTablePointer(); + + bool UpdateISAToDescriptorMapFromMemory(RemoteNXMapTable &hash_table); + + DescriptorMapUpdateResult + UpdateISAToDescriptorMapDynamic(RemoteNXMapTable &hash_table); + + uint32_t ParseClassInfoArray(const lldb_private::DataExtractor &data, + uint32_t num_class_infos); + + DescriptorMapUpdateResult UpdateISAToDescriptorMapSharedCache(); + + enum class SharedCacheWarningReason { + eExpressionExecutionFailure, + eNotEnoughClassesRead + }; + + void WarnIfNoClassesCached(SharedCacheWarningReason reason); + + lldb::addr_t GetSharedCacheReadOnlyAddress(); + + bool GetCFBooleanValuesIfNeeded(); + + friend class ClassDescriptorV2; + + std::unique_ptr<UtilityFunction> m_get_class_info_code; + lldb::addr_t m_get_class_info_args; + std::mutex m_get_class_info_args_mutex; + + std::unique_ptr<UtilityFunction> m_get_shared_cache_class_info_code; + lldb::addr_t m_get_shared_cache_class_info_args; + std::mutex m_get_shared_cache_class_info_args_mutex; + + std::unique_ptr<DeclVendor> m_decl_vendor_up; + lldb::addr_t m_tagged_pointer_obfuscator; + lldb::addr_t m_isa_hash_table_ptr; + HashTableSignature m_hash_signature; + bool m_has_object_getClass; + bool m_loaded_objc_opt; + std::unique_ptr<NonPointerISACache> m_non_pointer_isa_cache_up; + std::unique_ptr<TaggedPointerVendor> m_tagged_pointer_vendor_up; + EncodingToTypeSP m_encoding_to_type_sp; + bool m_noclasses_warning_emitted; + llvm::Optional<std::pair<lldb::addr_t, lldb::addr_t>> m_CFBoolean_values; +}; + +} // namespace lldb_private + +#endif // liblldb_AppleObjCRuntimeV2_h_ diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp new file mode 100644 index 000000000000..379ef3dca86c --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp @@ -0,0 +1,1145 @@ +//===-- AppleObjCTrampolineHandler.cpp ----------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "AppleObjCTrampolineHandler.h" +#include "AppleThreadPlanStepThroughObjCTrampoline.h" + +#include "lldb/Breakpoint/StoppointCallbackContext.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Core/Value.h" +#include "lldb/Expression/DiagnosticManager.h" +#include "lldb/Expression/FunctionCaller.h" +#include "lldb/Expression/UserExpression.h" +#include "lldb/Expression/UtilityFunction.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Symbol/Symbol.h" +#include "lldb/Target/ABI.h" +#include "lldb/Target/ExecutionContext.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/RegisterContext.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/Thread.h" +#include "lldb/Target/ThreadPlanRunToAddress.h" +#include "lldb/Utility/ConstString.h" +#include "lldb/Utility/FileSpec.h" +#include "lldb/Utility/Log.h" + +#include "llvm/ADT/STLExtras.h" + +#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h" + +#include <memory> + +using namespace lldb; +using namespace lldb_private; + +const char *AppleObjCTrampolineHandler::g_lookup_implementation_function_name = + "__lldb_objc_find_implementation_for_selector"; +const char *AppleObjCTrampolineHandler:: + g_lookup_implementation_with_stret_function_code = + " \n\ +extern \"C\" \n\ +{ \n\ + extern void *class_getMethodImplementation(void *objc_class, void *sel); \n\ + extern void *class_getMethodImplementation_stret(void *objc_class, \n\ + void *sel); \n\ + extern void * object_getClass (id object); \n\ + extern void * sel_getUid(char *name); \n\ + extern int printf(const char *format, ...); \n\ +} \n\ +extern \"C\" void * __lldb_objc_find_implementation_for_selector ( \n\ + void *object, \n\ + void *sel, \n\ + int is_stret, \n\ + int is_super, \n\ + int is_super2, \n\ + int is_fixup, \n\ + int is_fixed, \n\ + int debug) \n\ +{ \n\ + struct __lldb_imp_return_struct \n\ + { \n\ + void *class_addr; \n\ + void *sel_addr; \n\ + void *impl_addr; \n\ + }; \n\ + \n\ + struct __lldb_objc_class { \n\ + void *isa; \n\ + void *super_ptr; \n\ + }; \n\ + struct __lldb_objc_super { \n\ + void *receiver; \n\ + struct __lldb_objc_class *class_ptr; \n\ + }; \n\ + struct __lldb_msg_ref { \n\ + void *dont_know; \n\ + void *sel; \n\ + }; \n\ + \n\ + struct __lldb_imp_return_struct return_struct; \n\ + \n\ + if (debug) \n\ + printf (\"\\n*** Called with obj: 0x%p sel: 0x%p is_stret: %d is_super: %d, \"\n\ + \"is_super2: %d, is_fixup: %d, is_fixed: %d\\n\", \n\ + object, sel, is_stret, is_super, is_super2, is_fixup, is_fixed);\n\ + if (is_super) \n\ + { \n\ + if (is_super2) \n\ + { \n\ + return_struct.class_addr = ((__lldb_objc_super *) object)->class_ptr->super_ptr;\n\ + } \n\ + else \n\ + { \n\ + return_struct.class_addr = ((__lldb_objc_super *) object)->class_ptr;\n\ + } \n\ + } \n\ + else \n\ + { \n\ + // This code seems a little funny, but has its reasons... \n\ + \n\ + // The call to [object class] is here because if this is a \n\ + // class, and has not been called into yet, we need to do \n\ + // something to force the class to initialize itself. \n\ + // Then the call to object_getClass will actually return the \n\ + // correct class, either the class if object is a class \n\ + // instance, or the meta-class if it is a class pointer. \n\ + void *class_ptr = (void *) [(id) object class]; \n\ + return_struct.class_addr = (id) object_getClass((id) object); \n\ + if (debug) \n\ + { \n\ + if (class_ptr == object) \n\ + { \n\ + printf (\"Found a class object, need to use the meta class %p -> %p\\n\",\n\ + class_ptr, return_struct.class_addr); \n\ + } \n\ + else \n\ + { \n\ + printf (\"[object class] returned: %p object_getClass: %p.\\n\", \n\ + class_ptr, return_struct.class_addr); \n\ + } \n\ + } \n\ + } \n\ + \n\ + if (is_fixup) \n\ + { \n\ + if (is_fixed) \n\ + { \n\ + return_struct.sel_addr = ((__lldb_msg_ref *) sel)->sel; \n\ + } \n\ + else \n\ + { \n\ + char *sel_name = (char *) ((__lldb_msg_ref *) sel)->sel; \n\ + return_struct.sel_addr = sel_getUid (sel_name); \n\ + if (debug) \n\ + printf (\"\\n*** Got fixed up selector: %p for name %s.\\n\",\n\ + return_struct.sel_addr, sel_name); \n\ + } \n\ + } \n\ + else \n\ + { \n\ + return_struct.sel_addr = sel; \n\ + } \n\ + \n\ + if (is_stret) \n\ + { \n\ + return_struct.impl_addr = \n\ + class_getMethodImplementation_stret (return_struct.class_addr, \n\ + return_struct.sel_addr); \n\ + } \n\ + else \n\ + { \n\ + return_struct.impl_addr = \n\ + class_getMethodImplementation (return_struct.class_addr, \n\ + return_struct.sel_addr); \n\ + } \n\ + if (debug) \n\ + printf (\"\\n*** Returning implementation: %p.\\n\", \n\ + return_struct.impl_addr); \n\ + \n\ + return return_struct.impl_addr; \n\ +} \n\ +"; +const char * + AppleObjCTrampolineHandler::g_lookup_implementation_no_stret_function_code = + " \n\ +extern \"C\" \n\ +{ \n\ + extern void *class_getMethodImplementation(void *objc_class, void *sel); \n\ + extern void * object_getClass (id object); \n\ + extern void * sel_getUid(char *name); \n\ + extern int printf(const char *format, ...); \n\ +} \n\ +extern \"C\" void * __lldb_objc_find_implementation_for_selector (void *object, \n\ + void *sel, \n\ + int is_stret, \n\ + int is_super, \n\ + int is_super2, \n\ + int is_fixup, \n\ + int is_fixed, \n\ + int debug) \n\ +{ \n\ + struct __lldb_imp_return_struct \n\ + { \n\ + void *class_addr; \n\ + void *sel_addr; \n\ + void *impl_addr; \n\ + }; \n\ + \n\ + struct __lldb_objc_class { \n\ + void *isa; \n\ + void *super_ptr; \n\ + }; \n\ + struct __lldb_objc_super { \n\ + void *receiver; \n\ + struct __lldb_objc_class *class_ptr; \n\ + }; \n\ + struct __lldb_msg_ref { \n\ + void *dont_know; \n\ + void *sel; \n\ + }; \n\ + \n\ + struct __lldb_imp_return_struct return_struct; \n\ + \n\ + if (debug) \n\ + printf (\"\\n*** Called with obj: 0x%p sel: 0x%p is_stret: %d is_super: %d, \" \n\ + \"is_super2: %d, is_fixup: %d, is_fixed: %d\\n\", \n\ + object, sel, is_stret, is_super, is_super2, is_fixup, is_fixed); \n\ + if (is_super) \n\ + { \n\ + if (is_super2) \n\ + { \n\ + return_struct.class_addr = ((__lldb_objc_super *) object)->class_ptr->super_ptr; \n\ + } \n\ + else \n\ + { \n\ + return_struct.class_addr = ((__lldb_objc_super *) object)->class_ptr; \n\ + } \n\ + } \n\ + else \n\ + { \n\ + // This code seems a little funny, but has its reasons... \n\ + // The call to [object class] is here because if this is a class, and has not been called into \n\ + // yet, we need to do something to force the class to initialize itself. \n\ + // Then the call to object_getClass will actually return the correct class, either the class \n\ + // if object is a class instance, or the meta-class if it is a class pointer. \n\ + void *class_ptr = (void *) [(id) object class]; \n\ + return_struct.class_addr = (id) object_getClass((id) object); \n\ + if (debug) \n\ + { \n\ + if (class_ptr == object) \n\ + { \n\ + printf (\"Found a class object, need to return the meta class %p -> %p\\n\", \n\ + class_ptr, return_struct.class_addr); \n\ + } \n\ + else \n\ + { \n\ + printf (\"[object class] returned: %p object_getClass: %p.\\n\", \n\ + class_ptr, return_struct.class_addr); \n\ + } \n\ + } \n\ + } \n\ + \n\ + if (is_fixup) \n\ + { \n\ + if (is_fixed) \n\ + { \n\ + return_struct.sel_addr = ((__lldb_msg_ref *) sel)->sel; \n\ + } \n\ + else \n\ + { \n\ + char *sel_name = (char *) ((__lldb_msg_ref *) sel)->sel; \n\ + return_struct.sel_addr = sel_getUid (sel_name); \n\ + if (debug) \n\ + printf (\"\\n*** Got fixed up selector: %p for name %s.\\n\",\n\ + return_struct.sel_addr, sel_name); \n\ + } \n\ + } \n\ + else \n\ + { \n\ + return_struct.sel_addr = sel; \n\ + } \n\ + \n\ + return_struct.impl_addr = \n\ + class_getMethodImplementation (return_struct.class_addr, \n\ + return_struct.sel_addr); \n\ + if (debug) \n\ + printf (\"\\n*** Returning implementation: 0x%p.\\n\", \n\ + return_struct.impl_addr); \n\ + \n\ + return return_struct.impl_addr; \n\ +} \n\ +"; + +AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::VTableRegion( + AppleObjCVTables *owner, lldb::addr_t header_addr) + : m_valid(true), m_owner(owner), m_header_addr(header_addr), + m_code_start_addr(0), m_code_end_addr(0), m_next_region(0) { + SetUpRegion(); +} + +AppleObjCTrampolineHandler::~AppleObjCTrampolineHandler() {} + +void AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::SetUpRegion() { + // The header looks like: + // + // uint16_t headerSize + // uint16_t descSize + // uint32_t descCount + // void * next + // + // First read in the header: + + char memory_buffer[16]; + ProcessSP process_sp = m_owner->GetProcessSP(); + if (!process_sp) + return; + DataExtractor data(memory_buffer, sizeof(memory_buffer), + process_sp->GetByteOrder(), + process_sp->GetAddressByteSize()); + size_t actual_size = 8 + process_sp->GetAddressByteSize(); + Status error; + size_t bytes_read = + process_sp->ReadMemory(m_header_addr, memory_buffer, actual_size, error); + if (bytes_read != actual_size) { + m_valid = false; + return; + } + + lldb::offset_t offset = 0; + const uint16_t header_size = data.GetU16(&offset); + const uint16_t descriptor_size = data.GetU16(&offset); + const size_t num_descriptors = data.GetU32(&offset); + + m_next_region = data.GetPointer(&offset); + + // If the header size is 0, that means we've come in too early before this + // data is set up. + // Set ourselves as not valid, and continue. + if (header_size == 0 || num_descriptors == 0) { + m_valid = false; + return; + } + + // Now read in all the descriptors: + // The descriptor looks like: + // + // uint32_t offset + // uint32_t flags + // + // Where offset is either 0 - in which case it is unused, or it is + // the offset of the vtable code from the beginning of the + // descriptor record. Below, we'll convert that into an absolute + // code address, since I don't want to have to compute it over and + // over. + + // Ingest the whole descriptor array: + const lldb::addr_t desc_ptr = m_header_addr + header_size; + const size_t desc_array_size = num_descriptors * descriptor_size; + DataBufferSP data_sp(new DataBufferHeap(desc_array_size, '\0')); + uint8_t *dst = (uint8_t *)data_sp->GetBytes(); + + DataExtractor desc_extractor(dst, desc_array_size, process_sp->GetByteOrder(), + process_sp->GetAddressByteSize()); + bytes_read = process_sp->ReadMemory(desc_ptr, dst, desc_array_size, error); + if (bytes_read != desc_array_size) { + m_valid = false; + return; + } + + // The actual code for the vtables will be laid out consecutively, so I also + // compute the start and end of the whole code block. + + offset = 0; + m_code_start_addr = 0; + m_code_end_addr = 0; + + for (size_t i = 0; i < num_descriptors; i++) { + lldb::addr_t start_offset = offset; + uint32_t voffset = desc_extractor.GetU32(&offset); + uint32_t flags = desc_extractor.GetU32(&offset); + lldb::addr_t code_addr = desc_ptr + start_offset + voffset; + m_descriptors.push_back(VTableDescriptor(flags, code_addr)); + + if (m_code_start_addr == 0 || code_addr < m_code_start_addr) + m_code_start_addr = code_addr; + if (code_addr > m_code_end_addr) + m_code_end_addr = code_addr; + + offset = start_offset + descriptor_size; + } + // Finally, a little bird told me that all the vtable code blocks + // are the same size. Let's compute the blocks and if they are all + // the same add the size to the code end address: + lldb::addr_t code_size = 0; + bool all_the_same = true; + for (size_t i = 0; i < num_descriptors - 1; i++) { + lldb::addr_t this_size = + m_descriptors[i + 1].code_start - m_descriptors[i].code_start; + if (code_size == 0) + code_size = this_size; + else { + if (this_size != code_size) + all_the_same = false; + if (this_size > code_size) + code_size = this_size; + } + } + if (all_the_same) + m_code_end_addr += code_size; +} + +bool AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion:: + AddressInRegion(lldb::addr_t addr, uint32_t &flags) { + if (!IsValid()) + return false; + + if (addr < m_code_start_addr || addr > m_code_end_addr) + return false; + + std::vector<VTableDescriptor>::iterator pos, end = m_descriptors.end(); + for (pos = m_descriptors.begin(); pos != end; pos++) { + if (addr <= (*pos).code_start) { + flags = (*pos).flags; + return true; + } + } + return false; +} + +void AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::Dump( + Stream &s) { + s.Printf("Header addr: 0x%" PRIx64 " Code start: 0x%" PRIx64 + " Code End: 0x%" PRIx64 " Next: 0x%" PRIx64 "\n", + m_header_addr, m_code_start_addr, m_code_end_addr, m_next_region); + size_t num_elements = m_descriptors.size(); + for (size_t i = 0; i < num_elements; i++) { + s.Indent(); + s.Printf("Code start: 0x%" PRIx64 " Flags: %d\n", + m_descriptors[i].code_start, m_descriptors[i].flags); + } +} + +AppleObjCTrampolineHandler::AppleObjCVTables::AppleObjCVTables( + const ProcessSP &process_sp, const ModuleSP &objc_module_sp) + : m_process_wp(), m_trampoline_header(LLDB_INVALID_ADDRESS), + m_trampolines_changed_bp_id(LLDB_INVALID_BREAK_ID), + m_objc_module_sp(objc_module_sp) { + if (process_sp) + m_process_wp = process_sp; +} + +AppleObjCTrampolineHandler::AppleObjCVTables::~AppleObjCVTables() { + ProcessSP process_sp = GetProcessSP(); + if (process_sp) { + if (m_trampolines_changed_bp_id != LLDB_INVALID_BREAK_ID) + process_sp->GetTarget().RemoveBreakpointByID(m_trampolines_changed_bp_id); + } +} + +bool AppleObjCTrampolineHandler::AppleObjCVTables::InitializeVTableSymbols() { + if (m_trampoline_header != LLDB_INVALID_ADDRESS) + return true; + + ProcessSP process_sp = GetProcessSP(); + if (process_sp) { + Target &target = process_sp->GetTarget(); + + const ModuleList &target_modules = target.GetImages(); + std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex()); + size_t num_modules = target_modules.GetSize(); + if (!m_objc_module_sp) { + for (size_t i = 0; i < num_modules; i++) { + if (ObjCLanguageRuntime::Get(*process_sp) + ->IsModuleObjCLibrary( + target_modules.GetModuleAtIndexUnlocked(i))) { + m_objc_module_sp = target_modules.GetModuleAtIndexUnlocked(i); + break; + } + } + } + + if (m_objc_module_sp) { + ConstString trampoline_name("gdb_objc_trampolines"); + const Symbol *trampoline_symbol = + m_objc_module_sp->FindFirstSymbolWithNameAndType(trampoline_name, + eSymbolTypeData); + if (trampoline_symbol != nullptr) { + m_trampoline_header = trampoline_symbol->GetLoadAddress(&target); + if (m_trampoline_header == LLDB_INVALID_ADDRESS) + return false; + + // Next look up the "changed" symbol and set a breakpoint on that... + ConstString changed_name("gdb_objc_trampolines_changed"); + const Symbol *changed_symbol = + m_objc_module_sp->FindFirstSymbolWithNameAndType(changed_name, + eSymbolTypeCode); + if (changed_symbol != nullptr) { + const Address changed_symbol_addr = changed_symbol->GetAddress(); + if (!changed_symbol_addr.IsValid()) + return false; + + lldb::addr_t changed_addr = + changed_symbol_addr.GetOpcodeLoadAddress(&target); + if (changed_addr != LLDB_INVALID_ADDRESS) { + BreakpointSP trampolines_changed_bp_sp = + target.CreateBreakpoint(changed_addr, true, false); + if (trampolines_changed_bp_sp) { + m_trampolines_changed_bp_id = trampolines_changed_bp_sp->GetID(); + trampolines_changed_bp_sp->SetCallback(RefreshTrampolines, this, + true); + trampolines_changed_bp_sp->SetBreakpointKind( + "objc-trampolines-changed"); + return true; + } + } + } + } + } + } + return false; +} + +bool AppleObjCTrampolineHandler::AppleObjCVTables::RefreshTrampolines( + void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id, + lldb::user_id_t break_loc_id) { + AppleObjCVTables *vtable_handler = (AppleObjCVTables *)baton; + if (vtable_handler->InitializeVTableSymbols()) { + // The Update function is called with the address of an added region. So we + // grab that address, and + // feed it into ReadRegions. Of course, our friend the ABI will get the + // values for us. + ExecutionContext exe_ctx(context->exe_ctx_ref); + Process *process = exe_ctx.GetProcessPtr(); + const ABI *abi = process->GetABI().get(); + + ClangASTContext *clang_ast_context = + process->GetTarget().GetScratchClangASTContext(); + ValueList argument_values; + Value input_value; + CompilerType clang_void_ptr_type = + clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType(); + + input_value.SetValueType(Value::eValueTypeScalar); + // input_value.SetContext (Value::eContextTypeClangType, + // clang_void_ptr_type); + input_value.SetCompilerType(clang_void_ptr_type); + argument_values.PushValue(input_value); + + bool success = + abi->GetArgumentValues(exe_ctx.GetThreadRef(), argument_values); + if (!success) + return false; + + // Now get a pointer value from the zeroth argument. + Status error; + DataExtractor data; + error = argument_values.GetValueAtIndex(0)->GetValueAsData(&exe_ctx, data, + nullptr); + lldb::offset_t offset = 0; + lldb::addr_t region_addr = data.GetPointer(&offset); + + if (region_addr != 0) + vtable_handler->ReadRegions(region_addr); + } + return false; +} + +bool AppleObjCTrampolineHandler::AppleObjCVTables::ReadRegions() { + // The no argument version reads the start region from the value of + // the gdb_regions_header, and gets started from there. + + m_regions.clear(); + if (!InitializeVTableSymbols()) + return false; + Status error; + ProcessSP process_sp = GetProcessSP(); + if (process_sp) { + lldb::addr_t region_addr = + process_sp->ReadPointerFromMemory(m_trampoline_header, error); + if (error.Success()) + return ReadRegions(region_addr); + } + return false; +} + +bool AppleObjCTrampolineHandler::AppleObjCVTables::ReadRegions( + lldb::addr_t region_addr) { + ProcessSP process_sp = GetProcessSP(); + if (!process_sp) + return false; + + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); + + // We aren't starting at the trampoline symbol. + InitializeVTableSymbols(); + lldb::addr_t next_region = region_addr; + + // Read in the sizes of the headers. + while (next_region != 0) { + m_regions.push_back(VTableRegion(this, next_region)); + if (!m_regions.back().IsValid()) { + m_regions.clear(); + return false; + } + if (log) { + StreamString s; + m_regions.back().Dump(s); + LLDB_LOGF(log, "Read vtable region: \n%s", s.GetData()); + } + + next_region = m_regions.back().GetNextRegionAddr(); + } + + return true; +} + +bool AppleObjCTrampolineHandler::AppleObjCVTables::IsAddressInVTables( + lldb::addr_t addr, uint32_t &flags) { + region_collection::iterator pos, end = m_regions.end(); + for (pos = m_regions.begin(); pos != end; pos++) { + if ((*pos).AddressInRegion(addr, flags)) + return true; + } + return false; +} + +const AppleObjCTrampolineHandler::DispatchFunction + AppleObjCTrampolineHandler::g_dispatch_functions[] = { + // NAME STRET SUPER SUPER2 FIXUP TYPE + {"objc_msgSend", false, false, false, DispatchFunction::eFixUpNone}, + {"objc_msgSend_fixup", false, false, false, + DispatchFunction::eFixUpToFix}, + {"objc_msgSend_fixedup", false, false, false, + DispatchFunction::eFixUpFixed}, + {"objc_msgSend_stret", true, false, false, + DispatchFunction::eFixUpNone}, + {"objc_msgSend_stret_fixup", true, false, false, + DispatchFunction::eFixUpToFix}, + {"objc_msgSend_stret_fixedup", true, false, false, + DispatchFunction::eFixUpFixed}, + {"objc_msgSend_fpret", false, false, false, + DispatchFunction::eFixUpNone}, + {"objc_msgSend_fpret_fixup", false, false, false, + DispatchFunction::eFixUpToFix}, + {"objc_msgSend_fpret_fixedup", false, false, false, + DispatchFunction::eFixUpFixed}, + {"objc_msgSend_fp2ret", false, false, true, + DispatchFunction::eFixUpNone}, + {"objc_msgSend_fp2ret_fixup", false, false, true, + DispatchFunction::eFixUpToFix}, + {"objc_msgSend_fp2ret_fixedup", false, false, true, + DispatchFunction::eFixUpFixed}, + {"objc_msgSendSuper", false, true, false, DispatchFunction::eFixUpNone}, + {"objc_msgSendSuper_stret", true, true, false, + DispatchFunction::eFixUpNone}, + {"objc_msgSendSuper2", false, true, true, DispatchFunction::eFixUpNone}, + {"objc_msgSendSuper2_fixup", false, true, true, + DispatchFunction::eFixUpToFix}, + {"objc_msgSendSuper2_fixedup", false, true, true, + DispatchFunction::eFixUpFixed}, + {"objc_msgSendSuper2_stret", true, true, true, + DispatchFunction::eFixUpNone}, + {"objc_msgSendSuper2_stret_fixup", true, true, true, + DispatchFunction::eFixUpToFix}, + {"objc_msgSendSuper2_stret_fixedup", true, true, true, + DispatchFunction::eFixUpFixed}, +}; + +AppleObjCTrampolineHandler::AppleObjCTrampolineHandler( + const ProcessSP &process_sp, const ModuleSP &objc_module_sp) + : m_process_wp(), m_objc_module_sp(objc_module_sp), + m_lookup_implementation_function_code(nullptr), + m_impl_fn_addr(LLDB_INVALID_ADDRESS), + m_impl_stret_fn_addr(LLDB_INVALID_ADDRESS), + m_msg_forward_addr(LLDB_INVALID_ADDRESS) { + if (process_sp) + m_process_wp = process_sp; + // Look up the known resolution functions: + + ConstString get_impl_name("class_getMethodImplementation"); + ConstString get_impl_stret_name("class_getMethodImplementation_stret"); + ConstString msg_forward_name("_objc_msgForward"); + ConstString msg_forward_stret_name("_objc_msgForward_stret"); + + Target *target = process_sp ? &process_sp->GetTarget() : nullptr; + const Symbol *class_getMethodImplementation = + m_objc_module_sp->FindFirstSymbolWithNameAndType(get_impl_name, + eSymbolTypeCode); + const Symbol *class_getMethodImplementation_stret = + m_objc_module_sp->FindFirstSymbolWithNameAndType(get_impl_stret_name, + eSymbolTypeCode); + const Symbol *msg_forward = m_objc_module_sp->FindFirstSymbolWithNameAndType( + msg_forward_name, eSymbolTypeCode); + const Symbol *msg_forward_stret = + m_objc_module_sp->FindFirstSymbolWithNameAndType(msg_forward_stret_name, + eSymbolTypeCode); + + if (class_getMethodImplementation) + m_impl_fn_addr = + class_getMethodImplementation->GetAddress().GetOpcodeLoadAddress( + target); + if (class_getMethodImplementation_stret) + m_impl_stret_fn_addr = + class_getMethodImplementation_stret->GetAddress().GetOpcodeLoadAddress( + target); + if (msg_forward) + m_msg_forward_addr = msg_forward->GetAddress().GetOpcodeLoadAddress(target); + if (msg_forward_stret) + m_msg_forward_stret_addr = + msg_forward_stret->GetAddress().GetOpcodeLoadAddress(target); + + // FIXME: Do some kind of logging here. + if (m_impl_fn_addr == LLDB_INVALID_ADDRESS) { + // If we can't even find the ordinary get method implementation function, + // then we aren't going to be able to + // step through any method dispatches. Warn to that effect and get out of + // here. + if (process_sp->CanJIT()) { + process_sp->GetTarget().GetDebugger().GetErrorStream().Printf( + "Could not find implementation lookup function \"%s\"" + " step in through ObjC method dispatch will not work.\n", + get_impl_name.AsCString()); + } + return; + } else if (m_impl_stret_fn_addr == LLDB_INVALID_ADDRESS) { + // It there is no stret return lookup function, assume that it is the same + // as the straight lookup: + m_impl_stret_fn_addr = m_impl_fn_addr; + // Also we will use the version of the lookup code that doesn't rely on the + // stret version of the function. + m_lookup_implementation_function_code = + g_lookup_implementation_no_stret_function_code; + } else { + m_lookup_implementation_function_code = + g_lookup_implementation_with_stret_function_code; + } + + // Look up the addresses for the objc dispatch functions and cache + // them. For now I'm inspecting the symbol names dynamically to + // figure out how to dispatch to them. If it becomes more + // complicated than this we can turn the g_dispatch_functions char * + // array into a template table, and populate the DispatchFunction + // map from there. + + for (size_t i = 0; i != llvm::array_lengthof(g_dispatch_functions); i++) { + ConstString name_const_str(g_dispatch_functions[i].name); + const Symbol *msgSend_symbol = + m_objc_module_sp->FindFirstSymbolWithNameAndType(name_const_str, + eSymbolTypeCode); + if (msgSend_symbol && msgSend_symbol->ValueIsAddress()) { + // FIXME: Make g_dispatch_functions static table of + // DispatchFunctions, and have the map be address->index. + // Problem is we also need to lookup the dispatch function. For + // now we could have a side table of stret & non-stret dispatch + // functions. If that's as complex as it gets, we're fine. + + lldb::addr_t sym_addr = + msgSend_symbol->GetAddressRef().GetOpcodeLoadAddress(target); + + m_msgSend_map.insert(std::pair<lldb::addr_t, int>(sym_addr, i)); + } + } + + // Build our vtable dispatch handler here: + m_vtables_up.reset(new AppleObjCVTables(process_sp, m_objc_module_sp)); + if (m_vtables_up) + m_vtables_up->ReadRegions(); +} + +lldb::addr_t +AppleObjCTrampolineHandler::SetupDispatchFunction(Thread &thread, + ValueList &dispatch_values) { + ThreadSP thread_sp(thread.shared_from_this()); + ExecutionContext exe_ctx(thread_sp); + DiagnosticManager diagnostics; + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); + + lldb::addr_t args_addr = LLDB_INVALID_ADDRESS; + FunctionCaller *impl_function_caller = nullptr; + + // Scope for mutex locker: + { + std::lock_guard<std::mutex> guard(m_impl_function_mutex); + + // First stage is to make the ClangUtility to hold our injected function: + + if (!m_impl_code) { + if (m_lookup_implementation_function_code != nullptr) { + Status error; + m_impl_code.reset(exe_ctx.GetTargetRef().GetUtilityFunctionForLanguage( + m_lookup_implementation_function_code, eLanguageTypeObjC, + g_lookup_implementation_function_name, error)); + if (error.Fail()) { + LLDB_LOGF( + log, + "Failed to get Utility Function for implementation lookup: %s.", + error.AsCString()); + m_impl_code.reset(); + return args_addr; + } + + if (!m_impl_code->Install(diagnostics, exe_ctx)) { + if (log) { + LLDB_LOGF(log, "Failed to install implementation lookup."); + diagnostics.Dump(log); + } + m_impl_code.reset(); + return args_addr; + } + } else { + LLDB_LOGF(log, "No method lookup implementation code."); + return LLDB_INVALID_ADDRESS; + } + + // Next make the runner function for our implementation utility function. + ClangASTContext *clang_ast_context = + thread.GetProcess()->GetTarget().GetScratchClangASTContext(); + CompilerType clang_void_ptr_type = + clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType(); + Status error; + + impl_function_caller = m_impl_code->MakeFunctionCaller( + clang_void_ptr_type, dispatch_values, thread_sp, error); + if (error.Fail()) { + LLDB_LOGF(log, + "Error getting function caller for dispatch lookup: \"%s\".", + error.AsCString()); + return args_addr; + } + } else { + impl_function_caller = m_impl_code->GetFunctionCaller(); + } + } + + diagnostics.Clear(); + + // Now write down the argument values for this particular call. + // This looks like it might be a race condition if other threads + // were calling into here, but actually it isn't because we allocate + // a new args structure for this call by passing args_addr = + // LLDB_INVALID_ADDRESS... + + if (!impl_function_caller->WriteFunctionArguments( + exe_ctx, args_addr, dispatch_values, diagnostics)) { + if (log) { + LLDB_LOGF(log, "Error writing function arguments."); + diagnostics.Dump(log); + } + return args_addr; + } + + return args_addr; +} + +ThreadPlanSP +AppleObjCTrampolineHandler::GetStepThroughDispatchPlan(Thread &thread, + bool stop_others) { + ThreadPlanSP ret_plan_sp; + lldb::addr_t curr_pc = thread.GetRegisterContext()->GetPC(); + + DispatchFunction this_dispatch; + bool found_it = false; + + // First step is to look and see if we are in one of the known ObjC + // dispatch functions. We've already compiled a table of same, so + // consult it. + + MsgsendMap::iterator pos; + pos = m_msgSend_map.find(curr_pc); + if (pos != m_msgSend_map.end()) { + this_dispatch = g_dispatch_functions[(*pos).second]; + found_it = true; + } + + // Next check to see if we are in a vtable region: + + if (!found_it) { + uint32_t flags; + if (m_vtables_up) { + found_it = m_vtables_up->IsAddressInVTables(curr_pc, flags); + if (found_it) { + this_dispatch.name = "vtable"; + this_dispatch.stret_return = + (flags & AppleObjCVTables::eOBJC_TRAMPOLINE_STRET) == + AppleObjCVTables::eOBJC_TRAMPOLINE_STRET; + this_dispatch.is_super = false; + this_dispatch.is_super2 = false; + this_dispatch.fixedup = DispatchFunction::eFixUpFixed; + } + } + } + + if (found_it) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); + + // We are decoding a method dispatch. First job is to pull the + // arguments out: + + lldb::StackFrameSP thread_cur_frame = thread.GetStackFrameAtIndex(0); + + const ABI *abi = nullptr; + ProcessSP process_sp(thread.CalculateProcess()); + if (process_sp) + abi = process_sp->GetABI().get(); + if (abi == nullptr) + return ret_plan_sp; + + TargetSP target_sp(thread.CalculateTarget()); + + ClangASTContext *clang_ast_context = target_sp->GetScratchClangASTContext(); + ValueList argument_values; + Value void_ptr_value; + CompilerType clang_void_ptr_type = + clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType(); + void_ptr_value.SetValueType(Value::eValueTypeScalar); + // void_ptr_value.SetContext (Value::eContextTypeClangType, + // clang_void_ptr_type); + void_ptr_value.SetCompilerType(clang_void_ptr_type); + + int obj_index; + int sel_index; + + // If this is a struct return dispatch, then the first argument is + // the return struct pointer, and the object is the second, and + // the selector is the third. Otherwise the object is the first + // and the selector the second. + if (this_dispatch.stret_return) { + obj_index = 1; + sel_index = 2; + argument_values.PushValue(void_ptr_value); + argument_values.PushValue(void_ptr_value); + argument_values.PushValue(void_ptr_value); + } else { + obj_index = 0; + sel_index = 1; + argument_values.PushValue(void_ptr_value); + argument_values.PushValue(void_ptr_value); + } + + bool success = abi->GetArgumentValues(thread, argument_values); + if (!success) + return ret_plan_sp; + + lldb::addr_t obj_addr = + argument_values.GetValueAtIndex(obj_index)->GetScalar().ULongLong(); + if (obj_addr == 0x0) { + LLDB_LOGF( + log, + "Asked to step to dispatch to nil object, returning empty plan."); + return ret_plan_sp; + } + + ExecutionContext exe_ctx(thread.shared_from_this()); + Process *process = exe_ctx.GetProcessPtr(); + // isa_addr will store the class pointer that the method is being + // dispatched to - so either the class directly or the super class + // if this is one of the objc_msgSendSuper flavors. That's mostly + // used to look up the class/selector pair in our cache. + + lldb::addr_t isa_addr = LLDB_INVALID_ADDRESS; + lldb::addr_t sel_addr = + argument_values.GetValueAtIndex(sel_index)->GetScalar().ULongLong(); + + // Figure out the class this is being dispatched to and see if + // we've already cached this method call, If so we can push a + // run-to-address plan directly. Otherwise we have to figure out + // where the implementation lives. + + if (this_dispatch.is_super) { + if (this_dispatch.is_super2) { + // In the objc_msgSendSuper2 case, we don't get the object + // directly, we get a structure containing the object and the + // class to which the super message is being sent. So we need + // to dig the super out of the class and use that. + + Value super_value(*(argument_values.GetValueAtIndex(obj_index))); + super_value.GetScalar() += process->GetAddressByteSize(); + super_value.ResolveValue(&exe_ctx); + + if (super_value.GetScalar().IsValid()) { + + // isa_value now holds the class pointer. The second word of the + // class pointer is the super-class pointer: + super_value.GetScalar() += process->GetAddressByteSize(); + super_value.ResolveValue(&exe_ctx); + if (super_value.GetScalar().IsValid()) + isa_addr = super_value.GetScalar().ULongLong(); + else { + LLDB_LOGF(log, "Failed to extract the super class value from the " + "class in objc_super."); + } + } else { + LLDB_LOGF(log, "Failed to extract the class value from objc_super."); + } + } else { + // In the objc_msgSendSuper case, we don't get the object + // directly, we get a two element structure containing the + // object and the super class to which the super message is + // being sent. So the class we want is the second element of + // this structure. + + Value super_value(*(argument_values.GetValueAtIndex(obj_index))); + super_value.GetScalar() += process->GetAddressByteSize(); + super_value.ResolveValue(&exe_ctx); + + if (super_value.GetScalar().IsValid()) { + isa_addr = super_value.GetScalar().ULongLong(); + } else { + LLDB_LOGF(log, "Failed to extract the class value from objc_super."); + } + } + } else { + // In the direct dispatch case, the object->isa is the class pointer we + // want. + + // This is a little cheesy, but since object->isa is the first field, + // making the object value a load address value and resolving it will get + // the pointer sized data pointed to by that value... + + // Note, it isn't a fatal error not to be able to get the + // address from the object, since this might be a "tagged + // pointer" which isn't a real object, but rather some word + // length encoded dingus. + + Value isa_value(*(argument_values.GetValueAtIndex(obj_index))); + + isa_value.SetValueType(Value::eValueTypeLoadAddress); + isa_value.ResolveValue(&exe_ctx); + if (isa_value.GetScalar().IsValid()) { + isa_addr = isa_value.GetScalar().ULongLong(); + } else { + LLDB_LOGF(log, "Failed to extract the isa value from object."); + } + } + + // Okay, we've got the address of the class for which we're resolving this, + // let's see if it's in our cache: + lldb::addr_t impl_addr = LLDB_INVALID_ADDRESS; + + if (isa_addr != LLDB_INVALID_ADDRESS) { + if (log) { + LLDB_LOGF(log, + "Resolving call for class - 0x%" PRIx64 + " and selector - 0x%" PRIx64, + isa_addr, sel_addr); + } + ObjCLanguageRuntime *objc_runtime = + ObjCLanguageRuntime::Get(*thread.GetProcess()); + assert(objc_runtime != nullptr); + + impl_addr = objc_runtime->LookupInMethodCache(isa_addr, sel_addr); + } + + if (impl_addr != LLDB_INVALID_ADDRESS) { + // Yup, it was in the cache, so we can run to that address directly. + + LLDB_LOGF(log, "Found implementation address in cache: 0x%" PRIx64, + impl_addr); + + ret_plan_sp = std::make_shared<ThreadPlanRunToAddress>(thread, impl_addr, + stop_others); + } else { + // We haven't seen this class/selector pair yet. Look it up. + StreamString errors; + Address impl_code_address; + + ValueList dispatch_values; + + // We've will inject a little function in the target that takes the + // object, selector and some flags, + // and figures out the implementation. Looks like: + // void *__lldb_objc_find_implementation_for_selector (void *object, + // void *sel, + // int is_stret, + // int is_super, + // int is_super2, + // int is_fixup, + // int is_fixed, + // int debug) + // So set up the arguments for that call. + + dispatch_values.PushValue(*(argument_values.GetValueAtIndex(obj_index))); + dispatch_values.PushValue(*(argument_values.GetValueAtIndex(sel_index))); + + Value flag_value; + CompilerType clang_int_type = + clang_ast_context->GetBuiltinTypeForEncodingAndBitSize( + lldb::eEncodingSint, 32); + flag_value.SetValueType(Value::eValueTypeScalar); + // flag_value.SetContext (Value::eContextTypeClangType, clang_int_type); + flag_value.SetCompilerType(clang_int_type); + + if (this_dispatch.stret_return) + flag_value.GetScalar() = 1; + else + flag_value.GetScalar() = 0; + dispatch_values.PushValue(flag_value); + + if (this_dispatch.is_super) + flag_value.GetScalar() = 1; + else + flag_value.GetScalar() = 0; + dispatch_values.PushValue(flag_value); + + if (this_dispatch.is_super2) + flag_value.GetScalar() = 1; + else + flag_value.GetScalar() = 0; + dispatch_values.PushValue(flag_value); + + switch (this_dispatch.fixedup) { + case DispatchFunction::eFixUpNone: + flag_value.GetScalar() = 0; + dispatch_values.PushValue(flag_value); + dispatch_values.PushValue(flag_value); + break; + case DispatchFunction::eFixUpFixed: + flag_value.GetScalar() = 1; + dispatch_values.PushValue(flag_value); + flag_value.GetScalar() = 1; + dispatch_values.PushValue(flag_value); + break; + case DispatchFunction::eFixUpToFix: + flag_value.GetScalar() = 1; + dispatch_values.PushValue(flag_value); + flag_value.GetScalar() = 0; + dispatch_values.PushValue(flag_value); + break; + } + if (log && log->GetVerbose()) + flag_value.GetScalar() = 1; + else + flag_value.GetScalar() = 0; // FIXME - Set to 0 when debugging is done. + dispatch_values.PushValue(flag_value); + + // The step through code might have to fill in the cache, so it + // is not safe to run only one thread. So we override the + // stop_others value passed in to us here: + const bool trampoline_stop_others = false; + ret_plan_sp = std::make_shared<AppleThreadPlanStepThroughObjCTrampoline>( + thread, this, dispatch_values, isa_addr, sel_addr, + trampoline_stop_others); + if (log) { + StreamString s; + ret_plan_sp->GetDescription(&s, eDescriptionLevelFull); + LLDB_LOGF(log, "Using ObjC step plan: %s.\n", s.GetData()); + } + } + } + + return ret_plan_sp; +} + +FunctionCaller * +AppleObjCTrampolineHandler::GetLookupImplementationFunctionCaller() { + return m_impl_code->GetFunctionCaller(); +} diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.h b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.h new file mode 100644 index 000000000000..d120d671eeb3 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.h @@ -0,0 +1,158 @@ +//===-- AppleObjCTrampolineHandler.h ----------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef lldb_AppleObjCTrampolineHandler_h_ +#define lldb_AppleObjCTrampolineHandler_h_ + +#include <map> +#include <mutex> +#include <vector> + +#include "lldb/Expression/UtilityFunction.h" +#include "lldb/lldb-public.h" + +namespace lldb_private { + +class AppleObjCTrampolineHandler { +public: + AppleObjCTrampolineHandler(const lldb::ProcessSP &process_sp, + const lldb::ModuleSP &objc_module_sp); + + ~AppleObjCTrampolineHandler(); + + lldb::ThreadPlanSP GetStepThroughDispatchPlan(Thread &thread, + bool stop_others); + + FunctionCaller *GetLookupImplementationFunctionCaller(); + + bool AddrIsMsgForward(lldb::addr_t addr) const { + return (addr == m_msg_forward_addr || addr == m_msg_forward_stret_addr); + } + + struct DispatchFunction { + public: + enum FixUpState { eFixUpNone, eFixUpFixed, eFixUpToFix }; + + const char *name; + bool stret_return; + bool is_super; + bool is_super2; + FixUpState fixedup; + }; + + lldb::addr_t SetupDispatchFunction(Thread &thread, + ValueList &dispatch_values); + +private: + static const char *g_lookup_implementation_function_name; + static const char *g_lookup_implementation_with_stret_function_code; + static const char *g_lookup_implementation_no_stret_function_code; + + class AppleObjCVTables { + public: + // These come from objc-gdb.h. + enum VTableFlags { + eOBJC_TRAMPOLINE_MESSAGE = (1 << 0), // trampoline acts like objc_msgSend + eOBJC_TRAMPOLINE_STRET = (1 << 1), // trampoline is struct-returning + eOBJC_TRAMPOLINE_VTABLE = (1 << 2) // trampoline is vtable dispatcher + }; + + private: + struct VTableDescriptor { + VTableDescriptor(uint32_t in_flags, lldb::addr_t in_code_start) + : flags(in_flags), code_start(in_code_start) {} + + uint32_t flags; + lldb::addr_t code_start; + }; + + class VTableRegion { + public: + VTableRegion() + : m_valid(false), m_owner(nullptr), + m_header_addr(LLDB_INVALID_ADDRESS), m_code_start_addr(0), + m_code_end_addr(0), m_next_region(0) {} + + VTableRegion(AppleObjCVTables *owner, lldb::addr_t header_addr); + + void SetUpRegion(); + + lldb::addr_t GetNextRegionAddr() { return m_next_region; } + + lldb::addr_t GetCodeStart() { return m_code_start_addr; } + + lldb::addr_t GetCodeEnd() { return m_code_end_addr; } + + uint32_t GetFlagsForVTableAtAddress(lldb::addr_t address) { return 0; } + + bool IsValid() { return m_valid; } + + bool AddressInRegion(lldb::addr_t addr, uint32_t &flags); + + void Dump(Stream &s); + + public: + bool m_valid; + AppleObjCVTables *m_owner; + lldb::addr_t m_header_addr; + lldb::addr_t m_code_start_addr; + lldb::addr_t m_code_end_addr; + std::vector<VTableDescriptor> m_descriptors; + lldb::addr_t m_next_region; + }; + + public: + AppleObjCVTables(const lldb::ProcessSP &process_sp, + const lldb::ModuleSP &objc_module_sp); + + ~AppleObjCVTables(); + + bool InitializeVTableSymbols(); + + static bool RefreshTrampolines(void *baton, + StoppointCallbackContext *context, + lldb::user_id_t break_id, + lldb::user_id_t break_loc_id); + bool ReadRegions(); + + bool ReadRegions(lldb::addr_t region_addr); + + bool IsAddressInVTables(lldb::addr_t addr, uint32_t &flags); + + lldb::ProcessSP GetProcessSP() { return m_process_wp.lock(); } + + private: + lldb::ProcessWP m_process_wp; + typedef std::vector<VTableRegion> region_collection; + lldb::addr_t m_trampoline_header; + lldb::break_id_t m_trampolines_changed_bp_id; + region_collection m_regions; + lldb::ModuleSP m_objc_module_sp; + }; + + static const DispatchFunction g_dispatch_functions[]; + + typedef std::map<lldb::addr_t, int> MsgsendMap; // This table maps an dispatch + // fn address to the index in + // g_dispatch_functions + MsgsendMap m_msgSend_map; + lldb::ProcessWP m_process_wp; + lldb::ModuleSP m_objc_module_sp; + const char *m_lookup_implementation_function_code; + std::unique_ptr<UtilityFunction> m_impl_code; + std::mutex m_impl_function_mutex; + lldb::addr_t m_impl_fn_addr; + lldb::addr_t m_impl_stret_fn_addr; + lldb::addr_t m_msg_forward_addr; + lldb::addr_t m_msg_forward_stret_addr; + std::unique_ptr<AppleObjCVTables> m_vtables_up; +}; + +} // namespace lldb_private + +#endif // lldb_AppleObjCTrampolineHandler_h_ diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp new file mode 100644 index 000000000000..6402e80d6f98 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp @@ -0,0 +1,374 @@ +//===-- AppleObjCTypeEncodingParser.cpp -------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "AppleObjCTypeEncodingParser.h" + +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Symbol/ClangUtil.h" +#include "lldb/Symbol/CompilerType.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/Target.h" +#include "lldb/Utility/StringLexer.h" + +#include <vector> + +using namespace lldb_private; + +AppleObjCTypeEncodingParser::AppleObjCTypeEncodingParser( + ObjCLanguageRuntime &runtime) + : ObjCLanguageRuntime::EncodingToType(), m_runtime(runtime) { + if (!m_scratch_ast_ctx_up) + m_scratch_ast_ctx_up.reset(new ClangASTContext(runtime.GetProcess() + ->GetTarget() + .GetArchitecture() + .GetTriple() + .str() + .c_str())); +} + +std::string AppleObjCTypeEncodingParser::ReadStructName(StringLexer &type) { + StreamString buffer; + while (type.HasAtLeast(1) && type.Peek() != '=') + buffer.Printf("%c", type.Next()); + return buffer.GetString(); +} + +std::string AppleObjCTypeEncodingParser::ReadQuotedString(StringLexer &type) { + StreamString buffer; + while (type.HasAtLeast(1) && type.Peek() != '"') + buffer.Printf("%c", type.Next()); + StringLexer::Character next = type.Next(); + UNUSED_IF_ASSERT_DISABLED(next); + assert(next == '"'); + return buffer.GetString(); +} + +uint32_t AppleObjCTypeEncodingParser::ReadNumber(StringLexer &type) { + uint32_t total = 0; + while (type.HasAtLeast(1) && isdigit(type.Peek())) + total = 10 * total + (type.Next() - '0'); + return total; +} + +// as an extension to the published grammar recent runtimes emit structs like +// this: +// "{CGRect=\"origin\"{CGPoint=\"x\"d\"y\"d}\"size\"{CGSize=\"width\"d\"height\"d}}" + +AppleObjCTypeEncodingParser::StructElement::StructElement() + : name(""), type(clang::QualType()), bitfield(0) {} + +AppleObjCTypeEncodingParser::StructElement +AppleObjCTypeEncodingParser::ReadStructElement(clang::ASTContext &ast_ctx, + StringLexer &type, + bool for_expression) { + StructElement retval; + if (type.NextIf('"')) + retval.name = ReadQuotedString(type); + if (!type.NextIf('"')) + return retval; + uint32_t bitfield_size = 0; + retval.type = BuildType(ast_ctx, type, for_expression, &bitfield_size); + retval.bitfield = bitfield_size; + return retval; +} + +clang::QualType AppleObjCTypeEncodingParser::BuildStruct( + clang::ASTContext &ast_ctx, StringLexer &type, bool for_expression) { + return BuildAggregate(ast_ctx, type, for_expression, '{', '}', + clang::TTK_Struct); +} + +clang::QualType AppleObjCTypeEncodingParser::BuildUnion( + clang::ASTContext &ast_ctx, StringLexer &type, bool for_expression) { + return BuildAggregate(ast_ctx, type, for_expression, '(', ')', + clang::TTK_Union); +} + +clang::QualType AppleObjCTypeEncodingParser::BuildAggregate( + clang::ASTContext &ast_ctx, StringLexer &type, bool for_expression, + char opener, char closer, uint32_t kind) { + if (!type.NextIf(opener)) + return clang::QualType(); + std::string name(ReadStructName(type)); + + // We do not handle templated classes/structs at the moment. If the name has + // a < in it, we are going to abandon this. We're still obliged to parse it, + // so we just set a flag that means "Don't actually build anything." + + const bool is_templated = name.find('<') != std::string::npos; + + if (!type.NextIf('=')) + return clang::QualType(); + bool in_union = true; + std::vector<StructElement> elements; + while (in_union && type.HasAtLeast(1)) { + if (type.NextIf(closer)) { + in_union = false; + break; + } else { + auto element = ReadStructElement(ast_ctx, type, for_expression); + if (element.type.isNull()) + break; + else + elements.push_back(element); + } + } + if (in_union) + return clang::QualType(); + + if (is_templated) + return clang::QualType(); // This is where we bail out. Sorry! + + ClangASTContext *lldb_ctx = ClangASTContext::GetASTContext(&ast_ctx); + if (!lldb_ctx) + return clang::QualType(); + CompilerType union_type(lldb_ctx->CreateRecordType( + nullptr, lldb::eAccessPublic, name.c_str(), kind, lldb::eLanguageTypeC)); + if (union_type) { + ClangASTContext::StartTagDeclarationDefinition(union_type); + + unsigned int count = 0; + for (auto element : elements) { + if (element.name.empty()) { + StreamString elem_name; + elem_name.Printf("__unnamed_%u", count); + element.name = elem_name.GetString(); + } + ClangASTContext::AddFieldToRecordType( + union_type, element.name.c_str(), + CompilerType(ClangASTContext::GetASTContext(&ast_ctx), + element.type.getAsOpaquePtr()), + lldb::eAccessPublic, element.bitfield); + ++count; + } + ClangASTContext::CompleteTagDeclarationDefinition(union_type); + } + return ClangUtil::GetQualType(union_type); +} + +clang::QualType AppleObjCTypeEncodingParser::BuildArray( + clang::ASTContext &ast_ctx, StringLexer &type, bool for_expression) { + if (!type.NextIf('[')) + return clang::QualType(); + uint32_t size = ReadNumber(type); + clang::QualType element_type(BuildType(ast_ctx, type, for_expression)); + if (!type.NextIf(']')) + return clang::QualType(); + ClangASTContext *lldb_ctx = ClangASTContext::GetASTContext(&ast_ctx); + if (!lldb_ctx) + return clang::QualType(); + CompilerType array_type(lldb_ctx->CreateArrayType( + CompilerType(ClangASTContext::GetASTContext(&ast_ctx), + element_type.getAsOpaquePtr()), + size, false)); + return ClangUtil::GetQualType(array_type); +} + +// the runtime can emit these in the form of @"SomeType", giving more specifics +// this would be interesting for expression parser interop, but since we +// actually try to avoid exposing the ivar info to the expression evaluator, +// consume but ignore the type info and always return an 'id'; if anything, +// dynamic typing will resolve things for us anyway +clang::QualType AppleObjCTypeEncodingParser::BuildObjCObjectPointerType( + clang::ASTContext &ast_ctx, StringLexer &type, bool for_expression) { + if (!type.NextIf('@')) + return clang::QualType(); + + std::string name; + + if (type.NextIf('"')) { + // We have to be careful here. We're used to seeing + // @"NSString" + // but in records it is possible that the string following an @ is the name + // of the next field and @ means "id". This is the case if anything + // unquoted except for "}", the end of the type, or another name follows + // the quoted string. + // + // E.g. + // - @"NSString"@ means "id, followed by a field named NSString of type id" + // - @"NSString"} means "a pointer to NSString and the end of the struct" - + // @"NSString""nextField" means "a pointer to NSString and a field named + // nextField" - @"NSString" followed by the end of the string means "a + // pointer to NSString" + // + // As a result, the rule is: If we see @ followed by a quoted string, we + // peek. - If we see }, ), ], the end of the string, or a quote ("), the + // quoted string is a class name. - If we see anything else, the quoted + // string is a field name and we push it back onto type. + + name = ReadQuotedString(type); + + if (type.HasAtLeast(1)) { + switch (type.Peek()) { + default: + // roll back + type.PutBack(name.length() + + 2); // undo our consumption of the string and of the quotes + name.clear(); + break; + case '}': + case ')': + case ']': + case '"': + // the quoted string is a class name – see the rule + break; + } + } else { + // the quoted string is a class name – see the rule + } + } + + if (for_expression && !name.empty()) { + size_t less_than_pos = name.find('<'); + + if (less_than_pos != std::string::npos) { + if (less_than_pos == 0) + return ast_ctx.getObjCIdType(); + else + name.erase(less_than_pos); + } + + DeclVendor *decl_vendor = m_runtime.GetDeclVendor(); + if (!decl_vendor) + return clang::QualType(); + + auto types = decl_vendor->FindTypes(ConstString(name), /*max_matches*/ 1); + +// The user can forward-declare something that has no definition. The runtime +// doesn't prohibit this at all. This is a rare and very weird case. We keep +// this assert in debug builds so we catch other weird cases. +#ifdef LLDB_CONFIGURATION_DEBUG + assert(!types.empty()); +#else + if (types.empty()) + return ast_ctx.getObjCIdType(); +#endif + + return ClangUtil::GetQualType(types.front().GetPointerType()); + } else { + // We're going to resolve this dynamically anyway, so just smile and wave. + return ast_ctx.getObjCIdType(); + } +} + +clang::QualType +AppleObjCTypeEncodingParser::BuildType(clang::ASTContext &ast_ctx, + StringLexer &type, bool for_expression, + uint32_t *bitfield_bit_size) { + if (!type.HasAtLeast(1)) + return clang::QualType(); + + switch (type.Peek()) { + default: + break; + case '{': + return BuildStruct(ast_ctx, type, for_expression); + case '[': + return BuildArray(ast_ctx, type, for_expression); + case '(': + return BuildUnion(ast_ctx, type, for_expression); + case '@': + return BuildObjCObjectPointerType(ast_ctx, type, for_expression); + } + + switch (type.Next()) { + default: + type.PutBack(1); + return clang::QualType(); + case 'c': + return ast_ctx.CharTy; + case 'i': + return ast_ctx.IntTy; + case 's': + return ast_ctx.ShortTy; + case 'l': + return ast_ctx.getIntTypeForBitwidth(32, true); + // this used to be done like this: + // ClangASTContext *lldb_ctx = ClangASTContext::GetASTContext(&ast_ctx); + // if (!lldb_ctx) + // return clang::QualType(); + // return lldb_ctx->GetIntTypeFromBitSize(32, true).GetQualType(); + // which uses one of the constants if one is available, but we don't think + // all this work is necessary. + case 'q': + return ast_ctx.LongLongTy; + case 'C': + return ast_ctx.UnsignedCharTy; + case 'I': + return ast_ctx.UnsignedIntTy; + case 'S': + return ast_ctx.UnsignedShortTy; + case 'L': + return ast_ctx.getIntTypeForBitwidth(32, false); + // see note for 'l' + case 'Q': + return ast_ctx.UnsignedLongLongTy; + case 'f': + return ast_ctx.FloatTy; + case 'd': + return ast_ctx.DoubleTy; + case 'B': + return ast_ctx.BoolTy; + case 'v': + return ast_ctx.VoidTy; + case '*': + return ast_ctx.getPointerType(ast_ctx.CharTy); + case '#': + return ast_ctx.getObjCClassType(); + case ':': + return ast_ctx.getObjCSelType(); + case 'b': { + uint32_t size = ReadNumber(type); + if (bitfield_bit_size) { + *bitfield_bit_size = size; + return ast_ctx.UnsignedIntTy; // FIXME: the spec is fairly vague here. + } else + return clang::QualType(); + } + case 'r': { + clang::QualType target_type = BuildType(ast_ctx, type, for_expression); + if (target_type.isNull()) + return clang::QualType(); + else if (target_type == ast_ctx.UnknownAnyTy) + return ast_ctx.UnknownAnyTy; + else + return ast_ctx.getConstType(target_type); + } + case '^': { + if (!for_expression && type.NextIf('?')) { + // if we are not supporting the concept of unknownAny, but what is being + // created here is an unknownAny*, then we can just get away with a void* + // this is theoretically wrong (in the same sense as 'theoretically + // nothing exists') but is way better than outright failure in many + // practical cases + return ast_ctx.VoidPtrTy; + } else { + clang::QualType target_type = BuildType(ast_ctx, type, for_expression); + if (target_type.isNull()) + return clang::QualType(); + else if (target_type == ast_ctx.UnknownAnyTy) + return ast_ctx.UnknownAnyTy; + else + return ast_ctx.getPointerType(target_type); + } + } + case '?': + return for_expression ? ast_ctx.UnknownAnyTy : clang::QualType(); + } +} + +CompilerType AppleObjCTypeEncodingParser::RealizeType( + clang::ASTContext &ast_ctx, const char *name, bool for_expression) { + if (name && name[0]) { + StringLexer lexer(name); + clang::QualType qual_type = BuildType(ast_ctx, lexer, for_expression); + return CompilerType(ClangASTContext::GetASTContext(&ast_ctx), + qual_type.getAsOpaquePtr()); + } + return CompilerType(); +} diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.h b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.h new file mode 100644 index 000000000000..590bc4ba9eae --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.h @@ -0,0 +1,73 @@ +//===-- AppleObjCTypeEncodingParser.h ---------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_AppleObjCTypeEncodingParser_h_ +#define liblldb_AppleObjCTypeEncodingParser_h_ + +#include "clang/AST/ASTContext.h" + +#include "lldb/lldb-private.h" + +#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h" + +namespace lldb_private { +class StringLexer; +class AppleObjCTypeEncodingParser : public ObjCLanguageRuntime::EncodingToType { +public: + AppleObjCTypeEncodingParser(ObjCLanguageRuntime &runtime); + ~AppleObjCTypeEncodingParser() override = default; + + CompilerType RealizeType(clang::ASTContext &ast_ctx, const char *name, + bool for_expression) override; + +private: + struct StructElement { + std::string name; + clang::QualType type; + uint32_t bitfield; + + StructElement(); + ~StructElement() = default; + }; + + clang::QualType BuildType(clang::ASTContext &ast_ctx, StringLexer &type, + bool for_expression, + uint32_t *bitfield_bit_size = nullptr); + + clang::QualType BuildStruct(clang::ASTContext &ast_ctx, StringLexer &type, + bool for_expression); + + clang::QualType BuildAggregate(clang::ASTContext &ast_ctx, StringLexer &type, + bool for_expression, char opener, char closer, + uint32_t kind); + + clang::QualType BuildUnion(clang::ASTContext &ast_ctx, StringLexer &type, + bool for_expression); + + clang::QualType BuildArray(clang::ASTContext &ast_ctx, StringLexer &type, + bool for_expression); + + std::string ReadStructName(StringLexer &type); + + StructElement ReadStructElement(clang::ASTContext &ast_ctx, StringLexer &type, + bool for_expression); + + clang::QualType BuildObjCObjectPointerType(clang::ASTContext &ast_ctx, + StringLexer &type, + bool for_expression); + + uint32_t ReadNumber(StringLexer &type); + + std::string ReadQuotedString(StringLexer &type); + + ObjCLanguageRuntime &m_runtime; +}; + +} // namespace lldb_private + +#endif // liblldb_AppleObjCTypeEncodingParser_h_ diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp new file mode 100644 index 000000000000..af630eee7265 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp @@ -0,0 +1,201 @@ +//===-- AppleThreadPlanStepThroughObjCTrampoline.cpp +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "AppleThreadPlanStepThroughObjCTrampoline.h" + +#include "AppleObjCTrampolineHandler.h" +#include "lldb/Expression/DiagnosticManager.h" +#include "lldb/Expression/FunctionCaller.h" +#include "lldb/Expression/UtilityFunction.h" +#include "lldb/Target/ExecutionContext.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/Thread.h" +#include "lldb/Target/ThreadPlanRunToAddress.h" +#include "lldb/Target/ThreadPlanStepOut.h" +#include "lldb/Utility/Log.h" + +#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h" + +#include <memory> + +using namespace lldb; +using namespace lldb_private; + +// ThreadPlanStepThroughObjCTrampoline constructor +AppleThreadPlanStepThroughObjCTrampoline:: + AppleThreadPlanStepThroughObjCTrampoline( + Thread &thread, AppleObjCTrampolineHandler *trampoline_handler, + ValueList &input_values, lldb::addr_t isa_addr, lldb::addr_t sel_addr, + bool stop_others) + : ThreadPlan(ThreadPlan::eKindGeneric, + "MacOSX Step through ObjC Trampoline", thread, eVoteNoOpinion, + eVoteNoOpinion), + m_trampoline_handler(trampoline_handler), + m_args_addr(LLDB_INVALID_ADDRESS), m_input_values(input_values), + m_isa_addr(isa_addr), m_sel_addr(sel_addr), m_impl_function(nullptr), + m_stop_others(stop_others) {} + +// Destructor +AppleThreadPlanStepThroughObjCTrampoline:: + ~AppleThreadPlanStepThroughObjCTrampoline() {} + +void AppleThreadPlanStepThroughObjCTrampoline::DidPush() { + // Setting up the memory space for the called function text might require + // allocations, i.e. a nested function call. This needs to be done as a + // PreResumeAction. + m_thread.GetProcess()->AddPreResumeAction(PreResumeInitializeFunctionCaller, + (void *)this); +} + +bool AppleThreadPlanStepThroughObjCTrampoline::InitializeFunctionCaller() { + if (!m_func_sp) { + DiagnosticManager diagnostics; + m_args_addr = + m_trampoline_handler->SetupDispatchFunction(m_thread, m_input_values); + + if (m_args_addr == LLDB_INVALID_ADDRESS) { + return false; + } + m_impl_function = + m_trampoline_handler->GetLookupImplementationFunctionCaller(); + ExecutionContext exc_ctx; + EvaluateExpressionOptions options; + options.SetUnwindOnError(true); + options.SetIgnoreBreakpoints(true); + options.SetStopOthers(m_stop_others); + m_thread.CalculateExecutionContext(exc_ctx); + m_func_sp = m_impl_function->GetThreadPlanToCallFunction( + exc_ctx, m_args_addr, options, diagnostics); + m_func_sp->SetOkayToDiscard(true); + m_thread.QueueThreadPlan(m_func_sp, false); + } + return true; +} + +bool AppleThreadPlanStepThroughObjCTrampoline:: + PreResumeInitializeFunctionCaller(void *void_myself) { + AppleThreadPlanStepThroughObjCTrampoline *myself = + static_cast<AppleThreadPlanStepThroughObjCTrampoline *>(void_myself); + return myself->InitializeFunctionCaller(); +} + +void AppleThreadPlanStepThroughObjCTrampoline::GetDescription( + Stream *s, lldb::DescriptionLevel level) { + if (level == lldb::eDescriptionLevelBrief) + s->Printf("Step through ObjC trampoline"); + else { + s->Printf("Stepping to implementation of ObjC method - obj: 0x%llx, isa: " + "0x%" PRIx64 ", sel: 0x%" PRIx64, + m_input_values.GetValueAtIndex(0)->GetScalar().ULongLong(), + m_isa_addr, m_sel_addr); + } +} + +bool AppleThreadPlanStepThroughObjCTrampoline::ValidatePlan(Stream *error) { + return true; +} + +bool AppleThreadPlanStepThroughObjCTrampoline::DoPlanExplainsStop( + Event *event_ptr) { + // If we get asked to explain the stop it will be because something went + // wrong (like the implementation for selector function crashed... We're + // going to figure out what to do about that, so we do explain the stop. + return true; +} + +lldb::StateType AppleThreadPlanStepThroughObjCTrampoline::GetPlanRunState() { + return eStateRunning; +} + +bool AppleThreadPlanStepThroughObjCTrampoline::ShouldStop(Event *event_ptr) { + // First stage: we are still handling the "call a function to get the target + // of the dispatch" + if (m_func_sp) { + if (!m_func_sp->IsPlanComplete()) { + return false; + } else { + if (!m_func_sp->PlanSucceeded()) { + SetPlanComplete(false); + return true; + } + m_func_sp.reset(); + } + } + + // Second stage, if all went well with the function calling, then fetch the + // target address, and queue up a "run to that address" plan. + if (!m_run_to_sp) { + Value target_addr_value; + ExecutionContext exc_ctx; + m_thread.CalculateExecutionContext(exc_ctx); + m_impl_function->FetchFunctionResults(exc_ctx, m_args_addr, + target_addr_value); + m_impl_function->DeallocateFunctionResults(exc_ctx, m_args_addr); + lldb::addr_t target_addr = target_addr_value.GetScalar().ULongLong(); + Address target_so_addr; + target_so_addr.SetOpcodeLoadAddress(target_addr, exc_ctx.GetTargetPtr()); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); + if (target_addr == 0) { + LLDB_LOGF(log, "Got target implementation of 0x0, stopping."); + SetPlanComplete(); + return true; + } + if (m_trampoline_handler->AddrIsMsgForward(target_addr)) { + LLDB_LOGF(log, + "Implementation lookup returned msgForward function: 0x%" PRIx64 + ", stopping.", + target_addr); + + SymbolContext sc = m_thread.GetStackFrameAtIndex(0)->GetSymbolContext( + eSymbolContextEverything); + Status status; + const bool abort_other_plans = false; + const bool first_insn = true; + const uint32_t frame_idx = 0; + m_run_to_sp = m_thread.QueueThreadPlanForStepOutNoShouldStop( + abort_other_plans, &sc, first_insn, m_stop_others, eVoteNoOpinion, + eVoteNoOpinion, frame_idx, status); + if (m_run_to_sp && status.Success()) + m_run_to_sp->SetPrivate(true); + return false; + } + + LLDB_LOGF(log, "Running to ObjC method implementation: 0x%" PRIx64, + target_addr); + + ObjCLanguageRuntime *objc_runtime = + ObjCLanguageRuntime::Get(*GetThread().GetProcess()); + assert(objc_runtime != nullptr); + objc_runtime->AddToMethodCache(m_isa_addr, m_sel_addr, target_addr); + LLDB_LOGF(log, + "Adding {isa-addr=0x%" PRIx64 ", sel-addr=0x%" PRIx64 + "} = addr=0x%" PRIx64 " to cache.", + m_isa_addr, m_sel_addr, target_addr); + + // Extract the target address from the value: + + m_run_to_sp = std::make_shared<ThreadPlanRunToAddress>( + m_thread, target_so_addr, m_stop_others); + m_thread.QueueThreadPlan(m_run_to_sp, false); + m_run_to_sp->SetPrivate(true); + return false; + } else if (m_thread.IsThreadPlanDone(m_run_to_sp.get())) { + // Third stage, work the run to target plan. + SetPlanComplete(); + return true; + } + return false; +} + +// The base class MischiefManaged does some cleanup - so you have to call it in +// your MischiefManaged derived class. +bool AppleThreadPlanStepThroughObjCTrampoline::MischiefManaged() { + return IsPlanComplete(); +} + +bool AppleThreadPlanStepThroughObjCTrampoline::WillStop() { return true; } diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.h b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.h new file mode 100644 index 000000000000..96f37851a35f --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.h @@ -0,0 +1,76 @@ +//===-- AppleThreadPlanStepThroughObjCTrampoline.h --------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef lldb_AppleThreadPlanStepThroughObjCTrampoline_h_ +#define lldb_AppleThreadPlanStepThroughObjCTrampoline_h_ + +#include "AppleObjCTrampolineHandler.h" +#include "lldb/Core/Value.h" +#include "lldb/Target/ThreadPlan.h" +#include "lldb/lldb-enumerations.h" +#include "lldb/lldb-types.h" + +namespace lldb_private { + +class AppleThreadPlanStepThroughObjCTrampoline : public ThreadPlan { +public: + AppleThreadPlanStepThroughObjCTrampoline( + Thread &thread, AppleObjCTrampolineHandler *trampoline_handler, + ValueList &values, lldb::addr_t isa_addr, lldb::addr_t sel_addr, + bool stop_others); + + ~AppleThreadPlanStepThroughObjCTrampoline() override; + + static bool PreResumeInitializeFunctionCaller(void *myself); + + void GetDescription(Stream *s, lldb::DescriptionLevel level) override; + + bool ValidatePlan(Stream *error) override; + + lldb::StateType GetPlanRunState() override; + + bool ShouldStop(Event *event_ptr) override; + + bool StopOthers() override { return m_stop_others; } + + // The base class MischiefManaged does some cleanup - so you have to call it + // in your MischiefManaged derived class. + bool MischiefManaged() override; + + void DidPush() override; + + bool WillStop() override; + +protected: + bool DoPlanExplainsStop(Event *event_ptr) override; + +private: + bool InitializeFunctionCaller(); + + AppleObjCTrampolineHandler *m_trampoline_handler; // FIXME - ensure this + // doesn't go away on us? + // SP maybe? + lldb::addr_t m_args_addr; // Stores the address for our step through function + // result structure. + // lldb::addr_t m_object_addr; // This is only for Description. + ValueList m_input_values; + lldb::addr_t m_isa_addr; // isa_addr and sel_addr are the keys we will use to + // cache the implementation. + lldb::addr_t m_sel_addr; + lldb::ThreadPlanSP m_func_sp; // This is the function call plan. We fill it + // at start, then set it + // to NULL when this plan is done. That way we know to go to: + lldb::ThreadPlanSP m_run_to_sp; // The plan that runs to the target. + FunctionCaller *m_impl_function; // This is a pointer to a impl function that + // is owned by the client that pushes this plan. + bool m_stop_others; +}; + +} // namespace lldb_private + +#endif // lldb_AppleThreadPlanStepThroughObjCTrampoline_h_ diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.cpp b/lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.cpp new file mode 100644 index 000000000000..87ae4c2c6c48 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.cpp @@ -0,0 +1,434 @@ +//===-- ObjCLanguageRuntime.cpp ---------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +#include "clang/AST/Type.h" + +#include "ObjCLanguageRuntime.h" + +#include "lldb/Core/MappedHash.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Symbol/SymbolContext.h" +#include "lldb/Symbol/SymbolFile.h" +#include "lldb/Symbol/Type.h" +#include "lldb/Symbol/TypeList.h" +#include "lldb/Symbol/Variable.h" +#include "lldb/Target/Target.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Timer.h" + +#include "llvm/ADT/StringRef.h" +#include "llvm/Support/DJB.h" + +using namespace lldb; +using namespace lldb_private; + +char ObjCLanguageRuntime::ID = 0; + +// Destructor +ObjCLanguageRuntime::~ObjCLanguageRuntime() {} + +ObjCLanguageRuntime::ObjCLanguageRuntime(Process *process) + : LanguageRuntime(process), m_impl_cache(), + m_has_new_literals_and_indexing(eLazyBoolCalculate), + m_isa_to_descriptor(), m_hash_to_isa_map(), m_type_size_cache(), + m_isa_to_descriptor_stop_id(UINT32_MAX), m_complete_class_cache(), + m_negative_complete_class_cache() {} + +bool ObjCLanguageRuntime::IsWhitelistedRuntimeValue(ConstString name) { + static ConstString g_self = ConstString("self"); + static ConstString g_cmd = ConstString("_cmd"); + return name == g_self || name == g_cmd; +} + +bool ObjCLanguageRuntime::AddClass(ObjCISA isa, + const ClassDescriptorSP &descriptor_sp, + const char *class_name) { + if (isa != 0) { + m_isa_to_descriptor[isa] = descriptor_sp; + // class_name is assumed to be valid + m_hash_to_isa_map.insert(std::make_pair(llvm::djbHash(class_name), isa)); + return true; + } + return false; +} + +void ObjCLanguageRuntime::AddToMethodCache(lldb::addr_t class_addr, + lldb::addr_t selector, + lldb::addr_t impl_addr) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); + if (log) { + LLDB_LOGF(log, + "Caching: class 0x%" PRIx64 " selector 0x%" PRIx64 + " implementation 0x%" PRIx64 ".", + class_addr, selector, impl_addr); + } + m_impl_cache.insert(std::pair<ClassAndSel, lldb::addr_t>( + ClassAndSel(class_addr, selector), impl_addr)); +} + +lldb::addr_t ObjCLanguageRuntime::LookupInMethodCache(lldb::addr_t class_addr, + lldb::addr_t selector) { + MsgImplMap::iterator pos, end = m_impl_cache.end(); + pos = m_impl_cache.find(ClassAndSel(class_addr, selector)); + if (pos != end) + return (*pos).second; + return LLDB_INVALID_ADDRESS; +} + +lldb::TypeSP +ObjCLanguageRuntime::LookupInCompleteClassCache(ConstString &name) { + CompleteClassMap::iterator complete_class_iter = + m_complete_class_cache.find(name); + + if (complete_class_iter != m_complete_class_cache.end()) { + // Check the weak pointer to make sure the type hasn't been unloaded + TypeSP complete_type_sp(complete_class_iter->second.lock()); + + if (complete_type_sp) + return complete_type_sp; + else + m_complete_class_cache.erase(name); + } + + if (m_negative_complete_class_cache.count(name) > 0) + return TypeSP(); + + const ModuleList &modules = m_process->GetTarget().GetImages(); + + SymbolContextList sc_list; + modules.FindSymbolsWithNameAndType(name, eSymbolTypeObjCClass, sc_list); + const size_t matching_symbols = sc_list.GetSize(); + + if (matching_symbols) { + SymbolContext sc; + + sc_list.GetContextAtIndex(0, sc); + + ModuleSP module_sp(sc.module_sp); + + if (!module_sp) + return TypeSP(); + + const bool exact_match = true; + const uint32_t max_matches = UINT32_MAX; + TypeList types; + + llvm::DenseSet<SymbolFile *> searched_symbol_files; + module_sp->FindTypes(name, exact_match, max_matches, searched_symbol_files, + types); + + for (uint32_t i = 0; i < types.GetSize(); ++i) { + TypeSP type_sp(types.GetTypeAtIndex(i)); + + if (ClangASTContext::IsObjCObjectOrInterfaceType( + type_sp->GetForwardCompilerType())) { + if (type_sp->IsCompleteObjCClass()) { + m_complete_class_cache[name] = type_sp; + return type_sp; + } + } + } + } + m_negative_complete_class_cache.insert(name); + return TypeSP(); +} + +size_t ObjCLanguageRuntime::GetByteOffsetForIvar(CompilerType &parent_qual_type, + const char *ivar_name) { + return LLDB_INVALID_IVAR_OFFSET; +} + +bool ObjCLanguageRuntime::ClassDescriptor::IsPointerValid( + lldb::addr_t value, uint32_t ptr_size, bool allow_NULLs, bool allow_tagged, + bool check_version_specific) const { + if (!value) + return allow_NULLs; + if ((value % 2) == 1 && allow_tagged) + return true; + if ((value % ptr_size) == 0) + return (check_version_specific ? CheckPointer(value, ptr_size) : true); + else + return false; +} + +ObjCLanguageRuntime::ObjCISA +ObjCLanguageRuntime::GetISA(ConstString name) { + ISAToDescriptorIterator pos = GetDescriptorIterator(name); + if (pos != m_isa_to_descriptor.end()) + return pos->first; + return 0; +} + +ObjCLanguageRuntime::ISAToDescriptorIterator +ObjCLanguageRuntime::GetDescriptorIterator(ConstString name) { + ISAToDescriptorIterator end = m_isa_to_descriptor.end(); + + if (name) { + UpdateISAToDescriptorMap(); + if (m_hash_to_isa_map.empty()) { + // No name hashes were provided, we need to just linearly power through + // the names and find a match + for (ISAToDescriptorIterator pos = m_isa_to_descriptor.begin(); + pos != end; ++pos) { + if (pos->second->GetClassName() == name) + return pos; + } + } else { + // Name hashes were provided, so use them to efficiently lookup name to + // isa/descriptor + const uint32_t name_hash = llvm::djbHash(name.GetStringRef()); + std::pair<HashToISAIterator, HashToISAIterator> range = + m_hash_to_isa_map.equal_range(name_hash); + for (HashToISAIterator range_pos = range.first; range_pos != range.second; + ++range_pos) { + ISAToDescriptorIterator pos = + m_isa_to_descriptor.find(range_pos->second); + if (pos != m_isa_to_descriptor.end()) { + if (pos->second->GetClassName() == name) + return pos; + } + } + } + } + return end; +} + +std::pair<ObjCLanguageRuntime::ISAToDescriptorIterator, + ObjCLanguageRuntime::ISAToDescriptorIterator> +ObjCLanguageRuntime::GetDescriptorIteratorPair(bool update_if_needed) { + if (update_if_needed) + UpdateISAToDescriptorMapIfNeeded(); + + return std::pair<ObjCLanguageRuntime::ISAToDescriptorIterator, + ObjCLanguageRuntime::ISAToDescriptorIterator>( + m_isa_to_descriptor.begin(), m_isa_to_descriptor.end()); +} + +ObjCLanguageRuntime::ObjCISA +ObjCLanguageRuntime::GetParentClass(ObjCLanguageRuntime::ObjCISA isa) { + ClassDescriptorSP objc_class_sp(GetClassDescriptorFromISA(isa)); + if (objc_class_sp) { + ClassDescriptorSP objc_super_class_sp(objc_class_sp->GetSuperclass()); + if (objc_super_class_sp) + return objc_super_class_sp->GetISA(); + } + return 0; +} + +ConstString +ObjCLanguageRuntime::GetActualTypeName(ObjCLanguageRuntime::ObjCISA isa) { + ClassDescriptorSP objc_class_sp(GetNonKVOClassDescriptor(isa)); + if (objc_class_sp) + return objc_class_sp->GetClassName(); + return ConstString(); +} + +ObjCLanguageRuntime::ClassDescriptorSP +ObjCLanguageRuntime::GetClassDescriptorFromClassName( + ConstString class_name) { + ISAToDescriptorIterator pos = GetDescriptorIterator(class_name); + if (pos != m_isa_to_descriptor.end()) + return pos->second; + return ClassDescriptorSP(); +} + +ObjCLanguageRuntime::ClassDescriptorSP +ObjCLanguageRuntime::GetClassDescriptor(ValueObject &valobj) { + ClassDescriptorSP objc_class_sp; + // if we get an invalid VO (which might still happen when playing around with + // pointers returned by the expression parser, don't consider this a valid + // ObjC object) + if (valobj.GetCompilerType().IsValid()) { + addr_t isa_pointer = valobj.GetPointerValue(); + if (isa_pointer != LLDB_INVALID_ADDRESS) { + ExecutionContext exe_ctx(valobj.GetExecutionContextRef()); + + Process *process = exe_ctx.GetProcessPtr(); + if (process) { + Status error; + ObjCISA isa = process->ReadPointerFromMemory(isa_pointer, error); + if (isa != LLDB_INVALID_ADDRESS) + objc_class_sp = GetClassDescriptorFromISA(isa); + } + } + } + return objc_class_sp; +} + +ObjCLanguageRuntime::ClassDescriptorSP +ObjCLanguageRuntime::GetNonKVOClassDescriptor(ValueObject &valobj) { + ObjCLanguageRuntime::ClassDescriptorSP objc_class_sp( + GetClassDescriptor(valobj)); + if (objc_class_sp) { + if (!objc_class_sp->IsKVO()) + return objc_class_sp; + + ClassDescriptorSP non_kvo_objc_class_sp(objc_class_sp->GetSuperclass()); + if (non_kvo_objc_class_sp && non_kvo_objc_class_sp->IsValid()) + return non_kvo_objc_class_sp; + } + return ClassDescriptorSP(); +} + +ObjCLanguageRuntime::ClassDescriptorSP +ObjCLanguageRuntime::GetClassDescriptorFromISA(ObjCISA isa) { + if (isa) { + UpdateISAToDescriptorMap(); + ObjCLanguageRuntime::ISAToDescriptorIterator pos = + m_isa_to_descriptor.find(isa); + if (pos != m_isa_to_descriptor.end()) + return pos->second; + } + return ClassDescriptorSP(); +} + +ObjCLanguageRuntime::ClassDescriptorSP +ObjCLanguageRuntime::GetNonKVOClassDescriptor(ObjCISA isa) { + if (isa) { + ClassDescriptorSP objc_class_sp = GetClassDescriptorFromISA(isa); + if (objc_class_sp && objc_class_sp->IsValid()) { + if (!objc_class_sp->IsKVO()) + return objc_class_sp; + + ClassDescriptorSP non_kvo_objc_class_sp(objc_class_sp->GetSuperclass()); + if (non_kvo_objc_class_sp && non_kvo_objc_class_sp->IsValid()) + return non_kvo_objc_class_sp; + } + } + return ClassDescriptorSP(); +} + +CompilerType +ObjCLanguageRuntime::EncodingToType::RealizeType(const char *name, + bool for_expression) { + if (m_scratch_ast_ctx_up) + return RealizeType(*m_scratch_ast_ctx_up, name, for_expression); + return CompilerType(); +} + +CompilerType ObjCLanguageRuntime::EncodingToType::RealizeType( + ClangASTContext &ast_ctx, const char *name, bool for_expression) { + clang::ASTContext *clang_ast = ast_ctx.getASTContext(); + if (!clang_ast) + return CompilerType(); + return RealizeType(*clang_ast, name, for_expression); +} + +ObjCLanguageRuntime::EncodingToType::~EncodingToType() {} + +ObjCLanguageRuntime::EncodingToTypeSP ObjCLanguageRuntime::GetEncodingToType() { + return nullptr; +} + +bool ObjCLanguageRuntime::GetTypeBitSize(const CompilerType &compiler_type, + uint64_t &size) { + void *opaque_ptr = compiler_type.GetOpaqueQualType(); + size = m_type_size_cache.Lookup(opaque_ptr); + // an ObjC object will at least have an ISA, so 0 is definitely not OK + if (size > 0) + return true; + + ClassDescriptorSP class_descriptor_sp = + GetClassDescriptorFromClassName(compiler_type.GetTypeName()); + if (!class_descriptor_sp) + return false; + + int32_t max_offset = INT32_MIN; + uint64_t sizeof_max = 0; + bool found = false; + + for (size_t idx = 0; idx < class_descriptor_sp->GetNumIVars(); idx++) { + const auto &ivar = class_descriptor_sp->GetIVarAtIndex(idx); + int32_t cur_offset = ivar.m_offset; + if (cur_offset > max_offset) { + max_offset = cur_offset; + sizeof_max = ivar.m_size; + found = true; + } + } + + size = 8 * (max_offset + sizeof_max); + if (found) + m_type_size_cache.Insert(opaque_ptr, size); + + return found; +} + +lldb::BreakpointPreconditionSP +ObjCLanguageRuntime::GetBreakpointExceptionPrecondition(LanguageType language, + bool throw_bp) { + if (language != eLanguageTypeObjC) + return lldb::BreakpointPreconditionSP(); + if (!throw_bp) + return lldb::BreakpointPreconditionSP(); + BreakpointPreconditionSP precondition_sp( + new ObjCLanguageRuntime::ObjCExceptionPrecondition()); + return precondition_sp; +} + +// Exception breakpoint Precondition class for ObjC: +void ObjCLanguageRuntime::ObjCExceptionPrecondition::AddClassName( + const char *class_name) { + m_class_names.insert(class_name); +} + +ObjCLanguageRuntime::ObjCExceptionPrecondition::ObjCExceptionPrecondition() {} + +bool ObjCLanguageRuntime::ObjCExceptionPrecondition::EvaluatePrecondition( + StoppointCallbackContext &context) { + return true; +} + +void ObjCLanguageRuntime::ObjCExceptionPrecondition::GetDescription( + Stream &stream, lldb::DescriptionLevel level) {} + +Status ObjCLanguageRuntime::ObjCExceptionPrecondition::ConfigurePrecondition( + Args &args) { + Status error; + if (args.GetArgumentCount() > 0) + error.SetErrorString( + "The ObjC Exception breakpoint doesn't support extra options."); + return error; +} + +llvm::Optional<CompilerType> +ObjCLanguageRuntime::GetRuntimeType(CompilerType base_type) { + CompilerType class_type; + bool is_pointer_type = false; + + if (ClangASTContext::IsObjCObjectPointerType(base_type, &class_type)) + is_pointer_type = true; + else if (ClangASTContext::IsObjCObjectOrInterfaceType(base_type)) + class_type = base_type; + else + return llvm::None; + + if (!class_type) + return llvm::None; + + ConstString class_name(class_type.GetConstTypeName()); + if (!class_name) + return llvm::None; + + TypeSP complete_objc_class_type_sp = LookupInCompleteClassCache(class_name); + if (!complete_objc_class_type_sp) + return llvm::None; + + CompilerType complete_class( + complete_objc_class_type_sp->GetFullCompilerType()); + if (complete_class.GetCompleteType()) { + if (is_pointer_type) + return complete_class.GetPointerType(); + else + return complete_class; + } + + return llvm::None; +} diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h b/lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h new file mode 100644 index 000000000000..39acd6e9f268 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h @@ -0,0 +1,430 @@ +//===-- ObjCLanguageRuntime.h -----------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_ObjCLanguageRuntime_h_ +#define liblldb_ObjCLanguageRuntime_h_ + +#include <functional> +#include <map> +#include <memory> +#include <unordered_set> + +#include "llvm/Support/Casting.h" + +#include "lldb/Breakpoint/BreakpointPrecondition.h" +#include "lldb/Core/ClangForward.h" +#include "lldb/Core/PluginInterface.h" +#include "lldb/Core/ThreadSafeDenseMap.h" +#include "lldb/Symbol/CompilerType.h" +#include "lldb/Symbol/Type.h" +#include "lldb/Target/LanguageRuntime.h" +#include "lldb/lldb-private.h" + +class CommandObjectObjC_ClassTable_Dump; + +namespace lldb_private { + +class UtilityFunction; + +class ObjCLanguageRuntime : public LanguageRuntime { +public: + enum class ObjCRuntimeVersions { + eObjC_VersionUnknown = 0, + eAppleObjC_V1 = 1, + eAppleObjC_V2 = 2 + }; + + typedef lldb::addr_t ObjCISA; + + class ClassDescriptor; + typedef std::shared_ptr<ClassDescriptor> ClassDescriptorSP; + + // the information that we want to support retrieving from an ObjC class this + // needs to be pure virtual since there are at least 2 different + // implementations of the runtime, and more might come + class ClassDescriptor { + public: + ClassDescriptor() + : m_is_kvo(eLazyBoolCalculate), m_is_cf(eLazyBoolCalculate), + m_type_wp() {} + + virtual ~ClassDescriptor() = default; + + virtual ConstString GetClassName() = 0; + + virtual ClassDescriptorSP GetSuperclass() = 0; + + virtual ClassDescriptorSP GetMetaclass() const = 0; + + // virtual if any implementation has some other version-specific rules but + // for the known v1/v2 this is all that needs to be done + virtual bool IsKVO() { + if (m_is_kvo == eLazyBoolCalculate) { + const char *class_name = GetClassName().AsCString(); + if (class_name && *class_name) + m_is_kvo = + (LazyBool)(strstr(class_name, "NSKVONotifying_") == class_name); + } + return (m_is_kvo == eLazyBoolYes); + } + + // virtual if any implementation has some other version-specific rules but + // for the known v1/v2 this is all that needs to be done + virtual bool IsCFType() { + if (m_is_cf == eLazyBoolCalculate) { + const char *class_name = GetClassName().AsCString(); + if (class_name && *class_name) + m_is_cf = (LazyBool)(strcmp(class_name, "__NSCFType") == 0 || + strcmp(class_name, "NSCFType") == 0); + } + return (m_is_cf == eLazyBoolYes); + } + + virtual bool IsValid() = 0; + + virtual bool GetTaggedPointerInfo(uint64_t *info_bits = nullptr, + uint64_t *value_bits = nullptr, + uint64_t *payload = nullptr) = 0; + + virtual uint64_t GetInstanceSize() = 0; + + // use to implement version-specific additional constraints on pointers + virtual bool CheckPointer(lldb::addr_t value, uint32_t ptr_size) const { + return true; + } + + virtual ObjCISA GetISA() = 0; + + // This should return true iff the interface could be completed + virtual bool + Describe(std::function<void(ObjCISA)> const &superclass_func, + std::function<bool(const char *, const char *)> const + &instance_method_func, + std::function<bool(const char *, const char *)> const + &class_method_func, + std::function<bool(const char *, const char *, lldb::addr_t, + uint64_t)> const &ivar_func) const { + return false; + } + + lldb::TypeSP GetType() { return m_type_wp.lock(); } + + void SetType(const lldb::TypeSP &type_sp) { m_type_wp = type_sp; } + + struct iVarDescriptor { + ConstString m_name; + CompilerType m_type; + uint64_t m_size; + int32_t m_offset; + }; + + virtual size_t GetNumIVars() { return 0; } + + virtual iVarDescriptor GetIVarAtIndex(size_t idx) { + return iVarDescriptor(); + } + + protected: + bool IsPointerValid(lldb::addr_t value, uint32_t ptr_size, + bool allow_NULLs = false, bool allow_tagged = false, + bool check_version_specific = false) const; + + private: + LazyBool m_is_kvo; + LazyBool m_is_cf; + lldb::TypeWP m_type_wp; + }; + + class EncodingToType { + public: + virtual ~EncodingToType(); + + virtual CompilerType RealizeType(ClangASTContext &ast_ctx, const char *name, + bool for_expression); + virtual CompilerType RealizeType(const char *name, bool for_expression); + + virtual CompilerType RealizeType(clang::ASTContext &ast_ctx, + const char *name, bool for_expression) = 0; + + protected: + std::unique_ptr<ClangASTContext> m_scratch_ast_ctx_up; + }; + + class ObjCExceptionPrecondition : public BreakpointPrecondition { + public: + ObjCExceptionPrecondition(); + + ~ObjCExceptionPrecondition() override = default; + + bool EvaluatePrecondition(StoppointCallbackContext &context) override; + void GetDescription(Stream &stream, lldb::DescriptionLevel level) override; + Status ConfigurePrecondition(Args &args) override; + + protected: + void AddClassName(const char *class_name); + + private: + std::unordered_set<std::string> m_class_names; + }; + + static lldb::BreakpointPreconditionSP + GetBreakpointExceptionPrecondition(lldb::LanguageType language, + bool throw_bp); + + class TaggedPointerVendor { + public: + virtual ~TaggedPointerVendor() = default; + + virtual bool IsPossibleTaggedPointer(lldb::addr_t ptr) = 0; + + virtual ObjCLanguageRuntime::ClassDescriptorSP + GetClassDescriptor(lldb::addr_t ptr) = 0; + + protected: + TaggedPointerVendor() = default; + + private: + DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendor); + }; + + ~ObjCLanguageRuntime() override; + + static char ID; + + bool isA(const void *ClassID) const override { + return ClassID == &ID || LanguageRuntime::isA(ClassID); + } + + static bool classof(const LanguageRuntime *runtime) { + return runtime->isA(&ID); + } + + static ObjCLanguageRuntime *Get(Process &process) { + return llvm::cast_or_null<ObjCLanguageRuntime>( + process.GetLanguageRuntime(lldb::eLanguageTypeObjC)); + } + + virtual TaggedPointerVendor *GetTaggedPointerVendor() { return nullptr; } + + typedef std::shared_ptr<EncodingToType> EncodingToTypeSP; + + virtual EncodingToTypeSP GetEncodingToType(); + + virtual ClassDescriptorSP GetClassDescriptor(ValueObject &in_value); + + ClassDescriptorSP GetNonKVOClassDescriptor(ValueObject &in_value); + + virtual ClassDescriptorSP + GetClassDescriptorFromClassName(ConstString class_name); + + virtual ClassDescriptorSP GetClassDescriptorFromISA(ObjCISA isa); + + ClassDescriptorSP GetNonKVOClassDescriptor(ObjCISA isa); + + lldb::LanguageType GetLanguageType() const override { + return lldb::eLanguageTypeObjC; + } + + virtual bool IsModuleObjCLibrary(const lldb::ModuleSP &module_sp) = 0; + + virtual bool ReadObjCLibrary(const lldb::ModuleSP &module_sp) = 0; + + virtual bool HasReadObjCLibrary() = 0; + + lldb::addr_t LookupInMethodCache(lldb::addr_t class_addr, lldb::addr_t sel); + + void AddToMethodCache(lldb::addr_t class_addr, lldb::addr_t sel, + lldb::addr_t impl_addr); + + TypeAndOrName LookupInClassNameCache(lldb::addr_t class_addr); + + void AddToClassNameCache(lldb::addr_t class_addr, const char *name, + lldb::TypeSP type_sp); + + void AddToClassNameCache(lldb::addr_t class_addr, + const TypeAndOrName &class_or_type_name); + + lldb::TypeSP LookupInCompleteClassCache(ConstString &name); + + llvm::Optional<CompilerType> GetRuntimeType(CompilerType base_type) override; + + virtual UtilityFunction *CreateObjectChecker(const char *) = 0; + + virtual ObjCRuntimeVersions GetRuntimeVersion() const { + return ObjCRuntimeVersions::eObjC_VersionUnknown; + } + + bool IsValidISA(ObjCISA isa) { + UpdateISAToDescriptorMap(); + return m_isa_to_descriptor.count(isa) > 0; + } + + virtual void UpdateISAToDescriptorMapIfNeeded() = 0; + + void UpdateISAToDescriptorMap() { + if (m_process && m_process->GetStopID() != m_isa_to_descriptor_stop_id) { + UpdateISAToDescriptorMapIfNeeded(); + } + } + + virtual ObjCISA GetISA(ConstString name); + + virtual ConstString GetActualTypeName(ObjCISA isa); + + virtual ObjCISA GetParentClass(ObjCISA isa); + + // Finds the byte offset of the child_type ivar in parent_type. If it can't + // find the offset, returns LLDB_INVALID_IVAR_OFFSET. + + virtual size_t GetByteOffsetForIvar(CompilerType &parent_qual_type, + const char *ivar_name); + + bool HasNewLiteralsAndIndexing() { + if (m_has_new_literals_and_indexing == eLazyBoolCalculate) { + if (CalculateHasNewLiteralsAndIndexing()) + m_has_new_literals_and_indexing = eLazyBoolYes; + else + m_has_new_literals_and_indexing = eLazyBoolNo; + } + + return (m_has_new_literals_and_indexing == eLazyBoolYes); + } + + void SymbolsDidLoad(const ModuleList &module_list) override { + m_negative_complete_class_cache.clear(); + } + + bool GetTypeBitSize(const CompilerType &compiler_type, + uint64_t &size) override; + + /// Check whether the name is "self" or "_cmd" and should show up in + /// "frame variable". + bool IsWhitelistedRuntimeValue(ConstString name) override; + +protected: + // Classes that inherit from ObjCLanguageRuntime can see and modify these + ObjCLanguageRuntime(Process *process); + + virtual bool CalculateHasNewLiteralsAndIndexing() { return false; } + + bool ISAIsCached(ObjCISA isa) const { + return m_isa_to_descriptor.find(isa) != m_isa_to_descriptor.end(); + } + + bool AddClass(ObjCISA isa, const ClassDescriptorSP &descriptor_sp) { + if (isa != 0) { + m_isa_to_descriptor[isa] = descriptor_sp; + return true; + } + return false; + } + + bool AddClass(ObjCISA isa, const ClassDescriptorSP &descriptor_sp, + const char *class_name); + + bool AddClass(ObjCISA isa, const ClassDescriptorSP &descriptor_sp, + uint32_t class_name_hash) { + if (isa != 0) { + m_isa_to_descriptor[isa] = descriptor_sp; + m_hash_to_isa_map.insert(std::make_pair(class_name_hash, isa)); + return true; + } + return false; + } + +private: + // We keep a map of <Class,Selector>->Implementation so we don't have to call + // the resolver function over and over. + + // FIXME: We need to watch for the loading of Protocols, and flush the cache + // for any + // class that we see so changed. + + struct ClassAndSel { + ClassAndSel() { + sel_addr = LLDB_INVALID_ADDRESS; + class_addr = LLDB_INVALID_ADDRESS; + } + + ClassAndSel(lldb::addr_t in_sel_addr, lldb::addr_t in_class_addr) + : class_addr(in_class_addr), sel_addr(in_sel_addr) {} + + bool operator==(const ClassAndSel &rhs) { + if (class_addr == rhs.class_addr && sel_addr == rhs.sel_addr) + return true; + else + return false; + } + + bool operator<(const ClassAndSel &rhs) const { + if (class_addr < rhs.class_addr) + return true; + else if (class_addr > rhs.class_addr) + return false; + else { + if (sel_addr < rhs.sel_addr) + return true; + else + return false; + } + } + + lldb::addr_t class_addr; + lldb::addr_t sel_addr; + }; + + typedef std::map<ClassAndSel, lldb::addr_t> MsgImplMap; + typedef std::map<ObjCISA, ClassDescriptorSP> ISAToDescriptorMap; + typedef std::multimap<uint32_t, ObjCISA> HashToISAMap; + typedef ISAToDescriptorMap::iterator ISAToDescriptorIterator; + typedef HashToISAMap::iterator HashToISAIterator; + typedef ThreadSafeDenseMap<void *, uint64_t> TypeSizeCache; + + MsgImplMap m_impl_cache; + LazyBool m_has_new_literals_and_indexing; + ISAToDescriptorMap m_isa_to_descriptor; + HashToISAMap m_hash_to_isa_map; + TypeSizeCache m_type_size_cache; + +protected: + uint32_t m_isa_to_descriptor_stop_id; + + typedef std::map<ConstString, lldb::TypeWP> CompleteClassMap; + CompleteClassMap m_complete_class_cache; + + struct ConstStringSetHelpers { + size_t operator()(ConstString arg) const // for hashing + { + return (size_t)arg.GetCString(); + } + bool operator()(ConstString arg1, + ConstString arg2) const // for equality + { + return arg1.operator==(arg2); + } + }; + typedef std::unordered_set<ConstString, ConstStringSetHelpers, + ConstStringSetHelpers> + CompleteClassSet; + CompleteClassSet m_negative_complete_class_cache; + + ISAToDescriptorIterator GetDescriptorIterator(ConstString name); + + friend class ::CommandObjectObjC_ClassTable_Dump; + + std::pair<ISAToDescriptorIterator, ISAToDescriptorIterator> + GetDescriptorIteratorPair(bool update_if_needed = true); + + void ReadObjCLibraryIfNeeded(const ModuleList &module_list); + + DISALLOW_COPY_AND_ASSIGN(ObjCLanguageRuntime); +}; + +} // namespace lldb_private + +#endif // liblldb_ObjCLanguageRuntime_h_ diff --git a/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.cpp b/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.cpp new file mode 100644 index 000000000000..b396781e6726 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.cpp @@ -0,0 +1,191 @@ +//===-- RenderScriptExpressionOpts.cpp --------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <string> + +#include "llvm/ADT/None.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/IR/Instruction.h" +#include "llvm/IR/Instructions.h" +#include "llvm/IR/LegacyPassManager.h" +#include "llvm/IR/Module.h" +#include "llvm/Support/TargetRegistry.h" +#include "llvm/Target/TargetMachine.h" +#include "llvm/Target/TargetOptions.h" + +#include "clang/Basic/TargetOptions.h" + +#include "lldb/Target/Process.h" +#include "lldb/Target/Target.h" +#include "lldb/Utility/Log.h" + +#include "RenderScriptExpressionOpts.h" +#include "RenderScriptRuntime.h" +#include "RenderScriptx86ABIFixups.h" + +using namespace lldb_private; +using namespace lldb_renderscript; + +// [``slang``](https://android.googlesource.com/platform/frameworks/compile/slang), +// the compiler frontend for RenderScript embeds an ARM specific triple in IR +// that is shipped in the app, after generating IR that has some assumptions +// that an ARM device is the target. As the IR is then compiled on a device of +// unknown (at time the IR was generated at least) architecture, when calling +// RenderScript API function as part of debugger expressions, we have to +// perform a fixup pass that removes those assumptions right before the module +// is sent to be generated by the llvm backend. + +namespace { +bool registerRSDefaultTargetOpts(clang::TargetOptions &proto, + const llvm::Triple::ArchType &arch) { + switch (arch) { + case llvm::Triple::ArchType::x86: + proto.Triple = "i686--linux-android"; + proto.CPU = "atom"; + proto.Features.push_back("+long64"); + // Fallthrough for common x86 family features + LLVM_FALLTHROUGH; + case llvm::Triple::ArchType::x86_64: + proto.Features.push_back("+mmx"); + proto.Features.push_back("+sse"); + proto.Features.push_back("+sse2"); + proto.Features.push_back("+sse3"); + proto.Features.push_back("+ssse3"); + proto.Features.push_back("+sse4.1"); + proto.Features.push_back("+sse4.2"); + break; + case llvm::Triple::ArchType::mipsel: + // pretend this is `arm' for the front-end + proto.Triple = "armv7-none-linux-android"; + proto.CPU = ""; + proto.Features.push_back("+long64"); + break; + case llvm::Triple::ArchType::mips64el: + // pretend this is `aarch64' for the front-end + proto.Triple = "aarch64-none-linux-android"; + proto.CPU = ""; + break; + default: + return false; + } + return true; +} +} // end anonymous namespace + +bool RenderScriptRuntimeModulePass::runOnModule(llvm::Module &module) { + bool changed_module = false; + Log *log( + GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_EXPRESSIONS)); + + std::string err; + llvm::StringRef real_triple = + m_process_ptr->GetTarget().GetArchitecture().GetTriple().getTriple(); + const llvm::Target *target_info = + llvm::TargetRegistry::lookupTarget(real_triple, err); + if (!target_info) { + if (log) + log->Warning("couldn't determine real target architecture: '%s'", + err.c_str()); + return false; + } + + llvm::Optional<llvm::Reloc::Model> reloc_model = llvm::None; + assert(m_process_ptr && "no available lldb process"); + switch (m_process_ptr->GetTarget().GetArchitecture().GetMachine()) { + case llvm::Triple::ArchType::x86: + changed_module |= fixupX86FunctionCalls(module); + // For some reason this triple gets totally missed by the backend, and must + // be set manually. There a reference in bcc/Main.cpp about auto feature- + // detection being removed from LLVM3.5, but I can't see that discussion + // anywhere public. + real_triple = "i686--linux-android"; + break; + case llvm::Triple::ArchType::x86_64: + changed_module |= fixupX86_64FunctionCalls(module); + break; + case llvm::Triple::ArchType::mipsel: + case llvm::Triple::ArchType::mips64el: + // No actual IR fixup pass is needed on MIPS, but the datalayout and + // targetmachine do need to be explicitly set. + + // bcc explicitly compiles MIPS code to use the static relocation model due + // to an issue with relocations in mclinker. see + // libbcc/support/CompilerConfig.cpp for details + reloc_model = llvm::Reloc::Static; + changed_module = true; + break; + case llvm::Triple::ArchType::arm: + case llvm::Triple::ArchType::aarch64: + // ARM subtargets need no fixup passes as they are the initial target as + // generated by the + // slang compiler frontend. + break; + default: + if (log) + log->Warning("Ignoring unknown renderscript target"); + return false; + } + + if (changed_module) { + llvm::TargetOptions options; + llvm::TargetMachine *target_machine = target_info->createTargetMachine( + real_triple, "", "", options, reloc_model); + assert(target_machine && + "failed to identify RenderScriptRuntime target machine"); + // We've been using a triple and datalayout of some ARM variant all along, + // so we need to let the backend know that this is no longer the case. + if (log) { + LLDB_LOGF(log, "%s - Changing RS target triple to '%s'", __FUNCTION__, + real_triple.str().c_str()); + LLDB_LOGF( + log, "%s - Changing RS datalayout to '%s'", __FUNCTION__, + target_machine->createDataLayout().getStringRepresentation().c_str()); + } + module.setTargetTriple(real_triple); + module.setDataLayout(target_machine->createDataLayout()); + } + return changed_module; +} + +char RenderScriptRuntimeModulePass::ID = 0; + +namespace lldb_private { + +bool RenderScriptRuntime::GetOverrideExprOptions(clang::TargetOptions &proto) { + auto *process = GetProcess(); + assert(process); + return registerRSDefaultTargetOpts( + proto, process->GetTarget().GetArchitecture().GetMachine()); +} + +bool RenderScriptRuntime::GetIRPasses(LLVMUserExpression::IRPasses &passes) { + if (!m_ir_passes) + m_ir_passes = new RSIRPasses(GetProcess()); + assert(m_ir_passes); + + passes.EarlyPasses = m_ir_passes->EarlyPasses; + passes.LatePasses = m_ir_passes->LatePasses; + + return true; +} + +namespace lldb_renderscript { + +RSIRPasses::RSIRPasses(Process *process) { + IRPasses(); + assert(process); + + EarlyPasses = std::make_shared<llvm::legacy::PassManager>(); + assert(EarlyPasses); + EarlyPasses->add(new RenderScriptRuntimeModulePass(process)); +} + +RSIRPasses::~RSIRPasses() {} + +} // namespace lldb_renderscript +} // namespace lldb_private diff --git a/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.h b/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.h new file mode 100644 index 000000000000..3ec4e37b6db0 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.h @@ -0,0 +1,52 @@ +//===-- RenderScriptExpressionOpts.h ----------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_RENDERSCRIPT_EXPROPTS_H +#define LLDB_RENDERSCRIPT_EXPROPTS_H + +#include "llvm/IR/Module.h" +#include "llvm/Support/TargetRegistry.h" +#include "llvm/Target/TargetMachine.h" +#include "llvm/Target/TargetOptions.h" + +#include "lldb/Target/LanguageRuntime.h" +#include "lldb/Target/Process.h" +#include "lldb/lldb-private.h" + +#include "RenderScriptRuntime.h" +#include "RenderScriptx86ABIFixups.h" + +// RenderScriptRuntimeModulePass is a simple llvm::ModulesPass that is used +// during expression evaluation to apply RenderScript-specific fixes for +// expression evaluation. In particular this is used to make expression IR +// conformant with the ABI generated by the slang frontend. This ModulePass is +// executed in ClangExpressionParser::PrepareForExecution whenever an +// expression's DWARF language is eLanguageTypeExtRenderscript + +class RenderScriptRuntimeModulePass : public llvm::ModulePass { +public: + static char ID; + RenderScriptRuntimeModulePass(const lldb_private::Process *process) + : ModulePass(ID), m_process_ptr(process) {} + + bool runOnModule(llvm::Module &module) override; + +private: + const lldb_private::Process *m_process_ptr; +}; + +namespace lldb_private { +namespace lldb_renderscript { +struct RSIRPasses : public lldb_private::LLVMUserExpression::IRPasses { + RSIRPasses(lldb_private::Process *process); + + ~RSIRPasses(); +}; +} // namespace lldb_renderscript +} // namespace lldb_private +#endif diff --git a/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp b/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp new file mode 100644 index 000000000000..5200749d759f --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp @@ -0,0 +1,4940 @@ +//===-- RenderScriptRuntime.cpp ---------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "RenderScriptRuntime.h" +#include "RenderScriptScriptGroup.h" + +#include "lldb/Breakpoint/StoppointCallbackContext.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/DumpDataExtractor.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/Core/ValueObjectVariable.h" +#include "lldb/DataFormatters/DumpValueObjectOptions.h" +#include "lldb/Expression/UserExpression.h" +#include "lldb/Host/OptionParser.h" +#include "lldb/Host/StringConvert.h" +#include "lldb/Interpreter/CommandInterpreter.h" +#include "lldb/Interpreter/CommandObjectMultiword.h" +#include "lldb/Interpreter/CommandReturnObject.h" +#include "lldb/Interpreter/Options.h" +#include "lldb/Symbol/Function.h" +#include "lldb/Symbol/Symbol.h" +#include "lldb/Symbol/Type.h" +#include "lldb/Symbol/VariableList.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/RegisterContext.h" +#include "lldb/Target/SectionLoadList.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/Thread.h" +#include "lldb/Utility/Args.h" +#include "lldb/Utility/ConstString.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/RegisterValue.h" +#include "lldb/Utility/RegularExpression.h" +#include "lldb/Utility/Status.h" + +#include "llvm/ADT/StringSwitch.h" + +#include <memory> + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_renderscript; + +#define FMT_COORD "(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ")" + +char RenderScriptRuntime::ID = 0; + +namespace { + +// The empirical_type adds a basic level of validation to arbitrary data +// allowing us to track if data has been discovered and stored or not. An +// empirical_type will be marked as valid only if it has been explicitly +// assigned to. +template <typename type_t> class empirical_type { +public: + // Ctor. Contents is invalid when constructed. + empirical_type() : valid(false) {} + + // Return true and copy contents to out if valid, else return false. + bool get(type_t &out) const { + if (valid) + out = data; + return valid; + } + + // Return a pointer to the contents or nullptr if it was not valid. + const type_t *get() const { return valid ? &data : nullptr; } + + // Assign data explicitly. + void set(const type_t in) { + data = in; + valid = true; + } + + // Mark contents as invalid. + void invalidate() { valid = false; } + + // Returns true if this type contains valid data. + bool isValid() const { return valid; } + + // Assignment operator. + empirical_type<type_t> &operator=(const type_t in) { + set(in); + return *this; + } + + // Dereference operator returns contents. + // Warning: Will assert if not valid so use only when you know data is valid. + const type_t &operator*() const { + assert(valid); + return data; + } + +protected: + bool valid; + type_t data; +}; + +// ArgItem is used by the GetArgs() function when reading function arguments +// from the target. +struct ArgItem { + enum { ePointer, eInt32, eInt64, eLong, eBool } type; + + uint64_t value; + + explicit operator uint64_t() const { return value; } +}; + +// Context structure to be passed into GetArgsXXX(), argument reading functions +// below. +struct GetArgsCtx { + RegisterContext *reg_ctx; + Process *process; +}; + +bool GetArgsX86(const GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) { + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + + Status err; + + // get the current stack pointer + uint64_t sp = ctx.reg_ctx->GetSP(); + + for (size_t i = 0; i < num_args; ++i) { + ArgItem &arg = arg_list[i]; + // advance up the stack by one argument + sp += sizeof(uint32_t); + // get the argument type size + size_t arg_size = sizeof(uint32_t); + // read the argument from memory + arg.value = 0; + Status err; + size_t read = + ctx.process->ReadMemory(sp, &arg.value, sizeof(uint32_t), err); + if (read != arg_size || !err.Success()) { + LLDB_LOGF(log, "%s - error reading argument: %" PRIu64 " '%s'", + __FUNCTION__, uint64_t(i), err.AsCString()); + return false; + } + } + return true; +} + +bool GetArgsX86_64(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) { + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + + // number of arguments passed in registers + static const uint32_t args_in_reg = 6; + // register passing order + static const std::array<const char *, args_in_reg> reg_names{ + {"rdi", "rsi", "rdx", "rcx", "r8", "r9"}}; + // argument type to size mapping + static const std::array<size_t, 5> arg_size{{ + 8, // ePointer, + 4, // eInt32, + 8, // eInt64, + 8, // eLong, + 4, // eBool, + }}; + + Status err; + + // get the current stack pointer + uint64_t sp = ctx.reg_ctx->GetSP(); + // step over the return address + sp += sizeof(uint64_t); + + // check the stack alignment was correct (16 byte aligned) + if ((sp & 0xf) != 0x0) { + LLDB_LOGF(log, "%s - stack misaligned", __FUNCTION__); + return false; + } + + // find the start of arguments on the stack + uint64_t sp_offset = 0; + for (uint32_t i = args_in_reg; i < num_args; ++i) { + sp_offset += arg_size[arg_list[i].type]; + } + // round up to multiple of 16 + sp_offset = (sp_offset + 0xf) & 0xf; + sp += sp_offset; + + for (size_t i = 0; i < num_args; ++i) { + bool success = false; + ArgItem &arg = arg_list[i]; + // arguments passed in registers + if (i < args_in_reg) { + const RegisterInfo *reg = + ctx.reg_ctx->GetRegisterInfoByName(reg_names[i]); + RegisterValue reg_val; + if (ctx.reg_ctx->ReadRegister(reg, reg_val)) + arg.value = reg_val.GetAsUInt64(0, &success); + } + // arguments passed on the stack + else { + // get the argument type size + const size_t size = arg_size[arg_list[i].type]; + // read the argument from memory + arg.value = 0; + // note: due to little endian layout reading 4 or 8 bytes will give the + // correct value. + size_t read = ctx.process->ReadMemory(sp, &arg.value, size, err); + success = (err.Success() && read == size); + // advance past this argument + sp -= size; + } + // fail if we couldn't read this argument + if (!success) { + LLDB_LOGF(log, "%s - error reading argument: %" PRIu64 ", reason: %s", + __FUNCTION__, uint64_t(i), err.AsCString("n/a")); + return false; + } + } + return true; +} + +bool GetArgsArm(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) { + // number of arguments passed in registers + static const uint32_t args_in_reg = 4; + + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + + Status err; + + // get the current stack pointer + uint64_t sp = ctx.reg_ctx->GetSP(); + + for (size_t i = 0; i < num_args; ++i) { + bool success = false; + ArgItem &arg = arg_list[i]; + // arguments passed in registers + if (i < args_in_reg) { + const RegisterInfo *reg = ctx.reg_ctx->GetRegisterInfoAtIndex(i); + RegisterValue reg_val; + if (ctx.reg_ctx->ReadRegister(reg, reg_val)) + arg.value = reg_val.GetAsUInt32(0, &success); + } + // arguments passed on the stack + else { + // get the argument type size + const size_t arg_size = sizeof(uint32_t); + // clear all 64bits + arg.value = 0; + // read this argument from memory + size_t bytes_read = + ctx.process->ReadMemory(sp, &arg.value, arg_size, err); + success = (err.Success() && bytes_read == arg_size); + // advance the stack pointer + sp += sizeof(uint32_t); + } + // fail if we couldn't read this argument + if (!success) { + LLDB_LOGF(log, "%s - error reading argument: %" PRIu64 ", reason: %s", + __FUNCTION__, uint64_t(i), err.AsCString("n/a")); + return false; + } + } + return true; +} + +bool GetArgsAarch64(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) { + // number of arguments passed in registers + static const uint32_t args_in_reg = 8; + + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + + for (size_t i = 0; i < num_args; ++i) { + bool success = false; + ArgItem &arg = arg_list[i]; + // arguments passed in registers + if (i < args_in_reg) { + const RegisterInfo *reg = ctx.reg_ctx->GetRegisterInfoAtIndex(i); + RegisterValue reg_val; + if (ctx.reg_ctx->ReadRegister(reg, reg_val)) + arg.value = reg_val.GetAsUInt64(0, &success); + } + // arguments passed on the stack + else { + LLDB_LOGF(log, "%s - reading arguments spilled to stack not implemented", + __FUNCTION__); + } + // fail if we couldn't read this argument + if (!success) { + LLDB_LOGF(log, "%s - error reading argument: %" PRIu64, __FUNCTION__, + uint64_t(i)); + return false; + } + } + return true; +} + +bool GetArgsMipsel(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) { + // number of arguments passed in registers + static const uint32_t args_in_reg = 4; + // register file offset to first argument + static const uint32_t reg_offset = 4; + + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + + Status err; + + // find offset to arguments on the stack (+16 to skip over a0-a3 shadow + // space) + uint64_t sp = ctx.reg_ctx->GetSP() + 16; + + for (size_t i = 0; i < num_args; ++i) { + bool success = false; + ArgItem &arg = arg_list[i]; + // arguments passed in registers + if (i < args_in_reg) { + const RegisterInfo *reg = + ctx.reg_ctx->GetRegisterInfoAtIndex(i + reg_offset); + RegisterValue reg_val; + if (ctx.reg_ctx->ReadRegister(reg, reg_val)) + arg.value = reg_val.GetAsUInt64(0, &success); + } + // arguments passed on the stack + else { + const size_t arg_size = sizeof(uint32_t); + arg.value = 0; + size_t bytes_read = + ctx.process->ReadMemory(sp, &arg.value, arg_size, err); + success = (err.Success() && bytes_read == arg_size); + // advance the stack pointer + sp += arg_size; + } + // fail if we couldn't read this argument + if (!success) { + LLDB_LOGF(log, "%s - error reading argument: %" PRIu64 ", reason: %s", + __FUNCTION__, uint64_t(i), err.AsCString("n/a")); + return false; + } + } + return true; +} + +bool GetArgsMips64el(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) { + // number of arguments passed in registers + static const uint32_t args_in_reg = 8; + // register file offset to first argument + static const uint32_t reg_offset = 4; + + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + + Status err; + + // get the current stack pointer + uint64_t sp = ctx.reg_ctx->GetSP(); + + for (size_t i = 0; i < num_args; ++i) { + bool success = false; + ArgItem &arg = arg_list[i]; + // arguments passed in registers + if (i < args_in_reg) { + const RegisterInfo *reg = + ctx.reg_ctx->GetRegisterInfoAtIndex(i + reg_offset); + RegisterValue reg_val; + if (ctx.reg_ctx->ReadRegister(reg, reg_val)) + arg.value = reg_val.GetAsUInt64(0, &success); + } + // arguments passed on the stack + else { + // get the argument type size + const size_t arg_size = sizeof(uint64_t); + // clear all 64bits + arg.value = 0; + // read this argument from memory + size_t bytes_read = + ctx.process->ReadMemory(sp, &arg.value, arg_size, err); + success = (err.Success() && bytes_read == arg_size); + // advance the stack pointer + sp += arg_size; + } + // fail if we couldn't read this argument + if (!success) { + LLDB_LOGF(log, "%s - error reading argument: %" PRIu64 ", reason: %s", + __FUNCTION__, uint64_t(i), err.AsCString("n/a")); + return false; + } + } + return true; +} + +bool GetArgs(ExecutionContext &exe_ctx, ArgItem *arg_list, size_t num_args) { + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + + // verify that we have a target + if (!exe_ctx.GetTargetPtr()) { + LLDB_LOGF(log, "%s - invalid target", __FUNCTION__); + return false; + } + + GetArgsCtx ctx = {exe_ctx.GetRegisterContext(), exe_ctx.GetProcessPtr()}; + assert(ctx.reg_ctx && ctx.process); + + // dispatch based on architecture + switch (exe_ctx.GetTargetPtr()->GetArchitecture().GetMachine()) { + case llvm::Triple::ArchType::x86: + return GetArgsX86(ctx, arg_list, num_args); + + case llvm::Triple::ArchType::x86_64: + return GetArgsX86_64(ctx, arg_list, num_args); + + case llvm::Triple::ArchType::arm: + return GetArgsArm(ctx, arg_list, num_args); + + case llvm::Triple::ArchType::aarch64: + return GetArgsAarch64(ctx, arg_list, num_args); + + case llvm::Triple::ArchType::mipsel: + return GetArgsMipsel(ctx, arg_list, num_args); + + case llvm::Triple::ArchType::mips64el: + return GetArgsMips64el(ctx, arg_list, num_args); + + default: + // unsupported architecture + if (log) { + LLDB_LOGF(log, "%s - architecture not supported: '%s'", __FUNCTION__, + exe_ctx.GetTargetRef().GetArchitecture().GetArchitectureName()); + } + return false; + } +} + +bool IsRenderScriptScriptModule(ModuleSP module) { + if (!module) + return false; + return module->FindFirstSymbolWithNameAndType(ConstString(".rs.info"), + eSymbolTypeData) != nullptr; +} + +bool ParseCoordinate(llvm::StringRef coord_s, RSCoordinate &coord) { + // takes an argument of the form 'num[,num][,num]'. Where 'coord_s' is a + // comma separated 1,2 or 3-dimensional coordinate with the whitespace + // trimmed. Missing coordinates are defaulted to zero. If parsing of any + // elements fails the contents of &coord are undefined and `false` is + // returned, `true` otherwise + + llvm::SmallVector<llvm::StringRef, 4> matches; + + if (!RegularExpression("^([0-9]+),([0-9]+),([0-9]+)$") + .Execute(coord_s, &matches) && + !RegularExpression("^([0-9]+),([0-9]+)$").Execute(coord_s, &matches) && + !RegularExpression("^([0-9]+)$").Execute(coord_s, &matches)) + return false; + + auto get_index = [&](size_t idx, uint32_t &i) -> bool { + std::string group; + errno = 0; + if (idx + 1 < matches.size()) { + return !llvm::StringRef(matches[idx + 1]).getAsInteger<uint32_t>(10, i); + } + return true; + }; + + return get_index(0, coord.x) && get_index(1, coord.y) && + get_index(2, coord.z); +} + +bool SkipPrologue(lldb::ModuleSP &module, Address &addr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + SymbolContext sc; + uint32_t resolved_flags = + module->ResolveSymbolContextForAddress(addr, eSymbolContextFunction, sc); + if (resolved_flags & eSymbolContextFunction) { + if (sc.function) { + const uint32_t offset = sc.function->GetPrologueByteSize(); + ConstString name = sc.GetFunctionName(); + if (offset) + addr.Slide(offset); + LLDB_LOGF(log, "%s: Prologue offset for %s is %" PRIu32, __FUNCTION__, + name.AsCString(), offset); + } + return true; + } else + return false; +} +} // anonymous namespace + +// The ScriptDetails class collects data associated with a single script +// instance. +struct RenderScriptRuntime::ScriptDetails { + ~ScriptDetails() = default; + + enum ScriptType { eScript, eScriptC }; + + // The derived type of the script. + empirical_type<ScriptType> type; + // The name of the original source file. + empirical_type<std::string> res_name; + // Path to script .so file on the device. + empirical_type<std::string> shared_lib; + // Directory where kernel objects are cached on device. + empirical_type<std::string> cache_dir; + // Pointer to the context which owns this script. + empirical_type<lldb::addr_t> context; + // Pointer to the script object itself. + empirical_type<lldb::addr_t> script; +}; + +// This Element class represents the Element object in RS, defining the type +// associated with an Allocation. +struct RenderScriptRuntime::Element { + // Taken from rsDefines.h + enum DataKind { + RS_KIND_USER, + RS_KIND_PIXEL_L = 7, + RS_KIND_PIXEL_A, + RS_KIND_PIXEL_LA, + RS_KIND_PIXEL_RGB, + RS_KIND_PIXEL_RGBA, + RS_KIND_PIXEL_DEPTH, + RS_KIND_PIXEL_YUV, + RS_KIND_INVALID = 100 + }; + + // Taken from rsDefines.h + enum DataType { + RS_TYPE_NONE = 0, + RS_TYPE_FLOAT_16, + RS_TYPE_FLOAT_32, + RS_TYPE_FLOAT_64, + RS_TYPE_SIGNED_8, + RS_TYPE_SIGNED_16, + RS_TYPE_SIGNED_32, + RS_TYPE_SIGNED_64, + RS_TYPE_UNSIGNED_8, + RS_TYPE_UNSIGNED_16, + RS_TYPE_UNSIGNED_32, + RS_TYPE_UNSIGNED_64, + RS_TYPE_BOOLEAN, + + RS_TYPE_UNSIGNED_5_6_5, + RS_TYPE_UNSIGNED_5_5_5_1, + RS_TYPE_UNSIGNED_4_4_4_4, + + RS_TYPE_MATRIX_4X4, + RS_TYPE_MATRIX_3X3, + RS_TYPE_MATRIX_2X2, + + RS_TYPE_ELEMENT = 1000, + RS_TYPE_TYPE, + RS_TYPE_ALLOCATION, + RS_TYPE_SAMPLER, + RS_TYPE_SCRIPT, + RS_TYPE_MESH, + RS_TYPE_PROGRAM_FRAGMENT, + RS_TYPE_PROGRAM_VERTEX, + RS_TYPE_PROGRAM_RASTER, + RS_TYPE_PROGRAM_STORE, + RS_TYPE_FONT, + + RS_TYPE_INVALID = 10000 + }; + + std::vector<Element> children; // Child Element fields for structs + empirical_type<lldb::addr_t> + element_ptr; // Pointer to the RS Element of the Type + empirical_type<DataType> + type; // Type of each data pointer stored by the allocation + empirical_type<DataKind> + type_kind; // Defines pixel type if Allocation is created from an image + empirical_type<uint32_t> + type_vec_size; // Vector size of each data point, e.g '4' for uchar4 + empirical_type<uint32_t> field_count; // Number of Subelements + empirical_type<uint32_t> datum_size; // Size of a single Element with padding + empirical_type<uint32_t> padding; // Number of padding bytes + empirical_type<uint32_t> + array_size; // Number of items in array, only needed for structs + ConstString type_name; // Name of type, only needed for structs + + static ConstString + GetFallbackStructName(); // Print this as the type name of a struct Element + // If we can't resolve the actual struct name + + bool ShouldRefresh() const { + const bool valid_ptr = element_ptr.isValid() && *element_ptr.get() != 0x0; + const bool valid_type = + type.isValid() && type_vec_size.isValid() && type_kind.isValid(); + return !valid_ptr || !valid_type || !datum_size.isValid(); + } +}; + +// This AllocationDetails class collects data associated with a single +// allocation instance. +struct RenderScriptRuntime::AllocationDetails { + struct Dimension { + uint32_t dim_1; + uint32_t dim_2; + uint32_t dim_3; + uint32_t cube_map; + + Dimension() { + dim_1 = 0; + dim_2 = 0; + dim_3 = 0; + cube_map = 0; + } + }; + + // The FileHeader struct specifies the header we use for writing allocations + // to a binary file. Our format begins with the ASCII characters "RSAD", + // identifying the file as an allocation dump. Member variables dims and + // hdr_size are then written consecutively, immediately followed by an + // instance of the ElementHeader struct. Because Elements can contain + // subelements, there may be more than one instance of the ElementHeader + // struct. With this first instance being the root element, and the other + // instances being the root's descendants. To identify which instances are an + // ElementHeader's children, each struct is immediately followed by a + // sequence of consecutive offsets to the start of its child structs. These + // offsets are + // 4 bytes in size, and the 0 offset signifies no more children. + struct FileHeader { + uint8_t ident[4]; // ASCII 'RSAD' identifying the file + uint32_t dims[3]; // Dimensions + uint16_t hdr_size; // Header size in bytes, including all element headers + }; + + struct ElementHeader { + uint16_t type; // DataType enum + uint32_t kind; // DataKind enum + uint32_t element_size; // Size of a single element, including padding + uint16_t vector_size; // Vector width + uint32_t array_size; // Number of elements in array + }; + + // Monotonically increasing from 1 + static uint32_t ID; + + // Maps Allocation DataType enum and vector size to printable strings using + // mapping from RenderScript numerical types summary documentation + static const char *RsDataTypeToString[][4]; + + // Maps Allocation DataKind enum to printable strings + static const char *RsDataKindToString[]; + + // Maps allocation types to format sizes for printing. + static const uint32_t RSTypeToFormat[][3]; + + // Give each allocation an ID as a way + // for commands to reference it. + const uint32_t id; + + // Allocation Element type + RenderScriptRuntime::Element element; + // Dimensions of the Allocation + empirical_type<Dimension> dimension; + // Pointer to address of the RS Allocation + empirical_type<lldb::addr_t> address; + // Pointer to the data held by the Allocation + empirical_type<lldb::addr_t> data_ptr; + // Pointer to the RS Type of the Allocation + empirical_type<lldb::addr_t> type_ptr; + // Pointer to the RS Context of the Allocation + empirical_type<lldb::addr_t> context; + // Size of the allocation + empirical_type<uint32_t> size; + // Stride between rows of the allocation + empirical_type<uint32_t> stride; + + // Give each allocation an id, so we can reference it in user commands. + AllocationDetails() : id(ID++) {} + + bool ShouldRefresh() const { + bool valid_ptrs = data_ptr.isValid() && *data_ptr.get() != 0x0; + valid_ptrs = valid_ptrs && type_ptr.isValid() && *type_ptr.get() != 0x0; + return !valid_ptrs || !dimension.isValid() || !size.isValid() || + element.ShouldRefresh(); + } +}; + +ConstString RenderScriptRuntime::Element::GetFallbackStructName() { + static const ConstString FallbackStructName("struct"); + return FallbackStructName; +} + +uint32_t RenderScriptRuntime::AllocationDetails::ID = 1; + +const char *RenderScriptRuntime::AllocationDetails::RsDataKindToString[] = { + "User", "Undefined", "Undefined", "Undefined", + "Undefined", "Undefined", "Undefined", // Enum jumps from 0 to 7 + "L Pixel", "A Pixel", "LA Pixel", "RGB Pixel", + "RGBA Pixel", "Pixel Depth", "YUV Pixel"}; + +const char *RenderScriptRuntime::AllocationDetails::RsDataTypeToString[][4] = { + {"None", "None", "None", "None"}, + {"half", "half2", "half3", "half4"}, + {"float", "float2", "float3", "float4"}, + {"double", "double2", "double3", "double4"}, + {"char", "char2", "char3", "char4"}, + {"short", "short2", "short3", "short4"}, + {"int", "int2", "int3", "int4"}, + {"long", "long2", "long3", "long4"}, + {"uchar", "uchar2", "uchar3", "uchar4"}, + {"ushort", "ushort2", "ushort3", "ushort4"}, + {"uint", "uint2", "uint3", "uint4"}, + {"ulong", "ulong2", "ulong3", "ulong4"}, + {"bool", "bool2", "bool3", "bool4"}, + {"packed_565", "packed_565", "packed_565", "packed_565"}, + {"packed_5551", "packed_5551", "packed_5551", "packed_5551"}, + {"packed_4444", "packed_4444", "packed_4444", "packed_4444"}, + {"rs_matrix4x4", "rs_matrix4x4", "rs_matrix4x4", "rs_matrix4x4"}, + {"rs_matrix3x3", "rs_matrix3x3", "rs_matrix3x3", "rs_matrix3x3"}, + {"rs_matrix2x2", "rs_matrix2x2", "rs_matrix2x2", "rs_matrix2x2"}, + + // Handlers + {"RS Element", "RS Element", "RS Element", "RS Element"}, + {"RS Type", "RS Type", "RS Type", "RS Type"}, + {"RS Allocation", "RS Allocation", "RS Allocation", "RS Allocation"}, + {"RS Sampler", "RS Sampler", "RS Sampler", "RS Sampler"}, + {"RS Script", "RS Script", "RS Script", "RS Script"}, + + // Deprecated + {"RS Mesh", "RS Mesh", "RS Mesh", "RS Mesh"}, + {"RS Program Fragment", "RS Program Fragment", "RS Program Fragment", + "RS Program Fragment"}, + {"RS Program Vertex", "RS Program Vertex", "RS Program Vertex", + "RS Program Vertex"}, + {"RS Program Raster", "RS Program Raster", "RS Program Raster", + "RS Program Raster"}, + {"RS Program Store", "RS Program Store", "RS Program Store", + "RS Program Store"}, + {"RS Font", "RS Font", "RS Font", "RS Font"}}; + +// Used as an index into the RSTypeToFormat array elements +enum TypeToFormatIndex { eFormatSingle = 0, eFormatVector, eElementSize }; + +// { format enum of single element, format enum of element vector, size of +// element} +const uint32_t RenderScriptRuntime::AllocationDetails::RSTypeToFormat[][3] = { + // RS_TYPE_NONE + {eFormatHex, eFormatHex, 1}, + // RS_TYPE_FLOAT_16 + {eFormatFloat, eFormatVectorOfFloat16, 2}, + // RS_TYPE_FLOAT_32 + {eFormatFloat, eFormatVectorOfFloat32, sizeof(float)}, + // RS_TYPE_FLOAT_64 + {eFormatFloat, eFormatVectorOfFloat64, sizeof(double)}, + // RS_TYPE_SIGNED_8 + {eFormatDecimal, eFormatVectorOfSInt8, sizeof(int8_t)}, + // RS_TYPE_SIGNED_16 + {eFormatDecimal, eFormatVectorOfSInt16, sizeof(int16_t)}, + // RS_TYPE_SIGNED_32 + {eFormatDecimal, eFormatVectorOfSInt32, sizeof(int32_t)}, + // RS_TYPE_SIGNED_64 + {eFormatDecimal, eFormatVectorOfSInt64, sizeof(int64_t)}, + // RS_TYPE_UNSIGNED_8 + {eFormatDecimal, eFormatVectorOfUInt8, sizeof(uint8_t)}, + // RS_TYPE_UNSIGNED_16 + {eFormatDecimal, eFormatVectorOfUInt16, sizeof(uint16_t)}, + // RS_TYPE_UNSIGNED_32 + {eFormatDecimal, eFormatVectorOfUInt32, sizeof(uint32_t)}, + // RS_TYPE_UNSIGNED_64 + {eFormatDecimal, eFormatVectorOfUInt64, sizeof(uint64_t)}, + // RS_TYPE_BOOL + {eFormatBoolean, eFormatBoolean, 1}, + // RS_TYPE_UNSIGNED_5_6_5 + {eFormatHex, eFormatHex, sizeof(uint16_t)}, + // RS_TYPE_UNSIGNED_5_5_5_1 + {eFormatHex, eFormatHex, sizeof(uint16_t)}, + // RS_TYPE_UNSIGNED_4_4_4_4 + {eFormatHex, eFormatHex, sizeof(uint16_t)}, + // RS_TYPE_MATRIX_4X4 + {eFormatVectorOfFloat32, eFormatVectorOfFloat32, sizeof(float) * 16}, + // RS_TYPE_MATRIX_3X3 + {eFormatVectorOfFloat32, eFormatVectorOfFloat32, sizeof(float) * 9}, + // RS_TYPE_MATRIX_2X2 + {eFormatVectorOfFloat32, eFormatVectorOfFloat32, sizeof(float) * 4}}; + +// Static Functions +LanguageRuntime * +RenderScriptRuntime::CreateInstance(Process *process, + lldb::LanguageType language) { + + if (language == eLanguageTypeExtRenderScript) + return new RenderScriptRuntime(process); + else + return nullptr; +} + +// Callback with a module to search for matching symbols. We first check that +// the module contains RS kernels. Then look for a symbol which matches our +// kernel name. The breakpoint address is finally set using the address of this +// symbol. +Searcher::CallbackReturn +RSBreakpointResolver::SearchCallback(SearchFilter &filter, + SymbolContext &context, Address *) { + ModuleSP module = context.module_sp; + + if (!module || !IsRenderScriptScriptModule(module)) + return Searcher::eCallbackReturnContinue; + + // Attempt to set a breakpoint on the kernel name symbol within the module + // library. If it's not found, it's likely debug info is unavailable - try to + // set a breakpoint on <name>.expand. + const Symbol *kernel_sym = + module->FindFirstSymbolWithNameAndType(m_kernel_name, eSymbolTypeCode); + if (!kernel_sym) { + std::string kernel_name_expanded(m_kernel_name.AsCString()); + kernel_name_expanded.append(".expand"); + kernel_sym = module->FindFirstSymbolWithNameAndType( + ConstString(kernel_name_expanded.c_str()), eSymbolTypeCode); + } + + if (kernel_sym) { + Address bp_addr = kernel_sym->GetAddress(); + if (filter.AddressPasses(bp_addr)) + m_breakpoint->AddLocation(bp_addr); + } + + return Searcher::eCallbackReturnContinue; +} + +Searcher::CallbackReturn +RSReduceBreakpointResolver::SearchCallback(lldb_private::SearchFilter &filter, + lldb_private::SymbolContext &context, + Address *) { + // We need to have access to the list of reductions currently parsed, as + // reduce names don't actually exist as symbols in a module. They are only + // identifiable by parsing the .rs.info packet, or finding the expand symbol. + // We therefore need access to the list of parsed rs modules to properly + // resolve reduction names. + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); + ModuleSP module = context.module_sp; + + if (!module || !IsRenderScriptScriptModule(module)) + return Searcher::eCallbackReturnContinue; + + if (!m_rsmodules) + return Searcher::eCallbackReturnContinue; + + for (const auto &module_desc : *m_rsmodules) { + if (module_desc->m_module != module) + continue; + + for (const auto &reduction : module_desc->m_reductions) { + if (reduction.m_reduce_name != m_reduce_name) + continue; + + std::array<std::pair<ConstString, int>, 5> funcs{ + {{reduction.m_init_name, eKernelTypeInit}, + {reduction.m_accum_name, eKernelTypeAccum}, + {reduction.m_comb_name, eKernelTypeComb}, + {reduction.m_outc_name, eKernelTypeOutC}, + {reduction.m_halter_name, eKernelTypeHalter}}}; + + for (const auto &kernel : funcs) { + // Skip constituent functions that don't match our spec + if (!(m_kernel_types & kernel.second)) + continue; + + const auto kernel_name = kernel.first; + const auto symbol = module->FindFirstSymbolWithNameAndType( + kernel_name, eSymbolTypeCode); + if (!symbol) + continue; + + auto address = symbol->GetAddress(); + if (filter.AddressPasses(address)) { + bool new_bp; + if (!SkipPrologue(module, address)) { + LLDB_LOGF(log, "%s: Error trying to skip prologue", __FUNCTION__); + } + m_breakpoint->AddLocation(address, &new_bp); + LLDB_LOGF(log, "%s: %s reduction breakpoint on %s in %s", + __FUNCTION__, new_bp ? "new" : "existing", + kernel_name.GetCString(), + address.GetModule()->GetFileSpec().GetCString()); + } + } + } + } + return eCallbackReturnContinue; +} + +Searcher::CallbackReturn RSScriptGroupBreakpointResolver::SearchCallback( + SearchFilter &filter, SymbolContext &context, Address *addr) { + + if (!m_breakpoint) + return eCallbackReturnContinue; + + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); + ModuleSP &module = context.module_sp; + + if (!module || !IsRenderScriptScriptModule(module)) + return Searcher::eCallbackReturnContinue; + + std::vector<std::string> names; + m_breakpoint->GetNames(names); + if (names.empty()) + return eCallbackReturnContinue; + + for (auto &name : names) { + const RSScriptGroupDescriptorSP sg = FindScriptGroup(ConstString(name)); + if (!sg) { + LLDB_LOGF(log, "%s: could not find script group for %s", __FUNCTION__, + name.c_str()); + continue; + } + + LLDB_LOGF(log, "%s: Found ScriptGroup for %s", __FUNCTION__, name.c_str()); + + for (const RSScriptGroupDescriptor::Kernel &k : sg->m_kernels) { + if (log) { + LLDB_LOGF(log, "%s: Adding breakpoint for %s", __FUNCTION__, + k.m_name.AsCString()); + LLDB_LOGF(log, "%s: Kernel address 0x%" PRIx64, __FUNCTION__, k.m_addr); + } + + const lldb_private::Symbol *sym = + module->FindFirstSymbolWithNameAndType(k.m_name, eSymbolTypeCode); + if (!sym) { + LLDB_LOGF(log, "%s: Unable to find symbol for %s", __FUNCTION__, + k.m_name.AsCString()); + continue; + } + + if (log) { + LLDB_LOGF(log, "%s: Found symbol name is %s", __FUNCTION__, + sym->GetName().AsCString()); + } + + auto address = sym->GetAddress(); + if (!SkipPrologue(module, address)) { + LLDB_LOGF(log, "%s: Error trying to skip prologue", __FUNCTION__); + } + + bool new_bp; + m_breakpoint->AddLocation(address, &new_bp); + + LLDB_LOGF(log, "%s: Placed %sbreakpoint on %s", __FUNCTION__, + new_bp ? "new " : "", k.m_name.AsCString()); + + // exit after placing the first breakpoint if we do not intend to stop on + // all kernels making up this script group + if (!m_stop_on_all) + break; + } + } + + return eCallbackReturnContinue; +} + +void RenderScriptRuntime::Initialize() { + PluginManager::RegisterPlugin(GetPluginNameStatic(), + "RenderScript language support", CreateInstance, + GetCommandObject); +} + +void RenderScriptRuntime::Terminate() { + PluginManager::UnregisterPlugin(CreateInstance); +} + +lldb_private::ConstString RenderScriptRuntime::GetPluginNameStatic() { + static ConstString plugin_name("renderscript"); + return plugin_name; +} + +RenderScriptRuntime::ModuleKind +RenderScriptRuntime::GetModuleKind(const lldb::ModuleSP &module_sp) { + if (module_sp) { + if (IsRenderScriptScriptModule(module_sp)) + return eModuleKindKernelObj; + + // Is this the main RS runtime library + const ConstString rs_lib("libRS.so"); + if (module_sp->GetFileSpec().GetFilename() == rs_lib) { + return eModuleKindLibRS; + } + + const ConstString rs_driverlib("libRSDriver.so"); + if (module_sp->GetFileSpec().GetFilename() == rs_driverlib) { + return eModuleKindDriver; + } + + const ConstString rs_cpureflib("libRSCpuRef.so"); + if (module_sp->GetFileSpec().GetFilename() == rs_cpureflib) { + return eModuleKindImpl; + } + } + return eModuleKindIgnored; +} + +bool RenderScriptRuntime::IsRenderScriptModule( + const lldb::ModuleSP &module_sp) { + return GetModuleKind(module_sp) != eModuleKindIgnored; +} + +void RenderScriptRuntime::ModulesDidLoad(const ModuleList &module_list) { + std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex()); + + size_t num_modules = module_list.GetSize(); + for (size_t i = 0; i < num_modules; i++) { + auto mod = module_list.GetModuleAtIndex(i); + if (IsRenderScriptModule(mod)) { + LoadModule(mod); + } + } +} + +// PluginInterface protocol +lldb_private::ConstString RenderScriptRuntime::GetPluginName() { + return GetPluginNameStatic(); +} + +uint32_t RenderScriptRuntime::GetPluginVersion() { return 1; } + +bool RenderScriptRuntime::GetDynamicTypeAndAddress( + ValueObject &in_value, lldb::DynamicValueType use_dynamic, + TypeAndOrName &class_type_or_name, Address &address, + Value::ValueType &value_type) { + return false; +} + +TypeAndOrName +RenderScriptRuntime::FixUpDynamicType(const TypeAndOrName &type_and_or_name, + ValueObject &static_value) { + return type_and_or_name; +} + +bool RenderScriptRuntime::CouldHaveDynamicValue(ValueObject &in_value) { + return false; +} + +lldb::BreakpointResolverSP +RenderScriptRuntime::CreateExceptionResolver(Breakpoint *bp, bool catch_bp, + bool throw_bp) { + BreakpointResolverSP resolver_sp; + return resolver_sp; +} + +const RenderScriptRuntime::HookDefn RenderScriptRuntime::s_runtimeHookDefns[] = + { + // rsdScript + {"rsdScriptInit", "_Z13rsdScriptInitPKN7android12renderscript7ContextEP" + "NS0_7ScriptCEPKcS7_PKhjj", + "_Z13rsdScriptInitPKN7android12renderscript7ContextEPNS0_" + "7ScriptCEPKcS7_PKhmj", + 0, RenderScriptRuntime::eModuleKindDriver, + &lldb_private::RenderScriptRuntime::CaptureScriptInit}, + {"rsdScriptInvokeForEachMulti", + "_Z27rsdScriptInvokeForEachMultiPKN7android12renderscript7ContextEPNS0" + "_6ScriptEjPPKNS0_10AllocationEjPS6_PKvjPK12RsScriptCall", + "_Z27rsdScriptInvokeForEachMultiPKN7android12renderscript7ContextEPNS0" + "_6ScriptEjPPKNS0_10AllocationEmPS6_PKvmPK12RsScriptCall", + 0, RenderScriptRuntime::eModuleKindDriver, + &lldb_private::RenderScriptRuntime::CaptureScriptInvokeForEachMulti}, + {"rsdScriptSetGlobalVar", "_Z21rsdScriptSetGlobalVarPKN7android12render" + "script7ContextEPKNS0_6ScriptEjPvj", + "_Z21rsdScriptSetGlobalVarPKN7android12renderscript7ContextEPKNS0_" + "6ScriptEjPvm", + 0, RenderScriptRuntime::eModuleKindDriver, + &lldb_private::RenderScriptRuntime::CaptureSetGlobalVar}, + + // rsdAllocation + {"rsdAllocationInit", "_Z17rsdAllocationInitPKN7android12renderscript7C" + "ontextEPNS0_10AllocationEb", + "_Z17rsdAllocationInitPKN7android12renderscript7ContextEPNS0_" + "10AllocationEb", + 0, RenderScriptRuntime::eModuleKindDriver, + &lldb_private::RenderScriptRuntime::CaptureAllocationInit}, + {"rsdAllocationRead2D", + "_Z19rsdAllocationRead2DPKN7android12renderscript7ContextEPKNS0_" + "10AllocationEjjj23RsAllocationCubemapFacejjPvjj", + "_Z19rsdAllocationRead2DPKN7android12renderscript7ContextEPKNS0_" + "10AllocationEjjj23RsAllocationCubemapFacejjPvmm", + 0, RenderScriptRuntime::eModuleKindDriver, nullptr}, + {"rsdAllocationDestroy", "_Z20rsdAllocationDestroyPKN7android12rendersc" + "ript7ContextEPNS0_10AllocationE", + "_Z20rsdAllocationDestroyPKN7android12renderscript7ContextEPNS0_" + "10AllocationE", + 0, RenderScriptRuntime::eModuleKindDriver, + &lldb_private::RenderScriptRuntime::CaptureAllocationDestroy}, + + // renderscript script groups + {"rsdDebugHintScriptGroup2", "_ZN7android12renderscript21debugHintScrip" + "tGroup2EPKcjPKPFvPK24RsExpandKernelDriver" + "InfojjjEj", + "_ZN7android12renderscript21debugHintScriptGroup2EPKcjPKPFvPK24RsExpan" + "dKernelDriverInfojjjEj", + 0, RenderScriptRuntime::eModuleKindImpl, + &lldb_private::RenderScriptRuntime::CaptureDebugHintScriptGroup2}}; + +const size_t RenderScriptRuntime::s_runtimeHookCount = + sizeof(s_runtimeHookDefns) / sizeof(s_runtimeHookDefns[0]); + +bool RenderScriptRuntime::HookCallback(void *baton, + StoppointCallbackContext *ctx, + lldb::user_id_t break_id, + lldb::user_id_t break_loc_id) { + RuntimeHook *hook = (RuntimeHook *)baton; + ExecutionContext exe_ctx(ctx->exe_ctx_ref); + + RenderScriptRuntime *lang_rt = llvm::cast<RenderScriptRuntime>( + exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + + lang_rt->HookCallback(hook, exe_ctx); + + return false; +} + +void RenderScriptRuntime::HookCallback(RuntimeHook *hook, + ExecutionContext &exe_ctx) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + LLDB_LOGF(log, "%s - '%s'", __FUNCTION__, hook->defn->name); + + if (hook->defn->grabber) { + (this->*(hook->defn->grabber))(hook, exe_ctx); + } +} + +void RenderScriptRuntime::CaptureDebugHintScriptGroup2( + RuntimeHook *hook_info, ExecutionContext &context) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + enum { + eGroupName = 0, + eGroupNameSize, + eKernel, + eKernelCount, + }; + + std::array<ArgItem, 4> args{{ + {ArgItem::ePointer, 0}, // const char *groupName + {ArgItem::eInt32, 0}, // const uint32_t groupNameSize + {ArgItem::ePointer, 0}, // const ExpandFuncTy *kernel + {ArgItem::eInt32, 0}, // const uint32_t kernelCount + }}; + + if (!GetArgs(context, args.data(), args.size())) { + LLDB_LOGF(log, "%s - Error while reading the function parameters", + __FUNCTION__); + return; + } else if (log) { + LLDB_LOGF(log, "%s - groupName : 0x%" PRIx64, __FUNCTION__, + addr_t(args[eGroupName])); + LLDB_LOGF(log, "%s - groupNameSize: %" PRIu64, __FUNCTION__, + uint64_t(args[eGroupNameSize])); + LLDB_LOGF(log, "%s - kernel : 0x%" PRIx64, __FUNCTION__, + addr_t(args[eKernel])); + LLDB_LOGF(log, "%s - kernelCount : %" PRIu64, __FUNCTION__, + uint64_t(args[eKernelCount])); + } + + // parse script group name + ConstString group_name; + { + Status err; + const uint64_t len = uint64_t(args[eGroupNameSize]); + std::unique_ptr<char[]> buffer(new char[uint32_t(len + 1)]); + m_process->ReadMemory(addr_t(args[eGroupName]), buffer.get(), len, err); + buffer.get()[len] = '\0'; + if (!err.Success()) { + LLDB_LOGF(log, "Error reading scriptgroup name from target"); + return; + } else { + LLDB_LOGF(log, "Extracted scriptgroup name %s", buffer.get()); + } + // write back the script group name + group_name.SetCString(buffer.get()); + } + + // create or access existing script group + RSScriptGroupDescriptorSP group; + { + // search for existing script group + for (auto sg : m_scriptGroups) { + if (sg->m_name == group_name) { + group = sg; + break; + } + } + if (!group) { + group = std::make_shared<RSScriptGroupDescriptor>(); + group->m_name = group_name; + m_scriptGroups.push_back(group); + } else { + // already have this script group + LLDB_LOGF(log, "Attempt to add duplicate script group %s", + group_name.AsCString()); + return; + } + } + assert(group); + + const uint32_t target_ptr_size = m_process->GetAddressByteSize(); + std::vector<addr_t> kernels; + // parse kernel addresses in script group + for (uint64_t i = 0; i < uint64_t(args[eKernelCount]); ++i) { + RSScriptGroupDescriptor::Kernel kernel; + // extract script group kernel addresses from the target + const addr_t ptr_addr = addr_t(args[eKernel]) + i * target_ptr_size; + uint64_t kernel_addr = 0; + Status err; + size_t read = + m_process->ReadMemory(ptr_addr, &kernel_addr, target_ptr_size, err); + if (!err.Success() || read != target_ptr_size) { + LLDB_LOGF(log, "Error parsing kernel address %" PRIu64 " in script group", + i); + return; + } + LLDB_LOGF(log, "Extracted scriptgroup kernel address - 0x%" PRIx64, + kernel_addr); + kernel.m_addr = kernel_addr; + + // try to resolve the associated kernel name + if (!ResolveKernelName(kernel.m_addr, kernel.m_name)) { + LLDB_LOGF(log, "Parsed scriptgroup kernel %" PRIu64 " - 0x%" PRIx64, i, + kernel_addr); + return; + } + + // try to find the non '.expand' function + { + const llvm::StringRef expand(".expand"); + const llvm::StringRef name_ref = kernel.m_name.GetStringRef(); + if (name_ref.endswith(expand)) { + const ConstString base_kernel(name_ref.drop_back(expand.size())); + // verify this function is a valid kernel + if (IsKnownKernel(base_kernel)) { + kernel.m_name = base_kernel; + LLDB_LOGF(log, "%s - found non expand version '%s'", __FUNCTION__, + base_kernel.GetCString()); + } + } + } + // add to a list of script group kernels we know about + group->m_kernels.push_back(kernel); + } + + // Resolve any pending scriptgroup breakpoints + { + Target &target = m_process->GetTarget(); + const BreakpointList &list = target.GetBreakpointList(); + const size_t num_breakpoints = list.GetSize(); + LLDB_LOGF(log, "Resolving %zu breakpoints", num_breakpoints); + for (size_t i = 0; i < num_breakpoints; ++i) { + const BreakpointSP bp = list.GetBreakpointAtIndex(i); + if (bp) { + if (bp->MatchesName(group_name.AsCString())) { + LLDB_LOGF(log, "Found breakpoint with name %s", + group_name.AsCString()); + bp->ResolveBreakpoint(); + } + } + } + } +} + +void RenderScriptRuntime::CaptureScriptInvokeForEachMulti( + RuntimeHook *hook, ExecutionContext &exe_ctx) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + enum { + eRsContext = 0, + eRsScript, + eRsSlot, + eRsAIns, + eRsInLen, + eRsAOut, + eRsUsr, + eRsUsrLen, + eRsSc, + }; + + std::array<ArgItem, 9> args{{ + ArgItem{ArgItem::ePointer, 0}, // const Context *rsc + ArgItem{ArgItem::ePointer, 0}, // Script *s + ArgItem{ArgItem::eInt32, 0}, // uint32_t slot + ArgItem{ArgItem::ePointer, 0}, // const Allocation **aIns + ArgItem{ArgItem::eInt32, 0}, // size_t inLen + ArgItem{ArgItem::ePointer, 0}, // Allocation *aout + ArgItem{ArgItem::ePointer, 0}, // const void *usr + ArgItem{ArgItem::eInt32, 0}, // size_t usrLen + ArgItem{ArgItem::ePointer, 0}, // const RsScriptCall *sc + }}; + + bool success = GetArgs(exe_ctx, &args[0], args.size()); + if (!success) { + LLDB_LOGF(log, "%s - Error while reading the function parameters", + __FUNCTION__); + return; + } + + const uint32_t target_ptr_size = m_process->GetAddressByteSize(); + Status err; + std::vector<uint64_t> allocs; + + // traverse allocation list + for (uint64_t i = 0; i < uint64_t(args[eRsInLen]); ++i) { + // calculate offest to allocation pointer + const addr_t addr = addr_t(args[eRsAIns]) + i * target_ptr_size; + + // Note: due to little endian layout, reading 32bits or 64bits into res + // will give the correct results. + uint64_t result = 0; + size_t read = m_process->ReadMemory(addr, &result, target_ptr_size, err); + if (read != target_ptr_size || !err.Success()) { + LLDB_LOGF(log, + "%s - Error while reading allocation list argument %" PRIu64, + __FUNCTION__, i); + } else { + allocs.push_back(result); + } + } + + // if there is an output allocation track it + if (uint64_t alloc_out = uint64_t(args[eRsAOut])) { + allocs.push_back(alloc_out); + } + + // for all allocations we have found + for (const uint64_t alloc_addr : allocs) { + AllocationDetails *alloc = LookUpAllocation(alloc_addr); + if (!alloc) + alloc = CreateAllocation(alloc_addr); + + if (alloc) { + // save the allocation address + if (alloc->address.isValid()) { + // check the allocation address we already have matches + assert(*alloc->address.get() == alloc_addr); + } else { + alloc->address = alloc_addr; + } + + // save the context + if (log) { + if (alloc->context.isValid() && + *alloc->context.get() != addr_t(args[eRsContext])) + LLDB_LOGF(log, "%s - Allocation used by multiple contexts", + __FUNCTION__); + } + alloc->context = addr_t(args[eRsContext]); + } + } + + // make sure we track this script object + if (lldb_private::RenderScriptRuntime::ScriptDetails *script = + LookUpScript(addr_t(args[eRsScript]), true)) { + if (log) { + if (script->context.isValid() && + *script->context.get() != addr_t(args[eRsContext])) + LLDB_LOGF(log, "%s - Script used by multiple contexts", __FUNCTION__); + } + script->context = addr_t(args[eRsContext]); + } +} + +void RenderScriptRuntime::CaptureSetGlobalVar(RuntimeHook *hook, + ExecutionContext &context) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + enum { + eRsContext, + eRsScript, + eRsId, + eRsData, + eRsLength, + }; + + std::array<ArgItem, 5> args{{ + ArgItem{ArgItem::ePointer, 0}, // eRsContext + ArgItem{ArgItem::ePointer, 0}, // eRsScript + ArgItem{ArgItem::eInt32, 0}, // eRsId + ArgItem{ArgItem::ePointer, 0}, // eRsData + ArgItem{ArgItem::eInt32, 0}, // eRsLength + }}; + + bool success = GetArgs(context, &args[0], args.size()); + if (!success) { + LLDB_LOGF(log, "%s - error reading the function parameters.", __FUNCTION__); + return; + } + + if (log) { + LLDB_LOGF(log, + "%s - 0x%" PRIx64 ",0x%" PRIx64 " slot %" PRIu64 " = 0x%" PRIx64 + ":%" PRIu64 "bytes.", + __FUNCTION__, uint64_t(args[eRsContext]), + uint64_t(args[eRsScript]), uint64_t(args[eRsId]), + uint64_t(args[eRsData]), uint64_t(args[eRsLength])); + + addr_t script_addr = addr_t(args[eRsScript]); + if (m_scriptMappings.find(script_addr) != m_scriptMappings.end()) { + auto rsm = m_scriptMappings[script_addr]; + if (uint64_t(args[eRsId]) < rsm->m_globals.size()) { + auto rsg = rsm->m_globals[uint64_t(args[eRsId])]; + LLDB_LOGF(log, "%s - Setting of '%s' within '%s' inferred", + __FUNCTION__, rsg.m_name.AsCString(), + rsm->m_module->GetFileSpec().GetFilename().AsCString()); + } + } + } +} + +void RenderScriptRuntime::CaptureAllocationInit(RuntimeHook *hook, + ExecutionContext &exe_ctx) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + enum { eRsContext, eRsAlloc, eRsForceZero }; + + std::array<ArgItem, 3> args{{ + ArgItem{ArgItem::ePointer, 0}, // eRsContext + ArgItem{ArgItem::ePointer, 0}, // eRsAlloc + ArgItem{ArgItem::eBool, 0}, // eRsForceZero + }}; + + bool success = GetArgs(exe_ctx, &args[0], args.size()); + if (!success) { + LLDB_LOGF(log, "%s - error while reading the function parameters", + __FUNCTION__); + return; + } + + LLDB_LOGF(log, "%s - 0x%" PRIx64 ",0x%" PRIx64 ",0x%" PRIx64 " .", + __FUNCTION__, uint64_t(args[eRsContext]), uint64_t(args[eRsAlloc]), + uint64_t(args[eRsForceZero])); + + AllocationDetails *alloc = CreateAllocation(uint64_t(args[eRsAlloc])); + if (alloc) + alloc->context = uint64_t(args[eRsContext]); +} + +void RenderScriptRuntime::CaptureAllocationDestroy(RuntimeHook *hook, + ExecutionContext &exe_ctx) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + enum { + eRsContext, + eRsAlloc, + }; + + std::array<ArgItem, 2> args{{ + ArgItem{ArgItem::ePointer, 0}, // eRsContext + ArgItem{ArgItem::ePointer, 0}, // eRsAlloc + }}; + + bool success = GetArgs(exe_ctx, &args[0], args.size()); + if (!success) { + LLDB_LOGF(log, "%s - error while reading the function parameters.", + __FUNCTION__); + return; + } + + LLDB_LOGF(log, "%s - 0x%" PRIx64 ", 0x%" PRIx64 ".", __FUNCTION__, + uint64_t(args[eRsContext]), uint64_t(args[eRsAlloc])); + + for (auto iter = m_allocations.begin(); iter != m_allocations.end(); ++iter) { + auto &allocation_up = *iter; // get the unique pointer + if (allocation_up->address.isValid() && + *allocation_up->address.get() == addr_t(args[eRsAlloc])) { + m_allocations.erase(iter); + LLDB_LOGF(log, "%s - deleted allocation entry.", __FUNCTION__); + return; + } + } + + LLDB_LOGF(log, "%s - couldn't find destroyed allocation.", __FUNCTION__); +} + +void RenderScriptRuntime::CaptureScriptInit(RuntimeHook *hook, + ExecutionContext &exe_ctx) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + Status err; + Process *process = exe_ctx.GetProcessPtr(); + + enum { eRsContext, eRsScript, eRsResNamePtr, eRsCachedDirPtr }; + + std::array<ArgItem, 4> args{ + {ArgItem{ArgItem::ePointer, 0}, ArgItem{ArgItem::ePointer, 0}, + ArgItem{ArgItem::ePointer, 0}, ArgItem{ArgItem::ePointer, 0}}}; + bool success = GetArgs(exe_ctx, &args[0], args.size()); + if (!success) { + LLDB_LOGF(log, "%s - error while reading the function parameters.", + __FUNCTION__); + return; + } + + std::string res_name; + process->ReadCStringFromMemory(addr_t(args[eRsResNamePtr]), res_name, err); + if (err.Fail()) { + LLDB_LOGF(log, "%s - error reading res_name: %s.", __FUNCTION__, + err.AsCString()); + } + + std::string cache_dir; + process->ReadCStringFromMemory(addr_t(args[eRsCachedDirPtr]), cache_dir, err); + if (err.Fail()) { + LLDB_LOGF(log, "%s - error reading cache_dir: %s.", __FUNCTION__, + err.AsCString()); + } + + LLDB_LOGF(log, "%s - 0x%" PRIx64 ",0x%" PRIx64 " => '%s' at '%s' .", + __FUNCTION__, uint64_t(args[eRsContext]), uint64_t(args[eRsScript]), + res_name.c_str(), cache_dir.c_str()); + + if (res_name.size() > 0) { + StreamString strm; + strm.Printf("librs.%s.so", res_name.c_str()); + + ScriptDetails *script = LookUpScript(addr_t(args[eRsScript]), true); + if (script) { + script->type = ScriptDetails::eScriptC; + script->cache_dir = cache_dir; + script->res_name = res_name; + script->shared_lib = strm.GetString(); + script->context = addr_t(args[eRsContext]); + } + + LLDB_LOGF(log, + "%s - '%s' tagged with context 0x%" PRIx64 + " and script 0x%" PRIx64 ".", + __FUNCTION__, strm.GetData(), uint64_t(args[eRsContext]), + uint64_t(args[eRsScript])); + } else if (log) { + LLDB_LOGF(log, "%s - resource name invalid, Script not tagged.", + __FUNCTION__); + } +} + +void RenderScriptRuntime::LoadRuntimeHooks(lldb::ModuleSP module, + ModuleKind kind) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!module) { + return; + } + + Target &target = GetProcess()->GetTarget(); + const llvm::Triple::ArchType machine = target.GetArchitecture().GetMachine(); + + if (machine != llvm::Triple::ArchType::x86 && + machine != llvm::Triple::ArchType::arm && + machine != llvm::Triple::ArchType::aarch64 && + machine != llvm::Triple::ArchType::mipsel && + machine != llvm::Triple::ArchType::mips64el && + machine != llvm::Triple::ArchType::x86_64) { + LLDB_LOGF(log, "%s - unable to hook runtime functions.", __FUNCTION__); + return; + } + + const uint32_t target_ptr_size = + target.GetArchitecture().GetAddressByteSize(); + + std::array<bool, s_runtimeHookCount> hook_placed; + hook_placed.fill(false); + + for (size_t idx = 0; idx < s_runtimeHookCount; idx++) { + const HookDefn *hook_defn = &s_runtimeHookDefns[idx]; + if (hook_defn->kind != kind) { + continue; + } + + const char *symbol_name = (target_ptr_size == 4) + ? hook_defn->symbol_name_m32 + : hook_defn->symbol_name_m64; + + const Symbol *sym = module->FindFirstSymbolWithNameAndType( + ConstString(symbol_name), eSymbolTypeCode); + if (!sym) { + if (log) { + LLDB_LOGF(log, "%s - symbol '%s' related to the function %s not found", + __FUNCTION__, symbol_name, hook_defn->name); + } + continue; + } + + addr_t addr = sym->GetLoadAddress(&target); + if (addr == LLDB_INVALID_ADDRESS) { + LLDB_LOGF(log, + "%s - unable to resolve the address of hook function '%s' " + "with symbol '%s'.", + __FUNCTION__, hook_defn->name, symbol_name); + continue; + } else { + LLDB_LOGF(log, "%s - function %s, address resolved at 0x%" PRIx64, + __FUNCTION__, hook_defn->name, addr); + } + + RuntimeHookSP hook(new RuntimeHook()); + hook->address = addr; + hook->defn = hook_defn; + hook->bp_sp = target.CreateBreakpoint(addr, true, false); + hook->bp_sp->SetCallback(HookCallback, hook.get(), true); + m_runtimeHooks[addr] = hook; + if (log) { + LLDB_LOGF(log, + "%s - successfully hooked '%s' in '%s' version %" PRIu64 + " at 0x%" PRIx64 ".", + __FUNCTION__, hook_defn->name, + module->GetFileSpec().GetFilename().AsCString(), + (uint64_t)hook_defn->version, (uint64_t)addr); + } + hook_placed[idx] = true; + } + + // log any unhooked function + if (log) { + for (size_t i = 0; i < hook_placed.size(); ++i) { + if (hook_placed[i]) + continue; + const HookDefn &hook_defn = s_runtimeHookDefns[i]; + if (hook_defn.kind != kind) + continue; + LLDB_LOGF(log, "%s - function %s was not hooked", __FUNCTION__, + hook_defn.name); + } + } +} + +void RenderScriptRuntime::FixupScriptDetails(RSModuleDescriptorSP rsmodule_sp) { + if (!rsmodule_sp) + return; + + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + const ModuleSP module = rsmodule_sp->m_module; + const FileSpec &file = module->GetPlatformFileSpec(); + + // Iterate over all of the scripts that we currently know of. Note: We cant + // push or pop to m_scripts here or it may invalidate rs_script. + for (const auto &rs_script : m_scripts) { + // Extract the expected .so file path for this script. + std::string shared_lib; + if (!rs_script->shared_lib.get(shared_lib)) + continue; + + // Only proceed if the module that has loaded corresponds to this script. + if (file.GetFilename() != ConstString(shared_lib.c_str())) + continue; + + // Obtain the script address which we use as a key. + lldb::addr_t script; + if (!rs_script->script.get(script)) + continue; + + // If we have a script mapping for the current script. + if (m_scriptMappings.find(script) != m_scriptMappings.end()) { + // if the module we have stored is different to the one we just received. + if (m_scriptMappings[script] != rsmodule_sp) { + LLDB_LOGF( + log, + "%s - script %" PRIx64 " wants reassigned to new rsmodule '%s'.", + __FUNCTION__, (uint64_t)script, + rsmodule_sp->m_module->GetFileSpec().GetFilename().AsCString()); + } + } + // We don't have a script mapping for the current script. + else { + // Obtain the script resource name. + std::string res_name; + if (rs_script->res_name.get(res_name)) + // Set the modules resource name. + rsmodule_sp->m_resname = res_name; + // Add Script/Module pair to map. + m_scriptMappings[script] = rsmodule_sp; + LLDB_LOGF(log, "%s - script %" PRIx64 " associated with rsmodule '%s'.", + __FUNCTION__, (uint64_t)script, + rsmodule_sp->m_module->GetFileSpec().GetFilename().AsCString()); + } + } +} + +// Uses the Target API to evaluate the expression passed as a parameter to the +// function The result of that expression is returned an unsigned 64 bit int, +// via the result* parameter. Function returns true on success, and false on +// failure +bool RenderScriptRuntime::EvalRSExpression(const char *expr, + StackFrame *frame_ptr, + uint64_t *result) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + LLDB_LOGF(log, "%s(%s)", __FUNCTION__, expr); + + ValueObjectSP expr_result; + EvaluateExpressionOptions options; + options.SetLanguage(lldb::eLanguageTypeC_plus_plus); + // Perform the actual expression evaluation + auto &target = GetProcess()->GetTarget(); + target.EvaluateExpression(expr, frame_ptr, expr_result, options); + + if (!expr_result) { + LLDB_LOGF(log, "%s: couldn't evaluate expression.", __FUNCTION__); + return false; + } + + // The result of the expression is invalid + if (!expr_result->GetError().Success()) { + Status err = expr_result->GetError(); + // Expression returned is void, so this is actually a success + if (err.GetError() == UserExpression::kNoResult) { + LLDB_LOGF(log, "%s - expression returned void.", __FUNCTION__); + + result = nullptr; + return true; + } + + LLDB_LOGF(log, "%s - error evaluating expression result: %s", __FUNCTION__, + err.AsCString()); + return false; + } + + bool success = false; + // We only read the result as an uint32_t. + *result = expr_result->GetValueAsUnsigned(0, &success); + + if (!success) { + LLDB_LOGF(log, "%s - couldn't convert expression result to uint32_t", + __FUNCTION__); + return false; + } + + return true; +} + +namespace { +// Used to index expression format strings +enum ExpressionStrings { + eExprGetOffsetPtr = 0, + eExprAllocGetType, + eExprTypeDimX, + eExprTypeDimY, + eExprTypeDimZ, + eExprTypeElemPtr, + eExprElementType, + eExprElementKind, + eExprElementVec, + eExprElementFieldCount, + eExprSubelementsId, + eExprSubelementsName, + eExprSubelementsArrSize, + + _eExprLast // keep at the end, implicit size of the array runtime_expressions +}; + +// max length of an expanded expression +const int jit_max_expr_size = 512; + +// Retrieve the string to JIT for the given expression +#define JIT_TEMPLATE_CONTEXT "void* ctxt = (void*)rsDebugGetContextWrapper(0x%" PRIx64 "); " +const char *JITTemplate(ExpressionStrings e) { + // Format strings containing the expressions we may need to evaluate. + static std::array<const char *, _eExprLast> runtime_expressions = { + {// Mangled GetOffsetPointer(Allocation*, xoff, yoff, zoff, lod, cubemap) + "(int*)_" + "Z12GetOffsetPtrPKN7android12renderscript10AllocationEjjjj23RsAllocation" + "CubemapFace" + "(0x%" PRIx64 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", 0, 0)", // eExprGetOffsetPtr + + // Type* rsaAllocationGetType(Context*, Allocation*) + JIT_TEMPLATE_CONTEXT "(void*)rsaAllocationGetType(ctxt, 0x%" PRIx64 ")", // eExprAllocGetType + + // rsaTypeGetNativeData(Context*, Type*, void* typeData, size) Pack the + // data in the following way mHal.state.dimX; mHal.state.dimY; + // mHal.state.dimZ; mHal.state.lodCount; mHal.state.faces; mElement; + // into typeData Need to specify 32 or 64 bit for uint_t since this + // differs between devices + JIT_TEMPLATE_CONTEXT + "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(ctxt" + ", 0x%" PRIx64 ", data, 6); data[0]", // eExprTypeDimX + JIT_TEMPLATE_CONTEXT + "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(ctxt" + ", 0x%" PRIx64 ", data, 6); data[1]", // eExprTypeDimY + JIT_TEMPLATE_CONTEXT + "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(ctxt" + ", 0x%" PRIx64 ", data, 6); data[2]", // eExprTypeDimZ + JIT_TEMPLATE_CONTEXT + "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(ctxt" + ", 0x%" PRIx64 ", data, 6); data[5]", // eExprTypeElemPtr + + // rsaElementGetNativeData(Context*, Element*, uint32_t* elemData,size) + // Pack mType; mKind; mNormalized; mVectorSize; NumSubElements into + // elemData + JIT_TEMPLATE_CONTEXT + "uint32_t data[5]; (void*)rsaElementGetNativeData(ctxt" + ", 0x%" PRIx64 ", data, 5); data[0]", // eExprElementType + JIT_TEMPLATE_CONTEXT + "uint32_t data[5]; (void*)rsaElementGetNativeData(ctxt" + ", 0x%" PRIx64 ", data, 5); data[1]", // eExprElementKind + JIT_TEMPLATE_CONTEXT + "uint32_t data[5]; (void*)rsaElementGetNativeData(ctxt" + ", 0x%" PRIx64 ", data, 5); data[3]", // eExprElementVec + JIT_TEMPLATE_CONTEXT + "uint32_t data[5]; (void*)rsaElementGetNativeData(ctxt" + ", 0x%" PRIx64 ", data, 5); data[4]", // eExprElementFieldCount + + // rsaElementGetSubElements(RsContext con, RsElement elem, uintptr_t + // *ids, const char **names, size_t *arraySizes, uint32_t dataSize) + // Needed for Allocations of structs to gather details about + // fields/Subelements Element* of field + JIT_TEMPLATE_CONTEXT "void* ids[%" PRIu32 "]; const char* names[%" PRIu32 + "]; size_t arr_size[%" PRIu32 "];" + "(void*)rsaElementGetSubElements(ctxt, 0x%" PRIx64 + ", ids, names, arr_size, %" PRIu32 "); ids[%" PRIu32 "]", // eExprSubelementsId + + // Name of field + JIT_TEMPLATE_CONTEXT "void* ids[%" PRIu32 "]; const char* names[%" PRIu32 + "]; size_t arr_size[%" PRIu32 "];" + "(void*)rsaElementGetSubElements(ctxt, 0x%" PRIx64 + ", ids, names, arr_size, %" PRIu32 "); names[%" PRIu32 "]", // eExprSubelementsName + + // Array size of field + JIT_TEMPLATE_CONTEXT "void* ids[%" PRIu32 "]; const char* names[%" PRIu32 + "]; size_t arr_size[%" PRIu32 "];" + "(void*)rsaElementGetSubElements(ctxt, 0x%" PRIx64 + ", ids, names, arr_size, %" PRIu32 "); arr_size[%" PRIu32 "]"}}; // eExprSubelementsArrSize + + return runtime_expressions[e]; +} +} // end of the anonymous namespace + +// JITs the RS runtime for the internal data pointer of an allocation. Is +// passed x,y,z coordinates for the pointer to a specific element. Then sets +// the data_ptr member in Allocation with the result. Returns true on success, +// false otherwise +bool RenderScriptRuntime::JITDataPointer(AllocationDetails *alloc, + StackFrame *frame_ptr, uint32_t x, + uint32_t y, uint32_t z) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!alloc->address.isValid()) { + LLDB_LOGF(log, "%s - failed to find allocation details.", __FUNCTION__); + return false; + } + + const char *fmt_str = JITTemplate(eExprGetOffsetPtr); + char expr_buf[jit_max_expr_size]; + + int written = snprintf(expr_buf, jit_max_expr_size, fmt_str, + *alloc->address.get(), x, y, z); + if (written < 0) { + LLDB_LOGF(log, "%s - encoding error in snprintf().", __FUNCTION__); + return false; + } else if (written >= jit_max_expr_size) { + LLDB_LOGF(log, "%s - expression too long.", __FUNCTION__); + return false; + } + + uint64_t result = 0; + if (!EvalRSExpression(expr_buf, frame_ptr, &result)) + return false; + + addr_t data_ptr = static_cast<lldb::addr_t>(result); + alloc->data_ptr = data_ptr; + + return true; +} + +// JITs the RS runtime for the internal pointer to the RS Type of an allocation +// Then sets the type_ptr member in Allocation with the result. Returns true on +// success, false otherwise +bool RenderScriptRuntime::JITTypePointer(AllocationDetails *alloc, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!alloc->address.isValid() || !alloc->context.isValid()) { + LLDB_LOGF(log, "%s - failed to find allocation details.", __FUNCTION__); + return false; + } + + const char *fmt_str = JITTemplate(eExprAllocGetType); + char expr_buf[jit_max_expr_size]; + + int written = snprintf(expr_buf, jit_max_expr_size, fmt_str, + *alloc->context.get(), *alloc->address.get()); + if (written < 0) { + LLDB_LOGF(log, "%s - encoding error in snprintf().", __FUNCTION__); + return false; + } else if (written >= jit_max_expr_size) { + LLDB_LOGF(log, "%s - expression too long.", __FUNCTION__); + return false; + } + + uint64_t result = 0; + if (!EvalRSExpression(expr_buf, frame_ptr, &result)) + return false; + + addr_t type_ptr = static_cast<lldb::addr_t>(result); + alloc->type_ptr = type_ptr; + + return true; +} + +// JITs the RS runtime for information about the dimensions and type of an +// allocation Then sets dimension and element_ptr members in Allocation with +// the result. Returns true on success, false otherwise +bool RenderScriptRuntime::JITTypePacked(AllocationDetails *alloc, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!alloc->type_ptr.isValid() || !alloc->context.isValid()) { + LLDB_LOGF(log, "%s - Failed to find allocation details.", __FUNCTION__); + return false; + } + + // Expression is different depending on if device is 32 or 64 bit + uint32_t target_ptr_size = + GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize(); + const uint32_t bits = target_ptr_size == 4 ? 32 : 64; + + // We want 4 elements from packed data + const uint32_t num_exprs = 4; + static_assert(num_exprs == (eExprTypeElemPtr - eExprTypeDimX + 1), + "Invalid number of expressions"); + + char expr_bufs[num_exprs][jit_max_expr_size]; + uint64_t results[num_exprs]; + + for (uint32_t i = 0; i < num_exprs; ++i) { + const char *fmt_str = JITTemplate(ExpressionStrings(eExprTypeDimX + i)); + int written = snprintf(expr_bufs[i], jit_max_expr_size, fmt_str, + *alloc->context.get(), bits, *alloc->type_ptr.get()); + if (written < 0) { + LLDB_LOGF(log, "%s - encoding error in snprintf().", __FUNCTION__); + return false; + } else if (written >= jit_max_expr_size) { + LLDB_LOGF(log, "%s - expression too long.", __FUNCTION__); + return false; + } + + // Perform expression evaluation + if (!EvalRSExpression(expr_bufs[i], frame_ptr, &results[i])) + return false; + } + + // Assign results to allocation members + AllocationDetails::Dimension dims; + dims.dim_1 = static_cast<uint32_t>(results[0]); + dims.dim_2 = static_cast<uint32_t>(results[1]); + dims.dim_3 = static_cast<uint32_t>(results[2]); + alloc->dimension = dims; + + addr_t element_ptr = static_cast<lldb::addr_t>(results[3]); + alloc->element.element_ptr = element_ptr; + + LLDB_LOGF(log, + "%s - dims (%" PRIu32 ", %" PRIu32 ", %" PRIu32 + ") Element*: 0x%" PRIx64 ".", + __FUNCTION__, dims.dim_1, dims.dim_2, dims.dim_3, element_ptr); + + return true; +} + +// JITs the RS runtime for information about the Element of an allocation Then +// sets type, type_vec_size, field_count and type_kind members in Element with +// the result. Returns true on success, false otherwise +bool RenderScriptRuntime::JITElementPacked(Element &elem, + const lldb::addr_t context, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!elem.element_ptr.isValid()) { + LLDB_LOGF(log, "%s - failed to find allocation details.", __FUNCTION__); + return false; + } + + // We want 4 elements from packed data + const uint32_t num_exprs = 4; + static_assert(num_exprs == (eExprElementFieldCount - eExprElementType + 1), + "Invalid number of expressions"); + + char expr_bufs[num_exprs][jit_max_expr_size]; + uint64_t results[num_exprs]; + + for (uint32_t i = 0; i < num_exprs; i++) { + const char *fmt_str = JITTemplate(ExpressionStrings(eExprElementType + i)); + int written = snprintf(expr_bufs[i], jit_max_expr_size, fmt_str, context, + *elem.element_ptr.get()); + if (written < 0) { + LLDB_LOGF(log, "%s - encoding error in snprintf().", __FUNCTION__); + return false; + } else if (written >= jit_max_expr_size) { + LLDB_LOGF(log, "%s - expression too long.", __FUNCTION__); + return false; + } + + // Perform expression evaluation + if (!EvalRSExpression(expr_bufs[i], frame_ptr, &results[i])) + return false; + } + + // Assign results to allocation members + elem.type = static_cast<RenderScriptRuntime::Element::DataType>(results[0]); + elem.type_kind = + static_cast<RenderScriptRuntime::Element::DataKind>(results[1]); + elem.type_vec_size = static_cast<uint32_t>(results[2]); + elem.field_count = static_cast<uint32_t>(results[3]); + + LLDB_LOGF(log, + "%s - data type %" PRIu32 ", pixel type %" PRIu32 + ", vector size %" PRIu32 ", field count %" PRIu32, + __FUNCTION__, *elem.type.get(), *elem.type_kind.get(), + *elem.type_vec_size.get(), *elem.field_count.get()); + + // If this Element has subelements then JIT rsaElementGetSubElements() for + // details about its fields + return !(*elem.field_count.get() > 0 && + !JITSubelements(elem, context, frame_ptr)); +} + +// JITs the RS runtime for information about the subelements/fields of a struct +// allocation This is necessary for infering the struct type so we can pretty +// print the allocation's contents. Returns true on success, false otherwise +bool RenderScriptRuntime::JITSubelements(Element &elem, + const lldb::addr_t context, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!elem.element_ptr.isValid() || !elem.field_count.isValid()) { + LLDB_LOGF(log, "%s - failed to find allocation details.", __FUNCTION__); + return false; + } + + const short num_exprs = 3; + static_assert(num_exprs == (eExprSubelementsArrSize - eExprSubelementsId + 1), + "Invalid number of expressions"); + + char expr_buffer[jit_max_expr_size]; + uint64_t results; + + // Iterate over struct fields. + const uint32_t field_count = *elem.field_count.get(); + for (uint32_t field_index = 0; field_index < field_count; ++field_index) { + Element child; + for (uint32_t expr_index = 0; expr_index < num_exprs; ++expr_index) { + const char *fmt_str = + JITTemplate(ExpressionStrings(eExprSubelementsId + expr_index)); + int written = snprintf(expr_buffer, jit_max_expr_size, fmt_str, + context, field_count, field_count, field_count, + *elem.element_ptr.get(), field_count, field_index); + if (written < 0) { + LLDB_LOGF(log, "%s - encoding error in snprintf().", __FUNCTION__); + return false; + } else if (written >= jit_max_expr_size) { + LLDB_LOGF(log, "%s - expression too long.", __FUNCTION__); + return false; + } + + // Perform expression evaluation + if (!EvalRSExpression(expr_buffer, frame_ptr, &results)) + return false; + + LLDB_LOGF(log, "%s - expr result 0x%" PRIx64 ".", __FUNCTION__, results); + + switch (expr_index) { + case 0: // Element* of child + child.element_ptr = static_cast<addr_t>(results); + break; + case 1: // Name of child + { + lldb::addr_t address = static_cast<addr_t>(results); + Status err; + std::string name; + GetProcess()->ReadCStringFromMemory(address, name, err); + if (!err.Fail()) + child.type_name = ConstString(name); + else { + LLDB_LOGF(log, "%s - warning: Couldn't read field name.", + __FUNCTION__); + } + break; + } + case 2: // Array size of child + child.array_size = static_cast<uint32_t>(results); + break; + } + } + + // We need to recursively JIT each Element field of the struct since + // structs can be nested inside structs. + if (!JITElementPacked(child, context, frame_ptr)) + return false; + elem.children.push_back(child); + } + + // Try to infer the name of the struct type so we can pretty print the + // allocation contents. + FindStructTypeName(elem, frame_ptr); + + return true; +} + +// JITs the RS runtime for the address of the last element in the allocation. +// The `elem_size` parameter represents the size of a single element, including +// padding. Which is needed as an offset from the last element pointer. Using +// this offset minus the starting address we can calculate the size of the +// allocation. Returns true on success, false otherwise +bool RenderScriptRuntime::JITAllocationSize(AllocationDetails *alloc, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!alloc->address.isValid() || !alloc->dimension.isValid() || + !alloc->data_ptr.isValid() || !alloc->element.datum_size.isValid()) { + LLDB_LOGF(log, "%s - failed to find allocation details.", __FUNCTION__); + return false; + } + + // Find dimensions + uint32_t dim_x = alloc->dimension.get()->dim_1; + uint32_t dim_y = alloc->dimension.get()->dim_2; + uint32_t dim_z = alloc->dimension.get()->dim_3; + + // Our plan of jitting the last element address doesn't seem to work for + // struct Allocations` Instead try to infer the size ourselves without any + // inter element padding. + if (alloc->element.children.size() > 0) { + if (dim_x == 0) + dim_x = 1; + if (dim_y == 0) + dim_y = 1; + if (dim_z == 0) + dim_z = 1; + + alloc->size = dim_x * dim_y * dim_z * *alloc->element.datum_size.get(); + + LLDB_LOGF(log, "%s - inferred size of struct allocation %" PRIu32 ".", + __FUNCTION__, *alloc->size.get()); + return true; + } + + const char *fmt_str = JITTemplate(eExprGetOffsetPtr); + char expr_buf[jit_max_expr_size]; + + // Calculate last element + dim_x = dim_x == 0 ? 0 : dim_x - 1; + dim_y = dim_y == 0 ? 0 : dim_y - 1; + dim_z = dim_z == 0 ? 0 : dim_z - 1; + + int written = snprintf(expr_buf, jit_max_expr_size, fmt_str, + *alloc->address.get(), dim_x, dim_y, dim_z); + if (written < 0) { + LLDB_LOGF(log, "%s - encoding error in snprintf().", __FUNCTION__); + return false; + } else if (written >= jit_max_expr_size) { + LLDB_LOGF(log, "%s - expression too long.", __FUNCTION__); + return false; + } + + uint64_t result = 0; + if (!EvalRSExpression(expr_buf, frame_ptr, &result)) + return false; + + addr_t mem_ptr = static_cast<lldb::addr_t>(result); + // Find pointer to last element and add on size of an element + alloc->size = static_cast<uint32_t>(mem_ptr - *alloc->data_ptr.get()) + + *alloc->element.datum_size.get(); + + return true; +} + +// JITs the RS runtime for information about the stride between rows in the +// allocation. This is done to detect padding, since allocated memory is +// 16-byte aligned. Returns true on success, false otherwise +bool RenderScriptRuntime::JITAllocationStride(AllocationDetails *alloc, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!alloc->address.isValid() || !alloc->data_ptr.isValid()) { + LLDB_LOGF(log, "%s - failed to find allocation details.", __FUNCTION__); + return false; + } + + const char *fmt_str = JITTemplate(eExprGetOffsetPtr); + char expr_buf[jit_max_expr_size]; + + int written = snprintf(expr_buf, jit_max_expr_size, fmt_str, + *alloc->address.get(), 0, 1, 0); + if (written < 0) { + LLDB_LOGF(log, "%s - encoding error in snprintf().", __FUNCTION__); + return false; + } else if (written >= jit_max_expr_size) { + LLDB_LOGF(log, "%s - expression too long.", __FUNCTION__); + return false; + } + + uint64_t result = 0; + if (!EvalRSExpression(expr_buf, frame_ptr, &result)) + return false; + + addr_t mem_ptr = static_cast<lldb::addr_t>(result); + alloc->stride = static_cast<uint32_t>(mem_ptr - *alloc->data_ptr.get()); + + return true; +} + +// JIT all the current runtime info regarding an allocation +bool RenderScriptRuntime::RefreshAllocation(AllocationDetails *alloc, + StackFrame *frame_ptr) { + // GetOffsetPointer() + if (!JITDataPointer(alloc, frame_ptr)) + return false; + + // rsaAllocationGetType() + if (!JITTypePointer(alloc, frame_ptr)) + return false; + + // rsaTypeGetNativeData() + if (!JITTypePacked(alloc, frame_ptr)) + return false; + + // rsaElementGetNativeData() + if (!JITElementPacked(alloc->element, *alloc->context.get(), frame_ptr)) + return false; + + // Sets the datum_size member in Element + SetElementSize(alloc->element); + + // Use GetOffsetPointer() to infer size of the allocation + return JITAllocationSize(alloc, frame_ptr); +} + +// Function attempts to set the type_name member of the paramaterised Element +// object. This string should be the name of the struct type the Element +// represents. We need this string for pretty printing the Element to users. +void RenderScriptRuntime::FindStructTypeName(Element &elem, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!elem.type_name.IsEmpty()) // Name already set + return; + else + elem.type_name = Element::GetFallbackStructName(); // Default type name if + // we don't succeed + + // Find all the global variables from the script rs modules + VariableList var_list; + for (auto module_sp : m_rsmodules) + module_sp->m_module->FindGlobalVariables( + RegularExpression(llvm::StringRef(".")), UINT32_MAX, var_list); + + // Iterate over all the global variables looking for one with a matching type + // to the Element. We make the assumption a match exists since there needs to + // be a global variable to reflect the struct type back into java host code. + for (uint32_t i = 0; i < var_list.GetSize(); ++i) { + const VariableSP var_sp(var_list.GetVariableAtIndex(i)); + if (!var_sp) + continue; + + ValueObjectSP valobj_sp = ValueObjectVariable::Create(frame_ptr, var_sp); + if (!valobj_sp) + continue; + + // Find the number of variable fields. + // If it has no fields, or more fields than our Element, then it can't be + // the struct we're looking for. Don't check for equality since RS can add + // extra struct members for padding. + size_t num_children = valobj_sp->GetNumChildren(); + if (num_children > elem.children.size() || num_children == 0) + continue; + + // Iterate over children looking for members with matching field names. If + // all the field names match, this is likely the struct we want. + // TODO: This could be made more robust by also checking children data + // sizes, or array size + bool found = true; + for (size_t i = 0; i < num_children; ++i) { + ValueObjectSP child = valobj_sp->GetChildAtIndex(i, true); + if (!child || (child->GetName() != elem.children[i].type_name)) { + found = false; + break; + } + } + + // RS can add extra struct members for padding in the format + // '#rs_padding_[0-9]+' + if (found && num_children < elem.children.size()) { + const uint32_t size_diff = elem.children.size() - num_children; + LLDB_LOGF(log, "%s - %" PRIu32 " padding struct entries", __FUNCTION__, + size_diff); + + for (uint32_t i = 0; i < size_diff; ++i) { + ConstString name = elem.children[num_children + i].type_name; + if (strcmp(name.AsCString(), "#rs_padding") < 0) + found = false; + } + } + + // We've found a global variable with matching type + if (found) { + // Dereference since our Element type isn't a pointer. + if (valobj_sp->IsPointerType()) { + Status err; + ValueObjectSP deref_valobj = valobj_sp->Dereference(err); + if (!err.Fail()) + valobj_sp = deref_valobj; + } + + // Save name of variable in Element. + elem.type_name = valobj_sp->GetTypeName(); + LLDB_LOGF(log, "%s - element name set to %s", __FUNCTION__, + elem.type_name.AsCString()); + + return; + } + } +} + +// Function sets the datum_size member of Element. Representing the size of a +// single instance including padding. Assumes the relevant allocation +// information has already been jitted. +void RenderScriptRuntime::SetElementSize(Element &elem) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + const Element::DataType type = *elem.type.get(); + assert(type >= Element::RS_TYPE_NONE && type <= Element::RS_TYPE_FONT && + "Invalid allocation type"); + + const uint32_t vec_size = *elem.type_vec_size.get(); + uint32_t data_size = 0; + uint32_t padding = 0; + + // Element is of a struct type, calculate size recursively. + if ((type == Element::RS_TYPE_NONE) && (elem.children.size() > 0)) { + for (Element &child : elem.children) { + SetElementSize(child); + const uint32_t array_size = + child.array_size.isValid() ? *child.array_size.get() : 1; + data_size += *child.datum_size.get() * array_size; + } + } + // These have been packed already + else if (type == Element::RS_TYPE_UNSIGNED_5_6_5 || + type == Element::RS_TYPE_UNSIGNED_5_5_5_1 || + type == Element::RS_TYPE_UNSIGNED_4_4_4_4) { + data_size = AllocationDetails::RSTypeToFormat[type][eElementSize]; + } else if (type < Element::RS_TYPE_ELEMENT) { + data_size = + vec_size * AllocationDetails::RSTypeToFormat[type][eElementSize]; + if (vec_size == 3) + padding = AllocationDetails::RSTypeToFormat[type][eElementSize]; + } else + data_size = + GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize(); + + elem.padding = padding; + elem.datum_size = data_size + padding; + LLDB_LOGF(log, "%s - element size set to %" PRIu32, __FUNCTION__, + data_size + padding); +} + +// Given an allocation, this function copies the allocation contents from +// device into a buffer on the heap. Returning a shared pointer to the buffer +// containing the data. +std::shared_ptr<uint8_t> +RenderScriptRuntime::GetAllocationData(AllocationDetails *alloc, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + // JIT all the allocation details + if (alloc->ShouldRefresh()) { + LLDB_LOGF(log, "%s - allocation details not calculated yet, jitting info", + __FUNCTION__); + + if (!RefreshAllocation(alloc, frame_ptr)) { + LLDB_LOGF(log, "%s - couldn't JIT allocation details", __FUNCTION__); + return nullptr; + } + } + + assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() && + alloc->element.type_vec_size.isValid() && alloc->size.isValid() && + "Allocation information not available"); + + // Allocate a buffer to copy data into + const uint32_t size = *alloc->size.get(); + std::shared_ptr<uint8_t> buffer(new uint8_t[size]); + if (!buffer) { + LLDB_LOGF(log, "%s - couldn't allocate a %" PRIu32 " byte buffer", + __FUNCTION__, size); + return nullptr; + } + + // Read the inferior memory + Status err; + lldb::addr_t data_ptr = *alloc->data_ptr.get(); + GetProcess()->ReadMemory(data_ptr, buffer.get(), size, err); + if (err.Fail()) { + LLDB_LOGF(log, + "%s - '%s' Couldn't read %" PRIu32 + " bytes of allocation data from 0x%" PRIx64, + __FUNCTION__, err.AsCString(), size, data_ptr); + return nullptr; + } + + return buffer; +} + +// Function copies data from a binary file into an allocation. There is a +// header at the start of the file, FileHeader, before the data content itself. +// Information from this header is used to display warnings to the user about +// incompatibilities +bool RenderScriptRuntime::LoadAllocation(Stream &strm, const uint32_t alloc_id, + const char *path, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + // Find allocation with the given id + AllocationDetails *alloc = FindAllocByID(strm, alloc_id); + if (!alloc) + return false; + + LLDB_LOGF(log, "%s - found allocation 0x%" PRIx64, __FUNCTION__, + *alloc->address.get()); + + // JIT all the allocation details + if (alloc->ShouldRefresh()) { + LLDB_LOGF(log, "%s - allocation details not calculated yet, jitting info.", + __FUNCTION__); + + if (!RefreshAllocation(alloc, frame_ptr)) { + LLDB_LOGF(log, "%s - couldn't JIT allocation details", __FUNCTION__); + return false; + } + } + + assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() && + alloc->element.type_vec_size.isValid() && alloc->size.isValid() && + alloc->element.datum_size.isValid() && + "Allocation information not available"); + + // Check we can read from file + FileSpec file(path); + FileSystem::Instance().Resolve(file); + if (!FileSystem::Instance().Exists(file)) { + strm.Printf("Error: File %s does not exist", path); + strm.EOL(); + return false; + } + + if (!FileSystem::Instance().Readable(file)) { + strm.Printf("Error: File %s does not have readable permissions", path); + strm.EOL(); + return false; + } + + // Read file into data buffer + auto data_sp = FileSystem::Instance().CreateDataBuffer(file.GetPath()); + + // Cast start of buffer to FileHeader and use pointer to read metadata + void *file_buf = data_sp->GetBytes(); + if (file_buf == nullptr || + data_sp->GetByteSize() < (sizeof(AllocationDetails::FileHeader) + + sizeof(AllocationDetails::ElementHeader))) { + strm.Printf("Error: File %s does not contain enough data for header", path); + strm.EOL(); + return false; + } + const AllocationDetails::FileHeader *file_header = + static_cast<AllocationDetails::FileHeader *>(file_buf); + + // Check file starts with ascii characters "RSAD" + if (memcmp(file_header->ident, "RSAD", 4)) { + strm.Printf("Error: File doesn't contain identifier for an RS allocation " + "dump. Are you sure this is the correct file?"); + strm.EOL(); + return false; + } + + // Look at the type of the root element in the header + AllocationDetails::ElementHeader root_el_hdr; + memcpy(&root_el_hdr, static_cast<uint8_t *>(file_buf) + + sizeof(AllocationDetails::FileHeader), + sizeof(AllocationDetails::ElementHeader)); + + LLDB_LOGF(log, "%s - header type %" PRIu32 ", element size %" PRIu32, + __FUNCTION__, root_el_hdr.type, root_el_hdr.element_size); + + // Check if the target allocation and file both have the same number of bytes + // for an Element + if (*alloc->element.datum_size.get() != root_el_hdr.element_size) { + strm.Printf("Warning: Mismatched Element sizes - file %" PRIu32 + " bytes, allocation %" PRIu32 " bytes", + root_el_hdr.element_size, *alloc->element.datum_size.get()); + strm.EOL(); + } + + // Check if the target allocation and file both have the same type + const uint32_t alloc_type = static_cast<uint32_t>(*alloc->element.type.get()); + const uint32_t file_type = root_el_hdr.type; + + if (file_type > Element::RS_TYPE_FONT) { + strm.Printf("Warning: File has unknown allocation type"); + strm.EOL(); + } else if (alloc_type != file_type) { + // Enum value isn't monotonous, so doesn't always index RsDataTypeToString + // array + uint32_t target_type_name_idx = alloc_type; + uint32_t head_type_name_idx = file_type; + if (alloc_type >= Element::RS_TYPE_ELEMENT && + alloc_type <= Element::RS_TYPE_FONT) + target_type_name_idx = static_cast<Element::DataType>( + (alloc_type - Element::RS_TYPE_ELEMENT) + + Element::RS_TYPE_MATRIX_2X2 + 1); + + if (file_type >= Element::RS_TYPE_ELEMENT && + file_type <= Element::RS_TYPE_FONT) + head_type_name_idx = static_cast<Element::DataType>( + (file_type - Element::RS_TYPE_ELEMENT) + Element::RS_TYPE_MATRIX_2X2 + + 1); + + const char *head_type_name = + AllocationDetails::RsDataTypeToString[head_type_name_idx][0]; + const char *target_type_name = + AllocationDetails::RsDataTypeToString[target_type_name_idx][0]; + + strm.Printf( + "Warning: Mismatched Types - file '%s' type, allocation '%s' type", + head_type_name, target_type_name); + strm.EOL(); + } + + // Advance buffer past header + file_buf = static_cast<uint8_t *>(file_buf) + file_header->hdr_size; + + // Calculate size of allocation data in file + size_t size = data_sp->GetByteSize() - file_header->hdr_size; + + // Check if the target allocation and file both have the same total data + // size. + const uint32_t alloc_size = *alloc->size.get(); + if (alloc_size != size) { + strm.Printf("Warning: Mismatched allocation sizes - file 0x%" PRIx64 + " bytes, allocation 0x%" PRIx32 " bytes", + (uint64_t)size, alloc_size); + strm.EOL(); + // Set length to copy to minimum + size = alloc_size < size ? alloc_size : size; + } + + // Copy file data from our buffer into the target allocation. + lldb::addr_t alloc_data = *alloc->data_ptr.get(); + Status err; + size_t written = GetProcess()->WriteMemory(alloc_data, file_buf, size, err); + if (!err.Success() || written != size) { + strm.Printf("Error: Couldn't write data to allocation %s", err.AsCString()); + strm.EOL(); + return false; + } + + strm.Printf("Contents of file '%s' read into allocation %" PRIu32, path, + alloc->id); + strm.EOL(); + + return true; +} + +// Function takes as parameters a byte buffer, which will eventually be written +// to file as the element header, an offset into that buffer, and an Element +// that will be saved into the buffer at the parametrised offset. Return value +// is the new offset after writing the element into the buffer. Elements are +// saved to the file as the ElementHeader struct followed by offsets to the +// structs of all the element's children. +size_t RenderScriptRuntime::PopulateElementHeaders( + const std::shared_ptr<uint8_t> header_buffer, size_t offset, + const Element &elem) { + // File struct for an element header with all the relevant details copied + // from elem. We assume members are valid already. + AllocationDetails::ElementHeader elem_header; + elem_header.type = *elem.type.get(); + elem_header.kind = *elem.type_kind.get(); + elem_header.element_size = *elem.datum_size.get(); + elem_header.vector_size = *elem.type_vec_size.get(); + elem_header.array_size = + elem.array_size.isValid() ? *elem.array_size.get() : 0; + const size_t elem_header_size = sizeof(AllocationDetails::ElementHeader); + + // Copy struct into buffer and advance offset We assume that header_buffer + // has been checked for nullptr before this method is called + memcpy(header_buffer.get() + offset, &elem_header, elem_header_size); + offset += elem_header_size; + + // Starting offset of child ElementHeader struct + size_t child_offset = + offset + ((elem.children.size() + 1) * sizeof(uint32_t)); + for (const RenderScriptRuntime::Element &child : elem.children) { + // Recursively populate the buffer with the element header structs of + // children. Then save the offsets where they were set after the parent + // element header. + memcpy(header_buffer.get() + offset, &child_offset, sizeof(uint32_t)); + offset += sizeof(uint32_t); + + child_offset = PopulateElementHeaders(header_buffer, child_offset, child); + } + + // Zero indicates no more children + memset(header_buffer.get() + offset, 0, sizeof(uint32_t)); + + return child_offset; +} + +// Given an Element object this function returns the total size needed in the +// file header to store the element's details. Taking into account the size of +// the element header struct, plus the offsets to all the element's children. +// Function is recursive so that the size of all ancestors is taken into +// account. +size_t RenderScriptRuntime::CalculateElementHeaderSize(const Element &elem) { + // Offsets to children plus zero terminator + size_t size = (elem.children.size() + 1) * sizeof(uint32_t); + // Size of header struct with type details + size += sizeof(AllocationDetails::ElementHeader); + + // Calculate recursively for all descendants + for (const Element &child : elem.children) + size += CalculateElementHeaderSize(child); + + return size; +} + +// Function copies allocation contents into a binary file. This file can then +// be loaded later into a different allocation. There is a header, FileHeader, +// before the allocation data containing meta-data. +bool RenderScriptRuntime::SaveAllocation(Stream &strm, const uint32_t alloc_id, + const char *path, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + // Find allocation with the given id + AllocationDetails *alloc = FindAllocByID(strm, alloc_id); + if (!alloc) + return false; + + LLDB_LOGF(log, "%s - found allocation 0x%" PRIx64 ".", __FUNCTION__, + *alloc->address.get()); + + // JIT all the allocation details + if (alloc->ShouldRefresh()) { + LLDB_LOGF(log, "%s - allocation details not calculated yet, jitting info.", + __FUNCTION__); + + if (!RefreshAllocation(alloc, frame_ptr)) { + LLDB_LOGF(log, "%s - couldn't JIT allocation details.", __FUNCTION__); + return false; + } + } + + assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() && + alloc->element.type_vec_size.isValid() && + alloc->element.datum_size.get() && + alloc->element.type_kind.isValid() && alloc->dimension.isValid() && + "Allocation information not available"); + + // Check we can create writable file + FileSpec file_spec(path); + FileSystem::Instance().Resolve(file_spec); + auto file = FileSystem::Instance().Open( + file_spec, File::eOpenOptionWrite | File::eOpenOptionCanCreate | + File::eOpenOptionTruncate); + + if (!file) { + std::string error = llvm::toString(file.takeError()); + strm.Printf("Error: Failed to open '%s' for writing: %s", path, + error.c_str()); + strm.EOL(); + return false; + } + + // Read allocation into buffer of heap memory + const std::shared_ptr<uint8_t> buffer = GetAllocationData(alloc, frame_ptr); + if (!buffer) { + strm.Printf("Error: Couldn't read allocation data into buffer"); + strm.EOL(); + return false; + } + + // Create the file header + AllocationDetails::FileHeader head; + memcpy(head.ident, "RSAD", 4); + head.dims[0] = static_cast<uint32_t>(alloc->dimension.get()->dim_1); + head.dims[1] = static_cast<uint32_t>(alloc->dimension.get()->dim_2); + head.dims[2] = static_cast<uint32_t>(alloc->dimension.get()->dim_3); + + const size_t element_header_size = CalculateElementHeaderSize(alloc->element); + assert((sizeof(AllocationDetails::FileHeader) + element_header_size) < + UINT16_MAX && + "Element header too large"); + head.hdr_size = static_cast<uint16_t>(sizeof(AllocationDetails::FileHeader) + + element_header_size); + + // Write the file header + size_t num_bytes = sizeof(AllocationDetails::FileHeader); + LLDB_LOGF(log, "%s - writing File Header, 0x%" PRIx64 " bytes", __FUNCTION__, + (uint64_t)num_bytes); + + Status err = file.get()->Write(&head, num_bytes); + if (!err.Success()) { + strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), path); + strm.EOL(); + return false; + } + + // Create the headers describing the element type of the allocation. + std::shared_ptr<uint8_t> element_header_buffer( + new uint8_t[element_header_size]); + if (element_header_buffer == nullptr) { + strm.Printf("Internal Error: Couldn't allocate %" PRIu64 + " bytes on the heap", + (uint64_t)element_header_size); + strm.EOL(); + return false; + } + + PopulateElementHeaders(element_header_buffer, 0, alloc->element); + + // Write headers for allocation element type to file + num_bytes = element_header_size; + LLDB_LOGF(log, "%s - writing element headers, 0x%" PRIx64 " bytes.", + __FUNCTION__, (uint64_t)num_bytes); + + err = file.get()->Write(element_header_buffer.get(), num_bytes); + if (!err.Success()) { + strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), path); + strm.EOL(); + return false; + } + + // Write allocation data to file + num_bytes = static_cast<size_t>(*alloc->size.get()); + LLDB_LOGF(log, "%s - writing 0x%" PRIx64 " bytes", __FUNCTION__, + (uint64_t)num_bytes); + + err = file.get()->Write(buffer.get(), num_bytes); + if (!err.Success()) { + strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), path); + strm.EOL(); + return false; + } + + strm.Printf("Allocation written to file '%s'", path); + strm.EOL(); + return true; +} + +bool RenderScriptRuntime::LoadModule(const lldb::ModuleSP &module_sp) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (module_sp) { + for (const auto &rs_module : m_rsmodules) { + if (rs_module->m_module == module_sp) { + // Check if the user has enabled automatically breaking on all RS + // kernels. + if (m_breakAllKernels) + BreakOnModuleKernels(rs_module); + + return false; + } + } + bool module_loaded = false; + switch (GetModuleKind(module_sp)) { + case eModuleKindKernelObj: { + RSModuleDescriptorSP module_desc; + module_desc = std::make_shared<RSModuleDescriptor>(module_sp); + if (module_desc->ParseRSInfo()) { + m_rsmodules.push_back(module_desc); + module_desc->WarnIfVersionMismatch(GetProcess() + ->GetTarget() + .GetDebugger() + .GetAsyncOutputStream() + .get()); + module_loaded = true; + } + if (module_loaded) { + FixupScriptDetails(module_desc); + } + break; + } + case eModuleKindDriver: { + if (!m_libRSDriver) { + m_libRSDriver = module_sp; + LoadRuntimeHooks(m_libRSDriver, RenderScriptRuntime::eModuleKindDriver); + } + break; + } + case eModuleKindImpl: { + if (!m_libRSCpuRef) { + m_libRSCpuRef = module_sp; + LoadRuntimeHooks(m_libRSCpuRef, RenderScriptRuntime::eModuleKindImpl); + } + break; + } + case eModuleKindLibRS: { + if (!m_libRS) { + m_libRS = module_sp; + static ConstString gDbgPresentStr("gDebuggerPresent"); + const Symbol *debug_present = m_libRS->FindFirstSymbolWithNameAndType( + gDbgPresentStr, eSymbolTypeData); + if (debug_present) { + Status err; + uint32_t flag = 0x00000001U; + Target &target = GetProcess()->GetTarget(); + addr_t addr = debug_present->GetLoadAddress(&target); + GetProcess()->WriteMemory(addr, &flag, sizeof(flag), err); + if (err.Success()) { + LLDB_LOGF(log, "%s - debugger present flag set on debugee.", + __FUNCTION__); + + m_debuggerPresentFlagged = true; + } else if (log) { + LLDB_LOGF(log, "%s - error writing debugger present flags '%s' ", + __FUNCTION__, err.AsCString()); + } + } else if (log) { + LLDB_LOGF( + log, + "%s - error writing debugger present flags - symbol not found", + __FUNCTION__); + } + } + break; + } + default: + break; + } + if (module_loaded) + Update(); + return module_loaded; + } + return false; +} + +void RenderScriptRuntime::Update() { + if (m_rsmodules.size() > 0) { + if (!m_initiated) { + Initiate(); + } + } +} + +void RSModuleDescriptor::WarnIfVersionMismatch(lldb_private::Stream *s) const { + if (!s) + return; + + if (m_slang_version.empty() || m_bcc_version.empty()) { + s->PutCString("WARNING: Unknown bcc or slang (llvm-rs-cc) version; debug " + "experience may be unreliable"); + s->EOL(); + } else if (m_slang_version != m_bcc_version) { + s->Printf("WARNING: The debug info emitted by the slang frontend " + "(llvm-rs-cc) used to build this module (%s) does not match the " + "version of bcc used to generate the debug information (%s). " + "This is an unsupported configuration and may result in a poor " + "debugging experience; proceed with caution", + m_slang_version.c_str(), m_bcc_version.c_str()); + s->EOL(); + } +} + +bool RSModuleDescriptor::ParsePragmaCount(llvm::StringRef *lines, + size_t n_lines) { + // Skip the pragma prototype line + ++lines; + for (; n_lines--; ++lines) { + const auto kv_pair = lines->split(" - "); + m_pragmas[kv_pair.first.trim().str()] = kv_pair.second.trim().str(); + } + return true; +} + +bool RSModuleDescriptor::ParseExportReduceCount(llvm::StringRef *lines, + size_t n_lines) { + // The list of reduction kernels in the `.rs.info` symbol is of the form + // "signature - accumulatordatasize - reduction_name - initializer_name - + // accumulator_name - combiner_name - outconverter_name - halter_name" Where + // a function is not explicitly named by the user, or is not generated by the + // compiler, it is named "." so the dash separated list should always be 8 + // items long + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + // Skip the exportReduceCount line + ++lines; + for (; n_lines--; ++lines) { + llvm::SmallVector<llvm::StringRef, 8> spec; + lines->split(spec, " - "); + if (spec.size() != 8) { + if (spec.size() < 8) { + if (log) + log->Error("Error parsing RenderScript reduction spec. wrong number " + "of fields"); + return false; + } else if (log) + log->Warning("Extraneous members in reduction spec: '%s'", + lines->str().c_str()); + } + + const auto sig_s = spec[0]; + uint32_t sig; + if (sig_s.getAsInteger(10, sig)) { + if (log) + log->Error("Error parsing Renderscript reduction spec: invalid kernel " + "signature: '%s'", + sig_s.str().c_str()); + return false; + } + + const auto accum_data_size_s = spec[1]; + uint32_t accum_data_size; + if (accum_data_size_s.getAsInteger(10, accum_data_size)) { + if (log) + log->Error("Error parsing Renderscript reduction spec: invalid " + "accumulator data size %s", + accum_data_size_s.str().c_str()); + return false; + } + + LLDB_LOGF(log, "Found RenderScript reduction '%s'", spec[2].str().c_str()); + + m_reductions.push_back(RSReductionDescriptor(this, sig, accum_data_size, + spec[2], spec[3], spec[4], + spec[5], spec[6], spec[7])); + } + return true; +} + +bool RSModuleDescriptor::ParseVersionInfo(llvm::StringRef *lines, + size_t n_lines) { + // Skip the versionInfo line + ++lines; + for (; n_lines--; ++lines) { + // We're only interested in bcc and slang versions, and ignore all other + // versionInfo lines + const auto kv_pair = lines->split(" - "); + if (kv_pair.first == "slang") + m_slang_version = kv_pair.second.str(); + else if (kv_pair.first == "bcc") + m_bcc_version = kv_pair.second.str(); + } + return true; +} + +bool RSModuleDescriptor::ParseExportForeachCount(llvm::StringRef *lines, + size_t n_lines) { + // Skip the exportForeachCount line + ++lines; + for (; n_lines--; ++lines) { + uint32_t slot; + // `forEach` kernels are listed in the `.rs.info` packet as a "slot - name" + // pair per line + const auto kv_pair = lines->split(" - "); + if (kv_pair.first.getAsInteger(10, slot)) + return false; + m_kernels.push_back(RSKernelDescriptor(this, kv_pair.second, slot)); + } + return true; +} + +bool RSModuleDescriptor::ParseExportVarCount(llvm::StringRef *lines, + size_t n_lines) { + // Skip the ExportVarCount line + ++lines; + for (; n_lines--; ++lines) + m_globals.push_back(RSGlobalDescriptor(this, *lines)); + return true; +} + +// The .rs.info symbol in renderscript modules contains a string which needs to +// be parsed. The string is basic and is parsed on a line by line basis. +bool RSModuleDescriptor::ParseRSInfo() { + assert(m_module); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + const Symbol *info_sym = m_module->FindFirstSymbolWithNameAndType( + ConstString(".rs.info"), eSymbolTypeData); + if (!info_sym) + return false; + + const addr_t addr = info_sym->GetAddressRef().GetFileAddress(); + if (addr == LLDB_INVALID_ADDRESS) + return false; + + const addr_t size = info_sym->GetByteSize(); + const FileSpec fs = m_module->GetFileSpec(); + + auto buffer = + FileSystem::Instance().CreateDataBuffer(fs.GetPath(), size, addr); + if (!buffer) + return false; + + // split rs.info. contents into lines + llvm::SmallVector<llvm::StringRef, 128> info_lines; + { + const llvm::StringRef raw_rs_info((const char *)buffer->GetBytes()); + raw_rs_info.split(info_lines, '\n'); + LLDB_LOGF(log, "'.rs.info symbol for '%s':\n%s", + m_module->GetFileSpec().GetCString(), raw_rs_info.str().c_str()); + } + + enum { + eExportVar, + eExportForEach, + eExportReduce, + ePragma, + eBuildChecksum, + eObjectSlot, + eVersionInfo, + }; + + const auto rs_info_handler = [](llvm::StringRef name) -> int { + return llvm::StringSwitch<int>(name) + // The number of visible global variables in the script + .Case("exportVarCount", eExportVar) + // The number of RenderScrip `forEach` kernels __attribute__((kernel)) + .Case("exportForEachCount", eExportForEach) + // The number of generalreductions: This marked in the script by + // `#pragma reduce()` + .Case("exportReduceCount", eExportReduce) + // Total count of all RenderScript specific `#pragmas` used in the + // script + .Case("pragmaCount", ePragma) + .Case("objectSlotCount", eObjectSlot) + .Case("versionInfo", eVersionInfo) + .Default(-1); + }; + + // parse all text lines of .rs.info + for (auto line = info_lines.begin(); line != info_lines.end(); ++line) { + const auto kv_pair = line->split(": "); + const auto key = kv_pair.first; + const auto val = kv_pair.second.trim(); + + const auto handler = rs_info_handler(key); + if (handler == -1) + continue; + // getAsInteger returns `true` on an error condition - we're only + // interested in numeric fields at the moment + uint64_t n_lines; + if (val.getAsInteger(10, n_lines)) { + LLDB_LOGV(log, "Failed to parse non-numeric '.rs.info' section {0}", + line->str()); + continue; + } + if (info_lines.end() - (line + 1) < (ptrdiff_t)n_lines) + return false; + + bool success = false; + switch (handler) { + case eExportVar: + success = ParseExportVarCount(line, n_lines); + break; + case eExportForEach: + success = ParseExportForeachCount(line, n_lines); + break; + case eExportReduce: + success = ParseExportReduceCount(line, n_lines); + break; + case ePragma: + success = ParsePragmaCount(line, n_lines); + break; + case eVersionInfo: + success = ParseVersionInfo(line, n_lines); + break; + default: { + LLDB_LOGF(log, "%s - skipping .rs.info field '%s'", __FUNCTION__, + line->str().c_str()); + continue; + } + } + if (!success) + return false; + line += n_lines; + } + return info_lines.size() > 0; +} + +void RenderScriptRuntime::DumpStatus(Stream &strm) const { + if (m_libRS) { + strm.Printf("Runtime Library discovered."); + strm.EOL(); + } + if (m_libRSDriver) { + strm.Printf("Runtime Driver discovered."); + strm.EOL(); + } + if (m_libRSCpuRef) { + strm.Printf("CPU Reference Implementation discovered."); + strm.EOL(); + } + + if (m_runtimeHooks.size()) { + strm.Printf("Runtime functions hooked:"); + strm.EOL(); + for (auto b : m_runtimeHooks) { + strm.Indent(b.second->defn->name); + strm.EOL(); + } + } else { + strm.Printf("Runtime is not hooked."); + strm.EOL(); + } +} + +void RenderScriptRuntime::DumpContexts(Stream &strm) const { + strm.Printf("Inferred RenderScript Contexts:"); + strm.EOL(); + strm.IndentMore(); + + std::map<addr_t, uint64_t> contextReferences; + + // Iterate over all of the currently discovered scripts. Note: We cant push + // or pop from m_scripts inside this loop or it may invalidate script. + for (const auto &script : m_scripts) { + if (!script->context.isValid()) + continue; + lldb::addr_t context = *script->context; + + if (contextReferences.find(context) != contextReferences.end()) { + contextReferences[context]++; + } else { + contextReferences[context] = 1; + } + } + + for (const auto &cRef : contextReferences) { + strm.Printf("Context 0x%" PRIx64 ": %" PRIu64 " script instances", + cRef.first, cRef.second); + strm.EOL(); + } + strm.IndentLess(); +} + +void RenderScriptRuntime::DumpKernels(Stream &strm) const { + strm.Printf("RenderScript Kernels:"); + strm.EOL(); + strm.IndentMore(); + for (const auto &module : m_rsmodules) { + strm.Printf("Resource '%s':", module->m_resname.c_str()); + strm.EOL(); + for (const auto &kernel : module->m_kernels) { + strm.Indent(kernel.m_name.AsCString()); + strm.EOL(); + } + } + strm.IndentLess(); +} + +RenderScriptRuntime::AllocationDetails * +RenderScriptRuntime::FindAllocByID(Stream &strm, const uint32_t alloc_id) { + AllocationDetails *alloc = nullptr; + + // See if we can find allocation using id as an index; + if (alloc_id <= m_allocations.size() && alloc_id != 0 && + m_allocations[alloc_id - 1]->id == alloc_id) { + alloc = m_allocations[alloc_id - 1].get(); + return alloc; + } + + // Fallback to searching + for (const auto &a : m_allocations) { + if (a->id == alloc_id) { + alloc = a.get(); + break; + } + } + + if (alloc == nullptr) { + strm.Printf("Error: Couldn't find allocation with id matching %" PRIu32, + alloc_id); + strm.EOL(); + } + + return alloc; +} + +// Prints the contents of an allocation to the output stream, which may be a +// file +bool RenderScriptRuntime::DumpAllocation(Stream &strm, StackFrame *frame_ptr, + const uint32_t id) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + // Check we can find the desired allocation + AllocationDetails *alloc = FindAllocByID(strm, id); + if (!alloc) + return false; // FindAllocByID() will print error message for us here + + LLDB_LOGF(log, "%s - found allocation 0x%" PRIx64, __FUNCTION__, + *alloc->address.get()); + + // Check we have information about the allocation, if not calculate it + if (alloc->ShouldRefresh()) { + LLDB_LOGF(log, "%s - allocation details not calculated yet, jitting info.", + __FUNCTION__); + + // JIT all the allocation information + if (!RefreshAllocation(alloc, frame_ptr)) { + strm.Printf("Error: Couldn't JIT allocation details"); + strm.EOL(); + return false; + } + } + + // Establish format and size of each data element + const uint32_t vec_size = *alloc->element.type_vec_size.get(); + const Element::DataType type = *alloc->element.type.get(); + + assert(type >= Element::RS_TYPE_NONE && type <= Element::RS_TYPE_FONT && + "Invalid allocation type"); + + lldb::Format format; + if (type >= Element::RS_TYPE_ELEMENT) + format = eFormatHex; + else + format = vec_size == 1 + ? static_cast<lldb::Format>( + AllocationDetails::RSTypeToFormat[type][eFormatSingle]) + : static_cast<lldb::Format>( + AllocationDetails::RSTypeToFormat[type][eFormatVector]); + + const uint32_t data_size = *alloc->element.datum_size.get(); + + LLDB_LOGF(log, "%s - element size %" PRIu32 " bytes, including padding", + __FUNCTION__, data_size); + + // Allocate a buffer to copy data into + std::shared_ptr<uint8_t> buffer = GetAllocationData(alloc, frame_ptr); + if (!buffer) { + strm.Printf("Error: Couldn't read allocation data"); + strm.EOL(); + return false; + } + + // Calculate stride between rows as there may be padding at end of rows since + // allocated memory is 16-byte aligned + if (!alloc->stride.isValid()) { + if (alloc->dimension.get()->dim_2 == 0) // We only have one dimension + alloc->stride = 0; + else if (!JITAllocationStride(alloc, frame_ptr)) { + strm.Printf("Error: Couldn't calculate allocation row stride"); + strm.EOL(); + return false; + } + } + const uint32_t stride = *alloc->stride.get(); + const uint32_t size = *alloc->size.get(); // Size of whole allocation + const uint32_t padding = + alloc->element.padding.isValid() ? *alloc->element.padding.get() : 0; + LLDB_LOGF(log, + "%s - stride %" PRIu32 " bytes, size %" PRIu32 + " bytes, padding %" PRIu32, + __FUNCTION__, stride, size, padding); + + // Find dimensions used to index loops, so need to be non-zero + uint32_t dim_x = alloc->dimension.get()->dim_1; + dim_x = dim_x == 0 ? 1 : dim_x; + + uint32_t dim_y = alloc->dimension.get()->dim_2; + dim_y = dim_y == 0 ? 1 : dim_y; + + uint32_t dim_z = alloc->dimension.get()->dim_3; + dim_z = dim_z == 0 ? 1 : dim_z; + + // Use data extractor to format output + const uint32_t target_ptr_size = + GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize(); + DataExtractor alloc_data(buffer.get(), size, GetProcess()->GetByteOrder(), + target_ptr_size); + + uint32_t offset = 0; // Offset in buffer to next element to be printed + uint32_t prev_row = 0; // Offset to the start of the previous row + + // Iterate over allocation dimensions, printing results to user + strm.Printf("Data (X, Y, Z):"); + for (uint32_t z = 0; z < dim_z; ++z) { + for (uint32_t y = 0; y < dim_y; ++y) { + // Use stride to index start of next row. + if (!(y == 0 && z == 0)) + offset = prev_row + stride; + prev_row = offset; + + // Print each element in the row individually + for (uint32_t x = 0; x < dim_x; ++x) { + strm.Printf("\n(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ") = ", x, y, z); + if ((type == Element::RS_TYPE_NONE) && + (alloc->element.children.size() > 0) && + (alloc->element.type_name != Element::GetFallbackStructName())) { + // Here we are dumping an Element of struct type. This is done using + // expression evaluation with the name of the struct type and pointer + // to element. Don't print the name of the resulting expression, + // since this will be '$[0-9]+' + DumpValueObjectOptions expr_options; + expr_options.SetHideName(true); + + // Setup expression as dereferencing a pointer cast to element + // address. + char expr_char_buffer[jit_max_expr_size]; + int written = + snprintf(expr_char_buffer, jit_max_expr_size, "*(%s*) 0x%" PRIx64, + alloc->element.type_name.AsCString(), + *alloc->data_ptr.get() + offset); + + if (written < 0 || written >= jit_max_expr_size) { + LLDB_LOGF(log, "%s - error in snprintf().", __FUNCTION__); + continue; + } + + // Evaluate expression + ValueObjectSP expr_result; + GetProcess()->GetTarget().EvaluateExpression(expr_char_buffer, + frame_ptr, expr_result); + + // Print the results to our stream. + expr_result->Dump(strm, expr_options); + } else { + DumpDataExtractor(alloc_data, &strm, offset, format, + data_size - padding, 1, 1, LLDB_INVALID_ADDRESS, 0, + 0); + } + offset += data_size; + } + } + } + strm.EOL(); + + return true; +} + +// Function recalculates all our cached information about allocations by +// jitting the RS runtime regarding each allocation we know about. Returns true +// if all allocations could be recomputed, false otherwise. +bool RenderScriptRuntime::RecomputeAllAllocations(Stream &strm, + StackFrame *frame_ptr) { + bool success = true; + for (auto &alloc : m_allocations) { + // JIT current allocation information + if (!RefreshAllocation(alloc.get(), frame_ptr)) { + strm.Printf("Error: Couldn't evaluate details for allocation %" PRIu32 + "\n", + alloc->id); + success = false; + } + } + + if (success) + strm.Printf("All allocations successfully recomputed"); + strm.EOL(); + + return success; +} + +// Prints information regarding currently loaded allocations. These details are +// gathered by jitting the runtime, which has as latency. Index parameter +// specifies a single allocation ID to print, or a zero value to print them all +void RenderScriptRuntime::ListAllocations(Stream &strm, StackFrame *frame_ptr, + const uint32_t index) { + strm.Printf("RenderScript Allocations:"); + strm.EOL(); + strm.IndentMore(); + + for (auto &alloc : m_allocations) { + // index will only be zero if we want to print all allocations + if (index != 0 && index != alloc->id) + continue; + + // JIT current allocation information + if (alloc->ShouldRefresh() && !RefreshAllocation(alloc.get(), frame_ptr)) { + strm.Printf("Error: Couldn't evaluate details for allocation %" PRIu32, + alloc->id); + strm.EOL(); + continue; + } + + strm.Printf("%" PRIu32 ":", alloc->id); + strm.EOL(); + strm.IndentMore(); + + strm.Indent("Context: "); + if (!alloc->context.isValid()) + strm.Printf("unknown\n"); + else + strm.Printf("0x%" PRIx64 "\n", *alloc->context.get()); + + strm.Indent("Address: "); + if (!alloc->address.isValid()) + strm.Printf("unknown\n"); + else + strm.Printf("0x%" PRIx64 "\n", *alloc->address.get()); + + strm.Indent("Data pointer: "); + if (!alloc->data_ptr.isValid()) + strm.Printf("unknown\n"); + else + strm.Printf("0x%" PRIx64 "\n", *alloc->data_ptr.get()); + + strm.Indent("Dimensions: "); + if (!alloc->dimension.isValid()) + strm.Printf("unknown\n"); + else + strm.Printf("(%" PRId32 ", %" PRId32 ", %" PRId32 ")\n", + alloc->dimension.get()->dim_1, alloc->dimension.get()->dim_2, + alloc->dimension.get()->dim_3); + + strm.Indent("Data Type: "); + if (!alloc->element.type.isValid() || + !alloc->element.type_vec_size.isValid()) + strm.Printf("unknown\n"); + else { + const int vector_size = *alloc->element.type_vec_size.get(); + Element::DataType type = *alloc->element.type.get(); + + if (!alloc->element.type_name.IsEmpty()) + strm.Printf("%s\n", alloc->element.type_name.AsCString()); + else { + // Enum value isn't monotonous, so doesn't always index + // RsDataTypeToString array + if (type >= Element::RS_TYPE_ELEMENT && type <= Element::RS_TYPE_FONT) + type = + static_cast<Element::DataType>((type - Element::RS_TYPE_ELEMENT) + + Element::RS_TYPE_MATRIX_2X2 + 1); + + if (type >= (sizeof(AllocationDetails::RsDataTypeToString) / + sizeof(AllocationDetails::RsDataTypeToString[0])) || + vector_size > 4 || vector_size < 1) + strm.Printf("invalid type\n"); + else + strm.Printf( + "%s\n", + AllocationDetails::RsDataTypeToString[static_cast<uint32_t>(type)] + [vector_size - 1]); + } + } + + strm.Indent("Data Kind: "); + if (!alloc->element.type_kind.isValid()) + strm.Printf("unknown\n"); + else { + const Element::DataKind kind = *alloc->element.type_kind.get(); + if (kind < Element::RS_KIND_USER || kind > Element::RS_KIND_PIXEL_YUV) + strm.Printf("invalid kind\n"); + else + strm.Printf( + "%s\n", + AllocationDetails::RsDataKindToString[static_cast<uint32_t>(kind)]); + } + + strm.EOL(); + strm.IndentLess(); + } + strm.IndentLess(); +} + +// Set breakpoints on every kernel found in RS module +void RenderScriptRuntime::BreakOnModuleKernels( + const RSModuleDescriptorSP rsmodule_sp) { + for (const auto &kernel : rsmodule_sp->m_kernels) { + // Don't set breakpoint on 'root' kernel + if (strcmp(kernel.m_name.AsCString(), "root") == 0) + continue; + + CreateKernelBreakpoint(kernel.m_name); + } +} + +// Method is internally called by the 'kernel breakpoint all' command to enable +// or disable breaking on all kernels. When do_break is true we want to enable +// this functionality. When do_break is false we want to disable it. +void RenderScriptRuntime::SetBreakAllKernels(bool do_break, TargetSP target) { + Log *log( + GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS)); + + InitSearchFilter(target); + + // Set breakpoints on all the kernels + if (do_break && !m_breakAllKernels) { + m_breakAllKernels = true; + + for (const auto &module : m_rsmodules) + BreakOnModuleKernels(module); + + LLDB_LOGF(log, + "%s(True) - breakpoints set on all currently loaded kernels.", + __FUNCTION__); + } else if (!do_break && + m_breakAllKernels) // Breakpoints won't be set on any new kernels. + { + m_breakAllKernels = false; + + LLDB_LOGF(log, "%s(False) - breakpoints no longer automatically set.", + __FUNCTION__); + } +} + +// Given the name of a kernel this function creates a breakpoint using our own +// breakpoint resolver, and returns the Breakpoint shared pointer. +BreakpointSP +RenderScriptRuntime::CreateKernelBreakpoint(ConstString name) { + Log *log( + GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS)); + + if (!m_filtersp) { + LLDB_LOGF(log, "%s - error, no breakpoint search filter set.", + __FUNCTION__); + return nullptr; + } + + BreakpointResolverSP resolver_sp(new RSBreakpointResolver(nullptr, name)); + Target &target = GetProcess()->GetTarget(); + BreakpointSP bp = target.CreateBreakpoint( + m_filtersp, resolver_sp, false, false, false); + + // Give RS breakpoints a specific name, so the user can manipulate them as a + // group. + Status err; + target.AddNameToBreakpoint(bp, "RenderScriptKernel", err); + if (err.Fail() && log) + LLDB_LOGF(log, "%s - error setting break name, '%s'.", __FUNCTION__, + err.AsCString()); + + return bp; +} + +BreakpointSP +RenderScriptRuntime::CreateReductionBreakpoint(ConstString name, + int kernel_types) { + Log *log( + GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS)); + + if (!m_filtersp) { + LLDB_LOGF(log, "%s - error, no breakpoint search filter set.", + __FUNCTION__); + return nullptr; + } + + BreakpointResolverSP resolver_sp(new RSReduceBreakpointResolver( + nullptr, name, &m_rsmodules, kernel_types)); + Target &target = GetProcess()->GetTarget(); + BreakpointSP bp = target.CreateBreakpoint( + m_filtersp, resolver_sp, false, false, false); + + // Give RS breakpoints a specific name, so the user can manipulate them as a + // group. + Status err; + target.AddNameToBreakpoint(bp, "RenderScriptReduction", err); + if (err.Fail() && log) + LLDB_LOGF(log, "%s - error setting break name, '%s'.", __FUNCTION__, + err.AsCString()); + + return bp; +} + +// Given an expression for a variable this function tries to calculate the +// variable's value. If this is possible it returns true and sets the uint64_t +// parameter to the variables unsigned value. Otherwise function returns false. +bool RenderScriptRuntime::GetFrameVarAsUnsigned(const StackFrameSP frame_sp, + const char *var_name, + uint64_t &val) { + Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + Status err; + VariableSP var_sp; + + // Find variable in stack frame + ValueObjectSP value_sp(frame_sp->GetValueForVariableExpressionPath( + var_name, eNoDynamicValues, + StackFrame::eExpressionPathOptionCheckPtrVsMember | + StackFrame::eExpressionPathOptionsAllowDirectIVarAccess, + var_sp, err)); + if (!err.Success()) { + LLDB_LOGF(log, "%s - error, couldn't find '%s' in frame", __FUNCTION__, + var_name); + return false; + } + + // Find the uint32_t value for the variable + bool success = false; + val = value_sp->GetValueAsUnsigned(0, &success); + if (!success) { + LLDB_LOGF(log, "%s - error, couldn't parse '%s' as an uint32_t.", + __FUNCTION__, var_name); + return false; + } + + return true; +} + +// Function attempts to find the current coordinate of a kernel invocation by +// investigating the values of frame variables in the .expand function. These +// coordinates are returned via the coord array reference parameter. Returns +// true if the coordinates could be found, and false otherwise. +bool RenderScriptRuntime::GetKernelCoordinate(RSCoordinate &coord, + Thread *thread_ptr) { + static const char *const x_expr = "rsIndex"; + static const char *const y_expr = "p->current.y"; + static const char *const z_expr = "p->current.z"; + + Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!thread_ptr) { + LLDB_LOGF(log, "%s - Error, No thread pointer", __FUNCTION__); + + return false; + } + + // Walk the call stack looking for a function whose name has the suffix + // '.expand' and contains the variables we're looking for. + for (uint32_t i = 0; i < thread_ptr->GetStackFrameCount(); ++i) { + if (!thread_ptr->SetSelectedFrameByIndex(i)) + continue; + + StackFrameSP frame_sp = thread_ptr->GetSelectedFrame(); + if (!frame_sp) + continue; + + // Find the function name + const SymbolContext sym_ctx = + frame_sp->GetSymbolContext(eSymbolContextFunction); + const ConstString func_name = sym_ctx.GetFunctionName(); + if (!func_name) + continue; + + LLDB_LOGF(log, "%s - Inspecting function '%s'", __FUNCTION__, + func_name.GetCString()); + + // Check if function name has .expand suffix + if (!func_name.GetStringRef().endswith(".expand")) + continue; + + LLDB_LOGF(log, "%s - Found .expand function '%s'", __FUNCTION__, + func_name.GetCString()); + + // Get values for variables in .expand frame that tell us the current + // kernel invocation + uint64_t x, y, z; + bool found = GetFrameVarAsUnsigned(frame_sp, x_expr, x) && + GetFrameVarAsUnsigned(frame_sp, y_expr, y) && + GetFrameVarAsUnsigned(frame_sp, z_expr, z); + + if (found) { + // The RenderScript runtime uses uint32_t for these vars. If they're not + // within bounds, our frame parsing is garbage + assert(x <= UINT32_MAX && y <= UINT32_MAX && z <= UINT32_MAX); + coord.x = (uint32_t)x; + coord.y = (uint32_t)y; + coord.z = (uint32_t)z; + return true; + } + } + return false; +} + +// Callback when a kernel breakpoint hits and we're looking for a specific +// coordinate. Baton parameter contains a pointer to the target coordinate we +// want to break on. Function then checks the .expand frame for the current +// coordinate and breaks to user if it matches. Parameter 'break_id' is the id +// of the Breakpoint which made the callback. Parameter 'break_loc_id' is the +// id for the BreakpointLocation which was hit, a single logical breakpoint can +// have multiple addresses. +bool RenderScriptRuntime::KernelBreakpointHit(void *baton, + StoppointCallbackContext *ctx, + user_id_t break_id, + user_id_t break_loc_id) { + Log *log( + GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS)); + + assert(baton && + "Error: null baton in conditional kernel breakpoint callback"); + + // Coordinate we want to stop on + RSCoordinate target_coord = *static_cast<RSCoordinate *>(baton); + + LLDB_LOGF(log, "%s - Break ID %" PRIu64 ", " FMT_COORD, __FUNCTION__, + break_id, target_coord.x, target_coord.y, target_coord.z); + + // Select current thread + ExecutionContext context(ctx->exe_ctx_ref); + Thread *thread_ptr = context.GetThreadPtr(); + assert(thread_ptr && "Null thread pointer"); + + // Find current kernel invocation from .expand frame variables + RSCoordinate current_coord{}; + if (!GetKernelCoordinate(current_coord, thread_ptr)) { + LLDB_LOGF(log, "%s - Error, couldn't select .expand stack frame", + __FUNCTION__); + return false; + } + + LLDB_LOGF(log, "%s - " FMT_COORD, __FUNCTION__, current_coord.x, + current_coord.y, current_coord.z); + + // Check if the current kernel invocation coordinate matches our target + // coordinate + if (target_coord == current_coord) { + LLDB_LOGF(log, "%s, BREAKING " FMT_COORD, __FUNCTION__, current_coord.x, + current_coord.y, current_coord.z); + + BreakpointSP breakpoint_sp = + context.GetTargetPtr()->GetBreakpointByID(break_id); + assert(breakpoint_sp != nullptr && + "Error: Couldn't find breakpoint matching break id for callback"); + breakpoint_sp->SetEnabled(false); // Optimise since conditional breakpoint + // should only be hit once. + return true; + } + + // No match on coordinate + return false; +} + +void RenderScriptRuntime::SetConditional(BreakpointSP bp, Stream &messages, + const RSCoordinate &coord) { + messages.Printf("Conditional kernel breakpoint on coordinate " FMT_COORD, + coord.x, coord.y, coord.z); + messages.EOL(); + + // Allocate memory for the baton, and copy over coordinate + RSCoordinate *baton = new RSCoordinate(coord); + + // Create a callback that will be invoked every time the breakpoint is hit. + // The baton object passed to the handler is the target coordinate we want to + // break on. + bp->SetCallback(KernelBreakpointHit, baton, true); + + // Store a shared pointer to the baton, so the memory will eventually be + // cleaned up after destruction + m_conditional_breaks[bp->GetID()] = std::unique_ptr<RSCoordinate>(baton); +} + +// Tries to set a breakpoint on the start of a kernel, resolved using the +// kernel name. Argument 'coords', represents a three dimensional coordinate +// which can be used to specify a single kernel instance to break on. If this +// is set then we add a callback to the breakpoint. +bool RenderScriptRuntime::PlaceBreakpointOnKernel(TargetSP target, + Stream &messages, + const char *name, + const RSCoordinate *coord) { + if (!name) + return false; + + InitSearchFilter(target); + + ConstString kernel_name(name); + BreakpointSP bp = CreateKernelBreakpoint(kernel_name); + if (!bp) + return false; + + // We have a conditional breakpoint on a specific coordinate + if (coord) + SetConditional(bp, messages, *coord); + + bp->GetDescription(&messages, lldb::eDescriptionLevelInitial, false); + + return true; +} + +BreakpointSP +RenderScriptRuntime::CreateScriptGroupBreakpoint(ConstString name, + bool stop_on_all) { + Log *log( + GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS)); + + if (!m_filtersp) { + LLDB_LOGF(log, "%s - error, no breakpoint search filter set.", + __FUNCTION__); + return nullptr; + } + + BreakpointResolverSP resolver_sp(new RSScriptGroupBreakpointResolver( + nullptr, name, m_scriptGroups, stop_on_all)); + Target &target = GetProcess()->GetTarget(); + BreakpointSP bp = target.CreateBreakpoint( + m_filtersp, resolver_sp, false, false, false); + // Give RS breakpoints a specific name, so the user can manipulate them as a + // group. + Status err; + target.AddNameToBreakpoint(bp, name.GetCString(), err); + if (err.Fail() && log) + LLDB_LOGF(log, "%s - error setting break name, '%s'.", __FUNCTION__, + err.AsCString()); + // ask the breakpoint to resolve itself + bp->ResolveBreakpoint(); + return bp; +} + +bool RenderScriptRuntime::PlaceBreakpointOnScriptGroup(TargetSP target, + Stream &strm, + ConstString name, + bool multi) { + InitSearchFilter(target); + BreakpointSP bp = CreateScriptGroupBreakpoint(name, multi); + if (bp) + bp->GetDescription(&strm, lldb::eDescriptionLevelInitial, false); + return bool(bp); +} + +bool RenderScriptRuntime::PlaceBreakpointOnReduction(TargetSP target, + Stream &messages, + const char *reduce_name, + const RSCoordinate *coord, + int kernel_types) { + if (!reduce_name) + return false; + + InitSearchFilter(target); + BreakpointSP bp = + CreateReductionBreakpoint(ConstString(reduce_name), kernel_types); + if (!bp) + return false; + + if (coord) + SetConditional(bp, messages, *coord); + + bp->GetDescription(&messages, lldb::eDescriptionLevelInitial, false); + + return true; +} + +void RenderScriptRuntime::DumpModules(Stream &strm) const { + strm.Printf("RenderScript Modules:"); + strm.EOL(); + strm.IndentMore(); + for (const auto &module : m_rsmodules) { + module->Dump(strm); + } + strm.IndentLess(); +} + +RenderScriptRuntime::ScriptDetails * +RenderScriptRuntime::LookUpScript(addr_t address, bool create) { + for (const auto &s : m_scripts) { + if (s->script.isValid()) + if (*s->script == address) + return s.get(); + } + if (create) { + std::unique_ptr<ScriptDetails> s(new ScriptDetails); + s->script = address; + m_scripts.push_back(std::move(s)); + return m_scripts.back().get(); + } + return nullptr; +} + +RenderScriptRuntime::AllocationDetails * +RenderScriptRuntime::LookUpAllocation(addr_t address) { + for (const auto &a : m_allocations) { + if (a->address.isValid()) + if (*a->address == address) + return a.get(); + } + return nullptr; +} + +RenderScriptRuntime::AllocationDetails * +RenderScriptRuntime::CreateAllocation(addr_t address) { + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + + // Remove any previous allocation which contains the same address + auto it = m_allocations.begin(); + while (it != m_allocations.end()) { + if (*((*it)->address) == address) { + LLDB_LOGF(log, "%s - Removing allocation id: %d, address: 0x%" PRIx64, + __FUNCTION__, (*it)->id, address); + + it = m_allocations.erase(it); + } else { + it++; + } + } + + std::unique_ptr<AllocationDetails> a(new AllocationDetails); + a->address = address; + m_allocations.push_back(std::move(a)); + return m_allocations.back().get(); +} + +bool RenderScriptRuntime::ResolveKernelName(lldb::addr_t kernel_addr, + ConstString &name) { + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS); + + Target &target = GetProcess()->GetTarget(); + Address resolved; + // RenderScript module + if (!target.GetSectionLoadList().ResolveLoadAddress(kernel_addr, resolved)) { + LLDB_LOGF(log, "%s: unable to resolve 0x%" PRIx64 " to a loaded symbol", + __FUNCTION__, kernel_addr); + return false; + } + + Symbol *sym = resolved.CalculateSymbolContextSymbol(); + if (!sym) + return false; + + name = sym->GetName(); + assert(IsRenderScriptModule(resolved.CalculateSymbolContextModule())); + LLDB_LOGF(log, "%s: 0x%" PRIx64 " resolved to the symbol '%s'", __FUNCTION__, + kernel_addr, name.GetCString()); + return true; +} + +void RSModuleDescriptor::Dump(Stream &strm) const { + int indent = strm.GetIndentLevel(); + + strm.Indent(); + m_module->GetFileSpec().Dump(&strm); + strm.Indent(m_module->GetNumCompileUnits() ? "Debug info loaded." + : "Debug info does not exist."); + strm.EOL(); + strm.IndentMore(); + + strm.Indent(); + strm.Printf("Globals: %" PRIu64, static_cast<uint64_t>(m_globals.size())); + strm.EOL(); + strm.IndentMore(); + for (const auto &global : m_globals) { + global.Dump(strm); + } + strm.IndentLess(); + + strm.Indent(); + strm.Printf("Kernels: %" PRIu64, static_cast<uint64_t>(m_kernels.size())); + strm.EOL(); + strm.IndentMore(); + for (const auto &kernel : m_kernels) { + kernel.Dump(strm); + } + strm.IndentLess(); + + strm.Indent(); + strm.Printf("Pragmas: %" PRIu64, static_cast<uint64_t>(m_pragmas.size())); + strm.EOL(); + strm.IndentMore(); + for (const auto &key_val : m_pragmas) { + strm.Indent(); + strm.Printf("%s: %s", key_val.first.c_str(), key_val.second.c_str()); + strm.EOL(); + } + strm.IndentLess(); + + strm.Indent(); + strm.Printf("Reductions: %" PRIu64, + static_cast<uint64_t>(m_reductions.size())); + strm.EOL(); + strm.IndentMore(); + for (const auto &reduction : m_reductions) { + reduction.Dump(strm); + } + + strm.SetIndentLevel(indent); +} + +void RSGlobalDescriptor::Dump(Stream &strm) const { + strm.Indent(m_name.AsCString()); + VariableList var_list; + m_module->m_module->FindGlobalVariables(m_name, nullptr, 1U, var_list); + if (var_list.GetSize() == 1) { + auto var = var_list.GetVariableAtIndex(0); + auto type = var->GetType(); + if (type) { + strm.Printf(" - "); + type->DumpTypeName(&strm); + } else { + strm.Printf(" - Unknown Type"); + } + } else { + strm.Printf(" - variable identified, but not found in binary"); + const Symbol *s = m_module->m_module->FindFirstSymbolWithNameAndType( + m_name, eSymbolTypeData); + if (s) { + strm.Printf(" (symbol exists) "); + } + } + + strm.EOL(); +} + +void RSKernelDescriptor::Dump(Stream &strm) const { + strm.Indent(m_name.AsCString()); + strm.EOL(); +} + +void RSReductionDescriptor::Dump(lldb_private::Stream &stream) const { + stream.Indent(m_reduce_name.AsCString()); + stream.IndentMore(); + stream.EOL(); + stream.Indent(); + stream.Printf("accumulator: %s", m_accum_name.AsCString()); + stream.EOL(); + stream.Indent(); + stream.Printf("initializer: %s", m_init_name.AsCString()); + stream.EOL(); + stream.Indent(); + stream.Printf("combiner: %s", m_comb_name.AsCString()); + stream.EOL(); + stream.Indent(); + stream.Printf("outconverter: %s", m_outc_name.AsCString()); + stream.EOL(); + // XXX This is currently unspecified by RenderScript, and unused + // stream.Indent(); + // stream.Printf("halter: '%s'", m_init_name.AsCString()); + // stream.EOL(); + stream.IndentLess(); +} + +class CommandObjectRenderScriptRuntimeModuleDump : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeModuleDump(CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "renderscript module dump", + "Dumps renderscript specific information for all modules.", + "renderscript module dump", + eCommandRequiresProcess | eCommandProcessMustBeLaunched) {} + + ~CommandObjectRenderScriptRuntimeModuleDump() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + RenderScriptRuntime *runtime = llvm::cast<RenderScriptRuntime>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + runtime->DumpModules(result.GetOutputStream()); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } +}; + +class CommandObjectRenderScriptRuntimeModule : public CommandObjectMultiword { +public: + CommandObjectRenderScriptRuntimeModule(CommandInterpreter &interpreter) + : CommandObjectMultiword(interpreter, "renderscript module", + "Commands that deal with RenderScript modules.", + nullptr) { + LoadSubCommand( + "dump", CommandObjectSP(new CommandObjectRenderScriptRuntimeModuleDump( + interpreter))); + } + + ~CommandObjectRenderScriptRuntimeModule() override = default; +}; + +class CommandObjectRenderScriptRuntimeKernelList : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeKernelList(CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "renderscript kernel list", + "Lists renderscript kernel names and associated script resources.", + "renderscript kernel list", + eCommandRequiresProcess | eCommandProcessMustBeLaunched) {} + + ~CommandObjectRenderScriptRuntimeKernelList() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + RenderScriptRuntime *runtime = llvm::cast<RenderScriptRuntime>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + runtime->DumpKernels(result.GetOutputStream()); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } +}; + +static constexpr OptionDefinition g_renderscript_reduction_bp_set_options[] = { + {LLDB_OPT_SET_1, false, "function-role", 't', + OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeOneLiner, + "Break on a comma separated set of reduction kernel types " + "(accumulator,outcoverter,combiner,initializer"}, + {LLDB_OPT_SET_1, false, "coordinate", 'c', OptionParser::eRequiredArgument, + nullptr, {}, 0, eArgTypeValue, + "Set a breakpoint on a single invocation of the kernel with specified " + "coordinate.\n" + "Coordinate takes the form 'x[,y][,z] where x,y,z are positive " + "integers representing kernel dimensions. " + "Any unset dimensions will be defaulted to zero."}}; + +class CommandObjectRenderScriptRuntimeReductionBreakpointSet + : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeReductionBreakpointSet( + CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "renderscript reduction breakpoint set", + "Set a breakpoint on named RenderScript general reductions", + "renderscript reduction breakpoint set <kernel_name> [-t " + "<reduction_kernel_type,...>]", + eCommandRequiresProcess | eCommandProcessMustBeLaunched | + eCommandProcessMustBePaused), + m_options(){}; + + class CommandOptions : public Options { + public: + CommandOptions() + : Options(), + m_kernel_types(RSReduceBreakpointResolver::eKernelTypeAll) {} + + ~CommandOptions() override = default; + + Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, + ExecutionContext *exe_ctx) override { + Status err; + StreamString err_str; + const int short_option = m_getopt_table[option_idx].val; + switch (short_option) { + case 't': + if (!ParseReductionTypes(option_arg, err_str)) + err.SetErrorStringWithFormat( + "Unable to deduce reduction types for %s: %s", + option_arg.str().c_str(), err_str.GetData()); + break; + case 'c': { + auto coord = RSCoordinate{}; + if (!ParseCoordinate(option_arg, coord)) + err.SetErrorStringWithFormat("unable to parse coordinate for %s", + option_arg.str().c_str()); + else { + m_have_coord = true; + m_coord = coord; + } + break; + } + default: + err.SetErrorStringWithFormat("Invalid option '-%c'", short_option); + } + return err; + } + + void OptionParsingStarting(ExecutionContext *exe_ctx) override { + m_have_coord = false; + } + + llvm::ArrayRef<OptionDefinition> GetDefinitions() override { + return llvm::makeArrayRef(g_renderscript_reduction_bp_set_options); + } + + bool ParseReductionTypes(llvm::StringRef option_val, + StreamString &err_str) { + m_kernel_types = RSReduceBreakpointResolver::eKernelTypeNone; + const auto reduce_name_to_type = [](llvm::StringRef name) -> int { + return llvm::StringSwitch<int>(name) + .Case("accumulator", RSReduceBreakpointResolver::eKernelTypeAccum) + .Case("initializer", RSReduceBreakpointResolver::eKernelTypeInit) + .Case("outconverter", RSReduceBreakpointResolver::eKernelTypeOutC) + .Case("combiner", RSReduceBreakpointResolver::eKernelTypeComb) + .Case("all", RSReduceBreakpointResolver::eKernelTypeAll) + // Currently not exposed by the runtime + // .Case("halter", RSReduceBreakpointResolver::eKernelTypeHalter) + .Default(0); + }; + + // Matching a comma separated list of known words is fairly + // straightforward with PCRE, but we're using ERE, so we end up with a + // little ugliness... + RegularExpression match_type_list( + llvm::StringRef("^([[:alpha:]]+)(,[[:alpha:]]+){0,4}$")); + + assert(match_type_list.IsValid()); + + if (!match_type_list.Execute(option_val)) { + err_str.PutCString( + "a comma-separated list of kernel types is required"); + return false; + } + + // splitting on commas is much easier with llvm::StringRef than regex + llvm::SmallVector<llvm::StringRef, 5> type_names; + llvm::StringRef(option_val).split(type_names, ','); + + for (const auto &name : type_names) { + const int type = reduce_name_to_type(name); + if (!type) { + err_str.Printf("unknown kernel type name %s", name.str().c_str()); + return false; + } + m_kernel_types |= type; + } + + return true; + } + + int m_kernel_types; + llvm::StringRef m_reduce_name; + RSCoordinate m_coord; + bool m_have_coord; + }; + + Options *GetOptions() override { return &m_options; } + + bool DoExecute(Args &command, CommandReturnObject &result) override { + const size_t argc = command.GetArgumentCount(); + if (argc < 1) { + result.AppendErrorWithFormat("'%s' takes 1 argument of reduction name, " + "and an optional kernel type list", + m_cmd_name.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; + } + + RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + + auto &outstream = result.GetOutputStream(); + auto name = command.GetArgumentAtIndex(0); + auto &target = m_exe_ctx.GetTargetSP(); + auto coord = m_options.m_have_coord ? &m_options.m_coord : nullptr; + if (!runtime->PlaceBreakpointOnReduction(target, outstream, name, coord, + m_options.m_kernel_types)) { + result.SetStatus(eReturnStatusFailed); + result.AppendError("Error: unable to place breakpoint on reduction"); + return false; + } + result.AppendMessage("Breakpoint(s) created"); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } + +private: + CommandOptions m_options; +}; + +static constexpr OptionDefinition g_renderscript_kernel_bp_set_options[] = { + {LLDB_OPT_SET_1, false, "coordinate", 'c', OptionParser::eRequiredArgument, + nullptr, {}, 0, eArgTypeValue, + "Set a breakpoint on a single invocation of the kernel with specified " + "coordinate.\n" + "Coordinate takes the form 'x[,y][,z] where x,y,z are positive " + "integers representing kernel dimensions. " + "Any unset dimensions will be defaulted to zero."}}; + +class CommandObjectRenderScriptRuntimeKernelBreakpointSet + : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeKernelBreakpointSet( + CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "renderscript kernel breakpoint set", + "Sets a breakpoint on a renderscript kernel.", + "renderscript kernel breakpoint set <kernel_name> [-c x,y,z]", + eCommandRequiresProcess | eCommandProcessMustBeLaunched | + eCommandProcessMustBePaused), + m_options() {} + + ~CommandObjectRenderScriptRuntimeKernelBreakpointSet() override = default; + + Options *GetOptions() override { return &m_options; } + + class CommandOptions : public Options { + public: + CommandOptions() : Options() {} + + ~CommandOptions() override = default; + + Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, + ExecutionContext *exe_ctx) override { + Status err; + const int short_option = m_getopt_table[option_idx].val; + + switch (short_option) { + case 'c': { + auto coord = RSCoordinate{}; + if (!ParseCoordinate(option_arg, coord)) + err.SetErrorStringWithFormat( + "Couldn't parse coordinate '%s', should be in format 'x,y,z'.", + option_arg.str().c_str()); + else { + m_have_coord = true; + m_coord = coord; + } + break; + } + default: + err.SetErrorStringWithFormat("unrecognized option '%c'", short_option); + break; + } + return err; + } + + void OptionParsingStarting(ExecutionContext *exe_ctx) override { + m_have_coord = false; + } + + llvm::ArrayRef<OptionDefinition> GetDefinitions() override { + return llvm::makeArrayRef(g_renderscript_kernel_bp_set_options); + } + + RSCoordinate m_coord; + bool m_have_coord; + }; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + const size_t argc = command.GetArgumentCount(); + if (argc < 1) { + result.AppendErrorWithFormat( + "'%s' takes 1 argument of kernel name, and an optional coordinate.", + m_cmd_name.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; + } + + RenderScriptRuntime *runtime = llvm::cast<RenderScriptRuntime>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + + auto &outstream = result.GetOutputStream(); + auto &target = m_exe_ctx.GetTargetSP(); + auto name = command.GetArgumentAtIndex(0); + auto coord = m_options.m_have_coord ? &m_options.m_coord : nullptr; + if (!runtime->PlaceBreakpointOnKernel(target, outstream, name, coord)) { + result.SetStatus(eReturnStatusFailed); + result.AppendErrorWithFormat( + "Error: unable to set breakpoint on kernel '%s'", name); + return false; + } + + result.AppendMessage("Breakpoint(s) created"); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } + +private: + CommandOptions m_options; +}; + +class CommandObjectRenderScriptRuntimeKernelBreakpointAll + : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeKernelBreakpointAll( + CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "renderscript kernel breakpoint all", + "Automatically sets a breakpoint on all renderscript kernels that " + "are or will be loaded.\n" + "Disabling option means breakpoints will no longer be set on any " + "kernels loaded in the future, " + "but does not remove currently set breakpoints.", + "renderscript kernel breakpoint all <enable/disable>", + eCommandRequiresProcess | eCommandProcessMustBeLaunched | + eCommandProcessMustBePaused) {} + + ~CommandObjectRenderScriptRuntimeKernelBreakpointAll() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + const size_t argc = command.GetArgumentCount(); + if (argc != 1) { + result.AppendErrorWithFormat( + "'%s' takes 1 argument of 'enable' or 'disable'", m_cmd_name.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; + } + + RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + + bool do_break = false; + const char *argument = command.GetArgumentAtIndex(0); + if (strcmp(argument, "enable") == 0) { + do_break = true; + result.AppendMessage("Breakpoints will be set on all kernels."); + } else if (strcmp(argument, "disable") == 0) { + do_break = false; + result.AppendMessage("Breakpoints will not be set on any new kernels."); + } else { + result.AppendErrorWithFormat( + "Argument must be either 'enable' or 'disable'"); + result.SetStatus(eReturnStatusFailed); + return false; + } + + runtime->SetBreakAllKernels(do_break, m_exe_ctx.GetTargetSP()); + + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } +}; + +class CommandObjectRenderScriptRuntimeReductionBreakpoint + : public CommandObjectMultiword { +public: + CommandObjectRenderScriptRuntimeReductionBreakpoint( + CommandInterpreter &interpreter) + : CommandObjectMultiword(interpreter, "renderscript reduction breakpoint", + "Commands that manipulate breakpoints on " + "renderscript general reductions.", + nullptr) { + LoadSubCommand( + "set", CommandObjectSP( + new CommandObjectRenderScriptRuntimeReductionBreakpointSet( + interpreter))); + } + + ~CommandObjectRenderScriptRuntimeReductionBreakpoint() override = default; +}; + +class CommandObjectRenderScriptRuntimeKernelCoordinate + : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeKernelCoordinate( + CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "renderscript kernel coordinate", + "Shows the (x,y,z) coordinate of the current kernel invocation.", + "renderscript kernel coordinate", + eCommandRequiresProcess | eCommandProcessMustBeLaunched | + eCommandProcessMustBePaused) {} + + ~CommandObjectRenderScriptRuntimeKernelCoordinate() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + RSCoordinate coord{}; + bool success = RenderScriptRuntime::GetKernelCoordinate( + coord, m_exe_ctx.GetThreadPtr()); + Stream &stream = result.GetOutputStream(); + + if (success) { + stream.Printf("Coordinate: " FMT_COORD, coord.x, coord.y, coord.z); + stream.EOL(); + result.SetStatus(eReturnStatusSuccessFinishResult); + } else { + stream.Printf("Error: Coordinate could not be found."); + stream.EOL(); + result.SetStatus(eReturnStatusFailed); + } + return true; + } +}; + +class CommandObjectRenderScriptRuntimeKernelBreakpoint + : public CommandObjectMultiword { +public: + CommandObjectRenderScriptRuntimeKernelBreakpoint( + CommandInterpreter &interpreter) + : CommandObjectMultiword( + interpreter, "renderscript kernel", + "Commands that generate breakpoints on renderscript kernels.", + nullptr) { + LoadSubCommand( + "set", + CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelBreakpointSet( + interpreter))); + LoadSubCommand( + "all", + CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelBreakpointAll( + interpreter))); + } + + ~CommandObjectRenderScriptRuntimeKernelBreakpoint() override = default; +}; + +class CommandObjectRenderScriptRuntimeKernel : public CommandObjectMultiword { +public: + CommandObjectRenderScriptRuntimeKernel(CommandInterpreter &interpreter) + : CommandObjectMultiword(interpreter, "renderscript kernel", + "Commands that deal with RenderScript kernels.", + nullptr) { + LoadSubCommand( + "list", CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelList( + interpreter))); + LoadSubCommand( + "coordinate", + CommandObjectSP( + new CommandObjectRenderScriptRuntimeKernelCoordinate(interpreter))); + LoadSubCommand( + "breakpoint", + CommandObjectSP( + new CommandObjectRenderScriptRuntimeKernelBreakpoint(interpreter))); + } + + ~CommandObjectRenderScriptRuntimeKernel() override = default; +}; + +class CommandObjectRenderScriptRuntimeContextDump : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeContextDump(CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "renderscript context dump", + "Dumps renderscript context information.", + "renderscript context dump", + eCommandRequiresProcess | + eCommandProcessMustBeLaunched) {} + + ~CommandObjectRenderScriptRuntimeContextDump() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + RenderScriptRuntime *runtime = llvm::cast<RenderScriptRuntime>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + runtime->DumpContexts(result.GetOutputStream()); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } +}; + +static constexpr OptionDefinition g_renderscript_runtime_alloc_dump_options[] = { + {LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, + nullptr, {}, 0, eArgTypeFilename, + "Print results to specified file instead of command line."}}; + +class CommandObjectRenderScriptRuntimeContext : public CommandObjectMultiword { +public: + CommandObjectRenderScriptRuntimeContext(CommandInterpreter &interpreter) + : CommandObjectMultiword(interpreter, "renderscript context", + "Commands that deal with RenderScript contexts.", + nullptr) { + LoadSubCommand( + "dump", CommandObjectSP(new CommandObjectRenderScriptRuntimeContextDump( + interpreter))); + } + + ~CommandObjectRenderScriptRuntimeContext() override = default; +}; + +class CommandObjectRenderScriptRuntimeAllocationDump + : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeAllocationDump( + CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "renderscript allocation dump", + "Displays the contents of a particular allocation", + "renderscript allocation dump <ID>", + eCommandRequiresProcess | + eCommandProcessMustBeLaunched), + m_options() {} + + ~CommandObjectRenderScriptRuntimeAllocationDump() override = default; + + Options *GetOptions() override { return &m_options; } + + class CommandOptions : public Options { + public: + CommandOptions() : Options() {} + + ~CommandOptions() override = default; + + Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, + ExecutionContext *exe_ctx) override { + Status err; + const int short_option = m_getopt_table[option_idx].val; + + switch (short_option) { + case 'f': + m_outfile.SetFile(option_arg, FileSpec::Style::native); + FileSystem::Instance().Resolve(m_outfile); + if (FileSystem::Instance().Exists(m_outfile)) { + m_outfile.Clear(); + err.SetErrorStringWithFormat("file already exists: '%s'", + option_arg.str().c_str()); + } + break; + default: + err.SetErrorStringWithFormat("unrecognized option '%c'", short_option); + break; + } + return err; + } + + void OptionParsingStarting(ExecutionContext *exe_ctx) override { + m_outfile.Clear(); + } + + llvm::ArrayRef<OptionDefinition> GetDefinitions() override { + return llvm::makeArrayRef(g_renderscript_runtime_alloc_dump_options); + } + + FileSpec m_outfile; + }; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + const size_t argc = command.GetArgumentCount(); + if (argc < 1) { + result.AppendErrorWithFormat("'%s' takes 1 argument, an allocation ID. " + "As well as an optional -f argument", + m_cmd_name.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; + } + + RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + + const char *id_cstr = command.GetArgumentAtIndex(0); + bool success = false; + const uint32_t id = + StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &success); + if (!success) { + result.AppendErrorWithFormat("invalid allocation id argument '%s'", + id_cstr); + result.SetStatus(eReturnStatusFailed); + return false; + } + + Stream *output_stream_p = nullptr; + std::unique_ptr<Stream> output_stream_storage; + + const FileSpec &outfile_spec = + m_options.m_outfile; // Dump allocation to file instead + if (outfile_spec) { + // Open output file + std::string path = outfile_spec.GetPath(); + auto file = FileSystem::Instance().Open( + outfile_spec, File::eOpenOptionWrite | File::eOpenOptionCanCreate); + if (file) { + output_stream_storage = + std::make_unique<StreamFile>(std::move(file.get())); + output_stream_p = output_stream_storage.get(); + result.GetOutputStream().Printf("Results written to '%s'", + path.c_str()); + result.GetOutputStream().EOL(); + } else { + std::string error = llvm::toString(file.takeError()); + result.AppendErrorWithFormat("Couldn't open file '%s': %s", + path.c_str(), error.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; + } + } else + output_stream_p = &result.GetOutputStream(); + + assert(output_stream_p != nullptr); + bool dumped = + runtime->DumpAllocation(*output_stream_p, m_exe_ctx.GetFramePtr(), id); + + if (dumped) + result.SetStatus(eReturnStatusSuccessFinishResult); + else + result.SetStatus(eReturnStatusFailed); + + return true; + } + +private: + CommandOptions m_options; +}; + +static constexpr OptionDefinition g_renderscript_runtime_alloc_list_options[] = { + {LLDB_OPT_SET_1, false, "id", 'i', OptionParser::eRequiredArgument, nullptr, + {}, 0, eArgTypeIndex, + "Only show details of a single allocation with specified id."}}; + +class CommandObjectRenderScriptRuntimeAllocationList + : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeAllocationList( + CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "renderscript allocation list", + "List renderscript allocations and their information.", + "renderscript allocation list", + eCommandRequiresProcess | eCommandProcessMustBeLaunched), + m_options() {} + + ~CommandObjectRenderScriptRuntimeAllocationList() override = default; + + Options *GetOptions() override { return &m_options; } + + class CommandOptions : public Options { + public: + CommandOptions() : Options(), m_id(0) {} + + ~CommandOptions() override = default; + + Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, + ExecutionContext *exe_ctx) override { + Status err; + const int short_option = m_getopt_table[option_idx].val; + + switch (short_option) { + case 'i': + if (option_arg.getAsInteger(0, m_id)) + err.SetErrorStringWithFormat("invalid integer value for option '%c'", + short_option); + break; + default: + err.SetErrorStringWithFormat("unrecognized option '%c'", short_option); + break; + } + return err; + } + + void OptionParsingStarting(ExecutionContext *exe_ctx) override { m_id = 0; } + + llvm::ArrayRef<OptionDefinition> GetDefinitions() override { + return llvm::makeArrayRef(g_renderscript_runtime_alloc_list_options); + } + + uint32_t m_id; + }; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + runtime->ListAllocations(result.GetOutputStream(), m_exe_ctx.GetFramePtr(), + m_options.m_id); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } + +private: + CommandOptions m_options; +}; + +class CommandObjectRenderScriptRuntimeAllocationLoad + : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeAllocationLoad( + CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "renderscript allocation load", + "Loads renderscript allocation contents from a file.", + "renderscript allocation load <ID> <filename>", + eCommandRequiresProcess | eCommandProcessMustBeLaunched) {} + + ~CommandObjectRenderScriptRuntimeAllocationLoad() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + const size_t argc = command.GetArgumentCount(); + if (argc != 2) { + result.AppendErrorWithFormat( + "'%s' takes 2 arguments, an allocation ID and filename to read from.", + m_cmd_name.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; + } + + RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + + const char *id_cstr = command.GetArgumentAtIndex(0); + bool success = false; + const uint32_t id = + StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &success); + if (!success) { + result.AppendErrorWithFormat("invalid allocation id argument '%s'", + id_cstr); + result.SetStatus(eReturnStatusFailed); + return false; + } + + const char *path = command.GetArgumentAtIndex(1); + bool loaded = runtime->LoadAllocation(result.GetOutputStream(), id, path, + m_exe_ctx.GetFramePtr()); + + if (loaded) + result.SetStatus(eReturnStatusSuccessFinishResult); + else + result.SetStatus(eReturnStatusFailed); + + return true; + } +}; + +class CommandObjectRenderScriptRuntimeAllocationSave + : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeAllocationSave( + CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "renderscript allocation save", + "Write renderscript allocation contents to a file.", + "renderscript allocation save <ID> <filename>", + eCommandRequiresProcess | + eCommandProcessMustBeLaunched) {} + + ~CommandObjectRenderScriptRuntimeAllocationSave() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + const size_t argc = command.GetArgumentCount(); + if (argc != 2) { + result.AppendErrorWithFormat( + "'%s' takes 2 arguments, an allocation ID and filename to read from.", + m_cmd_name.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; + } + + RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + + const char *id_cstr = command.GetArgumentAtIndex(0); + bool success = false; + const uint32_t id = + StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &success); + if (!success) { + result.AppendErrorWithFormat("invalid allocation id argument '%s'", + id_cstr); + result.SetStatus(eReturnStatusFailed); + return false; + } + + const char *path = command.GetArgumentAtIndex(1); + bool saved = runtime->SaveAllocation(result.GetOutputStream(), id, path, + m_exe_ctx.GetFramePtr()); + + if (saved) + result.SetStatus(eReturnStatusSuccessFinishResult); + else + result.SetStatus(eReturnStatusFailed); + + return true; + } +}; + +class CommandObjectRenderScriptRuntimeAllocationRefresh + : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeAllocationRefresh( + CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "renderscript allocation refresh", + "Recomputes the details of all allocations.", + "renderscript allocation refresh", + eCommandRequiresProcess | + eCommandProcessMustBeLaunched) {} + + ~CommandObjectRenderScriptRuntimeAllocationRefresh() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + + bool success = runtime->RecomputeAllAllocations(result.GetOutputStream(), + m_exe_ctx.GetFramePtr()); + + if (success) { + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } else { + result.SetStatus(eReturnStatusFailed); + return false; + } + } +}; + +class CommandObjectRenderScriptRuntimeAllocation + : public CommandObjectMultiword { +public: + CommandObjectRenderScriptRuntimeAllocation(CommandInterpreter &interpreter) + : CommandObjectMultiword( + interpreter, "renderscript allocation", + "Commands that deal with RenderScript allocations.", nullptr) { + LoadSubCommand( + "list", + CommandObjectSP( + new CommandObjectRenderScriptRuntimeAllocationList(interpreter))); + LoadSubCommand( + "dump", + CommandObjectSP( + new CommandObjectRenderScriptRuntimeAllocationDump(interpreter))); + LoadSubCommand( + "save", + CommandObjectSP( + new CommandObjectRenderScriptRuntimeAllocationSave(interpreter))); + LoadSubCommand( + "load", + CommandObjectSP( + new CommandObjectRenderScriptRuntimeAllocationLoad(interpreter))); + LoadSubCommand( + "refresh", + CommandObjectSP(new CommandObjectRenderScriptRuntimeAllocationRefresh( + interpreter))); + } + + ~CommandObjectRenderScriptRuntimeAllocation() override = default; +}; + +class CommandObjectRenderScriptRuntimeStatus : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeStatus(CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "renderscript status", + "Displays current RenderScript runtime status.", + "renderscript status", + eCommandRequiresProcess | + eCommandProcessMustBeLaunched) {} + + ~CommandObjectRenderScriptRuntimeStatus() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + RenderScriptRuntime *runtime = llvm::cast<RenderScriptRuntime>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + runtime->DumpStatus(result.GetOutputStream()); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } +}; + +class CommandObjectRenderScriptRuntimeReduction + : public CommandObjectMultiword { +public: + CommandObjectRenderScriptRuntimeReduction(CommandInterpreter &interpreter) + : CommandObjectMultiword(interpreter, "renderscript reduction", + "Commands that handle general reduction kernels", + nullptr) { + LoadSubCommand( + "breakpoint", + CommandObjectSP(new CommandObjectRenderScriptRuntimeReductionBreakpoint( + interpreter))); + } + ~CommandObjectRenderScriptRuntimeReduction() override = default; +}; + +class CommandObjectRenderScriptRuntime : public CommandObjectMultiword { +public: + CommandObjectRenderScriptRuntime(CommandInterpreter &interpreter) + : CommandObjectMultiword( + interpreter, "renderscript", + "Commands for operating on the RenderScript runtime.", + "renderscript <subcommand> [<subcommand-options>]") { + LoadSubCommand( + "module", CommandObjectSP( + new CommandObjectRenderScriptRuntimeModule(interpreter))); + LoadSubCommand( + "status", CommandObjectSP( + new CommandObjectRenderScriptRuntimeStatus(interpreter))); + LoadSubCommand( + "kernel", CommandObjectSP( + new CommandObjectRenderScriptRuntimeKernel(interpreter))); + LoadSubCommand("context", + CommandObjectSP(new CommandObjectRenderScriptRuntimeContext( + interpreter))); + LoadSubCommand( + "allocation", + CommandObjectSP( + new CommandObjectRenderScriptRuntimeAllocation(interpreter))); + LoadSubCommand("scriptgroup", + NewCommandObjectRenderScriptScriptGroup(interpreter)); + LoadSubCommand( + "reduction", + CommandObjectSP( + new CommandObjectRenderScriptRuntimeReduction(interpreter))); + } + + ~CommandObjectRenderScriptRuntime() override = default; +}; + +void RenderScriptRuntime::Initiate() { assert(!m_initiated); } + +RenderScriptRuntime::RenderScriptRuntime(Process *process) + : lldb_private::CPPLanguageRuntime(process), m_initiated(false), + m_debuggerPresentFlagged(false), m_breakAllKernels(false), + m_ir_passes(nullptr) { + ModulesDidLoad(process->GetTarget().GetImages()); +} + +lldb::CommandObjectSP RenderScriptRuntime::GetCommandObject( + lldb_private::CommandInterpreter &interpreter) { + return CommandObjectSP(new CommandObjectRenderScriptRuntime(interpreter)); +} + +RenderScriptRuntime::~RenderScriptRuntime() = default; diff --git a/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h b/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h new file mode 100644 index 000000000000..c3740ba55a11 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h @@ -0,0 +1,587 @@ +//===-- RenderScriptRuntime.h -----------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_RenderScriptRuntime_h_ +#define liblldb_RenderScriptRuntime_h_ + +#include <array> +#include <map> +#include <memory> +#include <string> +#include <vector> + +#include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/StringRef.h" +#include "lldb/Core/Module.h" +#include "lldb/Expression/LLVMUserExpression.h" +#include "lldb/Target/LanguageRuntime.h" +#include "lldb/lldb-private.h" + +#include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h" + +namespace lldb_private { +namespace lldb_renderscript { + +typedef uint32_t RSSlot; +class RSModuleDescriptor; +struct RSGlobalDescriptor; +struct RSKernelDescriptor; +struct RSReductionDescriptor; +struct RSScriptGroupDescriptor; + +typedef std::shared_ptr<RSModuleDescriptor> RSModuleDescriptorSP; +typedef std::shared_ptr<RSGlobalDescriptor> RSGlobalDescriptorSP; +typedef std::shared_ptr<RSKernelDescriptor> RSKernelDescriptorSP; +typedef std::shared_ptr<RSScriptGroupDescriptor> RSScriptGroupDescriptorSP; + +struct RSCoordinate { + uint32_t x, y, z; + + RSCoordinate() : x(), y(), z(){}; + + bool operator==(const lldb_renderscript::RSCoordinate &rhs) { + return x == rhs.x && y == rhs.y && z == rhs.z; + } +}; + +// Breakpoint Resolvers decide where a breakpoint is placed, so having our own +// allows us to limit the search scope to RS kernel modules. As well as check +// for .expand kernels as a fallback. +class RSBreakpointResolver : public BreakpointResolver { +public: + RSBreakpointResolver(Breakpoint *bp, ConstString name) + : BreakpointResolver(bp, BreakpointResolver::NameResolver), + m_kernel_name(name) {} + + void GetDescription(Stream *strm) override { + if (strm) + strm->Printf("RenderScript kernel breakpoint for '%s'", + m_kernel_name.AsCString()); + } + + void Dump(Stream *s) const override {} + + Searcher::CallbackReturn SearchCallback(SearchFilter &filter, + SymbolContext &context, + Address *addr) override; + + lldb::SearchDepth GetDepth() override { return lldb::eSearchDepthModule; } + + lldb::BreakpointResolverSP + CopyForBreakpoint(Breakpoint &breakpoint) override { + lldb::BreakpointResolverSP ret_sp( + new RSBreakpointResolver(&breakpoint, m_kernel_name)); + return ret_sp; + } + +protected: + ConstString m_kernel_name; +}; + +class RSReduceBreakpointResolver : public BreakpointResolver { +public: + enum ReduceKernelTypeFlags { + eKernelTypeAll = ~(0), + eKernelTypeNone = 0, + eKernelTypeAccum = (1 << 0), + eKernelTypeInit = (1 << 1), + eKernelTypeComb = (1 << 2), + eKernelTypeOutC = (1 << 3), + eKernelTypeHalter = (1 << 4) + }; + + RSReduceBreakpointResolver( + Breakpoint *breakpoint, ConstString reduce_name, + std::vector<lldb_renderscript::RSModuleDescriptorSP> *rs_modules, + int kernel_types = eKernelTypeAll) + : BreakpointResolver(breakpoint, BreakpointResolver::NameResolver), + m_reduce_name(reduce_name), m_rsmodules(rs_modules), + m_kernel_types(kernel_types) { + // The reduce breakpoint resolver handles adding breakpoints for named + // reductions. + // Breakpoints will be resolved for all constituent kernels in the named + // reduction + } + + void GetDescription(Stream *strm) override { + if (strm) + strm->Printf("RenderScript reduce breakpoint for '%s'", + m_reduce_name.AsCString()); + } + + void Dump(Stream *s) const override {} + + Searcher::CallbackReturn SearchCallback(SearchFilter &filter, + SymbolContext &context, + Address *addr) override; + + lldb::SearchDepth GetDepth() override { return lldb::eSearchDepthModule; } + + lldb::BreakpointResolverSP + CopyForBreakpoint(Breakpoint &breakpoint) override { + lldb::BreakpointResolverSP ret_sp(new RSReduceBreakpointResolver( + &breakpoint, m_reduce_name, m_rsmodules, m_kernel_types)); + return ret_sp; + } + +private: + ConstString m_reduce_name; // The name of the reduction + std::vector<lldb_renderscript::RSModuleDescriptorSP> *m_rsmodules; + int m_kernel_types; +}; + +struct RSKernelDescriptor { +public: + RSKernelDescriptor(const RSModuleDescriptor *module, llvm::StringRef name, + uint32_t slot) + : m_module(module), m_name(name), m_slot(slot) {} + + void Dump(Stream &strm) const; + + const RSModuleDescriptor *m_module; + ConstString m_name; + RSSlot m_slot; +}; + +struct RSGlobalDescriptor { +public: + RSGlobalDescriptor(const RSModuleDescriptor *module, llvm::StringRef name) + : m_module(module), m_name(name) {} + + void Dump(Stream &strm) const; + + const RSModuleDescriptor *m_module; + ConstString m_name; +}; + +struct RSReductionDescriptor { + RSReductionDescriptor(const RSModuleDescriptor *module, uint32_t sig, + uint32_t accum_data_size, llvm::StringRef name, + llvm::StringRef init_name, llvm::StringRef accum_name, + llvm::StringRef comb_name, llvm::StringRef outc_name, + llvm::StringRef halter_name = ".") + : m_module(module), m_reduce_name(name), m_init_name(init_name), + m_accum_name(accum_name), m_comb_name(comb_name), + m_outc_name(outc_name), m_halter_name(halter_name) { + // TODO Check whether the combiner is an autogenerated name, and track + // this + } + + void Dump(Stream &strm) const; + + const RSModuleDescriptor *m_module; + ConstString m_reduce_name; // This is the name given to the general reduction + // as a group as passed to pragma + // reduce(m_reduce_name). There is no kernel function with this name + ConstString m_init_name; // The name of the initializer name. "." if no + // initializer given + ConstString m_accum_name; // The accumulator function name. "." if not given + ConstString m_comb_name; // The name of the combiner function. If this was not + // given, a name is generated by the + // compiler. TODO + ConstString m_outc_name; // The name of the outconverter + + ConstString m_halter_name; // The name of the halter function. XXX This is not + // yet specified by the RenderScript + // compiler or runtime, and its semantics and existence is still under + // discussion by the + // RenderScript Contributors + RSSlot m_accum_sig; // metatdata signature for this reduction (bitwise mask of + // type information (see + // libbcc/include/bcinfo/MetadataExtractor.h + uint32_t m_accum_data_size; // Data size of the accumulator function input + bool m_comb_name_generated; // Was the combiner name generated by the compiler +}; + +class RSModuleDescriptor { + std::string m_slang_version; + std::string m_bcc_version; + + bool ParseVersionInfo(llvm::StringRef *, size_t n_lines); + + bool ParseExportForeachCount(llvm::StringRef *, size_t n_lines); + + bool ParseExportVarCount(llvm::StringRef *, size_t n_lines); + + bool ParseExportReduceCount(llvm::StringRef *, size_t n_lines); + + bool ParseBuildChecksum(llvm::StringRef *, size_t n_lines); + + bool ParsePragmaCount(llvm::StringRef *, size_t n_lines); + +public: + RSModuleDescriptor(const lldb::ModuleSP &module) : m_module(module) {} + + ~RSModuleDescriptor() = default; + + bool ParseRSInfo(); + + void Dump(Stream &strm) const; + + void WarnIfVersionMismatch(Stream *s) const; + + const lldb::ModuleSP m_module; + std::vector<RSKernelDescriptor> m_kernels; + std::vector<RSGlobalDescriptor> m_globals; + std::vector<RSReductionDescriptor> m_reductions; + std::map<std::string, std::string> m_pragmas; + std::string m_resname; +}; + +struct RSScriptGroupDescriptor { + struct Kernel { + ConstString m_name; + lldb::addr_t m_addr; + }; + ConstString m_name; + std::vector<Kernel> m_kernels; +}; + +typedef std::vector<RSScriptGroupDescriptorSP> RSScriptGroupList; + +class RSScriptGroupBreakpointResolver : public BreakpointResolver { +public: + RSScriptGroupBreakpointResolver(Breakpoint *bp, ConstString name, + const RSScriptGroupList &groups, + bool stop_on_all) + : BreakpointResolver(bp, BreakpointResolver::NameResolver), + m_group_name(name), m_script_groups(groups), + m_stop_on_all(stop_on_all) {} + + void GetDescription(Stream *strm) override { + if (strm) + strm->Printf("RenderScript ScriptGroup breakpoint for '%s'", + m_group_name.AsCString()); + } + + void Dump(Stream *s) const override {} + + Searcher::CallbackReturn SearchCallback(SearchFilter &filter, + SymbolContext &context, + Address *addr) override; + + lldb::SearchDepth GetDepth() override { return lldb::eSearchDepthModule; } + + lldb::BreakpointResolverSP + CopyForBreakpoint(Breakpoint &breakpoint) override { + lldb::BreakpointResolverSP ret_sp(new RSScriptGroupBreakpointResolver( + &breakpoint, m_group_name, m_script_groups, m_stop_on_all)); + return ret_sp; + } + +protected: + const RSScriptGroupDescriptorSP + FindScriptGroup(ConstString name) const { + for (auto sg : m_script_groups) { + if (ConstString::Compare(sg->m_name, name) == 0) + return sg; + } + return RSScriptGroupDescriptorSP(); + } + + ConstString m_group_name; + const RSScriptGroupList &m_script_groups; + bool m_stop_on_all; +}; +} // namespace lldb_renderscript + +class RenderScriptRuntime : public lldb_private::CPPLanguageRuntime { +public: + enum ModuleKind { + eModuleKindIgnored, + eModuleKindLibRS, + eModuleKindDriver, + eModuleKindImpl, + eModuleKindKernelObj + }; + + ~RenderScriptRuntime() override; + + // Static Functions + static void Initialize(); + + static void Terminate(); + + static lldb_private::LanguageRuntime * + CreateInstance(Process *process, lldb::LanguageType language); + + static lldb::CommandObjectSP + GetCommandObject(CommandInterpreter &interpreter); + + static lldb_private::ConstString GetPluginNameStatic(); + + static char ID; + + bool isA(const void *ClassID) const override { + return ClassID == &ID || CPPLanguageRuntime::isA(ClassID); + } + + static bool classof(const LanguageRuntime *runtime) { + return runtime->isA(&ID); + } + + static bool IsRenderScriptModule(const lldb::ModuleSP &module_sp); + + static ModuleKind GetModuleKind(const lldb::ModuleSP &module_sp); + + static void ModulesDidLoad(const lldb::ProcessSP &process_sp, + const ModuleList &module_list); + + bool GetDynamicTypeAndAddress(ValueObject &in_value, + lldb::DynamicValueType use_dynamic, + TypeAndOrName &class_type_or_name, + Address &address, + Value::ValueType &value_type) override; + + TypeAndOrName FixUpDynamicType(const TypeAndOrName &type_and_or_name, + ValueObject &static_value) override; + + bool CouldHaveDynamicValue(ValueObject &in_value) override; + + lldb::BreakpointResolverSP CreateExceptionResolver(Breakpoint *bp, + bool catch_bp, + bool throw_bp) override; + + bool LoadModule(const lldb::ModuleSP &module_sp); + + void DumpModules(Stream &strm) const; + + void DumpContexts(Stream &strm) const; + + void DumpKernels(Stream &strm) const; + + bool DumpAllocation(Stream &strm, StackFrame *frame_ptr, const uint32_t id); + + void ListAllocations(Stream &strm, StackFrame *frame_ptr, + const uint32_t index); + + bool RecomputeAllAllocations(Stream &strm, StackFrame *frame_ptr); + + bool PlaceBreakpointOnKernel( + lldb::TargetSP target, Stream &messages, const char *name, + const lldb_renderscript::RSCoordinate *coords = nullptr); + + bool PlaceBreakpointOnReduction( + lldb::TargetSP target, Stream &messages, const char *reduce_name, + const lldb_renderscript::RSCoordinate *coords = nullptr, + int kernel_types = ~(0)); + + bool PlaceBreakpointOnScriptGroup(lldb::TargetSP target, Stream &strm, + ConstString name, bool stop_on_all); + + void SetBreakAllKernels(bool do_break, lldb::TargetSP target); + + void DumpStatus(Stream &strm) const; + + void ModulesDidLoad(const ModuleList &module_list) override; + + bool LoadAllocation(Stream &strm, const uint32_t alloc_id, + const char *filename, StackFrame *frame_ptr); + + bool SaveAllocation(Stream &strm, const uint32_t alloc_id, + const char *filename, StackFrame *frame_ptr); + + void Update(); + + void Initiate(); + + const lldb_renderscript::RSScriptGroupList &GetScriptGroups() const { + return m_scriptGroups; + }; + + bool IsKnownKernel(ConstString name) { + for (const auto &module : m_rsmodules) + for (const auto &kernel : module->m_kernels) + if (kernel.m_name == name) + return true; + return false; + } + + // PluginInterface protocol + lldb_private::ConstString GetPluginName() override; + + uint32_t GetPluginVersion() override; + + static bool GetKernelCoordinate(lldb_renderscript::RSCoordinate &coord, + Thread *thread_ptr); + + bool ResolveKernelName(lldb::addr_t kernel_address, ConstString &name); + +protected: + struct ScriptDetails; + struct AllocationDetails; + struct Element; + + lldb_renderscript::RSScriptGroupList m_scriptGroups; + + void InitSearchFilter(lldb::TargetSP target) { + if (!m_filtersp) + m_filtersp.reset(new SearchFilterForUnconstrainedSearches(target)); + } + + void FixupScriptDetails(lldb_renderscript::RSModuleDescriptorSP rsmodule_sp); + + void LoadRuntimeHooks(lldb::ModuleSP module, ModuleKind kind); + + bool RefreshAllocation(AllocationDetails *alloc, StackFrame *frame_ptr); + + bool EvalRSExpression(const char *expression, StackFrame *frame_ptr, + uint64_t *result); + + lldb::BreakpointSP CreateScriptGroupBreakpoint(ConstString name, + bool multi); + + lldb::BreakpointSP CreateKernelBreakpoint(ConstString name); + + lldb::BreakpointSP CreateReductionBreakpoint(ConstString name, + int kernel_types); + + void BreakOnModuleKernels( + const lldb_renderscript::RSModuleDescriptorSP rsmodule_sp); + + struct RuntimeHook; + typedef void (RenderScriptRuntime::*CaptureStateFn)( + RuntimeHook *hook_info, + ExecutionContext &context); // Please do this! + + struct HookDefn { + const char *name; + const char *symbol_name_m32; // mangled name for the 32 bit architectures + const char *symbol_name_m64; // mangled name for the 64 bit archs + uint32_t version; + ModuleKind kind; + CaptureStateFn grabber; + }; + + struct RuntimeHook { + lldb::addr_t address; + const HookDefn *defn; + lldb::BreakpointSP bp_sp; + }; + + typedef std::shared_ptr<RuntimeHook> RuntimeHookSP; + + lldb::ModuleSP m_libRS; + lldb::ModuleSP m_libRSDriver; + lldb::ModuleSP m_libRSCpuRef; + std::vector<lldb_renderscript::RSModuleDescriptorSP> m_rsmodules; + + std::vector<std::unique_ptr<ScriptDetails>> m_scripts; + std::vector<std::unique_ptr<AllocationDetails>> m_allocations; + + std::map<lldb::addr_t, lldb_renderscript::RSModuleDescriptorSP> + m_scriptMappings; + std::map<lldb::addr_t, RuntimeHookSP> m_runtimeHooks; + std::map<lldb::user_id_t, std::unique_ptr<lldb_renderscript::RSCoordinate>> + m_conditional_breaks; + + lldb::SearchFilterSP + m_filtersp; // Needed to create breakpoints through Target API + + bool m_initiated; + bool m_debuggerPresentFlagged; + bool m_breakAllKernels; + static const HookDefn s_runtimeHookDefns[]; + static const size_t s_runtimeHookCount; + LLVMUserExpression::IRPasses *m_ir_passes; + +private: + RenderScriptRuntime(Process *process); // Call CreateInstance instead. + + static bool HookCallback(void *baton, StoppointCallbackContext *ctx, + lldb::user_id_t break_id, + lldb::user_id_t break_loc_id); + + static bool KernelBreakpointHit(void *baton, StoppointCallbackContext *ctx, + lldb::user_id_t break_id, + lldb::user_id_t break_loc_id); + + void HookCallback(RuntimeHook *hook_info, ExecutionContext &context); + + // Callback function when 'debugHintScriptGroup2' executes on the target. + void CaptureDebugHintScriptGroup2(RuntimeHook *hook_info, + ExecutionContext &context); + + void CaptureScriptInit(RuntimeHook *hook_info, ExecutionContext &context); + + void CaptureAllocationInit(RuntimeHook *hook_info, ExecutionContext &context); + + void CaptureAllocationDestroy(RuntimeHook *hook_info, + ExecutionContext &context); + + void CaptureSetGlobalVar(RuntimeHook *hook_info, ExecutionContext &context); + + void CaptureScriptInvokeForEachMulti(RuntimeHook *hook_info, + ExecutionContext &context); + + AllocationDetails *FindAllocByID(Stream &strm, const uint32_t alloc_id); + + std::shared_ptr<uint8_t> GetAllocationData(AllocationDetails *alloc, + StackFrame *frame_ptr); + + void SetElementSize(Element &elem); + + static bool GetFrameVarAsUnsigned(const lldb::StackFrameSP, + const char *var_name, uint64_t &val); + + void FindStructTypeName(Element &elem, StackFrame *frame_ptr); + + size_t PopulateElementHeaders(const std::shared_ptr<uint8_t> header_buffer, + size_t offset, const Element &elem); + + size_t CalculateElementHeaderSize(const Element &elem); + + void SetConditional(lldb::BreakpointSP bp, lldb_private::Stream &messages, + const lldb_renderscript::RSCoordinate &coord); + // + // Helper functions for jitting the runtime + // + + bool JITDataPointer(AllocationDetails *alloc, StackFrame *frame_ptr, + uint32_t x = 0, uint32_t y = 0, uint32_t z = 0); + + bool JITTypePointer(AllocationDetails *alloc, StackFrame *frame_ptr); + + bool JITTypePacked(AllocationDetails *alloc, StackFrame *frame_ptr); + + bool JITElementPacked(Element &elem, const lldb::addr_t context, + StackFrame *frame_ptr); + + bool JITAllocationSize(AllocationDetails *alloc, StackFrame *frame_ptr); + + bool JITSubelements(Element &elem, const lldb::addr_t context, + StackFrame *frame_ptr); + + bool JITAllocationStride(AllocationDetails *alloc, StackFrame *frame_ptr); + + // Search for a script detail object using a target address. + // If a script does not currently exist this function will return nullptr. + // If 'create' is true and there is no previous script with this address, + // then a new Script detail object will be created for this address and + // returned. + ScriptDetails *LookUpScript(lldb::addr_t address, bool create); + + // Search for a previously saved allocation detail object using a target + // address. + // If an allocation does not exist for this address then nullptr will be + // returned. + AllocationDetails *LookUpAllocation(lldb::addr_t address); + + // Creates a new allocation with the specified address assigning a new ID and + // removes + // any previous stored allocation which has the same address. + AllocationDetails *CreateAllocation(lldb::addr_t address); + + bool GetOverrideExprOptions(clang::TargetOptions &prototype) override; + + bool GetIRPasses(LLVMUserExpression::IRPasses &passes) override; +}; + +} // namespace lldb_private + +#endif // liblldb_RenderScriptRuntime_h_ diff --git a/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptScriptGroup.cpp b/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptScriptGroup.cpp new file mode 100644 index 000000000000..45d0d028d047 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptScriptGroup.cpp @@ -0,0 +1,160 @@ +//===-- RenderScriptScriptGroup.cpp -----------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/Breakpoint/StoppointCallbackContext.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/Interpreter/CommandInterpreter.h" +#include "lldb/Interpreter/CommandObjectMultiword.h" +#include "lldb/Interpreter/CommandReturnObject.h" +#include "lldb/Interpreter/Options.h" +#include "lldb/Symbol/Symbol.h" +#include "lldb/Symbol/Type.h" +#include "lldb/Symbol/VariableList.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/Target.h" +#include "lldb/Utility/Args.h" +#include "lldb/Utility/ConstString.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Status.h" + +#include "RenderScriptRuntime.h" +#include "RenderScriptScriptGroup.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_renderscript; + +class CommandObjectRenderScriptScriptGroupBreakpointSet + : public CommandObjectParsed { +public: + CommandObjectRenderScriptScriptGroupBreakpointSet( + CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "renderscript scriptgroup breakpoint set", + "Place a breakpoint on all kernels forming a script group.", + "renderscript scriptgroup breakpoint set <group_name>", + eCommandRequiresProcess | eCommandProcessMustBeLaunched) {} + + ~CommandObjectRenderScriptScriptGroupBreakpointSet() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + Stream &stream = result.GetOutputStream(); + RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + assert(runtime); + auto &target = m_exe_ctx.GetTargetSP(); + bool stop_on_all = false; + const llvm::StringRef long_stop_all("--stop-on-all"), short_stop_all("-a"); + std::vector<ConstString> sites; + sites.reserve(command.GetArgumentCount()); + for (size_t i = 0; i < command.GetArgumentCount(); ++i) { + const auto arg = command.GetArgumentAtIndex(i); + if (long_stop_all == arg || short_stop_all == arg) + stop_on_all = true; + else + sites.push_back(ConstString(arg)); + } + for (const auto &name : sites) { + runtime->PlaceBreakpointOnScriptGroup(target, stream, name, stop_on_all); + } + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } +}; + +class CommandObjectRenderScriptScriptGroupBreakpoint + : public CommandObjectMultiword { +public: + CommandObjectRenderScriptScriptGroupBreakpoint( + CommandInterpreter &interpreter) + : CommandObjectMultiword( + interpreter, "renderscript scriptgroup breakpoint", + "Renderscript scriptgroup breakpoint interaction.", + "renderscript scriptgroup breakpoint set [--stop-on-all/-a]" + "<scriptgroup name> ...", + eCommandRequiresProcess | eCommandProcessMustBeLaunched) { + LoadSubCommand( + "set", + CommandObjectSP(new CommandObjectRenderScriptScriptGroupBreakpointSet( + interpreter))); + } + + ~CommandObjectRenderScriptScriptGroupBreakpoint() override = default; +}; + +class CommandObjectRenderScriptScriptGroupList : public CommandObjectParsed { +public: + CommandObjectRenderScriptScriptGroupList(CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "renderscript scriptgroup list", + "List all currently discovered script groups.", + "renderscript scriptgroup list", + eCommandRequiresProcess | + eCommandProcessMustBeLaunched) {} + + ~CommandObjectRenderScriptScriptGroupList() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + Stream &stream = result.GetOutputStream(); + RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + assert(runtime); + const RSScriptGroupList &groups = runtime->GetScriptGroups(); + // print script group count + stream.Printf("%" PRIu64 " script %s", uint64_t(groups.size()), + (groups.size() == 1) ? "group" : "groups"); + stream.EOL(); + // print script group details + stream.IndentMore(); + for (const RSScriptGroupDescriptorSP &g : groups) { + if (g) { + stream.Indent(); + // script group name + stream.Printf("%s", g->m_name.AsCString()); + stream.EOL(); + // print out the kernels + stream.IndentMore(); + for (const auto &k : g->m_kernels) { + stream.Indent(); + stream.Printf(". %s", k.m_name.AsCString()); + stream.EOL(); + } + stream.IndentLess(); + } + } + stream.IndentLess(); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } +}; + +class CommandObjectRenderScriptScriptGroup : public CommandObjectMultiword { +public: + CommandObjectRenderScriptScriptGroup(CommandInterpreter &interpreter) + : CommandObjectMultiword(interpreter, "renderscript scriptgroup", + "Command set for interacting with scriptgroups.", + nullptr, eCommandRequiresProcess | + eCommandProcessMustBeLaunched) { + LoadSubCommand( + "breakpoint", + CommandObjectSP( + new CommandObjectRenderScriptScriptGroupBreakpoint(interpreter))); + LoadSubCommand( + "list", CommandObjectSP( + new CommandObjectRenderScriptScriptGroupList(interpreter))); + } + + ~CommandObjectRenderScriptScriptGroup() override = default; +}; + +lldb::CommandObjectSP NewCommandObjectRenderScriptScriptGroup( + lldb_private::CommandInterpreter &interpreter) { + return CommandObjectSP(new CommandObjectRenderScriptScriptGroup(interpreter)); +} diff --git a/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptScriptGroup.h b/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptScriptGroup.h new file mode 100644 index 000000000000..c25e240f6d52 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptScriptGroup.h @@ -0,0 +1,17 @@ +//===-- RenderScriptScriptGroup.h -------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_RenderScriptScriptGroup_h_ +#define liblldb_RenderScriptScriptGroup_h_ + +#include "lldb/Interpreter/CommandInterpreter.h" + +lldb::CommandObjectSP NewCommandObjectRenderScriptScriptGroup( + lldb_private::CommandInterpreter &interpreter); + +#endif // liblldb_RenderScriptScriptGroup_h_ diff --git a/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp b/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp new file mode 100644 index 000000000000..a6d225d2fbd8 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp @@ -0,0 +1,280 @@ +//===-- RenderScriptx86ABIFixups.cpp ----------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <set> + +#include "llvm/ADT/StringRef.h" +#include "llvm/IR/BasicBlock.h" +#include "llvm/IR/CallSite.h" +#include "llvm/IR/Constants.h" +#include "llvm/IR/Function.h" +#include "llvm/IR/Instruction.h" +#include "llvm/IR/Instructions.h" +#include "llvm/IR/Module.h" +#include "llvm/IRReader/IRReader.h" +#include "llvm/Pass.h" + +#include "lldb/Target/Process.h" +#include "lldb/Utility/Log.h" + +using namespace lldb_private; +namespace { + +bool isRSAPICall(llvm::Module &module, llvm::CallInst *call_inst) { + // TODO get the list of renderscript modules from lldb and check if + // this llvm::Module calls into any of them. + (void)module; + const auto func_name = call_inst->getCalledFunction()->getName(); + if (func_name.startswith("llvm") || func_name.startswith("lldb")) + return false; + + if (call_inst->getCalledFunction()->isIntrinsic()) + return false; + + return true; +} + +bool isRSLargeReturnCall(llvm::Module &module, llvm::CallInst *call_inst) { + // i686 and x86_64 returns for large vectors in the RenderScript API are not + // handled as normal register pairs, but as a hidden sret type. This is not + // reflected in the debug info or mangled symbol name, and the android ABI + // for x86 and x86_64, (as well as the emulators) specifies there is no AVX, + // so bcc generates an sret function because we cannot natively return + // 256 bit vectors. + // This function simply checks whether a function has a > 128bit return type. + // It is perhaps an unreliable heuristic, and relies on bcc not generating + // AVX code, so if the android ABI one day provides for AVX, this function + // may go out of fashion. + (void)module; + if (!call_inst || !call_inst->getCalledFunction()) + return false; + + return call_inst->getCalledFunction() + ->getReturnType() + ->getPrimitiveSizeInBits() > 128; +} + +bool isRSAllocationPtrTy(const llvm::Type *type) { + if (!type->isPointerTy()) + return false; + auto ptr_type = type->getPointerElementType(); + + return ptr_type->isStructTy() && + ptr_type->getStructName().startswith("struct.rs_allocation"); +} + +bool isRSAllocationTyCallSite(llvm::Module &module, llvm::CallInst *call_inst) { + (void)module; + if (!call_inst->hasByValArgument()) + return false; + for (const auto ¶m : call_inst->operand_values()) + if (isRSAllocationPtrTy(param->getType())) + return true; + return false; +} + +llvm::FunctionType *cloneToStructRetFnTy(llvm::CallInst *call_inst) { + // on x86 StructReturn functions return a pointer to the return value, rather + // than the return value itself + // [ref](http://www.agner.org/optimize/calling_conventions.pdf section 6). We + // create a return type by getting the pointer type of the old return type, + // and inserting a new initial argument of pointer type of the original + // return type. + Log *log( + GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_EXPRESSIONS)); + + assert(call_inst && "no CallInst"); + llvm::Function *orig = call_inst->getCalledFunction(); + assert(orig && "CallInst has no called function"); + llvm::FunctionType *orig_type = orig->getFunctionType(); + auto name = orig->getName(); + LLDB_LOGF(log, "%s - cloning to StructRet function for '%s'", __FUNCTION__, + name.str().c_str()); + + unsigned num_params = orig_type->getNumParams(); + std::vector<llvm::Type *> new_params{num_params + 1, nullptr}; + std::vector<llvm::Type *> params{orig_type->param_begin(), + orig_type->param_end()}; + + // This may not work if the function is somehow declared void as llvm is + // strongly typed and represents void* with i8* + assert(!orig_type->getReturnType()->isVoidTy() && + "Cannot add StructRet attribute to void function"); + llvm::PointerType *return_type_ptr_type = + llvm::PointerType::getUnqual(orig->getReturnType()); + assert(return_type_ptr_type && + "failed to get function return type PointerType"); + if (!return_type_ptr_type) + return nullptr; + + LLDB_LOGF(log, + "%s - return type pointer type for StructRet clone @ '0x%p':\n", + __FUNCTION__, (void *)return_type_ptr_type); + // put the sret pointer argument in place at the beginning of the + // argument list. + params.emplace(params.begin(), return_type_ptr_type); + assert(params.size() == num_params + 1); + return llvm::FunctionType::get(return_type_ptr_type, params, + orig->isVarArg()); +} + +bool findRSCallSites(llvm::Module &module, + std::set<llvm::CallInst *> &rs_callsites, + bool (*predicate)(llvm::Module &, llvm::CallInst *)) { + bool found = false; + + for (auto &func : module.getFunctionList()) + for (auto &block : func.getBasicBlockList()) + for (auto &inst : block) { + llvm::CallInst *call_inst = + llvm::dyn_cast_or_null<llvm::CallInst>(&inst); + if (!call_inst || !call_inst->getCalledFunction()) + // This is not the call-site you are looking for... + continue; + if (isRSAPICall(module, call_inst) && predicate(module, call_inst)) { + rs_callsites.insert(call_inst); + found = true; + } + } + return found; +} + +bool fixupX86StructRetCalls(llvm::Module &module) { + bool changed = false; + // changing a basic block while iterating over it seems to have some + // undefined behaviour going on so we find all RS callsites first, then fix + // them up after consuming the iterator. + std::set<llvm::CallInst *> rs_callsites; + if (!findRSCallSites(module, rs_callsites, isRSLargeReturnCall)) + return false; + + for (auto call_inst : rs_callsites) { + llvm::FunctionType *new_func_type = cloneToStructRetFnTy(call_inst); + assert(new_func_type && + "failed to clone functionType for Renderscript ABI fixup"); + + llvm::CallSite call_site(call_inst); + llvm::Function *func = call_inst->getCalledFunction(); + assert(func && "cannot resolve function in RenderScriptRuntime"); + // Copy the original call arguments + std::vector<llvm::Value *> new_call_args(call_site.arg_begin(), + call_site.arg_end()); + + // Allocate enough space to store the return value of the original function + // we pass a pointer to this allocation as the StructRet param, and then + // copy its value into the lldb return value + const llvm::DataLayout &DL = module.getDataLayout(); + llvm::AllocaInst *return_value_alloc = new llvm::AllocaInst( + func->getReturnType(), DL.getAllocaAddrSpace(), "var_vector_return_alloc", + call_inst); + // use the new allocation as the new first argument + new_call_args.emplace(new_call_args.begin(), + llvm::cast<llvm::Value>(return_value_alloc)); + llvm::PointerType *new_func_ptr_type = + llvm::PointerType::get(new_func_type, 0); + // Create the type cast from the old function type to the new one + llvm::Constant *new_func_cast = llvm::ConstantExpr::getCast( + llvm::Instruction::BitCast, func, new_func_ptr_type); + // create an allocation for a new function pointer + llvm::AllocaInst *new_func_ptr = + new llvm::AllocaInst(new_func_ptr_type, DL.getAllocaAddrSpace(), + "new_func_ptr", call_inst); + // store the new_func_cast to the newly allocated space + (new llvm::StoreInst(new_func_cast, new_func_ptr, call_inst)) + ->setName("new_func_ptr_load_cast"); + // load the new function address ready for a jump + llvm::LoadInst *new_func_addr_load = + new llvm::LoadInst(new_func_ptr, "load_func_pointer", call_inst); + // and create a callinstruction from it + llvm::CallInst *new_call_inst = + llvm::CallInst::Create(new_func_type, new_func_addr_load, new_call_args, + "new_func_call", call_inst); + new_call_inst->setCallingConv(call_inst->getCallingConv()); + new_call_inst->setTailCall(call_inst->isTailCall()); + llvm::LoadInst *lldb_save_result_address = + new llvm::LoadInst(return_value_alloc, "save_return_val", call_inst); + + // Now remove the old broken call + call_inst->replaceAllUsesWith(lldb_save_result_address); + call_inst->eraseFromParent(); + changed = true; + } + return changed; +} + +bool fixupRSAllocationStructByValCalls(llvm::Module &module) { + // On x86_64, calls to functions in the RS runtime that take an + // `rs_allocation` type argument are actually handled as by-ref params by + // bcc, but appear to be passed by value by lldb (the callsite all use + // `struct byval`). On x86_64 Linux, struct arguments are transferred in + // registers if the struct size is no bigger than 128bits + // [ref](http://www.agner.org/optimize/calling_conventions.pdf) section 7.1 + // "Passing and returning objects" otherwise passed on the stack. an object + // of type `rs_allocation` is actually 256bits, so should be passed on the + // stack. However, code generated by bcc actually treats formal params of + // type `rs_allocation` as `rs_allocation *` so we need to convert the + // calling convention to pass by reference, and remove any hint of byval from + // formal parameters. + bool changed = false; + std::set<llvm::CallInst *> rs_callsites; + if (!findRSCallSites(module, rs_callsites, isRSAllocationTyCallSite)) + return false; + + std::set<llvm::Function *> rs_functions; + + // for all call instructions + for (auto call_inst : rs_callsites) { + // add the called function to a set so that we can strip its byval + // attributes in another pass + rs_functions.insert(call_inst->getCalledFunction()); + + // get the function attributes + llvm::AttributeList call_attribs = call_inst->getAttributes(); + + // iterate over the argument attributes + for (unsigned I = call_attribs.index_begin(); I != call_attribs.index_end(); + I++) { + // if this argument is passed by val + if (call_attribs.hasAttribute(I, llvm::Attribute::ByVal)) { + // strip away the byval attribute + call_inst->removeAttribute(I, llvm::Attribute::ByVal); + changed = true; + } + } + } + + // for all called function decls + for (auto func : rs_functions) { + // inspect all of the arguments in the call + for (auto &arg : func->args()) { + if (arg.hasByValAttr()) { + arg.removeAttr(llvm::Attribute::ByVal); + changed = true; + } + } + } + return changed; +} +} // end anonymous namespace + +namespace lldb_private { +namespace lldb_renderscript { + +bool fixupX86FunctionCalls(llvm::Module &module) { + return fixupX86StructRetCalls(module); +} + +bool fixupX86_64FunctionCalls(llvm::Module &module) { + bool changed = false; + changed |= fixupX86StructRetCalls(module); + changed |= fixupRSAllocationStructByValCalls(module); + return changed; +} + +} // end namespace lldb_renderscript +} // end namespace lldb_private diff --git a/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.h b/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.h new file mode 100644 index 000000000000..a5efc999aea4 --- /dev/null +++ b/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.h @@ -0,0 +1,22 @@ +//===-- RenderScriptx86ABIFixups.h ------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_RENDERSCRIPT_X86_H +#define LLDB_RENDERSCRIPT_X86_H + +#include "llvm/IR/Module.h" + +namespace lldb_private { +namespace lldb_renderscript { + +bool fixupX86FunctionCalls(llvm::Module &module); + +bool fixupX86_64FunctionCalls(llvm::Module &module); +} +} +#endif |