1 //===-- LocateSymbolFile.cpp ----------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "lldb/Symbol/LocateSymbolFile.h" 10 11 #include "lldb/Core/Debugger.h" 12 #include "lldb/Core/Module.h" 13 #include "lldb/Core/ModuleList.h" 14 #include "lldb/Core/ModuleSpec.h" 15 #include "lldb/Core/Progress.h" 16 #include "lldb/Host/FileSystem.h" 17 #include "lldb/Symbol/ObjectFile.h" 18 #include "lldb/Utility/ArchSpec.h" 19 #include "lldb/Utility/DataBuffer.h" 20 #include "lldb/Utility/DataExtractor.h" 21 #include "lldb/Utility/LLDBLog.h" 22 #include "lldb/Utility/Log.h" 23 #include "lldb/Utility/StreamString.h" 24 #include "lldb/Utility/Timer.h" 25 #include "lldb/Utility/UUID.h" 26 27 #include "llvm/ADT/SmallSet.h" 28 #include "llvm/Support/FileSystem.h" 29 #include "llvm/Support/ThreadPool.h" 30 31 // From MacOSX system header "mach/machine.h" 32 typedef int cpu_type_t; 33 typedef int cpu_subtype_t; 34 35 using namespace lldb; 36 using namespace lldb_private; 37 38 #if defined(__APPLE__) 39 40 // Forward declaration of method defined in source/Host/macosx/Symbols.cpp 41 int LocateMacOSXFilesUsingDebugSymbols(const ModuleSpec &module_spec, 42 ModuleSpec &return_module_spec); 43 44 #else 45 46 int LocateMacOSXFilesUsingDebugSymbols(const ModuleSpec &module_spec, 47 ModuleSpec &return_module_spec) { 48 // Cannot find MacOSX files using debug symbols on non MacOSX. 49 return 0; 50 } 51 52 #endif 53 54 static bool FileAtPathContainsArchAndUUID(const FileSpec &file_fspec, 55 const ArchSpec *arch, 56 const lldb_private::UUID *uuid) { 57 ModuleSpecList module_specs; 58 if (ObjectFile::GetModuleSpecifications(file_fspec, 0, 0, module_specs)) { 59 ModuleSpec spec; 60 for (size_t i = 0; i < module_specs.GetSize(); ++i) { 61 bool got_spec = module_specs.GetModuleSpecAtIndex(i, spec); 62 UNUSED_IF_ASSERT_DISABLED(got_spec); 63 assert(got_spec); 64 if ((uuid == nullptr || (spec.GetUUIDPtr() && spec.GetUUID() == *uuid)) && 65 (arch == nullptr || 66 (spec.GetArchitecturePtr() && 67 spec.GetArchitecture().IsCompatibleMatch(*arch)))) { 68 return true; 69 } 70 } 71 } 72 return false; 73 } 74 75 // Given a binary exec_fspec, and a ModuleSpec with an architecture/uuid, 76 // return true if there is a matching dSYM bundle next to the exec_fspec, 77 // and return that value in dsym_fspec. 78 // If there is a .dSYM.yaa compressed archive next to the exec_fspec, 79 // call through Symbols::DownloadObjectAndSymbolFile to download the 80 // expanded/uncompressed dSYM and return that filepath in dsym_fspec. 81 82 static bool LookForDsymNextToExecutablePath(const ModuleSpec &mod_spec, 83 const FileSpec &exec_fspec, 84 FileSpec &dsym_fspec) { 85 ConstString filename = exec_fspec.GetFilename(); 86 FileSpec dsym_directory = exec_fspec; 87 dsym_directory.RemoveLastPathComponent(); 88 89 std::string dsym_filename = filename.AsCString(); 90 dsym_filename += ".dSYM"; 91 dsym_directory.AppendPathComponent(dsym_filename); 92 dsym_directory.AppendPathComponent("Contents"); 93 dsym_directory.AppendPathComponent("Resources"); 94 dsym_directory.AppendPathComponent("DWARF"); 95 96 if (FileSystem::Instance().Exists(dsym_directory)) { 97 98 // See if the binary name exists in the dSYM DWARF 99 // subdir. 100 dsym_fspec = dsym_directory; 101 dsym_fspec.AppendPathComponent(filename.AsCString()); 102 if (FileSystem::Instance().Exists(dsym_fspec) && 103 FileAtPathContainsArchAndUUID(dsym_fspec, mod_spec.GetArchitecturePtr(), 104 mod_spec.GetUUIDPtr())) { 105 return true; 106 } 107 108 // See if we have "../CF.framework" - so we'll look for 109 // CF.framework.dSYM/Contents/Resources/DWARF/CF 110 // We need to drop the last suffix after '.' to match 111 // 'CF' in the DWARF subdir. 112 std::string binary_name(filename.AsCString()); 113 auto last_dot = binary_name.find_last_of('.'); 114 if (last_dot != std::string::npos) { 115 binary_name.erase(last_dot); 116 dsym_fspec = dsym_directory; 117 dsym_fspec.AppendPathComponent(binary_name); 118 if (FileSystem::Instance().Exists(dsym_fspec) && 119 FileAtPathContainsArchAndUUID(dsym_fspec, 120 mod_spec.GetArchitecturePtr(), 121 mod_spec.GetUUIDPtr())) { 122 return true; 123 } 124 } 125 } 126 127 // See if we have a .dSYM.yaa next to this executable path. 128 FileSpec dsym_yaa_fspec = exec_fspec; 129 dsym_yaa_fspec.RemoveLastPathComponent(); 130 std::string dsym_yaa_filename = filename.AsCString(); 131 dsym_yaa_filename += ".dSYM.yaa"; 132 dsym_yaa_fspec.AppendPathComponent(dsym_yaa_filename); 133 134 if (FileSystem::Instance().Exists(dsym_yaa_fspec)) { 135 ModuleSpec mutable_mod_spec = mod_spec; 136 Status error; 137 if (Symbols::DownloadObjectAndSymbolFile(mutable_mod_spec, error, true) && 138 FileSystem::Instance().Exists(mutable_mod_spec.GetSymbolFileSpec())) { 139 dsym_fspec = mutable_mod_spec.GetSymbolFileSpec(); 140 return true; 141 } 142 } 143 144 return false; 145 } 146 147 // Given a ModuleSpec with a FileSpec and optionally uuid/architecture 148 // filled in, look for a .dSYM bundle next to that binary. Returns true 149 // if a .dSYM bundle is found, and that path is returned in the dsym_fspec 150 // FileSpec. 151 // 152 // This routine looks a few directory layers above the given exec_path - 153 // exec_path might be /System/Library/Frameworks/CF.framework/CF and the 154 // dSYM might be /System/Library/Frameworks/CF.framework.dSYM. 155 // 156 // If there is a .dSYM.yaa compressed archive found next to the binary, 157 // we'll call DownloadObjectAndSymbolFile to expand it into a plain .dSYM 158 159 static bool LocateDSYMInVincinityOfExecutable(const ModuleSpec &module_spec, 160 FileSpec &dsym_fspec) { 161 Log *log = GetLog(LLDBLog::Host); 162 const FileSpec &exec_fspec = module_spec.GetFileSpec(); 163 if (exec_fspec) { 164 if (::LookForDsymNextToExecutablePath(module_spec, exec_fspec, 165 dsym_fspec)) { 166 if (log) { 167 LLDB_LOGF(log, "dSYM with matching UUID & arch found at %s", 168 dsym_fspec.GetPath().c_str()); 169 } 170 return true; 171 } else { 172 FileSpec parent_dirs = exec_fspec; 173 174 // Remove the binary name from the FileSpec 175 parent_dirs.RemoveLastPathComponent(); 176 177 // Add a ".dSYM" name to each directory component of the path, 178 // stripping off components. e.g. we may have a binary like 179 // /S/L/F/Foundation.framework/Versions/A/Foundation and 180 // /S/L/F/Foundation.framework.dSYM 181 // 182 // so we'll need to start with 183 // /S/L/F/Foundation.framework/Versions/A, add the .dSYM part to the 184 // "A", and if that doesn't exist, strip off the "A" and try it again 185 // with "Versions", etc., until we find a dSYM bundle or we've 186 // stripped off enough path components that there's no need to 187 // continue. 188 189 for (int i = 0; i < 4; i++) { 190 // Does this part of the path have a "." character - could it be a 191 // bundle's top level directory? 192 const char *fn = parent_dirs.GetFilename().AsCString(); 193 if (fn == nullptr) 194 break; 195 if (::strchr(fn, '.') != nullptr) { 196 if (::LookForDsymNextToExecutablePath(module_spec, parent_dirs, 197 dsym_fspec)) { 198 if (log) { 199 LLDB_LOGF(log, "dSYM with matching UUID & arch found at %s", 200 dsym_fspec.GetPath().c_str()); 201 } 202 return true; 203 } 204 } 205 parent_dirs.RemoveLastPathComponent(); 206 } 207 } 208 } 209 dsym_fspec.Clear(); 210 return false; 211 } 212 213 static FileSpec LocateExecutableSymbolFileDsym(const ModuleSpec &module_spec) { 214 const FileSpec *exec_fspec = module_spec.GetFileSpecPtr(); 215 const ArchSpec *arch = module_spec.GetArchitecturePtr(); 216 const UUID *uuid = module_spec.GetUUIDPtr(); 217 218 LLDB_SCOPED_TIMERF( 219 "LocateExecutableSymbolFileDsym (file = %s, arch = %s, uuid = %p)", 220 exec_fspec ? exec_fspec->GetFilename().AsCString("<NULL>") : "<NULL>", 221 arch ? arch->GetArchitectureName() : "<NULL>", (const void *)uuid); 222 223 FileSpec symbol_fspec; 224 ModuleSpec dsym_module_spec; 225 // First try and find the dSYM in the same directory as the executable or in 226 // an appropriate parent directory 227 if (!LocateDSYMInVincinityOfExecutable(module_spec, symbol_fspec)) { 228 // We failed to easily find the dSYM above, so use DebugSymbols 229 LocateMacOSXFilesUsingDebugSymbols(module_spec, dsym_module_spec); 230 } else { 231 dsym_module_spec.GetSymbolFileSpec() = symbol_fspec; 232 } 233 234 return dsym_module_spec.GetSymbolFileSpec(); 235 } 236 237 ModuleSpec Symbols::LocateExecutableObjectFile(const ModuleSpec &module_spec) { 238 ModuleSpec result; 239 const FileSpec &exec_fspec = module_spec.GetFileSpec(); 240 const ArchSpec *arch = module_spec.GetArchitecturePtr(); 241 const UUID *uuid = module_spec.GetUUIDPtr(); 242 LLDB_SCOPED_TIMERF( 243 "LocateExecutableObjectFile (file = %s, arch = %s, uuid = %p)", 244 exec_fspec ? exec_fspec.GetFilename().AsCString("<NULL>") : "<NULL>", 245 arch ? arch->GetArchitectureName() : "<NULL>", (const void *)uuid); 246 247 ModuleSpecList module_specs; 248 ModuleSpec matched_module_spec; 249 if (exec_fspec && 250 ObjectFile::GetModuleSpecifications(exec_fspec, 0, 0, module_specs) && 251 module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec)) { 252 result.GetFileSpec() = exec_fspec; 253 } else { 254 LocateMacOSXFilesUsingDebugSymbols(module_spec, result); 255 } 256 257 return result; 258 } 259 260 // Keep "symbols.enable-external-lookup" description in sync with this function. 261 262 FileSpec 263 Symbols::LocateExecutableSymbolFile(const ModuleSpec &module_spec, 264 const FileSpecList &default_search_paths) { 265 FileSpec symbol_file_spec = module_spec.GetSymbolFileSpec(); 266 if (symbol_file_spec.IsAbsolute() && 267 FileSystem::Instance().Exists(symbol_file_spec)) 268 return symbol_file_spec; 269 270 Progress progress(llvm::formatv( 271 "Locating external symbol file for {0}", 272 module_spec.GetFileSpec().GetFilename().AsCString("<Unknown>"))); 273 274 FileSpecList debug_file_search_paths = default_search_paths; 275 276 // Add module directory. 277 FileSpec module_file_spec = module_spec.GetFileSpec(); 278 // We keep the unresolved pathname if it fails. 279 FileSystem::Instance().ResolveSymbolicLink(module_file_spec, 280 module_file_spec); 281 282 ConstString file_dir = module_file_spec.GetDirectory(); 283 { 284 FileSpec file_spec(file_dir.AsCString(".")); 285 FileSystem::Instance().Resolve(file_spec); 286 debug_file_search_paths.AppendIfUnique(file_spec); 287 } 288 289 if (ModuleList::GetGlobalModuleListProperties().GetEnableExternalLookup()) { 290 291 // Add current working directory. 292 { 293 FileSpec file_spec("."); 294 FileSystem::Instance().Resolve(file_spec); 295 debug_file_search_paths.AppendIfUnique(file_spec); 296 } 297 298 #ifndef _WIN32 299 #if defined(__NetBSD__) 300 // Add /usr/libdata/debug directory. 301 { 302 FileSpec file_spec("/usr/libdata/debug"); 303 FileSystem::Instance().Resolve(file_spec); 304 debug_file_search_paths.AppendIfUnique(file_spec); 305 } 306 #else 307 // Add /usr/lib/debug directory. 308 { 309 FileSpec file_spec("/usr/lib/debug"); 310 FileSystem::Instance().Resolve(file_spec); 311 debug_file_search_paths.AppendIfUnique(file_spec); 312 } 313 #endif 314 #endif // _WIN32 315 } 316 317 std::string uuid_str; 318 const UUID &module_uuid = module_spec.GetUUID(); 319 if (module_uuid.IsValid()) { 320 // Some debug files are stored in the .build-id directory like this: 321 // /usr/lib/debug/.build-id/ff/e7fe727889ad82bb153de2ad065b2189693315.debug 322 uuid_str = module_uuid.GetAsString(""); 323 std::transform(uuid_str.begin(), uuid_str.end(), uuid_str.begin(), 324 ::tolower); 325 uuid_str.insert(2, 1, '/'); 326 uuid_str = uuid_str + ".debug"; 327 } 328 329 size_t num_directories = debug_file_search_paths.GetSize(); 330 for (size_t idx = 0; idx < num_directories; ++idx) { 331 FileSpec dirspec = debug_file_search_paths.GetFileSpecAtIndex(idx); 332 FileSystem::Instance().Resolve(dirspec); 333 if (!FileSystem::Instance().IsDirectory(dirspec)) 334 continue; 335 336 std::vector<std::string> files; 337 std::string dirname = dirspec.GetPath(); 338 339 if (!uuid_str.empty()) 340 files.push_back(dirname + "/.build-id/" + uuid_str); 341 if (symbol_file_spec.GetFilename()) { 342 files.push_back(dirname + "/" + 343 symbol_file_spec.GetFilename().GetCString()); 344 files.push_back(dirname + "/.debug/" + 345 symbol_file_spec.GetFilename().GetCString()); 346 347 // Some debug files may stored in the module directory like this: 348 // /usr/lib/debug/usr/lib/library.so.debug 349 if (!file_dir.IsEmpty()) 350 files.push_back(dirname + file_dir.AsCString() + "/" + 351 symbol_file_spec.GetFilename().GetCString()); 352 } 353 354 const uint32_t num_files = files.size(); 355 for (size_t idx_file = 0; idx_file < num_files; ++idx_file) { 356 const std::string &filename = files[idx_file]; 357 FileSpec file_spec(filename); 358 FileSystem::Instance().Resolve(file_spec); 359 360 if (llvm::sys::fs::equivalent(file_spec.GetPath(), 361 module_file_spec.GetPath())) 362 continue; 363 364 if (FileSystem::Instance().Exists(file_spec)) { 365 lldb_private::ModuleSpecList specs; 366 const size_t num_specs = 367 ObjectFile::GetModuleSpecifications(file_spec, 0, 0, specs); 368 ModuleSpec mspec; 369 bool valid_mspec = false; 370 if (num_specs == 2) { 371 // Special case to handle both i386 and i686 from ObjectFilePECOFF 372 ModuleSpec mspec2; 373 if (specs.GetModuleSpecAtIndex(0, mspec) && 374 specs.GetModuleSpecAtIndex(1, mspec2) && 375 mspec.GetArchitecture().GetTriple().isCompatibleWith( 376 mspec2.GetArchitecture().GetTriple())) { 377 valid_mspec = true; 378 } 379 } 380 if (!valid_mspec) { 381 assert(num_specs <= 1 && 382 "Symbol Vendor supports only a single architecture"); 383 if (num_specs == 1) { 384 if (specs.GetModuleSpecAtIndex(0, mspec)) { 385 valid_mspec = true; 386 } 387 } 388 } 389 if (valid_mspec) { 390 // Skip the uuids check if module_uuid is invalid. For example, 391 // this happens for *.dwp files since at the moment llvm-dwp 392 // doesn't output build ids, nor does binutils dwp. 393 if (!module_uuid.IsValid() || module_uuid == mspec.GetUUID()) 394 return file_spec; 395 } 396 } 397 } 398 } 399 400 return LocateExecutableSymbolFileDsym(module_spec); 401 } 402 403 void Symbols::DownloadSymbolFileAsync(const UUID &uuid) { 404 if (!ModuleList::GetGlobalModuleListProperties().GetEnableBackgroundLookup()) 405 return; 406 407 static llvm::SmallSet<UUID, 8> g_seen_uuids; 408 static std::mutex g_mutex; 409 Debugger::GetThreadPool().async([=]() { 410 { 411 std::lock_guard<std::mutex> guard(g_mutex); 412 if (g_seen_uuids.count(uuid)) 413 return; 414 g_seen_uuids.insert(uuid); 415 } 416 417 Status error; 418 ModuleSpec module_spec; 419 module_spec.GetUUID() = uuid; 420 if (!Symbols::DownloadObjectAndSymbolFile(module_spec, error, 421 /*force_lookup=*/true, 422 /*copy_executable=*/false)) 423 return; 424 425 if (error.Fail()) 426 return; 427 428 Debugger::ReportSymbolChange(module_spec); 429 }); 430 } 431 432 #if !defined(__APPLE__) 433 434 FileSpec Symbols::FindSymbolFileInBundle(const FileSpec &symfile_bundle, 435 const lldb_private::UUID *uuid, 436 const ArchSpec *arch) { 437 // FIXME 438 return FileSpec(); 439 } 440 441 bool Symbols::DownloadObjectAndSymbolFile(ModuleSpec &module_spec, 442 Status &error, bool force_lookup, 443 bool copy_executable) { 444 // Fill in the module_spec.GetFileSpec() for the object file and/or the 445 // module_spec.GetSymbolFileSpec() for the debug symbols file. 446 return false; 447 } 448 449 #endif 450