caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c6c7bfc4d2bc37f55f57504c19d47deb7645dd76
clang-p2996/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp
Pavel Labath d821c997aa Move RegisterValue,Scalar,State from Core to Utility 
These three classes have no external dependencies, but they are used
from various low-level APIs. Moving them down to Utility improves
overall code layering (although it still does not break any particular
dependency completely).

The XCode project will need to be updated after this change.

Differential Revision: https://reviews.llvm.org/D49740

llvm-svn: 339127
2018-08-07 11:07:21 +00:00

444 lines
15 KiB
C++
Raw Blame History

//===-- AppleObjCRuntimeV1.cpp --------------------------------------*- C++
//-*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#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 <vector>
using namespace lldb;
using namespace lldb_private;
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() == false;
}
//------------------------------------------------------------------
// 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 NULL;
} else
return NULL;
}
void AppleObjCRuntimeV1::Initialize() {
PluginManager::RegisterPlugin(
GetPluginNameStatic(), "Apple Objective-C Language Runtime - Version 1",
CreateInstance);
}
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.reset(new BreakpointResolverName(
bkpt, "objc_exception_throw", 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())
log->Printf("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())
log->Printf(
"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;
}
Reference in New Issue View Git Blame Copy Permalink