1 //===-- IRExecutionUnit.cpp -------------------------------------*- C++ -*-===// 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 #include "llvm/ExecutionEngine/ExecutionEngine.h" 11 #include "llvm/IR/LLVMContext.h" 12 #include "llvm/IR/Module.h" 13 #include "llvm/Support/SourceMgr.h" 14 #include "llvm/Support/raw_ostream.h" 15 16 #include "lldb/Core/DataBufferHeap.h" 17 #include "lldb/Core/DataExtractor.h" 18 #include "lldb/Core/Debugger.h" 19 #include "lldb/Core/Disassembler.h" 20 #include "lldb/Core/Log.h" 21 #include "lldb/Core/Module.h" 22 #include "lldb/Core/Section.h" 23 #include "lldb/Symbol/CompileUnit.h" 24 #include "lldb/Symbol/SymbolContext.h" 25 #include "lldb/Symbol/SymbolVendor.h" 26 #include "lldb/Symbol/SymbolFile.h" 27 #include "lldb/Expression/IRExecutionUnit.h" 28 #include "lldb/Target/ExecutionContext.h" 29 #include "lldb/Target/Target.h" 30 #include "lldb/Target/ObjCLanguageRuntime.h" 31 32 #include "lldb/../../source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h" 33 34 using namespace lldb_private; 35 36 IRExecutionUnit::IRExecutionUnit (std::unique_ptr<llvm::LLVMContext> &context_ap, 37 std::unique_ptr<llvm::Module> &module_ap, 38 ConstString &name, 39 const lldb::TargetSP &target_sp, 40 const SymbolContext &sym_ctx, 41 std::vector<std::string> &cpu_features) : 42 IRMemoryMap(target_sp), 43 m_context_ap(context_ap.release()), 44 m_module_ap(module_ap.release()), 45 m_module(m_module_ap.get()), 46 m_cpu_features(cpu_features), 47 m_name(name), 48 m_sym_ctx(sym_ctx), 49 m_did_jit(false), 50 m_function_load_addr(LLDB_INVALID_ADDRESS), 51 m_function_end_load_addr(LLDB_INVALID_ADDRESS) 52 { 53 } 54 55 lldb::addr_t 56 IRExecutionUnit::WriteNow (const uint8_t *bytes, 57 size_t size, 58 Error &error) 59 { 60 const bool zero_memory = false; 61 lldb::addr_t allocation_process_addr = Malloc (size, 62 8, 63 lldb::ePermissionsWritable | lldb::ePermissionsReadable, 64 eAllocationPolicyMirror, 65 zero_memory, 66 error); 67 68 if (!error.Success()) 69 return LLDB_INVALID_ADDRESS; 70 71 WriteMemory(allocation_process_addr, bytes, size, error); 72 73 if (!error.Success()) 74 { 75 Error err; 76 Free (allocation_process_addr, err); 77 78 return LLDB_INVALID_ADDRESS; 79 } 80 81 if (Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)) 82 { 83 DataBufferHeap my_buffer(size, 0); 84 Error err; 85 ReadMemory(my_buffer.GetBytes(), allocation_process_addr, size, err); 86 87 if (err.Success()) 88 { 89 DataExtractor my_extractor(my_buffer.GetBytes(), my_buffer.GetByteSize(), lldb::eByteOrderBig, 8); 90 my_extractor.PutToLog(log, 0, my_buffer.GetByteSize(), allocation_process_addr, 16, DataExtractor::TypeUInt8); 91 } 92 } 93 94 return allocation_process_addr; 95 } 96 97 void 98 IRExecutionUnit::FreeNow (lldb::addr_t allocation) 99 { 100 if (allocation == LLDB_INVALID_ADDRESS) 101 return; 102 103 Error err; 104 105 Free(allocation, err); 106 } 107 108 Error 109 IRExecutionUnit::DisassembleFunction (Stream &stream, 110 lldb::ProcessSP &process_wp) 111 { 112 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 113 114 ExecutionContext exe_ctx(process_wp); 115 116 Error ret; 117 118 ret.Clear(); 119 120 lldb::addr_t func_local_addr = LLDB_INVALID_ADDRESS; 121 lldb::addr_t func_remote_addr = LLDB_INVALID_ADDRESS; 122 123 for (JittedFunction &function : m_jitted_functions) 124 { 125 if (strstr(function.m_name.c_str(), m_name.AsCString())) 126 { 127 func_local_addr = function.m_local_addr; 128 func_remote_addr = function.m_remote_addr; 129 } 130 } 131 132 if (func_local_addr == LLDB_INVALID_ADDRESS) 133 { 134 ret.SetErrorToGenericError(); 135 ret.SetErrorStringWithFormat("Couldn't find function %s for disassembly", m_name.AsCString()); 136 return ret; 137 } 138 139 if (log) 140 log->Printf("Found function, has local address 0x%" PRIx64 " and remote address 0x%" PRIx64, (uint64_t)func_local_addr, (uint64_t)func_remote_addr); 141 142 std::pair <lldb::addr_t, lldb::addr_t> func_range; 143 144 func_range = GetRemoteRangeForLocal(func_local_addr); 145 146 if (func_range.first == 0 && func_range.second == 0) 147 { 148 ret.SetErrorToGenericError(); 149 ret.SetErrorStringWithFormat("Couldn't find code range for function %s", m_name.AsCString()); 150 return ret; 151 } 152 153 if (log) 154 log->Printf("Function's code range is [0x%" PRIx64 "+0x%" PRIx64 "]", func_range.first, func_range.second); 155 156 Target *target = exe_ctx.GetTargetPtr(); 157 if (!target) 158 { 159 ret.SetErrorToGenericError(); 160 ret.SetErrorString("Couldn't find the target"); 161 return ret; 162 } 163 164 lldb::DataBufferSP buffer_sp(new DataBufferHeap(func_range.second, 0)); 165 166 Process *process = exe_ctx.GetProcessPtr(); 167 Error err; 168 process->ReadMemory(func_remote_addr, buffer_sp->GetBytes(), buffer_sp->GetByteSize(), err); 169 170 if (!err.Success()) 171 { 172 ret.SetErrorToGenericError(); 173 ret.SetErrorStringWithFormat("Couldn't read from process: %s", err.AsCString("unknown error")); 174 return ret; 175 } 176 177 ArchSpec arch(target->GetArchitecture()); 178 179 const char *plugin_name = NULL; 180 const char *flavor_string = NULL; 181 lldb::DisassemblerSP disassembler_sp = Disassembler::FindPlugin(arch, flavor_string, plugin_name); 182 183 if (!disassembler_sp) 184 { 185 ret.SetErrorToGenericError(); 186 ret.SetErrorStringWithFormat("Unable to find disassembler plug-in for %s architecture.", arch.GetArchitectureName()); 187 return ret; 188 } 189 190 if (!process) 191 { 192 ret.SetErrorToGenericError(); 193 ret.SetErrorString("Couldn't find the process"); 194 return ret; 195 } 196 197 DataExtractor extractor(buffer_sp, 198 process->GetByteOrder(), 199 target->GetArchitecture().GetAddressByteSize()); 200 201 if (log) 202 { 203 log->Printf("Function data has contents:"); 204 extractor.PutToLog (log, 205 0, 206 extractor.GetByteSize(), 207 func_remote_addr, 208 16, 209 DataExtractor::TypeUInt8); 210 } 211 212 disassembler_sp->DecodeInstructions (Address (func_remote_addr), extractor, 0, UINT32_MAX, false, false); 213 214 InstructionList &instruction_list = disassembler_sp->GetInstructionList(); 215 instruction_list.Dump(&stream, true, true, &exe_ctx); 216 217 // FIXME: The DisassemblerLLVMC has a reference cycle and won't go away if it has any active instructions. 218 // I'll fix that but for now, just clear the list and it will go away nicely. 219 disassembler_sp->GetInstructionList().Clear(); 220 return ret; 221 } 222 223 static void ReportInlineAsmError(const llvm::SMDiagnostic &diagnostic, void *Context, unsigned LocCookie) 224 { 225 Error *err = static_cast<Error*>(Context); 226 227 if (err && err->Success()) 228 { 229 err->SetErrorToGenericError(); 230 err->SetErrorStringWithFormat("Inline assembly error: %s", diagnostic.getMessage().str().c_str()); 231 } 232 } 233 234 void 235 IRExecutionUnit::ReportSymbolLookupError(const ConstString &name) 236 { 237 m_failed_lookups.push_back(name); 238 } 239 240 void 241 IRExecutionUnit::GetRunnableInfo(Error &error, 242 lldb::addr_t &func_addr, 243 lldb::addr_t &func_end) 244 { 245 lldb::ProcessSP process_sp(GetProcessWP().lock()); 246 247 static Mutex s_runnable_info_mutex(Mutex::Type::eMutexTypeRecursive); 248 249 func_addr = LLDB_INVALID_ADDRESS; 250 func_end = LLDB_INVALID_ADDRESS; 251 252 if (!process_sp) 253 { 254 error.SetErrorToGenericError(); 255 error.SetErrorString("Couldn't write the JIT compiled code into the process because the process is invalid"); 256 return; 257 } 258 259 if (m_did_jit) 260 { 261 func_addr = m_function_load_addr; 262 func_end = m_function_end_load_addr; 263 264 return; 265 }; 266 267 Mutex::Locker runnable_info_mutex_locker(s_runnable_info_mutex); 268 269 m_did_jit = true; 270 271 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 272 273 std::string error_string; 274 275 if (log) 276 { 277 std::string s; 278 llvm::raw_string_ostream oss(s); 279 280 m_module->print(oss, NULL); 281 282 oss.flush(); 283 284 log->Printf ("Module being sent to JIT: \n%s", s.c_str()); 285 } 286 287 llvm::Triple triple(m_module->getTargetTriple()); 288 llvm::Function *function = m_module->getFunction (m_name.AsCString()); 289 llvm::Reloc::Model relocModel; 290 llvm::CodeModel::Model codeModel; 291 292 if (triple.isOSBinFormatELF()) 293 { 294 relocModel = llvm::Reloc::Static; 295 } 296 else 297 { 298 relocModel = llvm::Reloc::PIC_; 299 } 300 301 // This will be small for 32-bit and large for 64-bit. 302 codeModel = llvm::CodeModel::JITDefault; 303 304 m_module_ap->getContext().setInlineAsmDiagnosticHandler(ReportInlineAsmError, &error); 305 306 llvm::EngineBuilder builder(std::move(m_module_ap)); 307 308 builder.setEngineKind(llvm::EngineKind::JIT) 309 .setErrorStr(&error_string) 310 .setRelocationModel(relocModel) 311 .setMCJITMemoryManager(std::unique_ptr<MemoryManager>(new MemoryManager(*this))) 312 .setCodeModel(codeModel) 313 .setOptLevel(llvm::CodeGenOpt::Less); 314 315 llvm::StringRef mArch; 316 llvm::StringRef mCPU; 317 llvm::SmallVector<std::string, 0> mAttrs; 318 319 for (std::string &feature : m_cpu_features) 320 mAttrs.push_back(feature); 321 322 llvm::TargetMachine *target_machine = builder.selectTarget(triple, 323 mArch, 324 mCPU, 325 mAttrs); 326 327 m_execution_engine_ap.reset(builder.create(target_machine)); 328 329 m_strip_underscore = (m_execution_engine_ap->getDataLayout().getGlobalPrefix() == '_'); 330 331 if (!m_execution_engine_ap.get()) 332 { 333 error.SetErrorToGenericError(); 334 error.SetErrorStringWithFormat("Couldn't JIT the function: %s", error_string.c_str()); 335 return; 336 } 337 338 // Make sure we see all sections, including ones that don't have relocations... 339 m_execution_engine_ap->setProcessAllSections(true); 340 341 m_execution_engine_ap->DisableLazyCompilation(); 342 343 // We don't actually need the function pointer here, this just forces it to get resolved. 344 345 void *fun_ptr = m_execution_engine_ap->getPointerToFunction(function); 346 347 if (!error.Success()) 348 { 349 // We got an error through our callback! 350 return; 351 } 352 353 if (!function) 354 { 355 error.SetErrorToGenericError(); 356 error.SetErrorStringWithFormat("Couldn't find '%s' in the JITted module", m_name.AsCString()); 357 return; 358 } 359 360 if (!fun_ptr) 361 { 362 error.SetErrorToGenericError(); 363 error.SetErrorStringWithFormat("'%s' was in the JITted module but wasn't lowered", m_name.AsCString()); 364 return; 365 } 366 367 m_jitted_functions.push_back (JittedFunction(m_name.AsCString(), (lldb::addr_t)fun_ptr)); 368 369 CommitAllocations(process_sp); 370 ReportAllocations(*m_execution_engine_ap); 371 WriteData(process_sp); 372 373 if (m_failed_lookups.size()) 374 { 375 StreamString ss; 376 377 ss.PutCString("Couldn't lookup symbols:\n"); 378 379 bool emitNewLine = false; 380 381 for (const ConstString &failed_lookup : m_failed_lookups) 382 { 383 if (emitNewLine) 384 ss.PutCString("\n"); 385 emitNewLine = true; 386 ss.PutCString(" "); 387 ss.PutCString(Mangled(failed_lookup).GetDemangledName(lldb::eLanguageTypeObjC_plus_plus).AsCString()); 388 } 389 390 m_failed_lookups.clear(); 391 392 error.SetErrorString(ss.GetData()); 393 394 return; 395 } 396 397 m_function_load_addr = LLDB_INVALID_ADDRESS; 398 m_function_end_load_addr = LLDB_INVALID_ADDRESS; 399 400 for (JittedFunction &jitted_function : m_jitted_functions) 401 { 402 jitted_function.m_remote_addr = GetRemoteAddressForLocal (jitted_function.m_local_addr); 403 404 if (!jitted_function.m_name.compare(m_name.AsCString())) 405 { 406 AddrRange func_range = GetRemoteRangeForLocal(jitted_function.m_local_addr); 407 m_function_end_load_addr = func_range.first + func_range.second; 408 m_function_load_addr = jitted_function.m_remote_addr; 409 } 410 } 411 412 if (log) 413 { 414 log->Printf("Code can be run in the target."); 415 416 StreamString disassembly_stream; 417 418 Error err = DisassembleFunction(disassembly_stream, process_sp); 419 420 if (!err.Success()) 421 { 422 log->Printf("Couldn't disassemble function : %s", err.AsCString("unknown error")); 423 } 424 else 425 { 426 log->Printf("Function disassembly:\n%s", disassembly_stream.GetData()); 427 } 428 429 log->Printf("Sections: "); 430 for (AllocationRecord &record : m_records) 431 { 432 if (record.m_process_address != LLDB_INVALID_ADDRESS) 433 { 434 record.dump(log); 435 436 DataBufferHeap my_buffer(record.m_size, 0); 437 Error err; 438 ReadMemory(my_buffer.GetBytes(), record.m_process_address, record.m_size, err); 439 440 if (err.Success()) 441 { 442 DataExtractor my_extractor(my_buffer.GetBytes(), my_buffer.GetByteSize(), lldb::eByteOrderBig, 8); 443 my_extractor.PutToLog(log, 0, my_buffer.GetByteSize(), record.m_process_address, 16, DataExtractor::TypeUInt8); 444 } 445 } 446 else 447 { 448 record.dump(log); 449 450 DataExtractor my_extractor ((const void*)record.m_host_address, record.m_size, lldb::eByteOrderBig, 8); 451 my_extractor.PutToLog(log, 0, record.m_size, record.m_host_address, 16, DataExtractor::TypeUInt8); 452 } 453 } 454 } 455 456 func_addr = m_function_load_addr; 457 func_end = m_function_end_load_addr; 458 459 return; 460 } 461 462 IRExecutionUnit::~IRExecutionUnit () 463 { 464 m_module_ap.reset(); 465 m_execution_engine_ap.reset(); 466 m_context_ap.reset(); 467 } 468 469 IRExecutionUnit::MemoryManager::MemoryManager (IRExecutionUnit &parent) : 470 m_default_mm_ap (new llvm::SectionMemoryManager()), 471 m_parent (parent) 472 { 473 } 474 475 IRExecutionUnit::MemoryManager::~MemoryManager () 476 { 477 } 478 479 lldb::SectionType 480 IRExecutionUnit::GetSectionTypeFromSectionName (const llvm::StringRef &name, IRExecutionUnit::AllocationKind alloc_kind) 481 { 482 lldb::SectionType sect_type = lldb::eSectionTypeCode; 483 switch (alloc_kind) 484 { 485 case AllocationKind::Stub: sect_type = lldb::eSectionTypeCode; break; 486 case AllocationKind::Code: sect_type = lldb::eSectionTypeCode; break; 487 case AllocationKind::Data: sect_type = lldb::eSectionTypeData; break; 488 case AllocationKind::Global:sect_type = lldb::eSectionTypeData; break; 489 case AllocationKind::Bytes: sect_type = lldb::eSectionTypeOther; break; 490 } 491 492 if (!name.empty()) 493 { 494 if (name.equals("__text") || name.equals(".text")) 495 sect_type = lldb::eSectionTypeCode; 496 else if (name.equals("__data") || name.equals(".data")) 497 sect_type = lldb::eSectionTypeCode; 498 else if (name.startswith("__debug_") || name.startswith(".debug_")) 499 { 500 const uint32_t name_idx = name[0] == '_' ? 8 : 7; 501 llvm::StringRef dwarf_name(name.substr(name_idx)); 502 switch (dwarf_name[0]) 503 { 504 case 'a': 505 if (dwarf_name.equals("abbrev")) 506 sect_type = lldb::eSectionTypeDWARFDebugAbbrev; 507 else if (dwarf_name.equals("aranges")) 508 sect_type = lldb::eSectionTypeDWARFDebugAranges; 509 else if (dwarf_name.equals("addr")) 510 sect_type = lldb::eSectionTypeDWARFDebugAddr; 511 break; 512 513 case 'f': 514 if (dwarf_name.equals("frame")) 515 sect_type = lldb::eSectionTypeDWARFDebugFrame; 516 break; 517 518 case 'i': 519 if (dwarf_name.equals("info")) 520 sect_type = lldb::eSectionTypeDWARFDebugInfo; 521 break; 522 523 case 'l': 524 if (dwarf_name.equals("line")) 525 sect_type = lldb::eSectionTypeDWARFDebugLine; 526 else if (dwarf_name.equals("loc")) 527 sect_type = lldb::eSectionTypeDWARFDebugLoc; 528 break; 529 530 case 'm': 531 if (dwarf_name.equals("macinfo")) 532 sect_type = lldb::eSectionTypeDWARFDebugMacInfo; 533 break; 534 535 case 'p': 536 if (dwarf_name.equals("pubnames")) 537 sect_type = lldb::eSectionTypeDWARFDebugPubNames; 538 else if (dwarf_name.equals("pubtypes")) 539 sect_type = lldb::eSectionTypeDWARFDebugPubTypes; 540 break; 541 542 case 's': 543 if (dwarf_name.equals("str")) 544 sect_type = lldb::eSectionTypeDWARFDebugStr; 545 else if (dwarf_name.equals("str_offsets")) 546 sect_type = lldb::eSectionTypeDWARFDebugStrOffsets; 547 break; 548 549 case 'r': 550 if (dwarf_name.equals("ranges")) 551 sect_type = lldb::eSectionTypeDWARFDebugRanges; 552 break; 553 554 default: 555 break; 556 } 557 } 558 else if (name.startswith("__apple_") || name.startswith(".apple_")) 559 { 560 #if 0 561 const uint32_t name_idx = name[0] == '_' ? 8 : 7; 562 llvm::StringRef apple_name(name.substr(name_idx)); 563 switch (apple_name[0]) 564 { 565 case 'n': 566 if (apple_name.equals("names")) 567 sect_type = lldb::eSectionTypeDWARFAppleNames; 568 else if (apple_name.equals("namespac") || apple_name.equals("namespaces")) 569 sect_type = lldb::eSectionTypeDWARFAppleNamespaces; 570 break; 571 case 't': 572 if (apple_name.equals("types")) 573 sect_type = lldb::eSectionTypeDWARFAppleTypes; 574 break; 575 case 'o': 576 if (apple_name.equals("objc")) 577 sect_type = lldb::eSectionTypeDWARFAppleObjC; 578 break; 579 default: 580 break; 581 } 582 #else 583 sect_type = lldb::eSectionTypeInvalid; 584 #endif 585 } 586 else if (name.equals("__objc_imageinfo")) 587 sect_type = lldb::eSectionTypeOther; 588 } 589 return sect_type; 590 } 591 592 uint8_t * 593 IRExecutionUnit::MemoryManager::allocateCodeSection(uintptr_t Size, 594 unsigned Alignment, 595 unsigned SectionID, 596 llvm::StringRef SectionName) 597 { 598 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 599 600 uint8_t *return_value = m_default_mm_ap->allocateCodeSection(Size, Alignment, SectionID, SectionName); 601 602 m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value, 603 lldb::ePermissionsReadable | lldb::ePermissionsExecutable, 604 GetSectionTypeFromSectionName (SectionName, AllocationKind::Code), 605 Size, 606 Alignment, 607 SectionID, 608 SectionName.str().c_str())); 609 610 if (log) 611 { 612 log->Printf("IRExecutionUnit::allocateCodeSection(Size=0x%" PRIx64 ", Alignment=%u, SectionID=%u) = %p", 613 (uint64_t)Size, Alignment, SectionID, (void *)return_value); 614 } 615 616 return return_value; 617 } 618 619 uint8_t * 620 IRExecutionUnit::MemoryManager::allocateDataSection(uintptr_t Size, 621 unsigned Alignment, 622 unsigned SectionID, 623 llvm::StringRef SectionName, 624 bool IsReadOnly) 625 { 626 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 627 628 uint8_t *return_value = m_default_mm_ap->allocateDataSection(Size, Alignment, SectionID, SectionName, IsReadOnly); 629 630 uint32_t permissions = lldb::ePermissionsReadable; 631 if (!IsReadOnly) 632 permissions |= lldb::ePermissionsWritable; 633 m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value, 634 permissions, 635 GetSectionTypeFromSectionName (SectionName, AllocationKind::Data), 636 Size, 637 Alignment, 638 SectionID, 639 SectionName.str().c_str())); 640 if (log) 641 { 642 log->Printf("IRExecutionUnit::allocateDataSection(Size=0x%" PRIx64 ", Alignment=%u, SectionID=%u) = %p", 643 (uint64_t)Size, Alignment, SectionID, (void *)return_value); 644 } 645 646 return return_value; 647 } 648 649 static ConstString 650 FindBestAlternateMangledName(const ConstString &demangled, 651 const lldb::LanguageType &lang_type, 652 const SymbolContext &sym_ctx) 653 { 654 CPlusPlusLanguage::MethodName cpp_name(demangled); 655 std::string scope_qualified_name = cpp_name.GetScopeQualifiedName(); 656 657 if (!scope_qualified_name.size()) 658 return ConstString(); 659 660 if (!sym_ctx.module_sp) 661 return ConstString(); 662 663 SymbolVendor *sym_vendor = sym_ctx.module_sp->GetSymbolVendor(); 664 if (!sym_vendor) 665 return ConstString(); 666 667 lldb_private::SymbolFile *sym_file = sym_vendor->GetSymbolFile(); 668 if (!sym_file) 669 return ConstString(); 670 671 std::vector<ConstString> alternates; 672 sym_file->GetMangledNamesForFunction(scope_qualified_name, alternates); 673 674 std::vector<ConstString> param_and_qual_matches; 675 std::vector<ConstString> param_matches; 676 for (size_t i = 0; i < alternates.size(); i++) 677 { 678 ConstString alternate_mangled_name = alternates[i]; 679 Mangled mangled(alternate_mangled_name, true); 680 ConstString demangled = mangled.GetDemangledName(lang_type); 681 682 CPlusPlusLanguage::MethodName alternate_cpp_name(demangled); 683 if (!cpp_name.IsValid()) 684 continue; 685 686 if (alternate_cpp_name.GetArguments() == cpp_name.GetArguments()) 687 { 688 if (alternate_cpp_name.GetQualifiers() == cpp_name.GetQualifiers()) 689 param_and_qual_matches.push_back(alternate_mangled_name); 690 else 691 param_matches.push_back(alternate_mangled_name); 692 } 693 } 694 695 if (param_and_qual_matches.size()) 696 return param_and_qual_matches[0]; // It is assumed that there will be only one! 697 else if (param_matches.size()) 698 return param_matches[0]; // Return one of them as a best match 699 else 700 return ConstString(); 701 } 702 703 struct IRExecutionUnit::SearchSpec 704 { 705 ConstString name; 706 uint32_t mask; 707 708 SearchSpec(ConstString n, uint32_t m = lldb::eFunctionNameTypeAuto) : 709 name(n), 710 mask(m) 711 { 712 } 713 }; 714 715 void 716 IRExecutionUnit::CollectCandidateCNames(std::vector<IRExecutionUnit::SearchSpec> &C_specs, const ConstString &name) 717 { 718 if (m_strip_underscore && name.AsCString()[0] == '_') 719 C_specs.insert(C_specs.begin(), ConstString(&name.AsCString()[1])); 720 C_specs.push_back(SearchSpec(name)); 721 } 722 723 void 724 IRExecutionUnit::CollectCandidateCPlusPlusNames(std::vector<IRExecutionUnit::SearchSpec> &CPP_specs, const std::vector<SearchSpec> &C_specs, const SymbolContext &sc) 725 { 726 for (const SearchSpec &C_spec : C_specs) 727 { 728 const ConstString &name = C_spec.name; 729 730 if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) 731 { 732 Mangled mangled(name, true); 733 ConstString demangled = mangled.GetDemangledName(lldb::eLanguageTypeC_plus_plus); 734 735 if (demangled) 736 { 737 ConstString best_alternate_mangled_name = FindBestAlternateMangledName(demangled, lldb::eLanguageTypeC_plus_plus, sc); 738 739 if (best_alternate_mangled_name) 740 { 741 CPP_specs.push_back(best_alternate_mangled_name); 742 } 743 744 CPP_specs.push_back(SearchSpec(demangled, lldb::eFunctionNameTypeFull)); 745 } 746 } 747 748 // Maybe we're looking for a const symbol but the debug info told us it was const... 749 if (!strncmp(name.GetCString(), "_ZN", 3) && 750 strncmp(name.GetCString(), "_ZNK", 4)) 751 { 752 std::string fixed_scratch("_ZNK"); 753 fixed_scratch.append(name.GetCString() + 3); 754 CPP_specs.push_back(ConstString(fixed_scratch.c_str())); 755 } 756 757 // Maybe we're looking for a static symbol but we thought it was global... 758 if (!strncmp(name.GetCString(), "_Z", 2) && 759 strncmp(name.GetCString(), "_ZL", 3)) 760 { 761 std::string fixed_scratch("_ZL"); 762 fixed_scratch.append(name.GetCString() + 2); 763 CPP_specs.push_back(ConstString(fixed_scratch.c_str())); 764 } 765 766 } 767 } 768 769 lldb::addr_t 770 IRExecutionUnit::FindInSymbols(const std::vector<IRExecutionUnit::SearchSpec> &specs, const lldb_private::SymbolContext &sc) 771 { 772 Target *target = sc.target_sp.get(); 773 774 if (!target) 775 { 776 // we shouldn't be doing any symbol lookup at all without a target 777 return LLDB_INVALID_ADDRESS; 778 } 779 780 for (const SearchSpec &spec : specs) 781 { 782 SymbolContextList sc_list; 783 784 lldb::addr_t best_internal_load_address = LLDB_INVALID_ADDRESS; 785 786 std::function<bool (lldb::addr_t &, SymbolContextList &, const lldb_private::SymbolContext &)> get_external_load_address = 787 [&best_internal_load_address, target](lldb::addr_t &load_address, 788 SymbolContextList &sc_list, 789 const lldb_private::SymbolContext &sc) -> lldb::addr_t 790 { 791 load_address = LLDB_INVALID_ADDRESS; 792 793 for (size_t si = 0, se = sc_list.GetSize(); si < se; ++si) 794 { 795 SymbolContext candidate_sc; 796 797 sc_list.GetContextAtIndex(si, candidate_sc); 798 799 const bool is_external = (candidate_sc.function) || 800 (candidate_sc.symbol && candidate_sc.symbol->IsExternal()); 801 802 load_address = candidate_sc.symbol->ResolveCallableAddress(*target); 803 804 if (load_address == LLDB_INVALID_ADDRESS) 805 if (target->GetProcessSP()) 806 load_address = candidate_sc.symbol->GetAddress().GetLoadAddress(target); 807 else 808 load_address = candidate_sc.symbol->GetAddress().GetFileAddress(); 809 810 if (load_address != LLDB_INVALID_ADDRESS) 811 { 812 if (is_external) 813 { 814 return true; 815 } 816 else if (best_internal_load_address == LLDB_INVALID_ADDRESS) 817 { 818 best_internal_load_address = load_address; 819 load_address = LLDB_INVALID_ADDRESS; 820 } 821 } 822 } 823 824 return false; 825 }; 826 827 if (sc.module_sp) 828 { 829 sc.module_sp->FindFunctions(spec.name, 830 NULL, 831 spec.mask, 832 true, // include_symbols 833 false, // include_inlines 834 true, // append 835 sc_list); 836 } 837 838 lldb::addr_t load_address = LLDB_INVALID_ADDRESS; 839 840 if (get_external_load_address(load_address, sc_list, sc)) 841 { 842 return load_address; 843 } 844 else 845 { 846 sc_list.Clear(); 847 } 848 849 if (sc_list.GetSize() == 0 && sc.target_sp) 850 { 851 sc.target_sp->GetImages().FindFunctions(spec.name, 852 spec.mask, 853 true, // include_symbols 854 false, // include_inlines 855 true, // append 856 sc_list); 857 } 858 859 if (get_external_load_address(load_address, sc_list, sc)) 860 { 861 return load_address; 862 } 863 else 864 { 865 sc_list.Clear(); 866 } 867 868 if (sc_list.GetSize() == 0 && sc.target_sp) 869 { 870 sc.target_sp->GetImages().FindSymbolsWithNameAndType(spec.name, lldb::eSymbolTypeAny, sc_list); 871 } 872 873 if (get_external_load_address(load_address, sc_list, sc)) 874 { 875 return load_address; 876 } 877 // if there are any searches we try after this, add an sc_list.Clear() in an "else" clause here 878 879 if (best_internal_load_address != LLDB_INVALID_ADDRESS) 880 { 881 return best_internal_load_address; 882 } 883 } 884 885 return LLDB_INVALID_ADDRESS; 886 } 887 888 lldb::addr_t 889 IRExecutionUnit::FindInRuntimes(const std::vector<SearchSpec> &specs, const lldb_private::SymbolContext &sc) 890 { 891 lldb::TargetSP target_sp = sc.target_sp; 892 893 if (!target_sp) 894 { 895 return LLDB_INVALID_ADDRESS; 896 } 897 898 lldb::ProcessSP process_sp = sc.target_sp->GetProcessSP(); 899 900 if (!process_sp) 901 { 902 return LLDB_INVALID_ADDRESS; 903 } 904 905 ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime(); 906 907 if (runtime) 908 { 909 for (const SearchSpec &spec : specs) 910 { 911 lldb::addr_t symbol_load_addr = runtime->LookupRuntimeSymbol(spec.name); 912 913 if (symbol_load_addr != LLDB_INVALID_ADDRESS) 914 return symbol_load_addr; 915 } 916 } 917 918 return LLDB_INVALID_ADDRESS; 919 } 920 921 lldb::addr_t 922 IRExecutionUnit::FindSymbol(const lldb_private::ConstString &name) 923 { 924 std::vector<SearchSpec> candidate_C_names; 925 std::vector<SearchSpec> candidate_CPlusPlus_names; 926 927 CollectCandidateCNames(candidate_C_names, name); 928 929 lldb::addr_t ret = FindInSymbols(candidate_C_names, m_sym_ctx); 930 if (ret == LLDB_INVALID_ADDRESS) 931 ret = FindInRuntimes(candidate_C_names, m_sym_ctx); 932 933 if (ret == LLDB_INVALID_ADDRESS) 934 { 935 CollectCandidateCPlusPlusNames(candidate_CPlusPlus_names, candidate_C_names, m_sym_ctx); 936 ret = FindInSymbols(candidate_CPlusPlus_names, m_sym_ctx); 937 } 938 939 return ret; 940 } 941 942 uint64_t 943 IRExecutionUnit::MemoryManager::getSymbolAddress(const std::string &Name) 944 { 945 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 946 947 ConstString name_cs(Name.c_str()); 948 949 lldb::addr_t ret = m_parent.FindSymbol(name_cs); 950 951 if (ret == LLDB_INVALID_ADDRESS) 952 { 953 if (log) 954 log->Printf("IRExecutionUnit::getSymbolAddress(Name=\"%s\") = <not found>", 955 Name.c_str()); 956 957 m_parent.ReportSymbolLookupError(name_cs); 958 return 0xbad0bad0; 959 } 960 else 961 { 962 if (log) 963 log->Printf("IRExecutionUnit::getSymbolAddress(Name=\"%s\") = %" PRIx64, 964 Name.c_str(), 965 ret); 966 return ret; 967 } 968 } 969 970 void * 971 IRExecutionUnit::MemoryManager::getPointerToNamedFunction(const std::string &Name, 972 bool AbortOnFailure) { 973 assert (sizeof(void *) == 8); 974 975 return (void*)getSymbolAddress(Name); 976 } 977 978 lldb::addr_t 979 IRExecutionUnit::GetRemoteAddressForLocal (lldb::addr_t local_address) 980 { 981 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 982 983 for (AllocationRecord &record : m_records) 984 { 985 if (local_address >= record.m_host_address && 986 local_address < record.m_host_address + record.m_size) 987 { 988 if (record.m_process_address == LLDB_INVALID_ADDRESS) 989 return LLDB_INVALID_ADDRESS; 990 991 lldb::addr_t ret = record.m_process_address + (local_address - record.m_host_address); 992 993 if (log) 994 { 995 log->Printf("IRExecutionUnit::GetRemoteAddressForLocal() found 0x%" PRIx64 " in [0x%" PRIx64 "..0x%" PRIx64 "], and returned 0x%" PRIx64 " from [0x%" PRIx64 "..0x%" PRIx64 "].", 996 local_address, 997 (uint64_t)record.m_host_address, 998 (uint64_t)record.m_host_address + (uint64_t)record.m_size, 999 ret, 1000 record.m_process_address, 1001 record.m_process_address + record.m_size); 1002 } 1003 1004 return ret; 1005 } 1006 } 1007 1008 return LLDB_INVALID_ADDRESS; 1009 } 1010 1011 IRExecutionUnit::AddrRange 1012 IRExecutionUnit::GetRemoteRangeForLocal (lldb::addr_t local_address) 1013 { 1014 for (AllocationRecord &record : m_records) 1015 { 1016 if (local_address >= record.m_host_address && 1017 local_address < record.m_host_address + record.m_size) 1018 { 1019 if (record.m_process_address == LLDB_INVALID_ADDRESS) 1020 return AddrRange(0, 0); 1021 1022 return AddrRange(record.m_process_address, record.m_size); 1023 } 1024 } 1025 1026 return AddrRange (0, 0); 1027 } 1028 1029 bool 1030 IRExecutionUnit::CommitAllocations (lldb::ProcessSP &process_sp) 1031 { 1032 bool ret = true; 1033 1034 lldb_private::Error err; 1035 1036 for (AllocationRecord &record : m_records) 1037 { 1038 if (record.m_process_address != LLDB_INVALID_ADDRESS) 1039 continue; 1040 1041 switch (record.m_sect_type) 1042 { 1043 case lldb::eSectionTypeInvalid: 1044 case lldb::eSectionTypeDWARFDebugAbbrev: 1045 case lldb::eSectionTypeDWARFDebugAddr: 1046 case lldb::eSectionTypeDWARFDebugAranges: 1047 case lldb::eSectionTypeDWARFDebugFrame: 1048 case lldb::eSectionTypeDWARFDebugInfo: 1049 case lldb::eSectionTypeDWARFDebugLine: 1050 case lldb::eSectionTypeDWARFDebugLoc: 1051 case lldb::eSectionTypeDWARFDebugMacInfo: 1052 case lldb::eSectionTypeDWARFDebugPubNames: 1053 case lldb::eSectionTypeDWARFDebugPubTypes: 1054 case lldb::eSectionTypeDWARFDebugRanges: 1055 case lldb::eSectionTypeDWARFDebugStr: 1056 case lldb::eSectionTypeDWARFDebugStrOffsets: 1057 case lldb::eSectionTypeDWARFAppleNames: 1058 case lldb::eSectionTypeDWARFAppleTypes: 1059 case lldb::eSectionTypeDWARFAppleNamespaces: 1060 case lldb::eSectionTypeDWARFAppleObjC: 1061 err.Clear(); 1062 break; 1063 default: 1064 const bool zero_memory = false; 1065 record.m_process_address = Malloc (record.m_size, 1066 record.m_alignment, 1067 record.m_permissions, 1068 eAllocationPolicyProcessOnly, 1069 zero_memory, 1070 err); 1071 break; 1072 } 1073 1074 if (!err.Success()) 1075 { 1076 ret = false; 1077 break; 1078 } 1079 } 1080 1081 if (!ret) 1082 { 1083 for (AllocationRecord &record : m_records) 1084 { 1085 if (record.m_process_address != LLDB_INVALID_ADDRESS) 1086 { 1087 Free(record.m_process_address, err); 1088 record.m_process_address = LLDB_INVALID_ADDRESS; 1089 } 1090 } 1091 } 1092 1093 return ret; 1094 } 1095 1096 void 1097 IRExecutionUnit::ReportAllocations (llvm::ExecutionEngine &engine) 1098 { 1099 for (AllocationRecord &record : m_records) 1100 { 1101 if (record.m_process_address == LLDB_INVALID_ADDRESS) 1102 continue; 1103 1104 if (record.m_section_id == eSectionIDInvalid) 1105 continue; 1106 1107 engine.mapSectionAddress((void*)record.m_host_address, record.m_process_address); 1108 } 1109 1110 // Trigger re-application of relocations. 1111 engine.finalizeObject(); 1112 } 1113 1114 bool 1115 IRExecutionUnit::WriteData (lldb::ProcessSP &process_sp) 1116 { 1117 bool wrote_something = false; 1118 for (AllocationRecord &record : m_records) 1119 { 1120 if (record.m_process_address != LLDB_INVALID_ADDRESS) 1121 { 1122 lldb_private::Error err; 1123 WriteMemory (record.m_process_address, (uint8_t*)record.m_host_address, record.m_size, err); 1124 if (err.Success()) 1125 wrote_something = true; 1126 } 1127 } 1128 return wrote_something; 1129 } 1130 1131 void 1132 IRExecutionUnit::AllocationRecord::dump (Log *log) 1133 { 1134 if (!log) 1135 return; 1136 1137 log->Printf("[0x%llx+0x%llx]->0x%llx (alignment %d, section ID %d, name %s)", 1138 (unsigned long long)m_host_address, 1139 (unsigned long long)m_size, 1140 (unsigned long long)m_process_address, 1141 (unsigned)m_alignment, 1142 (unsigned)m_section_id, 1143 m_name.c_str()); 1144 } 1145 1146 1147 lldb::ByteOrder 1148 IRExecutionUnit::GetByteOrder () const 1149 { 1150 ExecutionContext exe_ctx (GetBestExecutionContextScope()); 1151 return exe_ctx.GetByteOrder(); 1152 } 1153 1154 uint32_t 1155 IRExecutionUnit::GetAddressByteSize () const 1156 { 1157 ExecutionContext exe_ctx (GetBestExecutionContextScope()); 1158 return exe_ctx.GetAddressByteSize(); 1159 } 1160 1161 void 1162 IRExecutionUnit::PopulateSymtab (lldb_private::ObjectFile *obj_file, 1163 lldb_private::Symtab &symtab) 1164 { 1165 // No symbols yet... 1166 } 1167 1168 1169 void 1170 IRExecutionUnit::PopulateSectionList (lldb_private::ObjectFile *obj_file, 1171 lldb_private::SectionList §ion_list) 1172 { 1173 for (AllocationRecord &record : m_records) 1174 { 1175 if (record.m_size > 0) 1176 { 1177 lldb::SectionSP section_sp (new lldb_private::Section (obj_file->GetModule(), 1178 obj_file, 1179 record.m_section_id, 1180 ConstString(record.m_name), 1181 record.m_sect_type, 1182 record.m_process_address, 1183 record.m_size, 1184 record.m_host_address, // file_offset (which is the host address for the data) 1185 record.m_size, // file_size 1186 0, 1187 record.m_permissions)); // flags 1188 section_list.AddSection (section_sp); 1189 } 1190 } 1191 } 1192 1193 bool 1194 IRExecutionUnit::GetArchitecture (lldb_private::ArchSpec &arch) 1195 { 1196 ExecutionContext exe_ctx (GetBestExecutionContextScope()); 1197 Target *target = exe_ctx.GetTargetPtr(); 1198 if (target) 1199 arch = target->GetArchitecture(); 1200 else 1201 arch.Clear(); 1202 return arch.IsValid(); 1203 } 1204 1205 lldb::ModuleSP 1206 IRExecutionUnit::GetJITModule () 1207 { 1208 ExecutionContext exe_ctx (GetBestExecutionContextScope()); 1209 Target *target = exe_ctx.GetTargetPtr(); 1210 if (target) 1211 { 1212 lldb::ModuleSP jit_module_sp = lldb_private::Module::CreateJITModule (std::static_pointer_cast<lldb_private::ObjectFileJITDelegate>(shared_from_this())); 1213 if (jit_module_sp) 1214 { 1215 bool changed = false; 1216 jit_module_sp->SetLoadAddress(*target, 0, true, changed); 1217 } 1218 return jit_module_sp; 1219 } 1220 return lldb::ModuleSP(); 1221 } 1222