contrib/llvm/tools/lldb/source/Expression/IRExecutionUnit.cpp

   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/SymbolContext.h"
  24 #include "lldb/Expression/IRExecutionUnit.h"
  25 #include "lldb/Target/ExecutionContext.h"
  26 #include "lldb/Target/Target.h"
  27 #include "lldb/Target/ObjCLanguageRuntime.h"
  28
  29 using namespace lldb_private;
  30
  31 IRExecutionUnit::IRExecutionUnit (std::unique_ptr<llvm::LLVMContext> &context_ap,
  32                                   std::unique_ptr<llvm::Module> &module_ap,
  33                                   ConstString &name,
  34                                   const lldb::TargetSP &target_sp,
  35                                   std::vector<std::string> &cpu_features) :
  36     IRMemoryMap(target_sp),
  37     m_context_ap(context_ap.release()),
  38     m_module_ap(module_ap.release()),
  39     m_module(m_module_ap.get()),
  40     m_cpu_features(cpu_features),
  41     m_name(name),
  42     m_did_jit(false),
  43     m_function_load_addr(LLDB_INVALID_ADDRESS),
  44     m_function_end_load_addr(LLDB_INVALID_ADDRESS)
  45 {
  46 }
  47
  48 lldb::addr_t
  49 IRExecutionUnit::WriteNow (const uint8_t *bytes,
  50                            size_t size,
  51                            Error &error)
  52 {
  53     lldb::addr_t allocation_process_addr = Malloc (size,
  54                                                    8,
  55                                                    lldb::ePermissionsWritable | lldb::ePermissionsReadable,
  56                                                    eAllocationPolicyMirror,
  57                                                    error);
  58
  59     if (!error.Success())
  60         return LLDB_INVALID_ADDRESS;
  61
  62     WriteMemory(allocation_process_addr, bytes, size, error);
  63
  64     if (!error.Success())
  65     {
  66         Error err;
  67         Free (allocation_process_addr, err);
  68
  69         return LLDB_INVALID_ADDRESS;
  70     }
  71
  72     if (Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS))
  73     {
  74         DataBufferHeap my_buffer(size, 0);
  75         Error err;
  76         ReadMemory(my_buffer.GetBytes(), allocation_process_addr, size, err);
  77
  78         if (err.Success())
  79         {
  80             DataExtractor my_extractor(my_buffer.GetBytes(), my_buffer.GetByteSize(), lldb::eByteOrderBig, 8);
  81             my_extractor.PutToLog(log, 0, my_buffer.GetByteSize(), allocation_process_addr, 16, DataExtractor::TypeUInt8);
  82         }
  83     }
  84
  85     return allocation_process_addr;
  86 }
  87
  88 void
  89 IRExecutionUnit::FreeNow (lldb::addr_t allocation)
  90 {
  91     if (allocation == LLDB_INVALID_ADDRESS)
  92         return;
  93
  94     Error err;
  95
  96     Free(allocation, err);
  97 }
  98
  99 Error
 100 IRExecutionUnit::DisassembleFunction (Stream &stream,
 101                                       lldb::ProcessSP &process_wp)
 102 {
 103     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 104
 105     ExecutionContext exe_ctx(process_wp);
 106
 107     Error ret;
 108
 109     ret.Clear();
 110
 111     lldb::addr_t func_local_addr = LLDB_INVALID_ADDRESS;
 112     lldb::addr_t func_remote_addr = LLDB_INVALID_ADDRESS;
 113
 114     for (JittedFunction &function : m_jitted_functions)
 115     {
 116         if (strstr(function.m_name.c_str(), m_name.AsCString()))
 117         {
 118             func_local_addr = function.m_local_addr;
 119             func_remote_addr = function.m_remote_addr;
 120         }
 121     }
 122
 123     if (func_local_addr == LLDB_INVALID_ADDRESS)
 124     {
 125         ret.SetErrorToGenericError();
 126         ret.SetErrorStringWithFormat("Couldn't find function %s for disassembly", m_name.AsCString());
 127         return ret;
 128     }
 129
 130     if (log)
 131         log->Printf("Found function, has local address 0x%" PRIx64 " and remote address 0x%" PRIx64, (uint64_t)func_local_addr, (uint64_t)func_remote_addr);
 132
 133     std::pair <lldb::addr_t, lldb::addr_t> func_range;
 134
 135     func_range = GetRemoteRangeForLocal(func_local_addr);
 136
 137     if (func_range.first == 0 && func_range.second == 0)
 138     {
 139         ret.SetErrorToGenericError();
 140         ret.SetErrorStringWithFormat("Couldn't find code range for function %s", m_name.AsCString());
 141         return ret;
 142     }
 143
 144     if (log)
 145         log->Printf("Function's code range is [0x%" PRIx64 "+0x%" PRIx64 "]", func_range.first, func_range.second);
 146
 147     Target *target = exe_ctx.GetTargetPtr();
 148     if (!target)
 149     {
 150         ret.SetErrorToGenericError();
 151         ret.SetErrorString("Couldn't find the target");
 152         return ret;
 153     }
 154
 155     lldb::DataBufferSP buffer_sp(new DataBufferHeap(func_range.second, 0));
 156
 157     Process *process = exe_ctx.GetProcessPtr();
 158     Error err;
 159     process->ReadMemory(func_remote_addr, buffer_sp->GetBytes(), buffer_sp->GetByteSize(), err);
 160
 161     if (!err.Success())
 162     {
 163         ret.SetErrorToGenericError();
 164         ret.SetErrorStringWithFormat("Couldn't read from process: %s", err.AsCString("unknown error"));
 165         return ret;
 166     }
 167
 168     ArchSpec arch(target->GetArchitecture());
 169
 170     const char *plugin_name = NULL;
 171     const char *flavor_string = NULL;
 172     lldb::DisassemblerSP disassembler_sp = Disassembler::FindPlugin(arch, flavor_string, plugin_name);
 173
 174     if (!disassembler_sp)
 175     {
 176         ret.SetErrorToGenericError();
 177         ret.SetErrorStringWithFormat("Unable to find disassembler plug-in for %s architecture.", arch.GetArchitectureName());
 178         return ret;
 179     }
 180
 181     if (!process)
 182     {
 183         ret.SetErrorToGenericError();
 184         ret.SetErrorString("Couldn't find the process");
 185         return ret;
 186     }
 187
 188     DataExtractor extractor(buffer_sp,
 189                             process->GetByteOrder(),
 190                             target->GetArchitecture().GetAddressByteSize());
 191
 192     if (log)
 193     {
 194         log->Printf("Function data has contents:");
 195         extractor.PutToLog (log,
 196                             0,
 197                             extractor.GetByteSize(),
 198                             func_remote_addr,
 199                             16,
 200                             DataExtractor::TypeUInt8);
 201     }
 202
 203     disassembler_sp->DecodeInstructions (Address (func_remote_addr), extractor, 0, UINT32_MAX, false, false);
 204
 205     InstructionList &instruction_list = disassembler_sp->GetInstructionList();
 206     instruction_list.Dump(&stream, true, true, &exe_ctx);
 207
 208     // FIXME: The DisassemblerLLVMC has a reference cycle and won't go away if it has any active instructions.
 209     // I'll fix that but for now, just clear the list and it will go away nicely.
 210     disassembler_sp->GetInstructionList().Clear();
 211     return ret;
 212 }
 213
 214 static void ReportInlineAsmError(const llvm::SMDiagnostic &diagnostic, void *Context, unsigned LocCookie)
 215 {
 216     Error *err = static_cast<Error*>(Context);
 217
 218     if (err && err->Success())
 219     {
 220         err->SetErrorToGenericError();
 221         err->SetErrorStringWithFormat("Inline assembly error: %s", diagnostic.getMessage().str().c_str());
 222     }
 223 }
 224
 225 void
 226 IRExecutionUnit::ReportSymbolLookupError(const ConstString &name)
 227 {
 228     m_failed_lookups.push_back(name);
 229 }
 230
 231 void
 232 IRExecutionUnit::GetRunnableInfo(Error &error,
 233                                  lldb::addr_t &func_addr,
 234                                  lldb::addr_t &func_end)
 235 {
 236     lldb::ProcessSP process_sp(GetProcessWP().lock());
 237
 238     static Mutex s_runnable_info_mutex(Mutex::Type::eMutexTypeRecursive);
 239
 240     func_addr = LLDB_INVALID_ADDRESS;
 241     func_end = LLDB_INVALID_ADDRESS;
 242
 243     if (!process_sp)
 244     {
 245         error.SetErrorToGenericError();
 246         error.SetErrorString("Couldn't write the JIT compiled code into the process because the process is invalid");
 247         return;
 248     }
 249
 250     if (m_did_jit)
 251     {
 252         func_addr = m_function_load_addr;
 253         func_end = m_function_end_load_addr;
 254
 255         return;
 256     };
 257
 258     Mutex::Locker runnable_info_mutex_locker(s_runnable_info_mutex);
 259
 260     m_did_jit = true;
 261
 262     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 263
 264     std::string error_string;
 265
 266     if (log)
 267     {
 268         std::string s;
 269         llvm::raw_string_ostream oss(s);
 270
 271         m_module->print(oss, NULL);
 272
 273         oss.flush();
 274
 275         log->Printf ("Module being sent to JIT: \n%s", s.c_str());
 276     }
 277
 278     llvm::Triple triple(m_module->getTargetTriple());
 279     llvm::Function *function = m_module->getFunction (m_name.AsCString());
 280     llvm::Reloc::Model relocModel;
 281     llvm::CodeModel::Model codeModel;
 282
 283     if (triple.isOSBinFormatELF())
 284     {
 285         relocModel = llvm::Reloc::Static;
 286         // This will be small for 32-bit and large for 64-bit.
 287         codeModel = llvm::CodeModel::JITDefault;
 288     }
 289     else
 290     {
 291         relocModel = llvm::Reloc::PIC_;
 292         codeModel = llvm::CodeModel::Small;
 293     }
 294
 295     m_module_ap->getContext().setInlineAsmDiagnosticHandler(ReportInlineAsmError, &error);
 296
 297     llvm::EngineBuilder builder(std::move(m_module_ap));
 298
 299     builder.setEngineKind(llvm::EngineKind::JIT)
 300     .setErrorStr(&error_string)
 301     .setRelocationModel(relocModel)
 302     .setMCJITMemoryManager(std::unique_ptr<MemoryManager>(new MemoryManager(*this)))
 303     .setCodeModel(codeModel)
 304     .setOptLevel(llvm::CodeGenOpt::Less);
 305
 306     llvm::StringRef mArch;
 307     llvm::StringRef mCPU;
 308     llvm::SmallVector<std::string, 0> mAttrs;
 309
 310     for (std::string &feature : m_cpu_features)
 311         mAttrs.push_back(feature);
 312
 313     llvm::TargetMachine *target_machine = builder.selectTarget(triple,
 314                                                                mArch,
 315                                                                mCPU,
 316                                                                mAttrs);
 317
 318     m_execution_engine_ap.reset(builder.create(target_machine));
 319
 320     if (!m_execution_engine_ap.get())
 321     {
 322         error.SetErrorToGenericError();
 323         error.SetErrorStringWithFormat("Couldn't JIT the function: %s", error_string.c_str());
 324         return;
 325     }
 326
 327     // Make sure we see all sections, including ones that don't have relocations...
 328     m_execution_engine_ap->setProcessAllSections(true);
 329
 330     m_execution_engine_ap->DisableLazyCompilation();
 331
 332     // We don't actually need the function pointer here, this just forces it to get resolved.
 333
 334     void *fun_ptr = m_execution_engine_ap->getPointerToFunction(function);
 335
 336     if (!error.Success())
 337     {
 338         // We got an error through our callback!
 339         return;
 340     }
 341
 342     if (!function)
 343     {
 344         error.SetErrorToGenericError();
 345         error.SetErrorStringWithFormat("Couldn't find '%s' in the JITted module", m_name.AsCString());
 346         return;
 347     }
 348
 349     if (!fun_ptr)
 350     {
 351         error.SetErrorToGenericError();
 352         error.SetErrorStringWithFormat("'%s' was in the JITted module but wasn't lowered", m_name.AsCString());
 353         return;
 354     }
 355
 356     m_jitted_functions.push_back (JittedFunction(m_name.AsCString(), (lldb::addr_t)fun_ptr));
 357
 358     CommitAllocations(process_sp);
 359     ReportAllocations(*m_execution_engine_ap);
 360     WriteData(process_sp);
 361
 362     if (m_failed_lookups.size())
 363     {
 364         StreamString ss;
 365
 366         ss.PutCString("Couldn't lookup symbols:\n");
 367
 368         bool emitNewLine = false;
 369
 370         for (const ConstString &failed_lookup : m_failed_lookups)
 371         {
 372             if (emitNewLine)
 373                 ss.PutCString("\n");
 374             emitNewLine = true;
 375             ss.PutCString("  ");
 376             ss.PutCString(Mangled(failed_lookup).GetDemangledName(lldb::eLanguageTypeObjC_plus_plus).AsCString());
 377         }
 378
 379         m_failed_lookups.clear();
 380
 381         error.SetErrorString(ss.GetData());
 382
 383         return;
 384     }
 385
 386     m_function_load_addr = LLDB_INVALID_ADDRESS;
 387     m_function_end_load_addr = LLDB_INVALID_ADDRESS;
 388
 389     for (JittedFunction &jitted_function : m_jitted_functions)
 390     {
 391         jitted_function.m_remote_addr = GetRemoteAddressForLocal (jitted_function.m_local_addr);
 392
 393         if (!jitted_function.m_name.compare(m_name.AsCString()))
 394         {
 395             AddrRange func_range = GetRemoteRangeForLocal(jitted_function.m_local_addr);
 396             m_function_end_load_addr = func_range.first + func_range.second;
 397             m_function_load_addr = jitted_function.m_remote_addr;
 398         }
 399     }
 400
 401     if (log)
 402     {
 403         log->Printf("Code can be run in the target.");
 404
 405         StreamString disassembly_stream;
 406
 407         Error err = DisassembleFunction(disassembly_stream, process_sp);
 408
 409         if (!err.Success())
 410         {
 411             log->Printf("Couldn't disassemble function : %s", err.AsCString("unknown error"));
 412         }
 413         else
 414         {
 415             log->Printf("Function disassembly:\n%s", disassembly_stream.GetData());
 416         }
 417
 418         log->Printf("Sections: ");
 419         for (AllocationRecord &record : m_records)
 420         {
 421             if (record.m_process_address != LLDB_INVALID_ADDRESS)
 422             {
 423                 record.dump(log);
 424
 425                 DataBufferHeap my_buffer(record.m_size, 0);
 426                 Error err;
 427                 ReadMemory(my_buffer.GetBytes(), record.m_process_address, record.m_size, err);
 428
 429                 if (err.Success())
 430                 {
 431                     DataExtractor my_extractor(my_buffer.GetBytes(), my_buffer.GetByteSize(), lldb::eByteOrderBig, 8);
 432                     my_extractor.PutToLog(log, 0, my_buffer.GetByteSize(), record.m_process_address, 16, DataExtractor::TypeUInt8);
 433                 }
 434             }
 435         }
 436     }
 437
 438     func_addr = m_function_load_addr;
 439     func_end = m_function_end_load_addr;
 440
 441     return;
 442 }
 443
 444 IRExecutionUnit::~IRExecutionUnit ()
 445 {
 446     m_module_ap.reset();
 447     m_execution_engine_ap.reset();
 448     m_context_ap.reset();
 449 }
 450
 451 IRExecutionUnit::MemoryManager::MemoryManager (IRExecutionUnit &parent) :
 452     m_default_mm_ap (new llvm::SectionMemoryManager()),
 453     m_parent (parent)
 454 {
 455 }
 456
 457 IRExecutionUnit::MemoryManager::~MemoryManager ()
 458 {
 459 }
 460
 461 lldb::SectionType
 462 IRExecutionUnit::GetSectionTypeFromSectionName (const llvm::StringRef &name, IRExecutionUnit::AllocationKind alloc_kind)
 463 {
 464     lldb::SectionType sect_type = lldb::eSectionTypeCode;
 465     switch (alloc_kind)
 466     {
 467         case AllocationKind::Stub:  sect_type = lldb::eSectionTypeCode; break;
 468         case AllocationKind::Code:  sect_type = lldb::eSectionTypeCode; break;
 469         case AllocationKind::Data:  sect_type = lldb::eSectionTypeData; break;
 470         case AllocationKind::Global:sect_type = lldb::eSectionTypeData; break;
 471         case AllocationKind::Bytes: sect_type = lldb::eSectionTypeOther; break;
 472     }
 473
 474     if (!name.empty())
 475     {
 476         if (name.equals("__text") || name.equals(".text"))
 477             sect_type = lldb::eSectionTypeCode;
 478         else if (name.equals("__data") || name.equals(".data"))
 479             sect_type = lldb::eSectionTypeCode;
 480         else if (name.startswith("__debug_") || name.startswith(".debug_"))
 481         {
 482             const uint32_t name_idx = name[0] == '_' ? 8 : 7;
 483             llvm::StringRef dwarf_name(name.substr(name_idx));
 484             switch (dwarf_name[0])
 485             {
 486                 case 'a':
 487                     if (dwarf_name.equals("abbrev"))
 488                         sect_type = lldb::eSectionTypeDWARFDebugAbbrev;
 489                     else if (dwarf_name.equals("aranges"))
 490                         sect_type = lldb::eSectionTypeDWARFDebugAranges;
 491                     break;
 492
 493                 case 'f':
 494                     if (dwarf_name.equals("frame"))
 495                         sect_type = lldb::eSectionTypeDWARFDebugFrame;
 496                     break;
 497
 498                 case 'i':
 499                     if (dwarf_name.equals("info"))
 500                         sect_type = lldb::eSectionTypeDWARFDebugInfo;
 501                     break;
 502
 503                 case 'l':
 504                     if (dwarf_name.equals("line"))
 505                         sect_type = lldb::eSectionTypeDWARFDebugLine;
 506                     else if (dwarf_name.equals("loc"))
 507                         sect_type = lldb::eSectionTypeDWARFDebugLoc;
 508                     break;
 509
 510                 case 'm':
 511                     if (dwarf_name.equals("macinfo"))
 512                         sect_type = lldb::eSectionTypeDWARFDebugMacInfo;
 513                     break;
 514
 515                 case 'p':
 516                     if (dwarf_name.equals("pubnames"))
 517                         sect_type = lldb::eSectionTypeDWARFDebugPubNames;
 518                     else if (dwarf_name.equals("pubtypes"))
 519                         sect_type = lldb::eSectionTypeDWARFDebugPubTypes;
 520                     break;
 521
 522                 case 's':
 523                     if (dwarf_name.equals("str"))
 524                         sect_type = lldb::eSectionTypeDWARFDebugStr;
 525                     break;
 526
 527                 case 'r':
 528                     if (dwarf_name.equals("ranges"))
 529                         sect_type = lldb::eSectionTypeDWARFDebugRanges;
 530                     break;
 531
 532                 default:
 533                     break;
 534             }
 535         }
 536         else if (name.startswith("__apple_") || name.startswith(".apple_"))
 537         {
 538 #if 0
 539             const uint32_t name_idx = name[0] == '_' ? 8 : 7;
 540             llvm::StringRef apple_name(name.substr(name_idx));
 541             switch (apple_name[0])
 542             {
 543                 case 'n':
 544                     if (apple_name.equals("names"))
 545                         sect_type = lldb::eSectionTypeDWARFAppleNames;
 546                     else if (apple_name.equals("namespac") || apple_name.equals("namespaces"))
 547                         sect_type = lldb::eSectionTypeDWARFAppleNamespaces;
 548                     break;
 549                 case 't':
 550                     if (apple_name.equals("types"))
 551                         sect_type = lldb::eSectionTypeDWARFAppleTypes;
 552                     break;
 553                 case 'o':
 554                     if (apple_name.equals("objc"))
 555                         sect_type = lldb::eSectionTypeDWARFAppleObjC;
 556                     break;
 557                 default:
 558                     break;
 559             }
 560 #else
 561             sect_type = lldb::eSectionTypeInvalid;
 562 #endif
 563         }
 564         else if (name.equals("__objc_imageinfo"))
 565             sect_type = lldb::eSectionTypeOther;
 566     }
 567     return sect_type;
 568 }
 569
 570 uint8_t *
 571 IRExecutionUnit::MemoryManager::allocateCodeSection(uintptr_t Size,
 572                                                     unsigned Alignment,
 573                                                     unsigned SectionID,
 574                                                     llvm::StringRef SectionName)
 575 {
 576     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 577
 578     uint8_t *return_value = m_default_mm_ap->allocateCodeSection(Size, Alignment, SectionID, SectionName);
 579
 580     m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value,
 581                                                   lldb::ePermissionsReadable | lldb::ePermissionsExecutable,
 582                                                   GetSectionTypeFromSectionName (SectionName, AllocationKind::Code),
 583                                                   Size,
 584                                                   Alignment,
 585                                                   SectionID,
 586                                                   SectionName.str().c_str()));
 587
 588     if (log)
 589     {
 590         log->Printf("IRExecutionUnit::allocateCodeSection(Size=0x%" PRIx64 ", Alignment=%u, SectionID=%u) = %p",
 591                     (uint64_t)Size, Alignment, SectionID, (void *)return_value);
 592     }
 593
 594     return return_value;
 595 }
 596
 597 uint8_t *
 598 IRExecutionUnit::MemoryManager::allocateDataSection(uintptr_t Size,
 599                                                     unsigned Alignment,
 600                                                     unsigned SectionID,
 601                                                     llvm::StringRef SectionName,
 602                                                     bool IsReadOnly)
 603 {
 604     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 605
 606     uint8_t *return_value = m_default_mm_ap->allocateDataSection(Size, Alignment, SectionID, SectionName, IsReadOnly);
 607
 608     uint32_t permissions = lldb::ePermissionsReadable;
 609     if (!IsReadOnly)
 610         permissions |= lldb::ePermissionsWritable;
 611     m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value,
 612                                                   permissions,
 613                                                   GetSectionTypeFromSectionName (SectionName, AllocationKind::Data),
 614                                                   Size,
 615                                                   Alignment,
 616                                                   SectionID,
 617                                                   SectionName.str().c_str()));
 618     if (log)
 619     {
 620         log->Printf("IRExecutionUnit::allocateDataSection(Size=0x%" PRIx64 ", Alignment=%u, SectionID=%u) = %p",
 621                     (uint64_t)Size, Alignment, SectionID, (void *)return_value);
 622     }
 623
 624     return return_value;
 625 }
 626
 627 uint64_t
 628 IRExecutionUnit::MemoryManager::getSymbolAddress(const std::string &Name)
 629 {
 630     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 631
 632     SymbolContextList sc_list;
 633
 634     ExecutionContextScope *exe_scope = m_parent.GetBestExecutionContextScope();
 635
 636     lldb::TargetSP target_sp = exe_scope->CalculateTarget();
 637
 638     const char *name = Name.c_str();
 639
 640     ConstString bare_name_cs(name);
 641     ConstString name_cs;
 642
 643     if (name[0] == '_')
 644         name_cs = ConstString(name + 1);
 645
 646     if (!target_sp)
 647     {
 648         if (log)
 649             log->Printf("IRExecutionUnit::getSymbolAddress(Name=\"%s\") = <no target>",
 650                         Name.c_str());
 651
 652         m_parent.ReportSymbolLookupError(name_cs);
 653
 654         return 0xbad0bad0;
 655     }
 656
 657     uint32_t num_matches = 0;
 658     lldb::ProcessSP process_sp = exe_scope->CalculateProcess();
 659
 660     if (!name_cs.IsEmpty())
 661     {
 662         target_sp->GetImages().FindSymbolsWithNameAndType(name_cs, lldb::eSymbolTypeAny, sc_list);
 663         num_matches = sc_list.GetSize();
 664     }
 665
 666     if (!num_matches)
 667     {
 668         target_sp->GetImages().FindSymbolsWithNameAndType(bare_name_cs, lldb::eSymbolTypeAny, sc_list);
 669         num_matches = sc_list.GetSize();
 670     }
 671
 672     lldb::addr_t symbol_load_addr = LLDB_INVALID_ADDRESS;
 673
 674     for (uint32_t i=0; i<num_matches && (symbol_load_addr == 0 || symbol_load_addr == LLDB_INVALID_ADDRESS); i++)
 675     {
 676         SymbolContext sym_ctx;
 677         sc_list.GetContextAtIndex(i, sym_ctx);
 678
 679         symbol_load_addr = sym_ctx.symbol->ResolveCallableAddress(*target_sp);
 680
 681         if (symbol_load_addr == LLDB_INVALID_ADDRESS)
 682             symbol_load_addr = sym_ctx.symbol->GetAddress().GetLoadAddress(target_sp.get());
 683     }
 684
 685     if (symbol_load_addr == LLDB_INVALID_ADDRESS && process_sp && name_cs)
 686     {
 687         // Try the Objective-C language runtime.
 688
 689         ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
 690
 691         if (runtime)
 692             symbol_load_addr = runtime->LookupRuntimeSymbol(name_cs);
 693     }
 694
 695     if (symbol_load_addr == LLDB_INVALID_ADDRESS)
 696     {
 697         if (log)
 698             log->Printf("IRExecutionUnit::getSymbolAddress(Name=\"%s\") = <not found>",
 699                         name);
 700
 701         m_parent.ReportSymbolLookupError(bare_name_cs);
 702
 703         return 0xbad0bad0;
 704     }
 705
 706     if (log)
 707         log->Printf("IRExecutionUnit::getSymbolAddress(Name=\"%s\") = %" PRIx64,
 708                     name,
 709                     symbol_load_addr);
 710
 711     if (symbol_load_addr == 0)
 712         return 0xbad00add;
 713
 714     return symbol_load_addr;
 715 }
 716
 717 void *
 718 IRExecutionUnit::MemoryManager::getPointerToNamedFunction(const std::string &Name,
 719                                                           bool AbortOnFailure) {
 720     assert (sizeof(void *) == 8);
 721
 722     return (void*)getSymbolAddress(Name);
 723 }
 724
 725 lldb::addr_t
 726 IRExecutionUnit::GetRemoteAddressForLocal (lldb::addr_t local_address)
 727 {
 728     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 729
 730     for (AllocationRecord &record : m_records)
 731     {
 732         if (local_address >= record.m_host_address &&
 733             local_address < record.m_host_address + record.m_size)
 734         {
 735             if (record.m_process_address == LLDB_INVALID_ADDRESS)
 736                 return LLDB_INVALID_ADDRESS;
 737
 738             lldb::addr_t ret = record.m_process_address + (local_address - record.m_host_address);
 739
 740             if (log)
 741             {
 742                 log->Printf("IRExecutionUnit::GetRemoteAddressForLocal() found 0x%" PRIx64 " in [0x%" PRIx64 "..0x%" PRIx64 "], and returned 0x%" PRIx64 " from [0x%" PRIx64 "..0x%" PRIx64 "].",
 743                             local_address,
 744                             (uint64_t)record.m_host_address,
 745                             (uint64_t)record.m_host_address + (uint64_t)record.m_size,
 746                             ret,
 747                             record.m_process_address,
 748                             record.m_process_address + record.m_size);
 749             }
 750
 751             return ret;
 752         }
 753     }
 754
 755     return LLDB_INVALID_ADDRESS;
 756 }
 757
 758 IRExecutionUnit::AddrRange
 759 IRExecutionUnit::GetRemoteRangeForLocal (lldb::addr_t local_address)
 760 {
 761     for (AllocationRecord &record : m_records)
 762     {
 763         if (local_address >= record.m_host_address &&
 764             local_address < record.m_host_address + record.m_size)
 765         {
 766             if (record.m_process_address == LLDB_INVALID_ADDRESS)
 767                 return AddrRange(0, 0);
 768
 769             return AddrRange(record.m_process_address, record.m_size);
 770         }
 771     }
 772
 773     return AddrRange (0, 0);
 774 }
 775
 776 bool
 777 IRExecutionUnit::CommitAllocations (lldb::ProcessSP &process_sp)
 778 {
 779     bool ret = true;
 780
 781     lldb_private::Error err;
 782
 783     for (AllocationRecord &record : m_records)
 784     {
 785         if (record.m_process_address != LLDB_INVALID_ADDRESS)
 786             continue;
 787
 788         switch (record.m_sect_type)
 789         {
 790         case lldb::eSectionTypeInvalid:
 791         case lldb::eSectionTypeDWARFDebugAbbrev:
 792         case lldb::eSectionTypeDWARFDebugAranges:
 793         case lldb::eSectionTypeDWARFDebugFrame:
 794         case lldb::eSectionTypeDWARFDebugInfo:
 795         case lldb::eSectionTypeDWARFDebugLine:
 796         case lldb::eSectionTypeDWARFDebugLoc:
 797         case lldb::eSectionTypeDWARFDebugMacInfo:
 798         case lldb::eSectionTypeDWARFDebugPubNames:
 799         case lldb::eSectionTypeDWARFDebugPubTypes:
 800         case lldb::eSectionTypeDWARFDebugRanges:
 801         case lldb::eSectionTypeDWARFDebugStr:
 802         case lldb::eSectionTypeDWARFAppleNames:
 803         case lldb::eSectionTypeDWARFAppleTypes:
 804         case lldb::eSectionTypeDWARFAppleNamespaces:
 805         case lldb::eSectionTypeDWARFAppleObjC:
 806             err.Clear();
 807             break;
 808         default:
 809             record.m_process_address = Malloc (record.m_size,
 810                                                record.m_alignment,
 811                                                record.m_permissions,
 812                                                eAllocationPolicyProcessOnly,
 813                                                err);
 814             break;
 815         }
 816
 817         if (!err.Success())
 818         {
 819             ret = false;
 820             break;
 821         }
 822     }
 823
 824     if (!ret)
 825     {
 826         for (AllocationRecord &record : m_records)
 827         {
 828             if (record.m_process_address != LLDB_INVALID_ADDRESS)
 829             {
 830                 Free(record.m_process_address, err);
 831                 record.m_process_address = LLDB_INVALID_ADDRESS;
 832             }
 833         }
 834     }
 835
 836     return ret;
 837 }
 838
 839 void
 840 IRExecutionUnit::ReportAllocations (llvm::ExecutionEngine &engine)
 841 {
 842     for (AllocationRecord &record : m_records)
 843     {
 844         if (record.m_process_address == LLDB_INVALID_ADDRESS)
 845             continue;
 846
 847         if (record.m_section_id == eSectionIDInvalid)
 848             continue;
 849
 850         engine.mapSectionAddress((void*)record.m_host_address, record.m_process_address);
 851     }
 852
 853     // Trigger re-application of relocations.
 854     engine.finalizeObject();
 855 }
 856
 857 bool
 858 IRExecutionUnit::WriteData (lldb::ProcessSP &process_sp)
 859 {
 860     bool wrote_something = false;
 861     for (AllocationRecord &record : m_records)
 862     {
 863         if (record.m_process_address != LLDB_INVALID_ADDRESS)
 864         {
 865             lldb_private::Error err;
 866             WriteMemory (record.m_process_address, (uint8_t*)record.m_host_address, record.m_size, err);
 867             if (err.Success())
 868                 wrote_something = true;
 869         }
 870     }
 871     return wrote_something;
 872 }
 873
 874 void
 875 IRExecutionUnit::AllocationRecord::dump (Log *log)
 876 {
 877     if (!log)
 878         return;
 879
 880     log->Printf("[0x%llx+0x%llx]->0x%llx (alignment %d, section ID %d)",
 881                 (unsigned long long)m_host_address,
 882                 (unsigned long long)m_size,
 883                 (unsigned long long)m_process_address,
 884                 (unsigned)m_alignment,
 885                 (unsigned)m_section_id);
 886 }
 887
 888
 889 lldb::ByteOrder
 890 IRExecutionUnit::GetByteOrder () const
 891 {
 892     ExecutionContext exe_ctx (GetBestExecutionContextScope());
 893     return exe_ctx.GetByteOrder();
 894 }
 895
 896 uint32_t
 897 IRExecutionUnit::GetAddressByteSize () const
 898 {
 899     ExecutionContext exe_ctx (GetBestExecutionContextScope());
 900     return exe_ctx.GetAddressByteSize();
 901 }
 902
 903 void
 904 IRExecutionUnit::PopulateSymtab (lldb_private::ObjectFile *obj_file,
 905                                  lldb_private::Symtab &symtab)
 906 {
 907     // No symbols yet...
 908 }
 909
 910
 911 void
 912 IRExecutionUnit::PopulateSectionList (lldb_private::ObjectFile *obj_file,
 913                                       lldb_private::SectionList &section_list)
 914 {
 915     for (AllocationRecord &record : m_records)
 916     {
 917         if (record.m_size > 0)
 918         {
 919             lldb::SectionSP section_sp (new lldb_private::Section (obj_file->GetModule(),
 920                                                                    obj_file,
 921                                                                    record.m_section_id,
 922                                                                    ConstString(record.m_name),
 923                                                                    record.m_sect_type,
 924                                                                    record.m_process_address,
 925                                                                    record.m_size,
 926                                                                    record.m_host_address,   // file_offset (which is the host address for the data)
 927                                                                    record.m_size,           // file_size
 928                                                                    0,
 929                                                                    record.m_permissions));  // flags
 930             section_list.AddSection (section_sp);
 931         }
 932     }
 933 }
 934
 935 bool
 936 IRExecutionUnit::GetArchitecture (lldb_private::ArchSpec &arch)
 937 {
 938     ExecutionContext exe_ctx (GetBestExecutionContextScope());
 939     Target *target = exe_ctx.GetTargetPtr();
 940     if (target)
 941         arch = target->GetArchitecture();
 942     else
 943         arch.Clear();
 944     return arch.IsValid();
 945 }
 946
 947 lldb::ModuleSP
 948 IRExecutionUnit::GetJITModule ()
 949 {
 950     ExecutionContext exe_ctx (GetBestExecutionContextScope());
 951     Target *target = exe_ctx.GetTargetPtr();
 952     if (target)
 953     {
 954         lldb::ModuleSP jit_module_sp = lldb_private::Module::CreateJITModule (std::static_pointer_cast<lldb_private::ObjectFileJITDelegate>(shared_from_this()));
 955         if (jit_module_sp)
 956         {
 957             bool changed = false;
 958             jit_module_sp->SetLoadAddress(*target, 0, true, changed);
 959         }
 960         return jit_module_sp;
 961     }
 962     return lldb::ModuleSP();
 963 }