{

std::string_view symbolName = symbol->GetFullNameRef();

// Symbols named `_OBJC_CLASS_$_` are references to external classes.

if (symbolName.size() > 14 && symbolName.rfind("_OBJC_CLASS_$_", 0) == 0)

return std::string(symbolName.substr(14));

// Symbols named `cls_` are classes defined in a loaded image other than

// the image currently being analyzed.

if (symbolName.size() > 4 && symbolName.rfind("cls_", 0) == 0)

return std::string(symbolName.substr(4));

return std::nullopt;

{

if (component.size() <= prefix.size() || component.rfind(prefix.data(), 0) != 0

|| !isupper(component[prefix.size()]))

{

return std::nullopt;

}

std::string result(component.substr(prefix.size()));

// Lowercase the first character if the second character is not also uppercase.

// This ensures we leave initialisms such as `URL` alone.

if (result.size() > 1 && islower(result[1]))

result[0] = tolower(result[0]);

return result;

{

// TODO: Handle other common patterns such as <do some action>With<arg>: and <do some action>For<arg>:

for (const auto& prefix : {"initWith", "with", "and", "using", "set", "read", "to", "for"})

{

if (auto argumentName = SelectorComponentWithoutPrefix(prefix, component); argumentName.has_value())

return std::move(*argumentName);

}

return component;

{

NamedTypeReferenceBuilder builder;

builder.SetName(QualifiedName(name));

return Type::NamedType(builder.Finalize());

{

auto existing = view->QueryMetadata(key);

if (!existing)

return false;

auto kv = existing->GetKeyValueStore();

auto it = kv.find("version");

if (it == kv.end())

return false;

return it->second->GetUnsignedInteger() >= currentVersion;

{

std::vector<Ref<Metadata>> combined = existing->GetArray();

if (fresh)

{

auto freshEntries = fresh->GetArray();

combined.insert(combined.end(), freshEntries.begin(), freshEntries.end());

}

return new Metadata(combined);

{

std::map<uint64_t, std::vector<uint64_t>> merged;

auto append = [&merged](const Ref<Metadata>& array) {

if (!array)

return;

for (const auto& entry : array->GetArray())

{

auto pair = entry->GetArray();

if (pair.size() != 2)

continue;

uint64_t key = pair[0]->GetUnsignedInteger();

auto& dest = merged[key];

for (uint64_t impl : pair[1]->GetUnsignedIntegerList())

{

if (std::find(dest.begin(), dest.end(), impl) == dest.end())

dest.push_back(impl);

}

}

};

append(existing);

append(fresh);

std::vector<Ref<Metadata>> result;

result.reserve(merged.size());

for (const auto& [key, impls] : merged)

{

std::vector<Ref<Metadata>> pair = {new Metadata(key), new Metadata(impls)};

result.push_back(new Metadata(pair));

}

return new Metadata(result);

{

std::map<uint64_t, std::string> merged;

auto insert = [&merged](const Ref<Metadata>& array) {

if (!array)

return;

for (const auto& entry : array->GetArray())

{

auto pair = entry->GetArray();

if (pair.size() != 2)

continue;

uint64_t key = pair[0]->GetUnsignedInteger();

merged.emplace(key, pair[1]->GetString());

}

};

insert(existing);

insert(fresh);

std::vector<Ref<Metadata>> result;

result.reserve(merged.size());

for (const auto& [key, name] : merged)

{

std::vector<Ref<Metadata>> pair = {new Metadata(key), new Metadata(name)};

result.push_back(new Metadata(pair));

}

return new Metadata(result);

{

if (!existing)

return fresh;

auto existingKv = existing->GetKeyValueStore();

// Merging records from an older metadata version would duplicate entries, as they

// describe the same locations as the fresh records. Replace them instead.

auto existingVersion = existingKv.find("version");

if (existingVersion == existingKv.end()

|| existingVersion->second->GetUnsignedInteger() != kObjCMetadataVersion)

return fresh;

auto freshKv = fresh->GetKeyValueStore();

std::map<std::string, Ref<Metadata>> merged = freshKv;

auto lookup = [](const std::map<std::string, Ref<Metadata>>& kv, const char* key) -> Ref<Metadata> {

auto it = kv.find(key);

return it != kv.end() ? it->second : nullptr;

};

for (const char* key : {"classes", "categories", "methods"})

{

if (auto existingArray = lookup(existingKv, key))

merged[key] = MergeObjCRecordsByLocation(existingArray, lookup(freshKv, key));

}

for (const char* key : {"selImplementations", "selRefImplementations"})

{

if (existingKv.count(key) || freshKv.count(key))

merged[key] = MergeSelectorImplLists(lookup(existingKv, key), lookup(freshKv, key));

}

if (existingKv.count("selRefToName") || freshKv.count("selRefToName"))

{

merged["selRefToName"] = MergeSelRefNames(

lookup(existingKv, "selRefToName"), lookup(freshKv, "selRefToName"));

}

return new Metadata(merged);

{

std::map<std::string, Ref<Metadata>> methodMeta;

methodMeta["loc"] = new Metadata(loc);

methodMeta["name"] = new Metadata(method.name);

methodMeta["types"] = new Metadata(method.types);

methodMeta["imp"] = new Metadata(method.imp);

return new Metadata(methodMeta);

{

std::map<std::string, Ref<Metadata>> clsMeta;

clsMeta["loc"] = new Metadata(loc);

clsMeta["name"] = new Metadata(cls.name);

clsMeta["typeName"] = new Metadata(cls.associatedName.GetString());

std::vector<uint64_t> instanceMethods;

std::vector<uint64_t> classMethods;

instanceMethods.reserve(cls.instanceClass.methodList.size());

classMethods.reserve(cls.metaClass.methodList.size());

for (const auto& [location, _] : cls.instanceClass.methodList)

instanceMethods.push_back(location);

clsMeta["instanceMethods"] = new Metadata(instanceMethods);

clsMeta["classMethods"] = new Metadata(classMethods);

return new Metadata(clsMeta);

{

Tasks needed = Tasks::None;

if (HasTask(requested, Tasks::Metadata) && !HasUpToDateMetadata(view))

needed |= Tasks::Metadata;

if (HasTask(requested, Tasks::Literals) && !HasUpToDateLiterals(view))

needed |= Tasks::Literals;

return needed;

{

if (HasTask(tasks, Tasks::Literals))

{

try

{

ProcessObjCLiterals();

}

catch (std::exception& ex)

{

m_logger->LogError("Failed to process Objective-C literals. Binary may be malformed");

m_logger->LogErrorF("Error: {:?}", ex.what());

}

}

if (HasTask(tasks, Tasks::Metadata))

{

try

{

ProcessObjCData();

}

catch (std::exception& ex)

{

m_logger->LogError("Failed to process Objective-C metadata. Binary may be malformed");

m_logger->LogErrorF("Error: {:?}", ex.what());

}

}

{

std::map<std::string, Ref<Metadata>> viewMeta;

viewMeta["version"] = new Metadata(kObjCMetadataVersion);

std::vector<Ref<Metadata>> classes;

classes.reserve(m_classes.size());

std::vector<Ref<Metadata>> categories;

categories.reserve(m_categories.size());

std::vector<Ref<Metadata>> methods;

methods.reserve(m_localMethods.size());

for (const auto& [clsLoc, cls] : m_classes)

classes.push_back(SerializeClass(clsLoc, cls));

viewMeta["classes"] = new Metadata(classes);

for (const auto& [catLoc, cat] : m_categories)

categories.push_back(SerializeClass(catLoc, cat));

viewMeta["categories"] = new Metadata(categories);

for (const auto& [methodLoc, method] : m_localMethods)

methods.push_back(SerializeMethod(methodLoc, method));

viewMeta["methods"] = new Metadata(methods);

// Required for workflow_objc type guessing, should be removed when that is no longer a thing.

std::vector<Ref<Metadata>> selRefToImps;

selRefToImps.reserve(m_selRefToImplementations.size());

for (const auto& [selRef, imps] : m_selRefToImplementations)

{

std::vector<Ref<Metadata>> mapBase = {new Metadata(selRef), new Metadata(imps)};

Ref<Metadata> mapObject = new Metadata(mapBase);

selRefToImps.push_back(mapObject);

}

viewMeta["selRefImplementations"] = new Metadata(selRefToImps);

std::vector<Ref<Metadata>> selToImps;

selToImps.reserve(m_selToImplementations.size());

for (const auto& [selRef, imps] : m_selToImplementations)

{

std::vector<Ref<Metadata>> mapBase = {new Metadata(selRef), new Metadata(imps)};

Ref<Metadata> mapObject = new Metadata(mapBase);

selToImps.push_back(mapObject);

}

viewMeta["selImplementations"] = new Metadata(selToImps);

std::vector<Ref<Metadata>> selRefToName;

selRefToName.reserve(m_selRefToName.size());

for (const auto& [selRef, name] : m_selRefToName)

{

std::vector<Ref<Metadata>> mapBase = {new Metadata(selRef), new Metadata(name)};

Ref<Metadata> mapObject = new Metadata(mapBase);

selRefToName.push_back(mapObject);

}

viewMeta["selRefToName"] = new Metadata(selRefToName);

// ---

return new Metadata(viewMeta);

{

std::vector<QualifiedNameOrType> result;

int pointerDepth = 0;

bool readingNamedType = false;

std::string namedType;

int readingStructDepth = 0;

std::string structType;

char last = 0;

for (char c : encodedType)

{

if (readingNamedType && c != '"')

{

namedType.push_back(c);

last = c;

continue;

}

else if (readingStructDepth > 0 && c != '{' && c != '}')

{

structType.push_back(c);

last = c;

continue;

}

if (std::isdigit(c))

continue;

QualifiedNameOrType nameOrType;

std::string qualifiedName;

switch (c)

{

case '^':

pointerDepth++;

last = c;

continue;

case '"':

if (!readingNamedType)

{

readingNamedType = true;

if (last == '@')

result.pop_back(); // We added an 'id' in the last cycle, remove it

last = c;

continue;

}

else

{

readingNamedType = false;

nameOrType.name = QualifiedName(namedType);

nameOrType.ptrCount = 1;

break;

}

case '{':

readingStructDepth++;

last = c;

continue;

case '}':

readingStructDepth--;

if (readingStructDepth < 0)

return {}; // seriously malformed type.

if (readingStructDepth == 0)

{

// TODO: Emit real struct types

nameOrType.type = Type::PointerType(m_data->GetAddressSize(), Type::VoidType());

break;

}

last = c;

continue;

case 'v':

nameOrType.type = Type::VoidType();

break;

case 'c':

nameOrType.type = Type::IntegerType(1, true);

break;

case 'A':

case 'C':

nameOrType.type = Type::IntegerType(1, false);

break;

case 's':

nameOrType.type = Type::IntegerType(2, true);

break;

case 'S':

nameOrType.type = Type::IntegerType(2, false);

break;

case 'i':

nameOrType.type = Type::IntegerType(4, true);

break;

case 'I':

nameOrType.type = Type::IntegerType(4, false);

break;

case 'l':

nameOrType.type = Type::IntegerType(4, true);

break;

case 'L':

nameOrType.type = Type::IntegerType(4, false);

break;

case 'q':

nameOrType.type = Type::IntegerType(8, true);

break;

case 'Q':

nameOrType.type = Type::IntegerType(8, false);

break;

case 'f':

nameOrType.type = Type::FloatType(4);

break;

case 'd':

nameOrType.type = Type::FloatType(8);

break;

case 'b':

case 'B':

nameOrType.type = Type::BoolType();

break;

case '*':

nameOrType.type = Type::PointerType(m_data->GetAddressSize(), Type::IntegerType(1, true));

break;

case '@':

nameOrType.type = m_types.id;

// There can be a type after this, like @"NSString", that overrides this

// The handler for " will catch it and drop this "id" entry.

break;

case ':':

nameOrType.type = m_types.sel;

break;

case '#':

qualifiedName = "objc_class_t";

break;

case '?':

if (last == '@')

{

// A pointer to a Clang block is encoded as `@?`. For now we continue to represent this

// as `id` as we cannot represent block types.

last = c;

continue;

}

[[fallthrough]];

case 'T':

nameOrType.type = Type::PointerType(8, Type::VoidType());

break;

default:

// BNLogWarn("Unknown type specifier %c", c);

last = c;

continue;

}

while (pointerDepth)

{

if (nameOrType.type)

nameOrType.type = Type::PointerType(8, nameOrType.type);

else

nameOrType.ptrCount++;

pointerDepth--;

}

if (!qualifiedName.empty())

nameOrType.name = QualifiedName(qualifiedName);

if (nameOrType.type == nullptr && nameOrType.name.IsEmpty())

{

nameOrType.type = Type::VoidType();

}

result.push_back(nameOrType);

last = c;

}

return result;

BNSymbolType type, QualifiedName typeName, const std::string& name, uint64_t addr)

{

DefineObjCSymbol(type, m_data->GetTypeByName(typeName), name, addr);

BNSymbolType type, Ref<Type> typeRef, const std::string& name, uint64_t addr)

{

if (name.size() == 0 || addr == 0)

return;

NameSpace nameSpace = m_data->GetInternalNameSpace();

if (type == ExternalSymbol)

{

nameSpace = m_data->GetExternalNameSpace();

}

Ref<Symbol> symbol = new Symbol(type, name, name, name, addr, LocalBinding, nameSpace);

uint64_t symbolAddress = symbol->GetAddress();

// Armv7/Thumb: This will rewrite the symbol's address.

// e.g. We pass in 0xc001, it will rewrite it to 0xc000 and create the function w/ the "thumb2" arch.

if (Ref<Symbol> existingSymbol = m_data->GetSymbolByAddress(symbolAddress))

m_data->UndefineAutoSymbol(existingSymbol);

Ref<Platform> targetPlatform = m_data->GetDefaultPlatform()->GetAssociatedPlatformByAddress(symbolAddress);

if (symbol->GetType() == FunctionSymbol)

{

// For thumb2 we want to get the adjusted address, we can do that using the target function.

Ref<Function> targetFunction = m_data->GetAnalysisFunction(targetPlatform, symbolAddress);

if (targetFunction && typeRef)

targetFunction->ApplyAutoDiscoveredType(typeRef);

auto adjustedSym =

new Symbol(FunctionSymbol, symbol->GetShortName(), symbol->GetFullName(), symbol->GetRawName(), symbolAddress);

m_data->DefineAutoSymbol(adjustedSym);

}

else

{

// Other symbol types can just use this, they don't need to worry about linear sweep removing them.

m_data->DefineAutoSymbolAndVariableOrFunction(targetPlatform, symbol, typeRef);

}

{

if (!classPtrSection)

return;

auto size = classPtrSection->GetEnd() - classPtrSection->GetStart();

if (size == 0)

return;

auto ptrSize = m_data->GetAddressSize();

auto ptrCount = size / ptrSize;

auto classPtrSectionStart = classPtrSection->GetStart();

for (size_t i = 0; i < ptrCount; i++)

{

Class cls;

view_ptr_t classPtr;

class_t clsStruct;

class_ro_t classRO;

bool hasValidMetaClass = false;

bool hasValidMetaClassRO = false;

class_t metaClsStruct;

class_ro_t metaClassRO;

view_ptr_t classPointerLocation = classPtrSectionStart + (i * m_data->GetAddressSize());

reader->Seek(classPointerLocation);

classPtr = ReadPointerAccountingForRelocations(reader);

reader->Seek(classPtr);

try

{

clsStruct.isa = ReadPointerAccountingForRelocations(reader);

clsStruct.super = reader->ReadPointer();

clsStruct.cache = reader->ReadPointer();

clsStruct.vtable = reader->ReadPointer();

clsStruct.data = ReadPointerAccountingForRelocations(reader);

}

catch (...)

{

m_logger->LogError("Failed to read class data at 0x%" PRIx64 " pointed to by @ 0x%" PRIx64, reader->GetOffset(),

classPointerLocation);

continue;

}

if (clsStruct.data & 1)

{

m_logger->LogInfo("Skipping class at 0x%" PRIx64 " as it contains swift types", classPtr);

continue;

}

// unset first two bits

view_ptr_t classROPtr = clsStruct.data & ~3;

reader->Seek(classROPtr);

try

{

classRO.flags = reader->Read32();

classRO.instanceStart = reader->Read32();

classRO.instanceSize = reader->Read32();

if (m_data->GetAddressSize() == 8)

classRO.reserved = reader->Read32();

classRO.ivarLayout = ReadPointerAccountingForRelocations(reader);

classRO.name = ReadPointerAccountingForRelocations(reader);

classRO.baseMethods = ReadPointerAccountingForRelocations(reader);

classRO.baseProtocols = ReadPointerAccountingForRelocations(reader);

classRO.ivars = ReadPointerAccountingForRelocations(reader);

classRO.weakIvarLayout = ReadPointerAccountingForRelocations(reader);

classRO.baseProperties = ReadPointerAccountingForRelocations(reader);

}

catch (...)

{

m_logger->LogError("Failed to read class RO data at 0x%" PRIx64 ". 0x%" PRIx64 ", objc_class_t @ 0x%" PRIx64,

reader->GetOffset(), classPointerLocation, classROPtr);

continue;

}

auto namePtr = classRO.name;

std::string name;

reader->Seek(namePtr);

try

{

name = reader->ReadCString();

}

catch (...)

{

m_logger->LogWarn(

"Failed to read class name at 0x%" PRIx64 ". Class has been given the placeholder name \"0x%" PRIx64 "\" ", namePtr,

classPtr);

char hexString[9];

hexString[8] = 0;

snprintf(hexString, sizeof(hexString), "%" PRIx64, classPtr);

name = "0x" + std::string(hexString);

}

cls.name = name;

DefineObjCSymbol(BNSymbolType::DataSymbol,

Type::PointerType(m_data->GetAddressSize(), m_data->GetTypeByName(m_typeNames.cls)), "clsPtr_" + name,

classPointerLocation);

DefineObjCSymbol(BNSymbolType::DataSymbol, m_typeNames.cls, "cls_" + name, classPtr);

DefineObjCSymbol(BNSymbolType::DataSymbol, m_typeNames.classRO, "cls_ro_" + name, classROPtr);

DefineObjCSymbol(BNSymbolType::DataSymbol, Type::ArrayType(Type::IntegerType(1, true), name.size() + 1),

"clsName_" + name, classRO.name);

if (classRO.baseProtocols && !m_skipClassBaseProtocols)

{

DefineObjCSymbol(BNSymbolType::DataSymbol, Type::NamedType(m_data, m_typeNames.protocolList),

"clsProtocols_" + name, classRO.baseProtocols);

reader->Seek(classRO.baseProtocols);

uint32_t count = reader->Read64();

view_ptr_t addr = reader->GetOffset();

for (uint32_t j = 0; j < count; j++)

{

m_data->DefineDataVariable(

addr, Type::PointerType(ptrSize, Type::NamedType(m_data, m_typeNames.protocol)));

addr += ptrSize;

}

}

if (clsStruct.isa)

{

reader->Seek(clsStruct.isa);

try

{

metaClsStruct.isa = ReadPointerAccountingForRelocations(reader);

metaClsStruct.super = reader->ReadPointer();

metaClsStruct.cache = reader->ReadPointer();

metaClsStruct.vtable = reader->ReadPointer();

metaClsStruct.data = ReadPointerAccountingForRelocations(reader) & ~1;

DefineObjCSymbol(BNSymbolType::DataSymbol, m_typeNames.cls, "metacls_" + name, clsStruct.isa);

hasValidMetaClass = true;

}

catch (...)

{

m_logger->LogWarn("Failed to read metaclass data at 0x%" PRIx64 " pointed to by objc_class_t @ 0x%" PRIx64,

reader->GetOffset(), classPtr);

}

}

if (hasValidMetaClass && (metaClsStruct.data & 1))

{

m_logger->LogInfo("Skipping metaclass at 0x%" PRIx64 " as it contains swift types", classPtr);

hasValidMetaClass = false;

}

if (hasValidMetaClass)

{

reader->Seek(metaClsStruct.data);

try

{

metaClassRO.flags = reader->Read32();

metaClassRO.instanceStart = reader->Read32();

metaClassRO.instanceSize = reader->Read32();

if (m_data->GetAddressSize() == 8)

metaClassRO.reserved = reader->Read32();

metaClassRO.ivarLayout = ReadPointerAccountingForRelocations(reader);

metaClassRO.name = ReadPointerAccountingForRelocations(reader);

metaClassRO.baseMethods = ReadPointerAccountingForRelocations(reader);

metaClassRO.baseProtocols = ReadPointerAccountingForRelocations(reader);

metaClassRO.ivars = ReadPointerAccountingForRelocations(reader);

metaClassRO.weakIvarLayout = ReadPointerAccountingForRelocations(reader);

metaClassRO.baseProperties = ReadPointerAccountingForRelocations(reader);

DefineObjCSymbol(

BNSymbolType::DataSymbol, m_typeNames.classRO, "metacls_ro_" + name, metaClsStruct.data);

hasValidMetaClassRO = true;

}

catch (...)

{

m_logger->LogWarn("Failed to read metaclass RO data at 0x%" PRIx64 " pointed to by meta objc_class_t @ 0x%" PRIx64,

reader->GetOffset(), clsStruct.isa);

}

}

if (classRO.baseMethods)

{

try

{

ReadMethodList(reader, cls.instanceClass, name, classRO.baseMethods);

}

catch (...)

{

m_logger->LogError("Failed to read the method list for class pointed to by 0x%" PRIx64, clsStruct.data);

}

}

if (hasValidMetaClassRO && metaClassRO.baseMethods)

{

try

{

ReadMethodList(reader, cls.metaClass, name, metaClassRO.baseMethods);

}

catch (...)

{

m_logger->LogError("Failed to read the method list for metaclass pointed to by 0x%" PRIx64, clsStruct.data);

}

}

if (classRO.ivars)

{

try

{

ReadIvarList(reader, cls.instanceClass, name, classRO.ivars);

}

catch (...)

{

m_logger->LogError("Failed to process ivars for class at 0x%" PRIx64, clsStruct.data);

}

}

m_classes[classPtr] = cls;

}

{

auto savedOffset = reader->GetOffset();

reader->Seek(offset);

auto target = ReadPointerAccountingForRelocations(reader);

reader->Seek(savedOffset);

if (target) {

if (auto it = m_classes.find(target); it != m_classes.end())

return it->second.name;

// Classes defined in other images are looked up by their symbol name.

// This is common for cross-image references in the shared cache.

if (auto symbol = GetSymbol(target))

{

if (auto className = ClassNameFromSymbolName(symbol))

return *className;

}

}

// If there's no target, or we can't find a symbol for it, check whether the pointer has a relocation

// that contains a symbol. This is the case for cross-image references outside of the shared cache.

for (const auto& relocation : m_data->GetRelocationsAt(offset))

{

if (auto symbol = relocation->GetSymbol())

return ClassNameFromSymbolName(symbol);

}

return std::nullopt;

{

if (!classPtrSection)

return;

auto size = classPtrSection->GetEnd() - classPtrSection->GetStart();

if (size == 0)

return;

auto ptrSize = m_data->GetAddressSize();

auto classPtrSectionStart = classPtrSection->GetStart();

auto classPtrSectionEnd = classPtrSection->GetEnd();

auto catType = Type::NamedType(m_data, m_typeNames.category);

auto ptrType = Type::PointerType(m_data->GetDefaultArchitecture(), catType);

for (size_t i = classPtrSectionStart; i < classPtrSectionEnd; i += ptrSize)

{

Class category;

category_t cat;

reader->Seek(i);

auto catLocation = ReadPointerAccountingForRelocations(reader);

reader->Seek(catLocation);

try

{

cat.name = ReadPointerAccountingForRelocations(reader);

cat.cls = ReadPointerAccountingForRelocations(reader);

cat.instanceMethods = ReadPointerAccountingForRelocations(reader);

cat.classMethods = ReadPointerAccountingForRelocations(reader);

cat.protocols = ReadPointerAccountingForRelocations(reader);

cat.instanceProperties = ReadPointerAccountingForRelocations(reader);

}

catch (...)

{

m_logger->LogError("Failed to read category pointed to by 0x%zx", i);

continue;

}

std::string categoryAdditionsName;

std::string categoryBaseClassName =

ClassNameForTargetOfPointerAt(reader, catLocation + ptrSize).value_or(std::string());

if (categoryBaseClassName.empty())

{

m_logger->LogInfo("Using base address as stand-in classname for category at 0x%" PRIx64, catLocation);

categoryBaseClassName = fmt::format("{:x}", catLocation);

}

try

{

reader->Seek(cat.name);

categoryAdditionsName = reader->ReadCString();

}

catch (...)

{

m_logger->LogWarn(

"Failed to read category name for category at 0x%" PRIx64 ". Using base address as stand-in category name",

catLocation);

categoryAdditionsName = fmt::format("{:x}", catLocation);

}

category.name = categoryBaseClassName + " (" + categoryAdditionsName + ")";

DefineObjCSymbol(BNSymbolType::DataSymbol, ptrType, "categoryPtr_" + category.name, i);

DefineObjCSymbol(BNSymbolType::DataSymbol, catType, "category_" + category.name, catLocation);

if (cat.instanceMethods)

{

try

{

ReadMethodList(reader, category.instanceClass, category.name, cat.instanceMethods);

}

catch (...)

{

m_logger->LogError(

"Failed to read the instance method list for category pointed to by 0x%" PRIx64, catLocation);

}

}

if (cat.classMethods)

{

try

{

ReadMethodList(reader, category.metaClass, category.name, cat.classMethods);

}

catch (...)

{

m_logger->LogError(

"Failed to read the class method list for category pointed to by 0x%" PRIx64, catLocation);

}

}

m_categories[catLocation] = category;

}

{

if (!listSection)

return;

auto size = listSection->GetEnd() - listSection->GetStart();

if (size == 0)

return;

auto ptrSize = m_data->GetAddressSize();

auto listSectionStart = listSection->GetStart();

auto listSectionEnd = listSection->GetEnd();

auto protocolType = Type::NamedType(m_data, m_typeNames.protocol);

auto ptrType = Type::PointerType(m_data->GetDefaultArchitecture(), protocolType);

for (size_t i = listSectionStart; i < listSectionEnd; i += ptrSize)

{

protocol_t protocol;

reader->Seek(i);

auto protocolLocation = ReadPointerAccountingForRelocations(reader);

reader->Seek(protocolLocation);

try

{

protocol.isa = ReadPointerAccountingForRelocations(reader);

protocol.mangledName = ReadPointerAccountingForRelocations(reader);

protocol.protocols = ReadPointerAccountingForRelocations(reader);

protocol.instanceMethods = ReadPointerAccountingForRelocations(reader);

protocol.classMethods = ReadPointerAccountingForRelocations(reader);

protocol.optionalInstanceMethods = ReadPointerAccountingForRelocations(reader);

protocol.optionalClassMethods = ReadPointerAccountingForRelocations(reader);

protocol.instanceProperties = ReadPointerAccountingForRelocations(reader);

}

catch (...)

{

m_logger->LogError("Failed to read protocol pointed to by 0x%zx", i);

continue;

}

std::string protocolName;

try

{

reader->Seek(protocol.mangledName);

protocolName = reader->ReadCString();

DefineObjCSymbol(BNSymbolType::DataSymbol,

Type::ArrayType(Type::IntegerType(1, true), protocolName.size() + 1), "protocolName_" + protocolName,

protocol.mangledName);

}

catch (...)

{

m_logger->LogError(

"Failed to read protocol name for protocol at 0x%" PRIx64 ". Using base address as stand-in protocol name",

protocolLocation);

protocolName = fmt::format("{:x}", protocolLocation);

}

Protocol protocolClass;

protocolClass.name = protocolName;

DefineObjCSymbol(BNSymbolType::DataSymbol, ptrType, "protocolPtr_" + protocolName, i);

DefineObjCSymbol(BNSymbolType::DataSymbol, protocolType, "protocol_" + protocolName, protocolLocation);

if (protocol.protocols)

{

DefineObjCSymbol(BNSymbolType::DataSymbol, Type::NamedType(m_data, m_typeNames.protocolList),

"protoProtocols_" + protocolName, protocol.protocols);

reader->Seek(protocol.protocols);

uint32_t count = reader->Read64();

if (count > MAX_PROTOCOL_COUNT)

{

m_logger->LogWarn("List of protocols at 0x%" PRIx64 " has too large a count of 0x%x, skipping...", protocol.protocols, count);

continue;

}

view_ptr_t addr = reader->GetOffset();

for (uint32_t j = 0; j < count; j++)

{

m_data->DefineDataVariable(

addr, Type::PointerType(ptrSize, Type::NamedType(m_data, m_typeNames.protocol)));

addr += ptrSize;

}

}

if (protocol.instanceMethods)

{

try

{

ReadMethodList(reader, protocolClass.instanceMethods, protocolName, protocol.instanceMethods);

}

catch (...)

{

m_logger->LogError(

"Failed to read the instance method list for protocol pointed to by 0x%" PRIx64, protocolLocation);

}

}

if (protocol.classMethods)

{

try

{

ReadMethodList(reader, protocolClass.classMethods, protocolName, protocol.classMethods);

}

catch (...)