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 for (const SearchSpec &spec : specs) 773 { 774 SymbolContextList sc_list; 775 776 if (sc.module_sp) 777 { 778 sc.module_sp->FindFunctions(spec.name, 779 NULL, 780 spec.mask, 781 true, // include_symbols 782 false, // include_inlines 783 true, // append 784 sc_list); 785 } 786 787 if (sc_list.GetSize() == 0 && sc.target_sp) 788 { 789 sc.target_sp->GetImages().FindFunctions(spec.name, 790 spec.mask, 791 true, // include_symbols 792 false, // include_inlines 793 true, // append 794 sc_list); 795 } 796 797 if (sc_list.GetSize() == 0 && sc.target_sp) 798 { 799 sc.target_sp->GetImages().FindSymbolsWithNameAndType(spec.name, lldb::eSymbolTypeAny, sc_list); 800 } 801 802 lldb::addr_t best_internal_load_address = LLDB_INVALID_ADDRESS; 803 804 for (size_t si = 0, se = sc_list.GetSize(); si < se; ++si) 805 { 806 bool is_external = false; 807 808 SymbolContext candidate_sc; 809 810 sc_list.GetContextAtIndex(si, candidate_sc); 811 if (candidate_sc.function) 812 { 813 is_external = true; 814 } 815 else if (sc.symbol) 816 { 817 if (sc.symbol->IsExternal()) 818 { 819 is_external = true; 820 } 821 } 822 823 lldb::addr_t load_address = candidate_sc.symbol->ResolveCallableAddress(*sc.target_sp); 824 825 if (load_address == LLDB_INVALID_ADDRESS) 826 load_address = candidate_sc.symbol->GetAddress().GetLoadAddress(sc.target_sp.get()); 827 828 if (load_address != LLDB_INVALID_ADDRESS) 829 { 830 if (is_external) 831 { 832 return load_address; 833 } 834 else 835 { 836 best_internal_load_address = load_address; 837 } 838 } 839 } 840 if (best_internal_load_address != LLDB_INVALID_ADDRESS) 841 { 842 return best_internal_load_address; 843 } 844 } 845 846 return LLDB_INVALID_ADDRESS; 847 } 848 849 lldb::addr_t 850 IRExecutionUnit::FindInRuntimes(const std::vector<SearchSpec> &specs, const lldb_private::SymbolContext &sc) 851 { 852 lldb::TargetSP target_sp = sc.target_sp; 853 854 if (!target_sp) 855 { 856 return LLDB_INVALID_ADDRESS; 857 } 858 859 lldb::ProcessSP process_sp = sc.target_sp->GetProcessSP(); 860 861 if (!process_sp) 862 { 863 return LLDB_INVALID_ADDRESS; 864 } 865 866 ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime(); 867 868 if (runtime) 869 { 870 for (const SearchSpec &spec : specs) 871 { 872 lldb::addr_t symbol_load_addr = runtime->LookupRuntimeSymbol(spec.name); 873 874 if (symbol_load_addr != LLDB_INVALID_ADDRESS) 875 return symbol_load_addr; 876 } 877 } 878 879 return LLDB_INVALID_ADDRESS; 880 } 881 882 lldb::addr_t 883 IRExecutionUnit::FindSymbol(const lldb_private::ConstString &name) 884 { 885 std::vector<SearchSpec> candidate_C_names; 886 std::vector<SearchSpec> candidate_CPlusPlus_names; 887 888 CollectCandidateCNames(candidate_C_names, name); 889 890 lldb::addr_t ret = FindInSymbols(candidate_C_names, m_sym_ctx); 891 if (ret == LLDB_INVALID_ADDRESS) 892 ret = FindInRuntimes(candidate_C_names, m_sym_ctx); 893 894 if (ret == LLDB_INVALID_ADDRESS) 895 { 896 CollectCandidateCPlusPlusNames(candidate_CPlusPlus_names, candidate_C_names, m_sym_ctx); 897 ret = FindInSymbols(candidate_CPlusPlus_names, m_sym_ctx); 898 } 899 900 return ret; 901 } 902 903 uint64_t 904 IRExecutionUnit::MemoryManager::getSymbolAddress(const std::string &Name) 905 { 906 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 907 908 ConstString name_cs(Name.c_str()); 909 910 lldb::addr_t ret = m_parent.FindSymbol(name_cs); 911 912 if (ret == LLDB_INVALID_ADDRESS) 913 { 914 if (log) 915 log->Printf("IRExecutionUnit::getSymbolAddress(Name=\"%s\") = <not found>", 916 Name.c_str()); 917 918 m_parent.ReportSymbolLookupError(name_cs); 919 return 0xbad0bad0; 920 } 921 else 922 { 923 if (log) 924 log->Printf("IRExecutionUnit::getSymbolAddress(Name=\"%s\") = %" PRIx64, 925 Name.c_str(), 926 ret); 927 return ret; 928 } 929 } 930 931 void * 932 IRExecutionUnit::MemoryManager::getPointerToNamedFunction(const std::string &Name, 933 bool AbortOnFailure) { 934 assert (sizeof(void *) == 8); 935 936 return (void*)getSymbolAddress(Name); 937 } 938 939 lldb::addr_t 940 IRExecutionUnit::GetRemoteAddressForLocal (lldb::addr_t local_address) 941 { 942 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 943 944 for (AllocationRecord &record : m_records) 945 { 946 if (local_address >= record.m_host_address && 947 local_address < record.m_host_address + record.m_size) 948 { 949 if (record.m_process_address == LLDB_INVALID_ADDRESS) 950 return LLDB_INVALID_ADDRESS; 951 952 lldb::addr_t ret = record.m_process_address + (local_address - record.m_host_address); 953 954 if (log) 955 { 956 log->Printf("IRExecutionUnit::GetRemoteAddressForLocal() found 0x%" PRIx64 " in [0x%" PRIx64 "..0x%" PRIx64 "], and returned 0x%" PRIx64 " from [0x%" PRIx64 "..0x%" PRIx64 "].", 957 local_address, 958 (uint64_t)record.m_host_address, 959 (uint64_t)record.m_host_address + (uint64_t)record.m_size, 960 ret, 961 record.m_process_address, 962 record.m_process_address + record.m_size); 963 } 964 965 return ret; 966 } 967 } 968 969 return LLDB_INVALID_ADDRESS; 970 } 971 972 IRExecutionUnit::AddrRange 973 IRExecutionUnit::GetRemoteRangeForLocal (lldb::addr_t local_address) 974 { 975 for (AllocationRecord &record : m_records) 976 { 977 if (local_address >= record.m_host_address && 978 local_address < record.m_host_address + record.m_size) 979 { 980 if (record.m_process_address == LLDB_INVALID_ADDRESS) 981 return AddrRange(0, 0); 982 983 return AddrRange(record.m_process_address, record.m_size); 984 } 985 } 986 987 return AddrRange (0, 0); 988 } 989 990 bool 991 IRExecutionUnit::CommitAllocations (lldb::ProcessSP &process_sp) 992 { 993 bool ret = true; 994 995 lldb_private::Error err; 996 997 for (AllocationRecord &record : m_records) 998 { 999 if (record.m_process_address != LLDB_INVALID_ADDRESS) 1000 continue; 1001 1002 switch (record.m_sect_type) 1003 { 1004 case lldb::eSectionTypeInvalid: 1005 case lldb::eSectionTypeDWARFDebugAbbrev: 1006 case lldb::eSectionTypeDWARFDebugAddr: 1007 case lldb::eSectionTypeDWARFDebugAranges: 1008 case lldb::eSectionTypeDWARFDebugFrame: 1009 case lldb::eSectionTypeDWARFDebugInfo: 1010 case lldb::eSectionTypeDWARFDebugLine: 1011 case lldb::eSectionTypeDWARFDebugLoc: 1012 case lldb::eSectionTypeDWARFDebugMacInfo: 1013 case lldb::eSectionTypeDWARFDebugPubNames: 1014 case lldb::eSectionTypeDWARFDebugPubTypes: 1015 case lldb::eSectionTypeDWARFDebugRanges: 1016 case lldb::eSectionTypeDWARFDebugStr: 1017 case lldb::eSectionTypeDWARFDebugStrOffsets: 1018 case lldb::eSectionTypeDWARFAppleNames: 1019 case lldb::eSectionTypeDWARFAppleTypes: 1020 case lldb::eSectionTypeDWARFAppleNamespaces: 1021 case lldb::eSectionTypeDWARFAppleObjC: 1022 err.Clear(); 1023 break; 1024 default: 1025 const bool zero_memory = false; 1026 record.m_process_address = Malloc (record.m_size, 1027 record.m_alignment, 1028 record.m_permissions, 1029 eAllocationPolicyProcessOnly, 1030 zero_memory, 1031 err); 1032 break; 1033 } 1034 1035 if (!err.Success()) 1036 { 1037 ret = false; 1038 break; 1039 } 1040 } 1041 1042 if (!ret) 1043 { 1044 for (AllocationRecord &record : m_records) 1045 { 1046 if (record.m_process_address != LLDB_INVALID_ADDRESS) 1047 { 1048 Free(record.m_process_address, err); 1049 record.m_process_address = LLDB_INVALID_ADDRESS; 1050 } 1051 } 1052 } 1053 1054 return ret; 1055 } 1056 1057 void 1058 IRExecutionUnit::ReportAllocations (llvm::ExecutionEngine &engine) 1059 { 1060 for (AllocationRecord &record : m_records) 1061 { 1062 if (record.m_process_address == LLDB_INVALID_ADDRESS) 1063 continue; 1064 1065 if (record.m_section_id == eSectionIDInvalid) 1066 continue; 1067 1068 engine.mapSectionAddress((void*)record.m_host_address, record.m_process_address); 1069 } 1070 1071 // Trigger re-application of relocations. 1072 engine.finalizeObject(); 1073 } 1074 1075 bool 1076 IRExecutionUnit::WriteData (lldb::ProcessSP &process_sp) 1077 { 1078 bool wrote_something = false; 1079 for (AllocationRecord &record : m_records) 1080 { 1081 if (record.m_process_address != LLDB_INVALID_ADDRESS) 1082 { 1083 lldb_private::Error err; 1084 WriteMemory (record.m_process_address, (uint8_t*)record.m_host_address, record.m_size, err); 1085 if (err.Success()) 1086 wrote_something = true; 1087 } 1088 } 1089 return wrote_something; 1090 } 1091 1092 void 1093 IRExecutionUnit::AllocationRecord::dump (Log *log) 1094 { 1095 if (!log) 1096 return; 1097 1098 log->Printf("[0x%llx+0x%llx]->0x%llx (alignment %d, section ID %d, name %s)", 1099 (unsigned long long)m_host_address, 1100 (unsigned long long)m_size, 1101 (unsigned long long)m_process_address, 1102 (unsigned)m_alignment, 1103 (unsigned)m_section_id, 1104 m_name.c_str()); 1105 } 1106 1107 1108 lldb::ByteOrder 1109 IRExecutionUnit::GetByteOrder () const 1110 { 1111 ExecutionContext exe_ctx (GetBestExecutionContextScope()); 1112 return exe_ctx.GetByteOrder(); 1113 } 1114 1115 uint32_t 1116 IRExecutionUnit::GetAddressByteSize () const 1117 { 1118 ExecutionContext exe_ctx (GetBestExecutionContextScope()); 1119 return exe_ctx.GetAddressByteSize(); 1120 } 1121 1122 void 1123 IRExecutionUnit::PopulateSymtab (lldb_private::ObjectFile *obj_file, 1124 lldb_private::Symtab &symtab) 1125 { 1126 // No symbols yet... 1127 } 1128 1129 1130 void 1131 IRExecutionUnit::PopulateSectionList (lldb_private::ObjectFile *obj_file, 1132 lldb_private::SectionList §ion_list) 1133 { 1134 for (AllocationRecord &record : m_records) 1135 { 1136 if (record.m_size > 0) 1137 { 1138 lldb::SectionSP section_sp (new lldb_private::Section (obj_file->GetModule(), 1139 obj_file, 1140 record.m_section_id, 1141 ConstString(record.m_name), 1142 record.m_sect_type, 1143 record.m_process_address, 1144 record.m_size, 1145 record.m_host_address, // file_offset (which is the host address for the data) 1146 record.m_size, // file_size 1147 0, 1148 record.m_permissions)); // flags 1149 section_list.AddSection (section_sp); 1150 } 1151 } 1152 } 1153 1154 bool 1155 IRExecutionUnit::GetArchitecture (lldb_private::ArchSpec &arch) 1156 { 1157 ExecutionContext exe_ctx (GetBestExecutionContextScope()); 1158 Target *target = exe_ctx.GetTargetPtr(); 1159 if (target) 1160 arch = target->GetArchitecture(); 1161 else 1162 arch.Clear(); 1163 return arch.IsValid(); 1164 } 1165 1166 lldb::ModuleSP 1167 IRExecutionUnit::GetJITModule () 1168 { 1169 ExecutionContext exe_ctx (GetBestExecutionContextScope()); 1170 Target *target = exe_ctx.GetTargetPtr(); 1171 if (target) 1172 { 1173 lldb::ModuleSP jit_module_sp = lldb_private::Module::CreateJITModule (std::static_pointer_cast<lldb_private::ObjectFileJITDelegate>(shared_from_this())); 1174 if (jit_module_sp) 1175 { 1176 bool changed = false; 1177 jit_module_sp->SetLoadAddress(*target, 0, true, changed); 1178 } 1179 return jit_module_sp; 1180 } 1181 return lldb::ModuleSP(); 1182 } 1183