{

uint32_t magic;

uint32_t version;

uint32_t lineCount;

uint32_t id; // executable's id, offset in string table

uint32_t os;

uint32_t arch;

{

uint64_t address;

uint32_t methodIndex;

uint32_t fileName; // Reference to the managed source file name in the string table

uint32_t line; // Managed line number

uint32_t parent;

{

void* debugSymbolData;

const usymliteLine* lines;

const char* strings;

usymliteHeader header;

std::string uuid;

std::string os;

std::string arch;

uint64_t firstLineAddress;

uint64_t lastLineAddress;

uint32_t maxStringIndex;

{

#if IL2CPP_TARGET_ARM64

return PathUtils::Combine(utils::Runtime::GetDataDir(), std::string("arm64"));

#elif IL2CPP_TARGET_X64

return PathUtils::Combine(utils::Runtime::GetDataDir(), std::string("x64"));

#else

return std::string("<NotImplemented>");

#endif

{

uint32_t head = 0;

uint32_t tail = s_usym.header.lineCount - 1;

while (head < tail)

{

uint32_t mid = (head + tail + 1) / 2;

uint64_t midAddr = s_usym.lines[mid].address;

if (address < midAddr)

{

tail = mid - 1;

}

else

{

head = mid;

}

}

uint64_t foundAddr = s_usym.lines[head].address;

// Find the last entry with this address

while (head + 1 < s_usym.header.lineCount && s_usym.lines[head + 1].address == foundAddr)

{

head += 1;

}

return s_usym.lines[head];

{

// You may want to change this to be a full path so it is easy to locate.

FILE* dumpFile = fopen("usymData.txt", "w");

uint64_t imageBase = (uint64_t)os::Image::GetImageBase();

for (uint32_t i = 0; i < s_usym.header.lineCount; i++)

{

if (s_usym.lines[i].methodIndex != noLine)

{

uint64_t address = s_usym.lines[i].address;

void* actualAddress = (void*)(s_usym.lines[i].address + imageBase);

const MethodInfo* methodInfo = vm::GlobalMetadata::GetMethodInfoFromMethodDefinitionIndex(s_usym.lines[i].methodIndex);

uint32_t methodIndex = s_usym.lines[i].methodIndex;

const char* filePath = GetString(s_usym.lines[i].fileName);

uint32_t sourceCodeLineNumber = s_usym.lines[i].line;

uint32_t parent = s_usym.lines[i].parent;

if (methodInfo != NULL)

fprintf(dumpFile, "%d [%p, %llu] Method Index: %d %s %s(%d) parent: %d\n", i, actualAddress, address, methodIndex, vm::Method::GetFullName(methodInfo).c_str(), filePath, sourceCodeLineNumber, parent);

}

}

fclose(dumpFile);

{

int error = 0;

std::string symbolsPath;

const StringView<char> symbolFileName = "il2cpp.usym";

// First, look for the symbol file next to the executable.

std::string applicationFolder = os::Path::GetApplicationFolder();

if (!applicationFolder.empty())

symbolsPath = PathUtils::Combine(applicationFolder, symbolFileName);

os::FileHandle* symbolsFileHandle = NULL;

if (!symbolsPath.empty())

symbolsFileHandle = os::File::Open(symbolsPath.c_str(), kFileModeOpen, kFileAccessRead, kFileShareRead, kFileOptionsNone, &error);

// (MacOS only) - Handle cases where the il2cpp.usym file's been dropped under an architecture specific (x64 or arm64) directory

if (symbolsPath.empty() || error != 0)

{

std::string archFolder = GetArchFolder();

if (!archFolder.empty())

symbolsPath = PathUtils::Combine(archFolder, symbolFileName);

if (!symbolsPath.empty())

symbolsFileHandle = os::File::Open(symbolsPath.c_str(), kFileModeOpen, kFileAccessRead, kFileShareRead, kFileOptionsNone, &error);

}

// If we don't have a symbol path yet or there was some error opening the file next to the executable, try to

// look in the data directory. For some platforms, the packaging won't allow the file to live next to the

// executable.

if (symbolsPath.empty() || error != 0)

{

symbolsPath = PathUtils::Combine(utils::Runtime::GetDataDir(), symbolFileName);

symbolsFileHandle = os::File::Open(symbolsPath.c_str(), kFileModeOpen, kFileAccessRead, kFileShareRead, kFileOptionsNone, &error);

if (error != 0)

return false;

}

s_usym.debugSymbolData = utils::MemoryMappedFile::Map(symbolsFileHandle);

int64_t length = os::File::GetLength(symbolsFileHandle, &error);

os::File::Close(symbolsFileHandle, &error);

if (error != 0)

{

utils::MemoryMappedFile::Unmap(s_usym.debugSymbolData);

s_usym.debugSymbolData = NULL;

return false;

}

s_usym.header = *(usymliteHeader *)((char *)s_usym.debugSymbolData);

if (s_usym.header.magic != magicUsymlite || s_usym.header.lineCount == 0)

{

utils::MemoryMappedFile::Unmap(s_usym.debugSymbolData);

s_usym.debugSymbolData = NULL;

return false;

}

int64_t lineOffset = headerSize;

int64_t stringOffset = lineOffset + (s_usym.header.lineCount * lineSize);

s_usym.maxStringIndex = (uint32_t)(length - stringOffset);

s_usym.lines = (const usymliteLine*)((const char *)s_usym.debugSymbolData + lineOffset);

s_usym.strings = ((const char *)s_usym.debugSymbolData + stringOffset);

#if IL2CPP_ENABLE_NATIVE_INSTRUCTION_POINTER_EMISSION

char* our_uuid = os::Image::GetImageUUID();

s_usym.uuid = std::string(GetString(s_usym.header.id));

if (our_uuid == NULL || s_usym.uuid != our_uuid)

{

// UUID mismatch means this usymfile is not for this program

il2cpp::utils::Logging::Write("Ignoring symbol file due to UUID mismatch. File contains %s but expected %s.", s_usym.uuid.c_str(), our_uuid);

utils::MemoryMappedFile::Unmap(s_usym.debugSymbolData);

s_usym.debugSymbolData = NULL;

s_usym.lines = NULL;

s_usym.strings = NULL;

return false;

}

IL2CPP_FREE(our_uuid);

#endif

s_usym.os = std::string(GetString(s_usym.header.os));

s_usym.arch = std::string(GetString(s_usym.header.arch));

s_usym.firstLineAddress = s_usym.lines[0].address;

s_usym.lastLineAddress = s_usym.lines[s_usym.header.lineCount - 1].address;

#if IL2CPP_DEBUG_DUMP_USYM_DATA

DumpUsymData();

#endif

return true;

{

if (line.parent != noLine)

{

InsertStackFrame(s_usym.lines[line.parent], stackFrames);

}

const MethodInfo* methodInfo = vm::GlobalMetadata::GetMethodInfoFromMethodDefinitionIndex(line.methodIndex);

Il2CppStackFrameInfo frameInfo = { 0 };

frameInfo.method = methodInfo;

frameInfo.raw_ip = (uintptr_t)line.address;

frameInfo.filePath = GetString(line.fileName);

frameInfo.sourceCodeLineNumber = line.line;

stackFrames->push_back(frameInfo);

{

if (s_usym.debugSymbolData == NULL || address == NULL)

{

return false;

}

// The instruction pointer points to the next address, so to get the address we came from, we subtract 1.

// findLine matches the address to the closest address <= the one we give, so it finds the one we need

uint64_t adjustedAddress = ((uint64_t)address) - ((uint64_t)os::Image::GetImageBase()) - 1;

#if IL2CPP_TARGET_ANDROID

// We don't seem to need to subtract by one for Android

// https://github.com/Unity-Technologies/unity-services-crash/commit/50611fcf29a1d876689942ed1f1cdca23e32c522

adjustedAddress += 1;

#endif

#if IL2CPP_TARGET_ARM64E

adjustedAddress = (uint64_t)ptrauth_strip((void*)adjustedAddress, ptrauth_key_return_address);

#endif

// Quick check to remove anything outside the range

if (adjustedAddress < s_usym.firstLineAddress || s_usym.lastLineAddress < adjustedAddress)

{

return false;

}

line = FindLine(adjustedAddress);

// End of symbol entries are placed to indicate that we're past the end of a C# function.

// These EOS entries have their Line and FileName set to 0xFFFFFFFF

if (line.line == noLine)

{

return false;

}

return true;

{

usymliteLine line;

if (!GetUsymLine(nativeInstructionPointer, line))

{

return false;

}

sourceLocation.filePath = GetString(line.fileName);

sourceLocation.lineNumber = line.line;

return true;

{

usymliteLine line;

if (!GetUsymLine(nativeInstructionPointer, line))

{

return false;

}

InsertStackFrame(line, stackFrames);

return true;

{

/*

return true;