1 //===-- LLVMSymbolize.cpp -------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // Implementation for LLVM symbolization library. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/DebugInfo/Symbolize/Symbolize.h" 15 16 #include "SymbolizableObjectFile.h" 17 18 #include "llvm/ADT/STLExtras.h" 19 #include "llvm/Config/config.h" 20 #include "llvm/DebugInfo/DWARF/DWARFContext.h" 21 #include "llvm/DebugInfo/PDB/PDB.h" 22 #include "llvm/DebugInfo/PDB/PDBContext.h" 23 #include "llvm/Object/ELFObjectFile.h" 24 #include "llvm/Object/MachO.h" 25 #include "llvm/Object/MachOUniversal.h" 26 #include "llvm/Support/COFF.h" 27 #include "llvm/Support/Casting.h" 28 #include "llvm/Support/Compression.h" 29 #include "llvm/Support/DataExtractor.h" 30 #include "llvm/Support/Errc.h" 31 #include "llvm/Support/FileSystem.h" 32 #include "llvm/Support/MemoryBuffer.h" 33 #include "llvm/Support/Path.h" 34 #include <stdlib.h> 35 36 #if defined(_MSC_VER) 37 #include <Windows.h> 38 #include <DbgHelp.h> 39 #pragma comment(lib, "dbghelp.lib") 40 41 // Windows.h conflicts with our COFF header definitions. 42 #ifdef IMAGE_FILE_MACHINE_I386 43 #undef IMAGE_FILE_MACHINE_I386 44 #endif 45 #endif 46 47 namespace llvm { 48 namespace symbolize { 49 50 ErrorOr<DILineInfo> LLVMSymbolizer::symbolizeCode(const std::string &ModuleName, 51 uint64_t ModuleOffset) { 52 auto InfoOrErr = getOrCreateModuleInfo(ModuleName); 53 if (auto EC = InfoOrErr.getError()) 54 return EC; 55 SymbolizableModule *Info = InfoOrErr.get(); 56 57 // If the user is giving us relative addresses, add the preferred base of the 58 // object to the offset before we do the query. It's what DIContext expects. 59 if (Opts.RelativeAddresses) 60 ModuleOffset += Info->getModulePreferredBase(); 61 62 DILineInfo LineInfo = Info->symbolizeCode(ModuleOffset, Opts.PrintFunctions, 63 Opts.UseSymbolTable); 64 if (Opts.Demangle) 65 LineInfo.FunctionName = DemangleName(LineInfo.FunctionName, Info); 66 return LineInfo; 67 } 68 69 ErrorOr<DIInliningInfo> 70 LLVMSymbolizer::symbolizeInlinedCode(const std::string &ModuleName, 71 uint64_t ModuleOffset) { 72 auto InfoOrErr = getOrCreateModuleInfo(ModuleName); 73 if (auto EC = InfoOrErr.getError()) 74 return EC; 75 SymbolizableModule *Info = InfoOrErr.get(); 76 77 // If the user is giving us relative addresses, add the preferred base of the 78 // object to the offset before we do the query. It's what DIContext expects. 79 if (Opts.RelativeAddresses) 80 ModuleOffset += Info->getModulePreferredBase(); 81 82 DIInliningInfo InlinedContext = Info->symbolizeInlinedCode( 83 ModuleOffset, Opts.PrintFunctions, Opts.UseSymbolTable); 84 if (Opts.Demangle) { 85 for (int i = 0, n = InlinedContext.getNumberOfFrames(); i < n; i++) { 86 auto *Frame = InlinedContext.getMutableFrame(i); 87 Frame->FunctionName = DemangleName(Frame->FunctionName, Info); 88 } 89 } 90 return InlinedContext; 91 } 92 93 ErrorOr<DIGlobal> LLVMSymbolizer::symbolizeData(const std::string &ModuleName, 94 uint64_t ModuleOffset) { 95 auto InfoOrErr = getOrCreateModuleInfo(ModuleName); 96 if (auto EC = InfoOrErr.getError()) 97 return EC; 98 SymbolizableModule *Info = InfoOrErr.get(); 99 100 // If the user is giving us relative addresses, add the preferred base of 101 // the object to the offset before we do the query. It's what DIContext 102 // expects. 103 if (Opts.RelativeAddresses) 104 ModuleOffset += Info->getModulePreferredBase(); 105 106 DIGlobal Global = Info->symbolizeData(ModuleOffset); 107 if (Opts.Demangle) 108 Global.Name = DemangleName(Global.Name, Info); 109 return Global; 110 } 111 112 void LLVMSymbolizer::flush() { 113 ObjectForUBPathAndArch.clear(); 114 BinaryForPath.clear(); 115 ObjectPairForPathArch.clear(); 116 Modules.clear(); 117 } 118 119 // For Path="/path/to/foo" and Basename="foo" assume that debug info is in 120 // /path/to/foo.dSYM/Contents/Resources/DWARF/foo. 121 // For Path="/path/to/bar.dSYM" and Basename="foo" assume that debug info is in 122 // /path/to/bar.dSYM/Contents/Resources/DWARF/foo. 123 static 124 std::string getDarwinDWARFResourceForPath( 125 const std::string &Path, const std::string &Basename) { 126 SmallString<16> ResourceName = StringRef(Path); 127 if (sys::path::extension(Path) != ".dSYM") { 128 ResourceName += ".dSYM"; 129 } 130 sys::path::append(ResourceName, "Contents", "Resources", "DWARF"); 131 sys::path::append(ResourceName, Basename); 132 return ResourceName.str(); 133 } 134 135 static bool checkFileCRC(StringRef Path, uint32_t CRCHash) { 136 ErrorOr<std::unique_ptr<MemoryBuffer>> MB = 137 MemoryBuffer::getFileOrSTDIN(Path); 138 if (!MB) 139 return false; 140 return !zlib::isAvailable() || CRCHash == zlib::crc32(MB.get()->getBuffer()); 141 } 142 143 static bool findDebugBinary(const std::string &OrigPath, 144 const std::string &DebuglinkName, uint32_t CRCHash, 145 std::string &Result) { 146 std::string OrigRealPath = OrigPath; 147 #if defined(HAVE_REALPATH) 148 if (char *RP = realpath(OrigPath.c_str(), nullptr)) { 149 OrigRealPath = RP; 150 free(RP); 151 } 152 #endif 153 SmallString<16> OrigDir(OrigRealPath); 154 llvm::sys::path::remove_filename(OrigDir); 155 SmallString<16> DebugPath = OrigDir; 156 // Try /path/to/original_binary/debuglink_name 157 llvm::sys::path::append(DebugPath, DebuglinkName); 158 if (checkFileCRC(DebugPath, CRCHash)) { 159 Result = DebugPath.str(); 160 return true; 161 } 162 // Try /path/to/original_binary/.debug/debuglink_name 163 DebugPath = OrigRealPath; 164 llvm::sys::path::append(DebugPath, ".debug", DebuglinkName); 165 if (checkFileCRC(DebugPath, CRCHash)) { 166 Result = DebugPath.str(); 167 return true; 168 } 169 // Try /usr/lib/debug/path/to/original_binary/debuglink_name 170 DebugPath = "/usr/lib/debug"; 171 llvm::sys::path::append(DebugPath, llvm::sys::path::relative_path(OrigDir), 172 DebuglinkName); 173 if (checkFileCRC(DebugPath, CRCHash)) { 174 Result = DebugPath.str(); 175 return true; 176 } 177 return false; 178 } 179 180 static bool getGNUDebuglinkContents(const ObjectFile *Obj, std::string &DebugName, 181 uint32_t &CRCHash) { 182 if (!Obj) 183 return false; 184 for (const SectionRef &Section : Obj->sections()) { 185 StringRef Name; 186 Section.getName(Name); 187 Name = Name.substr(Name.find_first_not_of("._")); 188 if (Name == "gnu_debuglink") { 189 StringRef Data; 190 Section.getContents(Data); 191 DataExtractor DE(Data, Obj->isLittleEndian(), 0); 192 uint32_t Offset = 0; 193 if (const char *DebugNameStr = DE.getCStr(&Offset)) { 194 // 4-byte align the offset. 195 Offset = (Offset + 3) & ~0x3; 196 if (DE.isValidOffsetForDataOfSize(Offset, 4)) { 197 DebugName = DebugNameStr; 198 CRCHash = DE.getU32(&Offset); 199 return true; 200 } 201 } 202 break; 203 } 204 } 205 return false; 206 } 207 208 static 209 bool darwinDsymMatchesBinary(const MachOObjectFile *DbgObj, 210 const MachOObjectFile *Obj) { 211 ArrayRef<uint8_t> dbg_uuid = DbgObj->getUuid(); 212 ArrayRef<uint8_t> bin_uuid = Obj->getUuid(); 213 if (dbg_uuid.empty() || bin_uuid.empty()) 214 return false; 215 return !memcmp(dbg_uuid.data(), bin_uuid.data(), dbg_uuid.size()); 216 } 217 218 ObjectFile *LLVMSymbolizer::lookUpDsymFile(const std::string &ExePath, 219 const MachOObjectFile *MachExeObj, const std::string &ArchName) { 220 // On Darwin we may find DWARF in separate object file in 221 // resource directory. 222 std::vector<std::string> DsymPaths; 223 StringRef Filename = sys::path::filename(ExePath); 224 DsymPaths.push_back(getDarwinDWARFResourceForPath(ExePath, Filename)); 225 for (const auto &Path : Opts.DsymHints) { 226 DsymPaths.push_back(getDarwinDWARFResourceForPath(Path, Filename)); 227 } 228 for (const auto &Path : DsymPaths) { 229 auto DbgObjOrErr = getOrCreateObject(Path, ArchName); 230 if (!DbgObjOrErr) 231 continue; 232 ObjectFile *DbgObj = DbgObjOrErr.get(); 233 const MachOObjectFile *MachDbgObj = dyn_cast<const MachOObjectFile>(DbgObj); 234 if (!MachDbgObj) 235 continue; 236 if (darwinDsymMatchesBinary(MachDbgObj, MachExeObj)) 237 return DbgObj; 238 } 239 return nullptr; 240 } 241 242 ObjectFile *LLVMSymbolizer::lookUpDebuglinkObject(const std::string &Path, 243 const ObjectFile *Obj, 244 const std::string &ArchName) { 245 std::string DebuglinkName; 246 uint32_t CRCHash; 247 std::string DebugBinaryPath; 248 if (!getGNUDebuglinkContents(Obj, DebuglinkName, CRCHash)) 249 return nullptr; 250 if (!findDebugBinary(Path, DebuglinkName, CRCHash, DebugBinaryPath)) 251 return nullptr; 252 auto DbgObjOrErr = getOrCreateObject(DebugBinaryPath, ArchName); 253 if (!DbgObjOrErr) 254 return nullptr; 255 return DbgObjOrErr.get(); 256 } 257 258 ErrorOr<LLVMSymbolizer::ObjectPair> 259 LLVMSymbolizer::getOrCreateObjectPair(const std::string &Path, 260 const std::string &ArchName) { 261 const auto &I = ObjectPairForPathArch.find(std::make_pair(Path, ArchName)); 262 if (I != ObjectPairForPathArch.end()) 263 return I->second; 264 265 auto ObjOrErr = getOrCreateObject(Path, ArchName); 266 if (auto EC = ObjOrErr.getError()) { 267 ObjectPairForPathArch.insert( 268 std::make_pair(std::make_pair(Path, ArchName), EC)); 269 return EC; 270 } 271 272 ObjectFile *Obj = ObjOrErr.get(); 273 assert(Obj != nullptr); 274 ObjectFile *DbgObj = nullptr; 275 276 if (auto MachObj = dyn_cast<const MachOObjectFile>(Obj)) 277 DbgObj = lookUpDsymFile(Path, MachObj, ArchName); 278 if (!DbgObj) 279 DbgObj = lookUpDebuglinkObject(Path, Obj, ArchName); 280 if (!DbgObj) 281 DbgObj = Obj; 282 ObjectPair Res = std::make_pair(Obj, DbgObj); 283 ObjectPairForPathArch.insert( 284 std::make_pair(std::make_pair(Path, ArchName), Res)); 285 return Res; 286 } 287 288 ErrorOr<ObjectFile *> 289 LLVMSymbolizer::getOrCreateObject(const std::string &Path, 290 const std::string &ArchName) { 291 const auto &I = BinaryForPath.find(Path); 292 Binary *Bin = nullptr; 293 if (I == BinaryForPath.end()) { 294 ErrorOr<OwningBinary<Binary>> BinOrErr = createBinary(Path); 295 if (auto EC = BinOrErr.getError()) { 296 BinaryForPath.insert(std::make_pair(Path, EC)); 297 return EC; 298 } 299 Bin = BinOrErr->getBinary(); 300 BinaryForPath.insert(std::make_pair(Path, std::move(BinOrErr.get()))); 301 } else if (auto EC = I->second.getError()) { 302 return EC; 303 } else { 304 Bin = I->second->getBinary(); 305 } 306 307 assert(Bin != nullptr); 308 309 if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(Bin)) { 310 const auto &I = ObjectForUBPathAndArch.find(std::make_pair(Path, ArchName)); 311 if (I != ObjectForUBPathAndArch.end()) { 312 if (auto EC = I->second.getError()) 313 return EC; 314 return I->second->get(); 315 } 316 ErrorOr<std::unique_ptr<ObjectFile>> ObjOrErr = 317 UB->getObjectForArch(ArchName); 318 if (auto EC = ObjOrErr.getError()) { 319 ObjectForUBPathAndArch.insert( 320 std::make_pair(std::make_pair(Path, ArchName), EC)); 321 return EC; 322 } 323 ObjectFile *Res = ObjOrErr->get(); 324 ObjectForUBPathAndArch.insert(std::make_pair(std::make_pair(Path, ArchName), 325 std::move(ObjOrErr.get()))); 326 return Res; 327 } 328 if (Bin->isObject()) { 329 return cast<ObjectFile>(Bin); 330 } 331 return object_error::arch_not_found; 332 } 333 334 ErrorOr<SymbolizableModule *> 335 LLVMSymbolizer::getOrCreateModuleInfo(const std::string &ModuleName) { 336 const auto &I = Modules.find(ModuleName); 337 if (I != Modules.end()) { 338 auto &InfoOrErr = I->second; 339 if (auto EC = InfoOrErr.getError()) 340 return EC; 341 return InfoOrErr->get(); 342 } 343 std::string BinaryName = ModuleName; 344 std::string ArchName = Opts.DefaultArch; 345 size_t ColonPos = ModuleName.find_last_of(':'); 346 // Verify that substring after colon form a valid arch name. 347 if (ColonPos != std::string::npos) { 348 std::string ArchStr = ModuleName.substr(ColonPos + 1); 349 if (Triple(ArchStr).getArch() != Triple::UnknownArch) { 350 BinaryName = ModuleName.substr(0, ColonPos); 351 ArchName = ArchStr; 352 } 353 } 354 auto ObjectsOrErr = getOrCreateObjectPair(BinaryName, ArchName); 355 if (auto EC = ObjectsOrErr.getError()) { 356 // Failed to find valid object file. 357 Modules.insert(std::make_pair(ModuleName, EC)); 358 return EC; 359 } 360 ObjectPair Objects = ObjectsOrErr.get(); 361 362 std::unique_ptr<DIContext> Context; 363 if (auto CoffObject = dyn_cast<COFFObjectFile>(Objects.first)) { 364 // If this is a COFF object, assume it contains PDB debug information. If 365 // we don't find any we will fall back to the DWARF case. 366 std::unique_ptr<IPDBSession> Session; 367 PDB_ErrorCode Error = loadDataForEXE(PDB_ReaderType::DIA, 368 Objects.first->getFileName(), Session); 369 if (Error == PDB_ErrorCode::Success) { 370 Context.reset(new PDBContext(*CoffObject, std::move(Session))); 371 } 372 } 373 if (!Context) 374 Context.reset(new DWARFContextInMemory(*Objects.second)); 375 assert(Context); 376 auto InfoOrErr = 377 SymbolizableObjectFile::create(Objects.first, std::move(Context)); 378 auto InsertResult = 379 Modules.insert(std::make_pair(ModuleName, std::move(InfoOrErr))); 380 assert(InsertResult.second); 381 if (auto EC = InsertResult.first->second.getError()) 382 return EC; 383 return InsertResult.first->second->get(); 384 } 385 386 // Undo these various manglings for Win32 extern "C" functions: 387 // cdecl - _foo 388 // stdcall - _foo@12 389 // fastcall - @foo@12 390 // vectorcall - foo@@12 391 // These are all different linkage names for 'foo'. 392 static StringRef demanglePE32ExternCFunc(StringRef SymbolName) { 393 // Remove any '_' or '@' prefix. 394 char Front = SymbolName.empty() ? '\0' : SymbolName[0]; 395 if (Front == '_' || Front == '@') 396 SymbolName = SymbolName.drop_front(); 397 398 // Remove any '@[0-9]+' suffix. 399 if (Front != '?') { 400 size_t AtPos = SymbolName.rfind('@'); 401 if (AtPos != StringRef::npos && 402 std::all_of(SymbolName.begin() + AtPos + 1, SymbolName.end(), 403 [](char C) { return C >= '0' && C <= '9'; })) { 404 SymbolName = SymbolName.substr(0, AtPos); 405 } 406 } 407 408 // Remove any ending '@' for vectorcall. 409 if (SymbolName.endswith("@")) 410 SymbolName = SymbolName.drop_back(); 411 412 return SymbolName; 413 } 414 415 #if !defined(_MSC_VER) 416 // Assume that __cxa_demangle is provided by libcxxabi (except for Windows). 417 extern "C" char *__cxa_demangle(const char *mangled_name, char *output_buffer, 418 size_t *length, int *status); 419 #endif 420 421 std::string LLVMSymbolizer::DemangleName(const std::string &Name, 422 const SymbolizableModule *ModInfo) { 423 #if !defined(_MSC_VER) 424 // We can spoil names of symbols with C linkage, so use an heuristic 425 // approach to check if the name should be demangled. 426 if (Name.substr(0, 2) == "_Z") { 427 int status = 0; 428 char *DemangledName = __cxa_demangle(Name.c_str(), nullptr, nullptr, &status); 429 if (status != 0) 430 return Name; 431 std::string Result = DemangledName; 432 free(DemangledName); 433 return Result; 434 } 435 #else 436 if (!Name.empty() && Name.front() == '?') { 437 // Only do MSVC C++ demangling on symbols starting with '?'. 438 char DemangledName[1024] = {0}; 439 DWORD result = ::UnDecorateSymbolName( 440 Name.c_str(), DemangledName, 1023, 441 UNDNAME_NO_ACCESS_SPECIFIERS | // Strip public, private, protected 442 UNDNAME_NO_ALLOCATION_LANGUAGE | // Strip __thiscall, __stdcall, etc 443 UNDNAME_NO_THROW_SIGNATURES | // Strip throw() specifications 444 UNDNAME_NO_MEMBER_TYPE | // Strip virtual, static, etc specifiers 445 UNDNAME_NO_MS_KEYWORDS | // Strip all MS extension keywords 446 UNDNAME_NO_FUNCTION_RETURNS); // Strip function return types 447 return (result == 0) ? Name : std::string(DemangledName); 448 } 449 #endif 450 if (ModInfo && ModInfo->isWin32Module()) 451 return std::string(demanglePE32ExternCFunc(Name)); 452 return Name; 453 } 454 455 } // namespace symbolize 456 } // namespace llvm 457
