llvm/lib/ExecutionEngine/Orc/DebuggerSupportPlugin.cpp

   1 //===------- DebuggerSupportPlugin.cpp - Utils for debugger support -------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 //
  10 //===----------------------------------------------------------------------===//
  11
  12 #include "llvm/ExecutionEngine/Orc/DebuggerSupportPlugin.h"
  13
  14 #include "llvm/ADT/SmallSet.h"
  15 #include "llvm/ADT/SmallVector.h"
  16 #include "llvm/ADT/StringSet.h"
  17 #include "llvm/BinaryFormat/MachO.h"
  18
  19 #define DEBUG_TYPE "orc"
  20
  21 using namespace llvm;
  22 using namespace llvm::jitlink;
  23 using namespace llvm::orc;
  24
  25 static const char *SynthDebugSectionName = "__jitlink_synth_debug_object";
  26
  27 namespace {
  28
  29 struct MachO64LE {
  30   using UIntPtr = uint64_t;
  31
  32   using Header = MachO::mach_header_64;
  33   using SegmentLC = MachO::segment_command_64;
  34   using Section = MachO::section_64;
  35   using NList = MachO::nlist_64;
  36
  37   static constexpr support::endianness Endianness = support::little;
  38   static constexpr const uint32_t Magic = MachO::MH_MAGIC_64;
  39   static constexpr const uint32_t SegmentCmd = MachO::LC_SEGMENT_64;
  40 };
  41
  42 class MachODebugObjectSynthesizerBase
  43     : public GDBJITDebugInfoRegistrationPlugin::DebugSectionSynthesizer {
  44 public:
  45   static bool isDebugSection(Section &Sec) {
  46     return Sec.getName().startswith("__DWARF,");
  47   }
  48
  49   MachODebugObjectSynthesizerBase(LinkGraph &G, ExecutorAddr RegisterActionAddr)
  50       : G(G), RegisterActionAddr(RegisterActionAddr) {}
  51   virtual ~MachODebugObjectSynthesizerBase() {}
  52
  53   Error preserveDebugSections() {
  54     if (G.findSectionByName(SynthDebugSectionName)) {
  55       LLVM_DEBUG({
  56         dbgs() << "MachODebugObjectSynthesizer skipping graph " << G.getName()
  57                << " which contains an unexpected existing "
  58                << SynthDebugSectionName << " section.\n";
  59       });
  60       return Error::success();
  61     }
  62
  63     LLVM_DEBUG({
  64       dbgs() << "MachODebugObjectSynthesizer visiting graph " << G.getName()
  65              << "\n";
  66     });
  67     for (auto &Sec : G.sections()) {
  68       if (!isDebugSection(Sec))
  69         continue;
  70       // Preserve blocks in this debug section by marking one existing symbol
  71       // live for each block, and introducing a new live, anonymous symbol for
  72       // each currently unreferenced block.
  73       LLVM_DEBUG({
  74         dbgs() << "  Preserving debug section " << Sec.getName() << "\n";
  75       });
  76       SmallSet<Block *, 8> PreservedBlocks;
  77       for (auto *Sym : Sec.symbols()) {
  78         bool NewPreservedBlock =
  79             PreservedBlocks.insert(&Sym->getBlock()).second;
  80         if (NewPreservedBlock)
  81           Sym->setLive(true);
  82       }
  83       for (auto *B : Sec.blocks())
  84         if (!PreservedBlocks.count(B))
  85           G.addAnonymousSymbol(*B, 0, 0, false, true);
  86     }
  87     return Error::success();
  88   }
  89
  90 protected:
  91   LinkGraph &G;
  92   ExecutorAddr RegisterActionAddr;
  93 };
  94
  95 template <typename MachOTraits>
  96 class MachODebugObjectSynthesizer : public MachODebugObjectSynthesizerBase {
  97 private:
  98   class MachOStructWriter {
  99   public:
 100     MachOStructWriter(MutableArrayRef<char> Buffer) : Buffer(Buffer) {}
 101
 102     size_t getOffset() const { return Offset; }
 103
 104     template <typename MachOStruct> void write(MachOStruct S) {
 105       assert(Offset + sizeof(S) <= Buffer.size() &&
 106              "Container block overflow while constructing debug MachO");
 107       if (MachOTraits::Endianness != support::endian::system_endianness())
 108         MachO::swapStruct(S);
 109       memcpy(Buffer.data() + Offset, &S, sizeof(S));
 110       Offset += sizeof(S);
 111     }
 112
 113   private:
 114     MutableArrayRef<char> Buffer;
 115     size_t Offset = 0;
 116   };
 117
 118 public:
 119   using MachODebugObjectSynthesizerBase::MachODebugObjectSynthesizerBase;
 120
 121   Error startSynthesis() override {
 122     LLVM_DEBUG({
 123       dbgs() << "Creating " << SynthDebugSectionName << " for " << G.getName()
 124              << "\n";
 125     });
 126     auto &SDOSec = G.createSection(SynthDebugSectionName, MemProt::Read);
 127
 128     struct DebugSectionInfo {
 129       Section *Sec = nullptr;
 130       StringRef SegName;
 131       StringRef SecName;
 132       uint64_t Alignment = 0;
 133       orc::ExecutorAddr StartAddr;
 134       uint64_t Size = 0;
 135     };
 136
 137     SmallVector<DebugSectionInfo, 12> DebugSecInfos;
 138     size_t NumSections = 0;
 139     for (auto &Sec : G.sections()) {
 140       if (llvm::empty(Sec.blocks()))
 141         continue;
 142
 143       ++NumSections;
 144       if (isDebugSection(Sec)) {
 145         size_t SepPos = Sec.getName().find(',');
 146         if (SepPos > 16 || (Sec.getName().size() - (SepPos + 1) > 16)) {
 147           LLVM_DEBUG({
 148             dbgs() << "Skipping debug object synthesis for graph "
 149                    << G.getName()
 150                    << ": encountered non-standard DWARF section name \""
 151                    << Sec.getName() << "\"\n";
 152           });
 153           return Error::success();
 154         }
 155         DebugSecInfos.push_back({&Sec, Sec.getName().substr(0, SepPos),
 156                                  Sec.getName().substr(SepPos + 1), 0,
 157                                  orc::ExecutorAddr(), 0});
 158       } else {
 159         NonDebugSections.push_back(&Sec);
 160
 161         // If the first block in the section has a non-zero alignment offset
 162         // then we need to add a padding block, since the section command in
 163         // the header doesn't allow for aligment offsets.
 164         SectionRange R(Sec);
 165         if (!R.empty()) {
 166           auto &FB = *R.getFirstBlock();
 167           if (FB.getAlignmentOffset() != 0) {
 168             auto Padding = G.allocateBuffer(FB.getAlignmentOffset());
 169             memset(Padding.data(), 0, Padding.size());
 170             G.createContentBlock(Sec, Padding,
 171                                  FB.getAddress() - FB.getAlignmentOffset(),
 172                                  FB.getAlignment(), 0);
 173           }
 174         }
 175       }
 176     }
 177
 178     // Create container block.
 179     size_t SectionsCmdSize =
 180         sizeof(typename MachOTraits::Section) * NumSections;
 181     size_t SegmentLCSize =
 182         sizeof(typename MachOTraits::SegmentLC) + SectionsCmdSize;
 183     size_t ContainerBlockSize =
 184         sizeof(typename MachOTraits::Header) + SegmentLCSize;
 185     auto ContainerBlockContent = G.allocateBuffer(ContainerBlockSize);
 186     MachOContainerBlock = &G.createMutableContentBlock(
 187         SDOSec, ContainerBlockContent, orc::ExecutorAddr(), 8, 0);
 188
 189     // Copy debug section blocks and symbols.
 190     orc::ExecutorAddr NextBlockAddr(MachOContainerBlock->getSize());
 191     for (auto &SI : DebugSecInfos) {
 192       assert(!llvm::empty(SI.Sec->blocks()) && "Empty debug info section?");
 193
 194       // Update addresses in debug section.
 195       LLVM_DEBUG({
 196         dbgs() << "  Appending " << SI.Sec->getName() << " ("
 197                << SI.Sec->blocks_size() << " block(s)) at "
 198                << formatv("{0:x8}", NextBlockAddr) << "\n";
 199       });
 200       for (auto *B : SI.Sec->blocks()) {
 201         NextBlockAddr = alignToBlock(NextBlockAddr, *B);
 202         B->setAddress(NextBlockAddr);
 203         NextBlockAddr += B->getSize();
 204       }
 205
 206       auto &FirstBlock = **SI.Sec->blocks().begin();
 207       if (FirstBlock.getAlignmentOffset() != 0)
 208         return make_error<StringError>(
 209             "First block in " + SI.Sec->getName() +
 210                 " section has non-zero alignment offset",
 211             inconvertibleErrorCode());
 212       if (FirstBlock.getAlignment() > std::numeric_limits<uint32_t>::max())
 213         return make_error<StringError>("First block in " + SI.Sec->getName() +
 214                                            " has alignment >4Gb",
 215                                        inconvertibleErrorCode());
 216
 217       SI.Alignment = FirstBlock.getAlignment();
 218       SI.StartAddr = FirstBlock.getAddress();
 219       SI.Size = NextBlockAddr - SI.StartAddr;
 220       G.mergeSections(SDOSec, *SI.Sec);
 221       SI.Sec = nullptr;
 222     }
 223     size_t DebugSectionsSize =
 224         NextBlockAddr - orc::ExecutorAddr(MachOContainerBlock->getSize());
 225
 226     // Write MachO header and debug section load commands.
 227     MachOStructWriter Writer(MachOContainerBlock->getAlreadyMutableContent());
 228     typename MachOTraits::Header Hdr;
 229     memset(&Hdr, 0, sizeof(Hdr));
 230     Hdr.magic = MachOTraits::Magic;
 231     switch (G.getTargetTriple().getArch()) {
 232     case Triple::x86_64:
 233       Hdr.cputype = MachO::CPU_TYPE_X86_64;
 234       Hdr.cpusubtype = MachO::CPU_SUBTYPE_X86_64_ALL;
 235       break;
 236     case Triple::aarch64:
 237       Hdr.cputype = MachO::CPU_TYPE_ARM64;
 238       Hdr.cpusubtype = MachO::CPU_SUBTYPE_ARM64_ALL;
 239       break;
 240     default:
 241       llvm_unreachable("Unsupported architecture");
 242     }
 243     Hdr.filetype = MachO::MH_OBJECT;
 244     Hdr.ncmds = 1;
 245     Hdr.sizeofcmds = SegmentLCSize;
 246     Hdr.flags = 0;
 247     Writer.write(Hdr);
 248
 249     typename MachOTraits::SegmentLC SegLC;
 250     memset(&SegLC, 0, sizeof(SegLC));
 251     SegLC.cmd = MachOTraits::SegmentCmd;
 252     SegLC.cmdsize = SegmentLCSize;
 253     SegLC.vmaddr = ContainerBlockSize;
 254     SegLC.vmsize = DebugSectionsSize;
 255     SegLC.fileoff = ContainerBlockSize;
 256     SegLC.filesize = DebugSectionsSize;
 257     SegLC.maxprot =
 258         MachO::VM_PROT_READ | MachO::VM_PROT_WRITE | MachO::VM_PROT_EXECUTE;
 259     SegLC.initprot =
 260         MachO::VM_PROT_READ | MachO::VM_PROT_WRITE | MachO::VM_PROT_EXECUTE;
 261     SegLC.nsects = NumSections;
 262     SegLC.flags = 0;
 263     Writer.write(SegLC);
 264
 265     StringSet<> ExistingLongNames;
 266     for (auto &SI : DebugSecInfos) {
 267       typename MachOTraits::Section Sec;
 268       memset(&Sec, 0, sizeof(Sec));
 269       memcpy(Sec.sectname, SI.SecName.data(), SI.SecName.size());
 270       memcpy(Sec.segname, SI.SegName.data(), SI.SegName.size());
 271       Sec.addr = SI.StartAddr.getValue();
 272       Sec.size = SI.Size;
 273       Sec.offset = SI.StartAddr.getValue();
 274       Sec.align = SI.Alignment;
 275       Sec.reloff = 0;
 276       Sec.nreloc = 0;
 277       Sec.flags = MachO::S_ATTR_DEBUG;
 278       Writer.write(Sec);
 279     }
 280
 281     // Set MachOContainerBlock to indicate success to
 282     // completeSynthesisAndRegister.
 283     NonDebugSectionsStart = Writer.getOffset();
 284     return Error::success();
 285   }
 286
 287   Error completeSynthesisAndRegister() override {
 288     if (!MachOContainerBlock) {
 289       LLVM_DEBUG({
 290         dbgs() << "Not writing MachO debug object header for " << G.getName()
 291                << " since createDebugSection failed\n";
 292       });
 293       return Error::success();
 294     }
 295
 296     LLVM_DEBUG({
 297       dbgs() << "Writing MachO debug object header for " << G.getName() << "\n";
 298     });
 299
 300     MachOStructWriter Writer(
 301         MachOContainerBlock->getAlreadyMutableContent().drop_front(
 302             NonDebugSectionsStart));
 303
 304     unsigned LongSectionNameIdx = 0;
 305     for (auto *Sec : NonDebugSections) {
 306       size_t SepPos = Sec->getName().find(',');
 307       StringRef SegName, SecName;
 308       std::string CustomSecName;
 309
 310       if ((SepPos == StringRef::npos && Sec->getName().size() <= 16)) {
 311         // No embedded segment name, short section name.
 312         SegName = "__JITLINK_CUSTOM";
 313         SecName = Sec->getName();
 314       } else if (SepPos < 16 && (Sec->getName().size() - (SepPos + 1) <= 16)) {
 315         // Canonical embedded segment and section name.
 316         SegName = Sec->getName().substr(0, SepPos);
 317         SecName = Sec->getName().substr(SepPos + 1);
 318       } else {
 319         // Long section name that needs to be truncated.
 320         assert(Sec->getName().size() > 16 &&
 321                "Short section name should have been handled above");
 322         SegName = "__JITLINK_CUSTOM";
 323         auto IdxStr = std::to_string(++LongSectionNameIdx);
 324         CustomSecName = Sec->getName().substr(0, 15 - IdxStr.size()).str();
 325         CustomSecName += ".";
 326         CustomSecName += IdxStr;
 327         SecName = StringRef(CustomSecName.data(), 16);
 328       }
 329
 330       SectionRange R(*Sec);
 331       if (R.getFirstBlock()->getAlignmentOffset() != 0)
 332         return make_error<StringError>(
 333             "While building MachO debug object for " + G.getName() +
 334                 " first block has non-zero alignment offset",
 335             inconvertibleErrorCode());
 336
 337       typename MachOTraits::Section SecCmd;
 338       memset(&SecCmd, 0, sizeof(SecCmd));
 339       memcpy(SecCmd.sectname, SecName.data(), SecName.size());
 340       memcpy(SecCmd.segname, SegName.data(), SegName.size());
 341       SecCmd.addr = R.getStart().getValue();
 342       SecCmd.size = R.getSize();
 343       SecCmd.offset = 0;
 344       SecCmd.align = R.getFirstBlock()->getAlignment();
 345       SecCmd.reloff = 0;
 346       SecCmd.nreloc = 0;
 347       SecCmd.flags = 0;
 348       Writer.write(SecCmd);
 349     }
 350
 351     SectionRange R(MachOContainerBlock->getSection());
 352     G.allocActions().push_back({cantFail(shared::WrapperFunctionCall::Create<
 353                                          SPSArgList<SPSExecutorAddrRange>>(
 354                                     RegisterActionAddr, R.getRange())),
 355                                 {}});
 356     return Error::success();
 357   }
 358
 359 private:
 360   Block *MachOContainerBlock = nullptr;
 361   SmallVector<Section *, 16> NonDebugSections;
 362   size_t NonDebugSectionsStart = 0;
 363 };
 364
 365 } // end anonymous namespace
 366
 367 namespace llvm {
 368 namespace orc {
 369
 370 Expected<std::unique_ptr<GDBJITDebugInfoRegistrationPlugin>>
 371 GDBJITDebugInfoRegistrationPlugin::Create(ExecutionSession &ES,
 372                                           JITDylib &ProcessJD,
 373                                           const Triple &TT) {
 374   auto RegisterActionAddr =
 375       TT.isOSBinFormatMachO()
 376           ? ES.intern("_llvm_orc_registerJITLoaderGDBAllocAction")
 377           : ES.intern("llvm_orc_registerJITLoaderGDBAllocAction");
 378
 379   if (auto Addr = ES.lookup({&ProcessJD}, RegisterActionAddr))
 380     return std::make_unique<GDBJITDebugInfoRegistrationPlugin>(
 381         ExecutorAddr(Addr->getAddress()));
 382   else
 383     return Addr.takeError();
 384 }
 385
 386 Error GDBJITDebugInfoRegistrationPlugin::notifyFailed(
 387     MaterializationResponsibility &MR) {
 388   return Error::success();
 389 }
 390
 391 Error GDBJITDebugInfoRegistrationPlugin::notifyRemovingResources(
 392     ResourceKey K) {
 393   return Error::success();
 394 }
 395
 396 void GDBJITDebugInfoRegistrationPlugin::notifyTransferringResources(
 397     ResourceKey DstKey, ResourceKey SrcKey) {}
 398
 399 void GDBJITDebugInfoRegistrationPlugin::modifyPassConfig(
 400     MaterializationResponsibility &MR, LinkGraph &LG,
 401     PassConfiguration &PassConfig) {
 402
 403   if (LG.getTargetTriple().getObjectFormat() == Triple::MachO)
 404     modifyPassConfigForMachO(MR, LG, PassConfig);
 405   else {
 406     LLVM_DEBUG({
 407       dbgs() << "GDBJITDebugInfoRegistrationPlugin skipping unspported graph "
 408              << LG.getName() << "(triple = " << LG.getTargetTriple().str()
 409              << "\n";
 410     });
 411   }
 412 }
 413
 414 void GDBJITDebugInfoRegistrationPlugin::modifyPassConfigForMachO(
 415     MaterializationResponsibility &MR, jitlink::LinkGraph &LG,
 416     jitlink::PassConfiguration &PassConfig) {
 417
 418   switch (LG.getTargetTriple().getArch()) {
 419   case Triple::x86_64:
 420   case Triple::aarch64:
 421     // Supported, continue.
 422     assert(LG.getPointerSize() == 8 && "Graph has incorrect pointer size");
 423     assert(LG.getEndianness() == support::little &&
 424            "Graph has incorrect endianness");
 425     break;
 426   default:
 427     // Unsupported.
 428     LLVM_DEBUG({
 429       dbgs() << "GDBJITDebugInfoRegistrationPlugin skipping unsupported "
 430              << "MachO graph " << LG.getName()
 431              << "(triple = " << LG.getTargetTriple().str()
 432              << ", pointer size = " << LG.getPointerSize() << ", endianness = "
 433              << (LG.getEndianness() == support::big ? "big" : "little")
 434              << ")\n";
 435     });
 436     return;
 437   }
 438
 439   // Scan for debug sections. If we find one then install passes.
 440   bool HasDebugSections = false;
 441   for (auto &Sec : LG.sections())
 442     if (MachODebugObjectSynthesizerBase::isDebugSection(Sec)) {
 443       HasDebugSections = true;
 444       break;
 445     }
 446
 447   if (HasDebugSections) {
 448     LLVM_DEBUG({
 449       dbgs() << "GDBJITDebugInfoRegistrationPlugin: Graph " << LG.getName()
 450              << " contains debug info. Installing debugger support passes.\n";
 451     });
 452
 453     auto MDOS = std::make_shared<MachODebugObjectSynthesizer<MachO64LE>>(
 454         LG, RegisterActionAddr);
 455     PassConfig.PrePrunePasses.push_back(
 456         [=](LinkGraph &G) { return MDOS->preserveDebugSections(); });
 457     PassConfig.PostPrunePasses.push_back(
 458         [=](LinkGraph &G) { return MDOS->startSynthesis(); });
 459     PassConfig.PreFixupPasses.push_back(
 460         [=](LinkGraph &G) { return MDOS->completeSynthesisAndRegister(); });
 461   } else {
 462     LLVM_DEBUG({
 463       dbgs() << "GDBJITDebugInfoRegistrationPlugin: Graph " << LG.getName()
 464              << " contains no debug info. Skipping.\n";
 465     });
 466   }
 467 }
 468
 469 } // namespace orc
 470 } // namespace llvm