[Mach-O] Dtrace Support Part 1: User SDT provider handling.

[Jean-Daniel]

Summary

Properly recognize dtrace symbols and convert call sites to nop.

While this change allows to compile a program with SDT providers,
the generated binary does not contain the dof section required to enable the defined probes at runtime.

Design note:
Dtrace user probes are encoded as undefined function calls in the generated objets. When reading a Mach-O object, we mark all dtrace calls as 'canBeNullAtBuildTime' so the resolver does not trigger 'unresolved symbol' error. Darwin does not support that flag, so using it on dtrace symbol should be OK.

Then, for each branch relocation that target a dtrace call, we generate a special reference, dtraceProbe or dtraceIsEnabled.

The dtraceProbe and dtraceIsEnabled relocations are used to replace the dtrace call by nop when generating the final executable.

[alexr]

DTrace exists for ELF as well. Can some of this be moved to support that?

[Jean-Daniel]

I don't think. ELF and Mach-O don't share any code and are not designed to do it.
Apart from the dtrace symbol parsing code, I don't see what can be shared with ELF here..

[kledzik]

Thanks for working on this!

lib/ReaderWriter/MachO/ArchHandler.h

258–265

We don't need this in the public interface for ArchHandler. All the "kind" values are private to each ArchHandler subclass.

267–269

This should be virtual and each subclass implements, then you don't need to pass in the "def" parameter. See later comment about changing this to isDtraceSite()

lib/ReaderWriter/MachO/ArchHandler_arm.cpp

546

This could be:

bool isProbe;
if ( isDtraceSite(*target, isProbe) ) {
    *kind = isProbe ? dtraceProbe : dtraceIsEnabled;
}

Where isDtraceSite() replaces branchKindForTarget()

1023–1038

Be nice to have an assert here that reads the *loc32 and validates it was a BL before changing instruction.

1244–1245

Hmmm. We should have dtraceProbeThumb and dtraceProbeArm in ArchHandler_arm. That will simply this.

[Jean-Daniel]

Take 2: Thanks for the review.

Dtrace relocation kinds where exposed to simplify the Dtrace relocation handling in the DofPass implementation (the Part 2). But I think it need more work anyway, so I completely removed the Dtrace ExtraInfo support for now and will reintroduce it when needed.

As I'm not an assembly expert, I'm not 100% sure about the assert to check the replaced instructions.

lib/ReaderWriter/MachO/ArchHandler.h

struct StubInfo {
     ReferenceInfo   stubHelperCommonReferenceToCache;
     OptionalRefInfo optStubHelperCommonReferenceToCache;
     ReferenceInfo   stubHelperCommonReferenceToBinder;
     OptionalRefInfo optStubHelperCommonReferenceToBinder;
   };
 
   virtual const StubInfo &stubInfo() = 0;
 
+  /// Utility method to check if an undefined reference is a dtrace reference
+  bool isDtraceSite(const Atom *target, bool &isProbe);
+
 protected:
   ArchHandler();
 
   static std::unique_ptr<mach_o::ArchHandler> create_x86_64();
   static std::unique_ptr<mach_o::ArchHandler> create_x86();
   static std::unique_ptr<mach_o::ArchHandler> create_arm();
   static std::unique_ptr<mach_o::ArchHandler> create_arm64();
 
   // Handy way to pack mach-o r_type and other bit fields into one 16-bit value.
   typedef uint16_t RelocPattern;
   enum {
     rScattered = 0x8000,
     rPcRel     = 0x4000,
     rExtern    = 0x2000,
     rLength1   = 0x0000,
     rLength2   = 0x0100,
     rLength4   = 0x0200,

lib/ReaderWriter/MachO/ArchHandler.cpp

if (ref->kindNamespace() == Reference::KindNamespace::mach_o &&
       assert(ref->kindArch() == kindArch() && "unexpected Reference arch");
       return ref->target();
     }
   }
 
   return nullptr;
 }
 
+bool
+ArchHandler::isDtraceSite(const Atom *target, bool &isProbe) {
+  DTraceSymbol dsym;
+  if (isa<UndefinedAtom>(target) && isDtraceSymbol(target->name(), &dsym)) {
+    if (dsym.type == "probe") {
+      isProbe = true;
+      return true;
+    } else if (dsym.type == "isenabled") {
+      isProbe = false;
+      return true;
+    }
+  }
+  return false;
+}
+
 } // namespace mach_o
 } // namespace lld
 
 
 

lib/ReaderWriter/MachO/ArchHandler_arm.cpp

enum ArmKind : Reference::KindValue {
     arm_movw_funcRel,      /// ex: movw r1, :lower16:(_foo-(L1+4))
     arm_movt_funcRel,      /// ex: movt r1, :upper16:(_foo-(L1+4))
     pointer32,             /// ex: .long _foo
     delta32,               /// ex: .long _foo - .
 
     // Kinds introduced by Passes:
     lazyPointer,           /// Location contains a lazy pointer.
     lazyImmediateLocation, /// Location contains immediate value used in stub.
+
+    // Dtrace support
+    dtraceProbeArm,           /// ___dtrace_probe$…
+    dtraceIsEnabledArm,       /// ___dtrace_isenabled$…
+    dtraceProbeThumb,
+    dtraceIsEnabledThumb,
   };
 
   // Utility functions for inspecting/updating instructions.
   static bool isThumbMovw(uint32_t instruction);
   static bool isThumbMovt(uint32_t instruction);
   static bool isArmMovw(uint32_t instruction);
   static bool isArmMovt(uint32_t instruction);
   static int32_t getDisplacementFromThumbBranch(uint32_t instruction, uint32_t);
const Registry::KindStrings ArchHandler_arm::_sKindStrings[] = {
   LLD_KIND_STRING_ENTRY(arm_movw),
   LLD_KIND_STRING_ENTRY(arm_movt),
   LLD_KIND_STRING_ENTRY(arm_movw_funcRel),
   LLD_KIND_STRING_ENTRY(arm_movt_funcRel),
   LLD_KIND_STRING_ENTRY(pointer32),
   LLD_KIND_STRING_ENTRY(delta32),
   LLD_KIND_STRING_ENTRY(lazyPointer),
   LLD_KIND_STRING_ENTRY(lazyImmediateLocation),
+  LLD_KIND_STRING_ENTRY(dtraceProbeArm),
+  LLD_KIND_STRING_ENTRY(dtraceIsEnabledArm),
+  LLD_KIND_STRING_ENTRY(dtraceProbeThumb),
+  LLD_KIND_STRING_ENTRY(dtraceIsEnabledThumb),
   LLD_KIND_STRING_END
 };
 
 const ArchHandler::StubInfo ArchHandler_arm::_sStubInfoArmPIC = {
   "dyld_stub_binder",
 
   // References in lazy pointer
   { Reference::KindArch::ARM, pointer32, 0, 0 },
std::error_code ArchHandler_arm::getReferenceInfo(
     FindAtomBySectionAndAddress atomFromAddress,
     FindAtomBySymbolIndex atomFromSymbolIndex, Reference::KindValue *kind,
     const lld::Atom **target, Reference::Addend *addend) {
   typedef std::error_code E;
   const uint8_t *fixupContent = &inAtom->rawContent()[offsetInAtom];
   uint64_t targetAddress;
   uint32_t instruction = *(const ulittle32_t *)fixupContent;
   int32_t displacement;
+  bool isProbe;
   switch (relocPattern(reloc)) {
   case ARM_THUMB_RELOC_BR22 | rPcRel | rExtern | rLength4:
     // ex: bl _foo (and _foo is undefined)
     if ((instruction & 0xD000F800) == 0x9000F000)
       *kind = thumb_b22;
     else
       *kind = thumb_bl22;
     if (E ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
+    if (isDtraceSite(*target, isProbe)) {
+      *kind = isProbe ? dtraceProbeThumb : dtraceIsEnabledThumb;
+    }
     // Instruction contains branch to addend.
     displacement = getDisplacementFromThumbBranch(instruction, fixupAddress);
     *addend = fixupAddress + 4 + displacement;
     return std::error_code();
   case ARM_THUMB_RELOC_BR22 | rPcRel | rLength4:
     // ex: bl _foo (and _foo is defined)
     if ((instruction & 0xD000F800) == 0x9000F000)
       *kind = thumb_b22;
case ARM_RELOC_BR24 | rPcRel | rExtern | rLength4:
     // ex: bl _foo (and _foo is undefined)
     if (((instruction & 0x0F000000) == 0x0A000000)
         && ((instruction & 0xF0000000) != 0xF0000000))
       *kind = arm_b24;
     else
       *kind = arm_bl24;
     if (E ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
+    if (isDtraceSite(*target, isProbe)) {
+      *kind = isProbe ? dtraceProbeArm : dtraceIsEnabledArm;
+    }
     // Instruction contains branch to addend.
     displacement = getDisplacementFromArmBranch(instruction);
     *addend = fixupAddress + 8 + displacement;
     return std::error_code();
   case ARM_RELOC_BR24 | rPcRel | rLength4:
     // ex: bl _foo (and _foo is defined)
     if (((instruction & 0x0F000000) == 0x0A000000)
         && ((instruction & 0xF0000000) != 0xF0000000))
else
       *loc32 = targetAddress - fixupAddress + ref.addend();
     break;
   case lazyPointer:
     // do nothing
     break;
   case lazyImmediateLocation:
     *loc32 = ref.addend();
     break;
+  case dtraceProbeArm:
+    // change call site to a NOP
+    assert(((*loc32 & 0xFF000000) == 0xEB000000) &&
+           "dtrace reloc is not a branch instruction.");
+    *loc32 = 0xE1A00000;
+    break;
+  case dtraceIsEnabledArm:
+    // change call site to 'eor r0, r0, r0'
+    assert(((*loc32 & 0xFF000000) == 0xEB000000) &&
+           "dtrace reloc is not a branch instruction.");
+    *loc32 = 0xE0200000;
+    break;
+  case dtraceProbeThumb:
+    // change 32-bit blx call site to two thumb NOPs
+    assert(((*loc32 & 0xD000F800) == 0xD000F000) &&
+           "dtrace reloc is not a branch instruction.");
+    *loc32 = 0x46C046C0;
+    break;
+  case dtraceIsEnabledThumb:
+    // change 32-bit blx call site to 'nop', 'eor r0, r0'
+    assert(((*loc32 & 0xD000F800) == 0xD000F000) &&
+           "dtrace reloc is not a branch instruction.");
+    *loc32 = 0x46C04040;
+    break;
   case invalid:
     llvm_unreachable("invalid ARM Reference Kind");
     break;
   }
 }
 
 void ArchHandler_arm::generateAtomContent(const DefinedAtom &atom,
                                           bool relocatable,
case pointer32:
     break;
   case delta32:
     *loc32 = targetAddress - fixupAddress + ref.addend();
     break;
   case lazyPointer:
   case lazyImmediateLocation:
     // do nothing
     break;
+  case dtraceProbeArm:
+  case dtraceIsEnabledArm:
+  case dtraceProbeThumb:
+  case dtraceIsEnabledThumb:
+    // do nothing
+    break;
   case invalid:
     llvm_unreachable("invalid ARM Reference Kind");
     break;
   }
 }
 
 void ArchHandler_arm::appendSectionRelocations(
                                    const DefinedAtom &atom,
                                    uint64_t atomSectionOffset,
                                    const Reference &ref,
                                    FindSymbolIndexForAtom symbolIndexForAtom,
                                    FindSectionIndexForAtom sectionIndexForAtom,
                                    FindAddressForAtom addressForAtom,
                                    normalized::Relocations &relocs) {
   if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
     return;
   assert(ref.kindArch() == Reference::KindArch::ARM);
   uint32_t sectionOffset = atomSectionOffset + ref.offsetInAtom();
   bool useExternalReloc = useExternalRelocationTo(*ref.target());
   uint32_t targetAtomAddress;
   uint32_t fromAtomAddress;
   uint16_t other16;
   switch (static_cast<ArmKind>(ref.kindValue())) {
   case modeThumbCode:
   case modeArmCode:
   case modeData:
     // Do nothing.
     break;
   case thumb_b22:
   case thumb_bl22:
+  case dtraceProbeThumb:
+  case dtraceIsEnabledThumb:
     if (useExternalReloc) {
       appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
                   ARM_THUMB_RELOC_BR22 | rExtern    | rPcRel | rLength4);
     } else {
       if (ref.addend() != 0)
         appendReloc(relocs, sectionOffset, 0, addressForAtom(*ref.target()),
                   ARM_THUMB_RELOC_BR22 | rScattered | rPcRel | rLength4);
       else
case thumb_movt_funcRel:
     other16 = (targetAtomAddress - fromAtomAddress + ref.addend()) & 0xFFFF;
     appendReloc(relocs, sectionOffset, 0, targetAtomAddress,
                 ARM_RELOC_HALF_SECTDIFF | rScattered | rLenThmbHi);
     appendReloc(relocs, other16, 0, fromAtomAddress,
                 ARM_RELOC_PAIR          | rScattered | rLenThmbHi);
     break;
   case arm_b24:
   case arm_bl24:
+  case dtraceProbeArm:
+  case dtraceIsEnabledArm:
     if (useExternalReloc) {
       appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
                   ARM_RELOC_BR24 | rExtern    | rPcRel | rLength4);
     } else {
       if (ref.addend() != 0)
         appendReloc(relocs, sectionOffset, 0, addressForAtom(*ref.target()),
                   ARM_RELOC_BR24 | rScattered | rPcRel | rLength4);
       else

lib/ReaderWriter/MachO/ArchHandler_arm64.cpp

enum Arm64Kind : Reference::KindValue {
     lazyImmediateLocation, /// Location contains immediate value used in stub.
     imageOffset,           /// Location contains offset of atom in final image
     imageOffsetGot,        /// Location contains offset of GOT entry for atom in
                            /// final image (typically personality function).
     unwindFDEToFunction,   /// Nearly delta64, but cannot be rematerialized in
                            /// relocatable object (yay for implicit contracts!).
     unwindInfoToEhFrame,   /// Fix low 24 bits of compact unwind encoding to
                            /// refer to __eh_frame entry.
+
+    // Dtrace support
+    dtraceProbe,           /// ___dtrace_probe$…
+    dtraceIsEnabled,       /// ___dtrace_isenabled$…
   };
 
   void applyFixupFinal(const Reference &ref, uint8_t *location,
                        uint64_t fixupAddress, uint64_t targetAddress,
                        uint64_t inAtomAddress, uint64_t imageBaseAddress,
                        FindAddressForAtom findSectionAddress);
 
   void applyFixupRelocatable(const Reference &ref, uint8_t *location,
const Registry::KindStrings ArchHandler_arm64::_sKindStrings[] = {
 
   LLD_KIND_STRING_ENTRY(addOffset12),
   LLD_KIND_STRING_ENTRY(lazyPointer),
   LLD_KIND_STRING_ENTRY(lazyImmediateLocation),
   LLD_KIND_STRING_ENTRY(imageOffset),
   LLD_KIND_STRING_ENTRY(imageOffsetGot),
   LLD_KIND_STRING_ENTRY(unwindFDEToFunction),
   LLD_KIND_STRING_ENTRY(unwindInfoToEhFrame),
+  LLD_KIND_STRING_ENTRY(dtraceProbe),
+  LLD_KIND_STRING_ENTRY(dtraceIsEnabled),
 
   LLD_KIND_STRING_END
 };
 
 const ArchHandler::StubInfo ArchHandler_arm64::_sStubInfo = {
   "dyld_stub_binder",
 
   // Lazy pointer references
std::error_code ArchHandler_arm64::getReferenceInfo(
     uint64_t fixupAddress, bool isBig,
     FindAtomBySectionAndAddress atomFromAddress,
     FindAtomBySymbolIndex atomFromSymbolIndex, Reference::KindValue *kind,
     const lld::Atom **target, Reference::Addend *addend) {
   const uint8_t *fixupContent = &inAtom->rawContent()[offsetInAtom];
   switch (relocPattern(reloc)) {
   case ARM64_RELOC_BRANCH26           | rPcRel | rExtern | rLength4:
     // ex: bl _foo
-    *kind = branch26;
     if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
+    bool isProbe;
+    if (isDtraceSite(*target, isProbe)) {
+      *kind = isProbe ? dtraceProbe : dtraceIsEnabled;
+    } else {
+      *kind = branch26;
+    }
     *addend = 0;
     return std::error_code();
   case ARM64_RELOC_PAGE21             | rPcRel | rExtern | rLength4:
     // ex: adrp x1, _foo@PAGE
     *kind = page21;
     if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
     *addend = 0;
void ArchHandler_arm64::applyFixupFinal(const Reference &ref, uint8_t *loc,
   case imageOffsetGot:
     llvm_unreachable("imageOffsetGot should have been changed to imageOffset");
     break;
   case unwindInfoToEhFrame:
     value64 = targetAddress - findSectionAddress(*ref.target()) + ref.addend();
     assert(value64 < 0xffffffU && "offset in __eh_frame too large");
     *loc32 = (*loc32 & 0xff000000U) | value64;
     return;
+  case dtraceProbe:
+    // change call site to a NOP
+    assert(((*loc32 & 0xFC000000) == 0x94000000) &&
+           "dtrace reloc is not a branch instruction.");
+    *loc32 = 0xD503201F;
+    return;
+  case dtraceIsEnabled:
+    // change call site to 'MOVZ X0,0'
+    assert(((*loc32 & 0xFC000000) == 0x94000000) &&
+           "dtrace reloc is not a branch instruction.");
+    *loc32 = 0xD2800000;
+    return;
   case invalid:
     // Fall into llvm_unreachable().
     break;
   }
   llvm_unreachable("invalid arm64 Reference Kind");
 }
 
 void ArchHandler_arm64::applyFixupRelocatable(const Reference &ref,
void ArchHandler_arm64::applyFixupRelocatable(const Reference &ref,
   case imageOffset:
   case imageOffsetGot:
   case unwindInfoToEhFrame:
     llvm_unreachable("fixup implies __unwind_info");
     return;
   case unwindFDEToFunction:
     // Do nothing for now
     return;
+  case dtraceProbe:
+  case dtraceIsEnabled:
+    // Do nothing
+    return;
   case invalid:
     // Fall into llvm_unreachable().
     break;
   }
   llvm_unreachable("unknown arm64 Reference Kind");
 }
 
 void ArchHandler_arm64::appendSectionRelocations(
     const DefinedAtom &atom, uint64_t atomSectionOffset, const Reference &ref,
     FindSymbolIndexForAtom symbolIndexForAtom,
     FindSectionIndexForAtom sectionIndexForAtom,
     FindAddressForAtom addressForAtom, normalized::Relocations &relocs) {
   if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
     return;
   assert(ref.kindArch() == Reference::KindArch::AArch64);
   uint32_t sectionOffset = atomSectionOffset + ref.offsetInAtom();
   switch (static_cast<Arm64Kind>(ref.kindValue())) {
   case branch26:
+  case dtraceProbe:
+  case dtraceIsEnabled:
     if (ref.addend()) {
       appendReloc(relocs, sectionOffset, ref.addend(), 0,
                   ARM64_RELOC_ADDEND | rLength4);
       appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
                   ARM64_RELOC_BRANCH26 | rPcRel | rExtern | rLength4);
      } else {
       appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
                   ARM64_RELOC_BRANCH26 | rPcRel | rExtern | rLength4);

lib/ReaderWriter/MachO/ArchHandler_x86.cpp

enum X86Kind : Reference::KindValue {
     funcRel32,             /// ex: movl _foo-L1(%eax), %eax
     pointer32,             /// ex: .long _foo
     delta32,               /// ex: .long _foo - .
     negDelta32,            /// ex: .long . - _foo
 
     // Kinds introduced by Passes:
     lazyPointer,           /// Location contains a lazy pointer.
     lazyImmediateLocation, /// Location contains immediate value used in stub.
+
+    // Dtrace support
+    dtraceProbe,           /// ___dtrace_probe$…
+    dtraceIsEnabled,       /// ___dtrace_isenabled$…
   };
 
   static bool useExternalRelocationTo(const Atom &target);
 
   void applyFixupFinal(const Reference &ref, uint8_t *location,
                        uint64_t fixupAddress, uint64_t targetAddress,
                        uint64_t inAtomAddress);
 
const Registry::KindStrings ArchHandler_x86::_sKindStrings[] = {
   LLD_KIND_STRING_ENTRY(branch16),
   LLD_KIND_STRING_ENTRY(abs32),
   LLD_KIND_STRING_ENTRY(funcRel32),
   LLD_KIND_STRING_ENTRY(pointer32),
   LLD_KIND_STRING_ENTRY(delta32),
   LLD_KIND_STRING_ENTRY(negDelta32),
   LLD_KIND_STRING_ENTRY(lazyPointer),
   LLD_KIND_STRING_ENTRY(lazyImmediateLocation),
+  LLD_KIND_STRING_ENTRY(dtraceProbe),
+  LLD_KIND_STRING_ENTRY(dtraceIsEnabled),
   LLD_KIND_STRING_END
 };
 
 const ArchHandler::StubInfo ArchHandler_x86::_sStubInfo = {
   "dyld_stub_binder",
 
   // Lazy pointer references
   { Reference::KindArch::x86, pointer32, 0, 0 },
ArchHandler_x86::getReferenceInfo(const Relocation &reloc,
                                   Reference::Addend *addend) {
   typedef std::error_code E;
   DefinedAtom::ContentPermissions perms;
   const uint8_t *fixupContent = &inAtom->rawContent()[offsetInAtom];
   uint64_t targetAddress;
   switch (relocPattern(reloc)) {
   case GENERIC_RELOC_VANILLA | rPcRel | rExtern | rLength4:
     // ex: call _foo (and _foo undefined)
-    *kind = branch32;
     if (E ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
+    bool isProbe;
+    if (isDtraceSite(*target, isProbe)) {
+      *kind = isProbe ? dtraceProbe : dtraceIsEnabled;
+    } else {
+      *kind = branch32;
+    }
     *addend = fixupAddress + 4 + (int32_t)*(const little32_t *)fixupContent;
     break;
   case GENERIC_RELOC_VANILLA | rPcRel | rLength4:
     // ex: call _foo (and _foo defined)
     *kind = branch32;
     targetAddress =
         fixupAddress + 4 + (int32_t) * (const little32_t *)fixupContent;
     return atomFromAddress(reloc.symbol, targetAddress, target, addend);
void ArchHandler_x86::applyFixupFinal(const Reference &ref, uint8_t *loc,
   case modeCode:
   case modeData:
   case lazyPointer:
     // do nothing
     break;
   case lazyImmediateLocation:
     *loc32 = ref.addend();
     break;
+  case dtraceProbe:
+    // change call site to a NOP
+    assert((loc[-1] == 0xE8) && "dtrace reloc is not a call instruction.");
+    loc[-1] = 0x90; // 1-byte nop
+    *loc32 = 0x00401F0F; // 4-byte nop
+    break;
+  case dtraceIsEnabled:
+    // change call site to a clear eax
+    assert((loc[-1] == 0xE8) && "dtrace reloc is not a call instruction.");
+    loc[-1] = 0x33; // xorl eax,eax
+    loc[0] = 0xC0;
+    loc[1] = 0x90; // 1-byte nop
+    loc[2] = 0x90; // 1-byte nop
+    loc[3] = 0x90; // 1-byte nop
+    break;
   case invalid:
     llvm_unreachable("invalid x86 Reference Kind");
     break;
   }
 }
 
 void ArchHandler_x86::applyFixupRelocatable(const Reference &ref,
                                                uint8_t *loc,
case negDelta32:
     *loc32 = fixupAddress - targetAddress + ref.addend();
     break;
   case modeCode:
   case modeData:
   case lazyPointer:
   case lazyImmediateLocation:
     // do nothing
     break;
+  case dtraceProbe:
+  case dtraceIsEnabled:
+    // do nothing
+    break;
   case invalid:
     llvm_unreachable("invalid x86 Reference Kind");
     break;
   }
 }
 
 bool ArchHandler_x86::useExternalRelocationTo(const Atom &target) {
   // Undefined symbols are referenced via external relocations.
void ArchHandler_x86::appendSectionRelocations(
   assert(ref.kindArch() == Reference::KindArch::x86);
   uint32_t sectionOffset = atomSectionOffset + ref.offsetInAtom();
   bool useExternalReloc = useExternalRelocationTo(*ref.target());
   switch (static_cast<X86Kind>(ref.kindValue())) {
   case modeCode:
   case modeData:
     break;
   case branch32:
+  case dtraceProbe:
+  case dtraceIsEnabled:
     if (useExternalReloc) {
       appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
                   GENERIC_RELOC_VANILLA | rExtern    | rPcRel | rLength4);
     } else {
       if (ref.addend() != 0)
         appendReloc(relocs, sectionOffset, 0, addressForAtom(*ref.target()),
                   GENERIC_RELOC_VANILLA | rScattered | rPcRel |  rLength4);
       else

lib/ReaderWriter/MachO/ArchHandler_x86_64.cpp

enum X86_64Kind: Reference::KindValue {
 
     imageOffset,           /// Location contains offset of atom in final image
     imageOffsetGot,        /// Location contains offset of GOT entry for atom in
                            /// final image (typically personality function).
     unwindFDEToFunction,   /// Nearly delta64, but cannot be rematerialized in
                            /// relocatable object (yay for implicit contracts!).
     unwindInfoToEhFrame,   /// Fix low 24 bits of compact unwind encoding to
                            /// refer to __eh_frame entry.
+
+    // Dtrace support
+    dtraceProbe,           /// ___dtrace_probe$…
+    dtraceIsEnabled,       /// ___dtrace_isenabled$…
   };
 
   Reference::KindValue kindFromReloc(const normalized::Relocation &reloc);
   Reference::KindValue kindFromRelocPair(const normalized::Relocation &reloc1,
                                          const normalized::Relocation &reloc2);
 
   void applyFixupFinal(const Reference &ref, uint8_t *location,
                        uint64_t fixupAddress, uint64_t targetAddress,
                        uint64_t inAtomAddress, uint64_t imageBaseAddress,
                        FindAddressForAtom findSectionAddress);
 
   void applyFixupRelocatable(const Reference &ref, uint8_t *location,
                              uint64_t fixupAddress,
                              uint64_t targetAddress,
                              uint64_t inAtomAddress);
 };
 
 
 ArchHandler_x86_64::ArchHandler_x86_64() { }
 
 ArchHandler_x86_64::~ArchHandler_x86_64() { }
 
 const Registry::KindStrings ArchHandler_x86_64::_sKindStrings[] = {
     LLD_KIND_STRING_ENTRY(invalid), LLD_KIND_STRING_ENTRY(branch32),
     LLD_KIND_STRING_ENTRY(ripRel32), LLD_KIND_STRING_ENTRY(ripRel32Minus1),
-  LLD_KIND_STRING_ENTRY(ripRel32Minus2), LLD_KIND_STRING_ENTRY(ripRel32Minus4),
-  LLD_KIND_STRING_ENTRY(ripRel32Anon), LLD_KIND_STRING_ENTRY(ripRel32GotLoad),
+    LLD_KIND_STRING_ENTRY(ripRel32Minus2),
+    LLD_KIND_STRING_ENTRY(ripRel32Minus4), LLD_KIND_STRING_ENTRY(ripRel32Anon),
+    LLD_KIND_STRING_ENTRY(ripRel32GotLoad),
     LLD_KIND_STRING_ENTRY(ripRel32GotLoadNowLea),
     LLD_KIND_STRING_ENTRY(ripRel32Got), LLD_KIND_STRING_ENTRY(lazyPointer),
     LLD_KIND_STRING_ENTRY(lazyImmediateLocation),
     LLD_KIND_STRING_ENTRY(pointer64), LLD_KIND_STRING_ENTRY(pointer64Anon),
     LLD_KIND_STRING_ENTRY(delta32), LLD_KIND_STRING_ENTRY(delta64),
     LLD_KIND_STRING_ENTRY(delta32Anon), LLD_KIND_STRING_ENTRY(delta64Anon),
-  LLD_KIND_STRING_ENTRY(negDelta32),
-  LLD_KIND_STRING_ENTRY(imageOffset), LLD_KIND_STRING_ENTRY(imageOffsetGot),
+    LLD_KIND_STRING_ENTRY(negDelta32), LLD_KIND_STRING_ENTRY(imageOffset),
+    LLD_KIND_STRING_ENTRY(imageOffsetGot),
     LLD_KIND_STRING_ENTRY(unwindFDEToFunction),
     LLD_KIND_STRING_ENTRY(unwindInfoToEhFrame),
-  LLD_KIND_STRING_END
-};
+    LLD_KIND_STRING_ENTRY(dtraceProbe), LLD_KIND_STRING_ENTRY(dtraceIsEnabled),
+    LLD_KIND_STRING_END};
 
 const ArchHandler::StubInfo ArchHandler_x86_64::_sStubInfo = {
   "dyld_stub_binder",
 
   // Lazy pointer references
   { Reference::KindArch::x86_64, pointer64, 0, 0 },
   { Reference::KindArch::x86_64, lazyPointer, 0, 0 },
 
if (*kind == invalid)
     return make_dynamic_error_code(Twine("unknown type"));
   const uint8_t *fixupContent = &inAtom->rawContent()[offsetInAtom];
   uint64_t targetAddress;
   switch (*kind) {
   case branch32:
   case ripRel32:
     if (E ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
+    bool isProbe;
+    if (*kind == branch32 && isDtraceSite(*target, isProbe))
+      *kind = isProbe ? dtraceProbe : dtraceIsEnabled;
     *addend = *(const little32_t *)fixupContent;
     return std::error_code();
   case ripRel32Minus1:
     if (E ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
     *addend = (int32_t)*(const little32_t *)fixupContent + 1;
     return std::error_code();
   case ripRel32Minus2:
case imageOffsetGot:
     *loc32 = (targetAddress - imageBaseAddress) + ref.addend();
     return;
   case unwindInfoToEhFrame: {
     uint64_t val = targetAddress - findSectionAddress(*ref.target()) + ref.addend();
     assert(val < 0xffffffU && "offset in __eh_frame too large");
     *loc32 = (*loc32 & 0xff000000U) | val;
     return;
   }
+  case dtraceProbe:
+    // change call site to a NOP
+    assert((loc[-1] == 0xE8) && "dtrace reloc is not a call instruction.");
+    loc[-1] = 0x90; // 1-byte nop
+    *loc32 = 0x00401F0F; // 4-byte nop
+    return;
+  case dtraceIsEnabled:
+    // change call site to a clear eax
+    assert((loc[-1] == 0xE8) && "dtrace reloc is not a call instruction.");
+    loc[-1] = 0x33; // xorl eax,eax
+    loc[0] = 0xC0;
+    loc[1] = 0x90; // 1-byte nop
+    loc[2] = 0x90; // 1-byte nop
+    loc[3] = 0x90; // 1-byte nop
+    return;
   case invalid:
     // Fall into llvm_unreachable().
     break;
   }
   llvm_unreachable("invalid x86_64 Reference Kind");
 }
 
 
void ArchHandler_x86_64::applyFixupRelocatable(const Reference &ref,
   case imageOffset:
   case imageOffsetGot:
   case unwindInfoToEhFrame:
     llvm_unreachable("fixup implies __unwind_info");
     return;
   case unwindFDEToFunction:
     // Do nothing for now
     return;
+  case dtraceProbe:
+  case dtraceIsEnabled:
+    // do nothing for object
+    return;
   case invalid:
     // Fall into llvm_unreachable().
     break;
   }
   llvm_unreachable("unknown x86_64 Reference Kind");
 }
 
 void ArchHandler_x86_64::appendSectionRelocations(
                                    const DefinedAtom &atom,
                                    uint64_t atomSectionOffset,
                                    const Reference &ref,
                                    FindSymbolIndexForAtom symbolIndexForAtom,
                                    FindSectionIndexForAtom sectionIndexForAtom,
                                    FindAddressForAtom addressForAtom,
                                    normalized::Relocations &relocs) {
   if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
     return;
   assert(ref.kindArch() == Reference::KindArch::x86_64);
   uint32_t sectionOffset = atomSectionOffset + ref.offsetInAtom();
   switch (static_cast<X86_64Kind>(ref.kindValue())) {
   case branch32:
+  case dtraceProbe:
+  case dtraceIsEnabled:
     appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
                 X86_64_RELOC_BRANCH | rPcRel | rExtern | rLength4);
     return;
   case ripRel32:
     appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
                 X86_64_RELOC_SIGNED | rPcRel | rExtern | rLength4 );
     return;
   case ripRel32Anon:

lib/ReaderWriter/MachO/File.h

 #include "lld/Core/SharedLibraryFile.h"
 #include "lld/Core/Simple.h"
 #include "llvm/ADT/StringMap.h"
 #include <unordered_map>
 
 namespace lld {
 namespace mach_o {
 
+class DtraceUndefinedAtom : public SimpleUndefinedAtom {
+public:
+  DtraceUndefinedAtom(const File &f, StringRef name)
+      : SimpleUndefinedAtom(f, name) {
+    assert(!name.empty() && "UndefinedAtoms must have a name");
+  }
+
+  CanBeNull canBeNull() const override {
+    return UndefinedAtom::canBeNullAtBuildtime;
+  }
+};
+
 using lld::mach_o::normalized::Section;
 
 class MachOFile : public SimpleFile {
 public:
   MachOFile(std::unique_ptr<MemoryBuffer> mb, MachOLinkingContext *ctx)
       : SimpleFile(mb->getBufferIdentifier()), _mb(std::move(mb)), _ctx(ctx) {}
 
   MachOFile(StringRef path) : SimpleFile(path) {}
void addZeroFillDefinedAtom(StringRef name, Atom::Scope scope,
     addAtomForSection(inSection, atom, sectionOffset);
   }
 
   void addUndefinedAtom(StringRef name, bool copyRefs) {
     if (copyRefs) {
       // Make a copy of the atom's name that is owned by this file.
       name = name.copy(allocator());
     }
-    SimpleUndefinedAtom *atom =
-        new (allocator()) SimpleUndefinedAtom(*this, name);
+    SimpleUndefinedAtom *atom;
+    if (normalized::isDtraceSymbol(name)) {
+      // dtrace symbols are placeholder symbols that should not be resolved.
+      // We mark them as 'canBeNullAtBuildtime' to make the resolver happy.
+      // Ideally we shouldn't event try to resolve them.
+      atom = new (allocator()) DtraceUndefinedAtom(*this, name);
+    } else {
+      atom = new (allocator()) SimpleUndefinedAtom(*this, name);
+    }
     addAtom(*atom);
     _undefAtoms[name] = atom;
   }
 
   void addTentativeDefAtom(StringRef name, Atom::Scope scope, uint64_t size,
                            DefinedAtom::Alignment align, bool copyRefs) {
     if (copyRefs) {
       // Make a copy of the atom's name that is owned by this file.

lib/ReaderWriter/MachO/MachONormalizedFile.h

 
 /// A normalized data-in-code entry.
 struct DataInCode {
   Hex32           offset;
   Hex16           length;
   DataRegionType  kind;
 };
 
+/// Dtrace symbol info
+struct DTraceSymbol {
+  StringRef type;
+  StringRef provider;
+  StringRef extra;
+};
+
+// Parse a symbol to dtermine if this is a dtrace runtime symbol.
+// "___dtrace_<type>$<provider>$<extra>
+bool isDtraceSymbol(StringRef symbol, DTraceSymbol *info = nullptr);
 
 /// A typedef so that YAML I/O can encode/decode mach_header.flags.
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, FileFlags)
 
 ///
 struct NormalizedFile {
   NormalizedFile() : arch(MachOLinkingContext::arch_unknown),
                      fileType(llvm::MachO::MH_OBJECT),

lib/ReaderWriter/MachO/MachONormalizedFileBinaryReader.cpp

loadFile(std::unique_ptr<MemoryBuffer> mb, const Registry &registry,
     result.push_back(std::unique_ptr<MachODylibFile>(file));
     return std::error_code();
   }
 
 private:
   MachOLinkingContext &_ctx;
 };
 
+bool isDtraceSymbol(StringRef symbol, DTraceSymbol *info) {
+  if (!symbol.startswith("___dtrace_"))
+    return false;
+  size_t sep = symbol.find('$');
+  if (sep == StringRef::npos)
+    return false;
+  if (info)
+    info->type = symbol.slice(10, sep);
+
+  sep++; // skip '$'
+  size_t sep2 = symbol.find('$', sep);
+  if (sep2 == StringRef::npos)
+    return false;
+  if (info) {
+    info->provider = symbol.slice(sep, sep2);
+    info->extra = symbol.substr(sep2 + 1);
+  }
+  return true;
+}
+
 } // namespace normalized
 } // namespace mach_o
 
 void Registry::addSupportMachOObjects(MachOLinkingContext &ctx) {
   MachOLinkingContext::Arch arch = ctx.arch();
   add(std::unique_ptr<Reader>(new mach_o::normalized::MachOObjectReader(ctx)));
   add(std::unique_ptr<Reader>(new mach_o::normalized::MachODylibReader(ctx)));
   addKindTable(Reference::KindNamespace::mach_o, ctx.archHandler().kindArch(),
                ctx.archHandler().kindStrings());
   add(std::unique_ptr<YamlIOTaggedDocumentHandler>(
                            new mach_o::MachOYamlIOTaggedDocumentHandler(arch)));
 }
 
 
 } // namespace lld

lib/ReaderWriter/MachO/MachONormalizedFileFromAtoms.cpp

struct SegmentInfo {
   std::vector<SectionInfo*>  sections;
   uint32_t                   normalizedSegmentIndex;
 };
 
 SegmentInfo::SegmentInfo(StringRef n)
  : name(n), address(0), size(0), access(0), normalizedSegmentIndex(0) {
 }
 
-
 class Util {
 public:
   Util(const MachOLinkingContext &ctxt)
       : _context(ctxt), _archHandler(ctxt.archHandler()), _entryAtom(nullptr) {}
   ~Util();
 
   void      assignAtomsToSections(const lld::File &atomFile);
   void      organizeSections();
for (AtomAndIndex &ai : globals) {
     _atomToSymbolIndex[ai.atom] = globalStartIndex + file.globalSymbols.size();
     file.globalSymbols.push_back(sym);
   }
 
 
   // Sort undefined symbol alphabetically, then add to symbol table.
   std::vector<AtomAndIndex> undefs;
   undefs.reserve(128);
+  if (rMode) {
+    // Only object can contains undefined atoms. atomFile though
+    // may contains canBeNullAtBuildTime symbols (dtrace) we want to ignore.
     for (const UndefinedAtom *atom : atomFile.undefined()) {
       AtomAndIndex ai = { atom, 0, N_EXT };
       undefs.push_back(ai);
     }
+  }
   for (const SharedLibraryAtom *atom : atomFile.sharedLibrary()) {
     AtomAndIndex ai = { atom, 0, N_EXT };
     undefs.push_back(ai);
   }
+
   std::sort(undefs.begin(), undefs.end(), AtomSorter());
   const uint32_t start = file.globalSymbols.size() + file.localSymbols.size();
   for (AtomAndIndex &ai : undefs) {
     Symbol sym;
     uint16_t desc = 0;
     if (!rMode) {
       uint8_t ordinal = dylibOrdinal(dyn_cast<SharedLibraryAtom>(ai.atom));
       llvm::MachO::SET_LIBRARY_ORDINAL(desc, ordinal);

test/lit.cfg

 
 llvm_config_output = llvm_config_cmd.stdout.read().decode('utf_8')
 llvm_config_output_list = llvm_config_output.split("\n")
 
 if re.search(r'DEBUG', llvm_config_output_list[0]):
     config.available_features.add('debug')
 if re.search(r'ON', llvm_config_output_list[1]):
     config.available_features.add('asserts')
+if re.search(r'AArch64', llvm_config_output_list[2]):
+    config.available_features.add('aarch64')
 if re.search(r'ARM', llvm_config_output_list[2]):
     config.available_features.add('arm')
 if re.search(r'Mips', llvm_config_output_list[2]):
     config.available_features.add('mips')
 if re.search(r'X86', llvm_config_output_list[2]):
     config.available_features.add('x86')
 llvm_config_cmd.wait()
 

test/mach-o/Inputs/dtrace-arm64.yaml

+--- !mach-o
+arch:            arm64
+file-type:       MH_OBJECT
+flags:           [ MH_SUBSECTIONS_VIA_SYMBOLS ]
+has-UUID:        false
+OS:              unknown
+sections:
+  - segment:         __TEXT
+    section:         __text
+    type:            S_REGULAR
+    attributes:      [ S_ATTR_PURE_INSTRUCTIONS ]
+    alignment:       2
+    address:         0x0000000000000000
+    content:         [ 0xFD, 0x7B, 0xBF, 0xA9, 0xFD, 0x03, 0x00, 0x91,
+                       0xFF, 0x83, 0x00, 0xD1, 0x08, 0x00, 0x80, 0x52,
+                       0xA0, 0x23, 0x3F, 0x29, 0xE1, 0x0B, 0x00, 0xF9,
+                       0x00, 0x00, 0x00, 0x94, 0x01, 0x00, 0x00, 0x14,
+                       0x00, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, 0x94,
+                       0xE0, 0x0F, 0x00, 0xB9, 0xE0, 0x0F, 0x40, 0xB9,
+                       0xE0, 0x0B, 0x00, 0xB9, 0xE0, 0x0B, 0x40, 0xB9,
+                       0x1F, 0x00, 0x00, 0x71, 0x41, 0x00, 0x00, 0x54,
+                       0x12, 0x00, 0x00, 0x14, 0x08, 0x00, 0x80, 0x52,
+                       0xE8, 0x07, 0x00, 0xB9, 0xE8, 0x07, 0x40, 0xB9,
+                       0x1F, 0x29, 0x00, 0x71, 0x4B, 0x00, 0x00, 0x54,
+                       0x0B, 0x00, 0x00, 0x14, 0x01, 0x00, 0x00, 0x14,
+                       0xE8, 0x07, 0x40, 0xB9, 0x00, 0x7D, 0x40, 0x93,
+                       0x00, 0x00, 0x00, 0x94, 0x01, 0x00, 0x00, 0x14,
+                       0xE8, 0x07, 0x40, 0xB9, 0xE9, 0x03, 0x00, 0x32,
+                       0x08, 0x01, 0x09, 0x0B, 0xE8, 0x07, 0x00, 0xB9,
+                       0xF3, 0xFF, 0xFF, 0x17, 0x01, 0x00, 0x00, 0x14,
+                       0x01, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x94,
+                       0x01, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x94,
+                       0x00, 0x00, 0x80, 0x52, 0xBF, 0x03, 0x00, 0x91,
+                       0xFD, 0x7B, 0xC1, 0xA8, 0xC0, 0x03, 0x5F, 0xD6 ]
+    relocations:
+      - offset:          0x00000018
+        type:            ARM64_RELOC_BRANCH26
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          2
+      - offset:          0x00000020
+        type:            ARM64_RELOC_BRANCH26
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          5
+      - offset:          0x00000024
+        type:            ARM64_RELOC_BRANCH26
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          1
+      - offset:          0x00000068
+        type:            ARM64_RELOC_BRANCH26
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          4
+      - offset:          0x0000008C
+        type:            ARM64_RELOC_BRANCH26
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          5
+      - offset:          0x00000094
+        type:            ARM64_RELOC_BRANCH26
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          3
+global-symbols:
+  - name:            _main
+    type:            N_SECT
+    scope:           [ N_EXT ]
+    sect:            1
+    value:           0x0000000000000000
+undefined-symbols:
+  - name:            '___dtrace_isenabled$std$bar$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$provider_with_long_name$foo$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$provider_with_long_name_too$foo$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$std$bar$v1$696e7436345f74'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$std$foo$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_stability$provider_with_long_name$v1$1_1_0_1_1_0_1_1_0_1_1_0_1_1_0'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_stability$provider_with_long_name_too$v1$1_1_0_1_1_0_1_1_0_1_1_0_1_1_0'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_stability$std$v1$1_1_0_1_1_0_1_1_0_1_1_0_1_1_0'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_typedefs$provider_with_long_name$v2'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_typedefs$provider_with_long_name_too$v2'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_typedefs$std$v2'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+page-size:       0x00004000
+...

test/mach-o/Inputs/dtrace-armv7s-thumb.yaml

+--- !mach-o
+arch:            armv7s
+file-type:       MH_OBJECT
+flags:           [ MH_SUBSECTIONS_VIA_SYMBOLS ]
+has-UUID:        false
+OS:              unknown
+sections:
+  - segment:         __TEXT
+    section:         __text
+    type:            S_REGULAR
+    attributes:      [ S_ATTR_PURE_INSTRUCTIONS ]
+    alignment:       2
+    address:         0x0000000000000000
+    content:         [ 0x80, 0xB5, 0x6F, 0x46, 0x87, 0xB0, 0x00, 0x22,
+                       0xC0, 0xF2, 0x00, 0x02, 0x06, 0x92, 0x05, 0x90,
+                       0x04, 0x91, 0xFF, 0xF7, 0xF5, 0xFF, 0xFF, 0xE7,
+                       0xFF, 0xF7, 0xF2, 0xFF, 0xFF, 0xF7, 0xF0, 0xFF,
+                       0x03, 0x90, 0x03, 0x98, 0x02, 0x90, 0x02, 0x98,
+                       0x00, 0x28, 0x15, 0xD0, 0x00, 0x20, 0xC0, 0xF2,
+                       0x00, 0x00, 0x01, 0x90, 0x01, 0x98, 0x0A, 0x28,
+                       0x0D, 0xDA, 0xFF, 0xE7, 0x01, 0x98, 0x01, 0x46,
+                       0x4F, 0xEA, 0xE0, 0x72, 0x00, 0x91, 0x11, 0x46,
+                       0xFF, 0xF7, 0xDA, 0xFF, 0xFF, 0xE7, 0x01, 0x98,
+                       0x01, 0x30, 0x01, 0x90, 0xEE, 0xE7, 0xFF, 0xE7,
+                       0xFF, 0xE7, 0xFF, 0xF7, 0xD1, 0xFF, 0xFF, 0xE7,
+                       0xFF, 0xF7, 0xCE, 0xFF, 0x00, 0x20, 0xC0, 0xF2,
+                       0x00, 0x00, 0x07, 0xB0, 0x80, 0xBD ]
+    relocations:
+      - offset:          0x00000012
+        type:            ARM_THUMB_RELOC_BR22
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          2
+      - offset:          0x00000018
+        type:            ARM_THUMB_RELOC_BR22
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          5
+      - offset:          0x0000001C
+        type:            ARM_THUMB_RELOC_BR22
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          1
+      - offset:          0x00000048
+        type:            ARM_THUMB_RELOC_BR22
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          4
+      - offset:          0x0000005A
+        type:            ARM_THUMB_RELOC_BR22
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          5
+      - offset:          0x00000060
+        type:            ARM_THUMB_RELOC_BR22
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          3
+global-symbols:
+  - name:            _main
+    type:            N_SECT
+    scope:           [ N_EXT ]
+    sect:            1
+    desc:            [ N_ARM_THUMB_DEF ]
+    value:           0x0000000000000000
+undefined-symbols:
+  - name:            '___dtrace_isenabled$std$bar$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$provider_with_long_name$foo$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$provider_with_long_name_too$foo$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$std$bar$v1$696e7436345f74'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$std$foo$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_stability$provider_with_long_name$v1$1_1_0_1_1_0_1_1_0_1_1_0_1_1_0'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_stability$provider_with_long_name_too$v1$1_1_0_1_1_0_1_1_0_1_1_0_1_1_0'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_stability$std$v1$1_1_0_1_1_0_1_1_0_1_1_0_1_1_0'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_typedefs$provider_with_long_name$v2'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_typedefs$provider_with_long_name_too$v2'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_typedefs$std$v2'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+...

test/mach-o/Inputs/dtrace-armv7s.yaml

+--- !mach-o
+arch:            armv7s
+file-type:       MH_OBJECT
+flags:           [ MH_SUBSECTIONS_VIA_SYMBOLS ]
+has-UUID:        false
+OS:              unknown
+sections:
+  - segment:         __TEXT
+    section:         __text
+    type:            S_REGULAR
+    attributes:      [ S_ATTR_PURE_INSTRUCTIONS ]
+    alignment:       2
+    address:         0x0000000000000000
+    content:         [ 0x80, 0x40, 0x2D, 0xE9, 0x0D, 0x70, 0xA0, 0xE1,
+                       0x1C, 0xD0, 0x4D, 0xE2, 0x00, 0x20, 0x00, 0xE3,
+                       0x04, 0x20, 0x07, 0xE5, 0x08, 0x00, 0x07, 0xE5,
+                       0x0C, 0x10, 0x07, 0xE5, 0xF7, 0xFF, 0xFF, 0xEB,
+                       0xFF, 0xFF, 0xFF, 0xEA, 0xF5, 0xFF, 0xFF, 0xEB,
+                       0xF4, 0xFF, 0xFF, 0xEB, 0x0C, 0x00, 0x8D, 0xE5,
+                       0x0C, 0x00, 0x9D, 0xE5, 0x08, 0x00, 0x8D, 0xE5,
+                       0x08, 0x00, 0x9D, 0xE5, 0x00, 0x00, 0x50, 0xE3,
+                       0x11, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xE3,
+                       0x04, 0x00, 0x8D, 0xE5, 0x04, 0x00, 0x9D, 0xE5,
+                       0x0A, 0x00, 0x50, 0xE3, 0x0B, 0x00, 0x00, 0xAA,
+                       0xFF, 0xFF, 0xFF, 0xEA, 0x04, 0x00, 0x9D, 0xE5,
+                       0x00, 0x10, 0xA0, 0xE1, 0xC0, 0x2F, 0xA0, 0xE1,
+                       0x00, 0x10, 0x8D, 0xE5, 0x02, 0x10, 0xA0, 0xE1,
+                       0xE2, 0xFF, 0xFF, 0xEB, 0xFF, 0xFF, 0xFF, 0xEA,
+                       0x04, 0x00, 0x9D, 0xE5, 0x01, 0x00, 0x80, 0xE2,
+                       0x04, 0x00, 0x8D, 0xE5, 0xF0, 0xFF, 0xFF, 0xEA,
+                       0xFF, 0xFF, 0xFF, 0xEA, 0xFF, 0xFF, 0xFF, 0xEA,
+                       0xDA, 0xFF, 0xFF, 0xEB, 0xFF, 0xFF, 0xFF, 0xEA,
+                       0xD8, 0xFF, 0xFF, 0xEB, 0x00, 0x00, 0x00, 0xE3,
+                       0x07, 0xD0, 0xA0, 0xE1, 0x80, 0x80, 0xBD, 0xE8 ]
+    relocations:
+      - offset:          0x0000001C
+        type:            ARM_RELOC_BR24
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          2
+      - offset:          0x00000024
+        type:            ARM_RELOC_BR24
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          5
+      - offset:          0x00000028
+        type:            ARM_RELOC_BR24
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          1
+      - offset:          0x00000070
+        type:            ARM_RELOC_BR24
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          4
+      - offset:          0x00000090
+        type:            ARM_RELOC_BR24
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          5
+      - offset:          0x00000098
+        type:            ARM_RELOC_BR24
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          3
+global-symbols:
+  - name:            _main
+    type:            N_SECT
+    scope:           [ N_EXT ]
+    sect:            1
+    value:           0x0000000000000000
+undefined-symbols:
+  - name:            '___dtrace_isenabled$std$bar$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$provider_with_long_name$foo$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$provider_with_long_name_too$foo$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$std$bar$v1$696e7436345f74'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$std$foo$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_stability$provider_with_long_name$v1$1_1_0_1_1_0_1_1_0_1_1_0_1_1_0'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_stability$provider_with_long_name_too$v1$1_1_0_1_1_0_1_1_0_1_1_0_1_1_0'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_stability$std$v1$1_1_0_1_1_0_1_1_0_1_1_0_1_1_0'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_typedefs$provider_with_long_name$v2'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_typedefs$provider_with_long_name_too$v2'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_typedefs$std$v2'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+...

test/mach-o/Inputs/dtrace-x86.yaml

+--- !mach-o
+arch:            x86
+file-type:       MH_OBJECT
+flags:           [ MH_SUBSECTIONS_VIA_SYMBOLS ]
+has-UUID:        false
+OS:              unknown
+sections:
+  - segment:         __TEXT
+    section:         __text
+    type:            S_REGULAR
+    attributes:      [ S_ATTR_PURE_INSTRUCTIONS ]
+    alignment:       4
+    address:         0x0000000000000000
+    content:         [ 0x55, 0x89, 0xE5, 0x83, 0xEC, 0x28, 0x8B, 0x45,
+                       0x0C, 0x8B, 0x4D, 0x08, 0xC7, 0x45, 0xFC, 0x00,
+                       0x00, 0x00, 0x00, 0x89, 0x4D, 0xF8, 0x89, 0x45,
+                       0xF4, 0xE8, 0xE2, 0xFF, 0xFF, 0xFF, 0xE9, 0x00,
+                       0x00, 0x00, 0x00, 0xE8, 0xD8, 0xFF, 0xFF, 0xFF,
+                       0xE8, 0xD3, 0xFF, 0xFF, 0xFF, 0x89, 0x45, 0xF0,
+                       0x8B, 0x45, 0xF0, 0x89, 0x45, 0xEC, 0x81, 0x7D,
+                       0xEC, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x84, 0x47,
+                       0x00, 0x00, 0x00, 0xC7, 0x45, 0xE8, 0x00, 0x00,
+                       0x00, 0x00, 0x81, 0x7D, 0xE8, 0x0A, 0x00, 0x00,
+                       0x00, 0x0F, 0x8D, 0x2E, 0x00, 0x00, 0x00, 0xE9,
+                       0x00, 0x00, 0x00, 0x00, 0x8B, 0x45, 0xE8, 0x89,
+                       0xC1, 0xC1, 0xF9, 0x1F, 0x89, 0xE2, 0x89, 0x4A,
+                       0x04, 0x89, 0x02, 0xE8, 0x90, 0xFF, 0xFF, 0xFF,
+                       0xE9, 0x00, 0x00, 0x00, 0x00, 0x8B, 0x45, 0xE8,
+                       0x05, 0x01, 0x00, 0x00, 0x00, 0x89, 0x45, 0xE8,
+                       0xE9, 0xC5, 0xFF, 0xFF, 0xFF, 0xE9, 0x00, 0x00,
+                       0x00, 0x00, 0xE9, 0x00, 0x00, 0x00, 0x00, 0xE8,
+                       0x6C, 0xFF, 0xFF, 0xFF, 0xE9, 0x00, 0x00, 0x00,
+                       0x00, 0xE8, 0x62, 0xFF, 0xFF, 0xFF, 0xB8, 0x00,
+                       0x00, 0x00, 0x00, 0x83, 0xC4, 0x28, 0x5D, 0xC3 ]
+    relocations:
+      - offset:          0x0000001A
+        type:            GENERIC_RELOC_VANILLA
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          2
+      - offset:          0x00000024
+        type:            GENERIC_RELOC_VANILLA
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          5
+      - offset:          0x00000029
+        type:            GENERIC_RELOC_VANILLA
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          1
+      - offset:          0x0000006C
+        type:            GENERIC_RELOC_VANILLA
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          4
+      - offset:          0x00000090
+        type:            GENERIC_RELOC_VANILLA
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          5
+      - offset:          0x0000009A
+        type:            GENERIC_RELOC_VANILLA
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          3
+global-symbols:
+  - name:            _main
+    type:            N_SECT
+    scope:           [ N_EXT ]
+    sect:            1
+    value:           0x0000000000000000
+undefined-symbols:
+  - name:            '___dtrace_isenabled$std$bar$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$provider_with_long_name$foo$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$provider_with_long_name_too$foo$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$std$bar$v1$696e7436345f74'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$std$foo$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_stability$provider_with_long_name$v1$1_1_0_1_1_0_1_1_0_1_1_0_1_1_0'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_stability$provider_with_long_name_too$v1$1_1_0_1_1_0_1_1_0_1_1_0_1_1_0'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_stability$std$v1$1_1_0_1_1_0_1_1_0_1_1_0_1_1_0'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_typedefs$provider_with_long_name$v2'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_typedefs$provider_with_long_name_too$v2'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_typedefs$std$v2'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+...

test/mach-o/Inputs/dtrace-x86_64.yaml

+#
+# --- dtrace probe file ---
+# provider std {
+#   probe foo();
+#   probe bar(int64_t time);
+# };
+#
+# provider provider_with_long_name {
+#   probe foo();
+# };
+#
+# provider provider_with_long_name_too {
+#   probe foo();
+# };
+#
+#
+# --- C source file ---
+# int main(int argc, const char * argv[]) {
+#   PROVIDER_WITH_LONG_NAME_FOO();
+#
+#   STD_FOO();
+#   if (STD_BAR_ENABLED()) {
+#     for (int i = 0; i < 10; ++i) {
+#       STD_BAR(i);
+#     }
+#   }
+#   STD_FOO();
+#
+#   PROVIDER_WITH_LONG_NAME_TOO_FOO();
+#   return 0;
+# }
+#
+
+--- !mach-o
+arch:            x86_64
+file-type:       MH_OBJECT
+flags:           [ MH_SUBSECTIONS_VIA_SYMBOLS ]
+has-UUID:        false
+OS:              unknown
+sections:
+  - segment:         __TEXT
+    section:         __text
+    type:            S_REGULAR
+    attributes:      [ S_ATTR_PURE_INSTRUCTIONS, S_ATTR_SOME_INSTRUCTIONS ]
+    alignment:       4
+    address:         0x0000000000000000
+    content:         [ 0x55, 0x48, 0x89, 0xE5, 0x48, 0x83, 0xEC, 0x20,
+                       0xC7, 0x45, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x89,
+                       0x7D, 0xF8, 0x48, 0x89, 0x75, 0xF0, 0xE8, 0x00,
+                       0x00, 0x00, 0x00, 0xE9, 0x00, 0x00, 0x00, 0x00,
+                       0xE8, 0x00, 0x00, 0x00, 0x00, 0xE8, 0x00, 0x00,
+                       0x00, 0x00, 0x89, 0x45, 0xEC, 0x8B, 0x45, 0xEC,
+                       0x89, 0x45, 0xE8, 0x81, 0x7D, 0xE8, 0x00, 0x00,
+                       0x00, 0x00, 0x0F, 0x84, 0x3C, 0x00, 0x00, 0x00,
+                       0xC7, 0x45, 0xE4, 0x00, 0x00, 0x00, 0x00, 0x81,
+                       0x7D, 0xE4, 0x0A, 0x00, 0x00, 0x00, 0x0F, 0x8D,
+                       0x23, 0x00, 0x00, 0x00, 0xE9, 0x00, 0x00, 0x00,
+                       0x00, 0x48, 0x63, 0x7D, 0xE4, 0xE8, 0x00, 0x00,
+                       0x00, 0x00, 0xE9, 0x00, 0x00, 0x00, 0x00, 0x8B,
+                       0x45, 0xE4, 0x05, 0x01, 0x00, 0x00, 0x00, 0x89,
+                       0x45, 0xE4, 0xE9, 0xD0, 0xFF, 0xFF, 0xFF, 0xE9,
+                       0x00, 0x00, 0x00, 0x00, 0xE9, 0x00, 0x00, 0x00,
+                       0x00, 0xE8, 0x00, 0x00, 0x00, 0x00, 0xE9, 0x00,
+                       0x00, 0x00, 0x00, 0xE8, 0x00, 0x00, 0x00, 0x00,
+                       0xB8, 0x00, 0x00, 0x00, 0x00, 0x48, 0x83, 0xC4,
+                       0x20, 0x5D, 0xC3 ]
+    relocations:
+      - offset:          0x00000017
+        type:            X86_64_RELOC_BRANCH
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          2
+      - offset:          0x00000021
+        type:            X86_64_RELOC_BRANCH
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          5
+      - offset:          0x00000026
+        type:            X86_64_RELOC_BRANCH
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          1
+      - offset:          0x0000005E
+        type:            X86_64_RELOC_BRANCH
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          4
+      - offset:          0x00000082
+        type:            X86_64_RELOC_BRANCH
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          5
+      - offset:          0x0000008C
+        type:            X86_64_RELOC_BRANCH
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          3
+global-symbols:
+  - name:            _main
+    type:            N_SECT
+    scope:           [ N_EXT ]
+    sect:            1
+    value:           0x0000000000000000
+undefined-symbols:
+  - name:            '___dtrace_isenabled$std$bar$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$provider_with_long_name$foo$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$provider_with_long_name_too$foo$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$std$bar$v1$696e7436345f74'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_probe$std$foo$v1'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_stability$provider_with_long_name$v1$1_1_0_1_1_0_1_1_0_1_1_0_1_1_0'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_stability$provider_with_long_name_too$v1$1_1_0_1_1_0_1_1_0_1_1_0_1_1_0'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_stability$std$v1$1_1_0_1_1_0_1_1_0_1_1_0_1_1_0'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_typedefs$provider_with_long_name$v2'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_typedefs$provider_with_long_name_too$v2'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+  - name:            '___dtrace_typedefs$std$v2'
+    type:            N_UNDF
+    scope:           [ N_EXT ]
+    value:           0x0000000000000000
+...

test/mach-o/dtrace-arm64.yaml

+# REQUIRES: aarch64
+#
+# RUN: lld -flavor darwin -arch arm64 %p/Inputs/dtrace-arm64.yaml -o %t %p/Inputs/libSystem.yaml
+# RUN: llvm-objdump -macho -d %t | FileCheck %s
+
+# CHECK:      1f 20 03 d5 nop
+# CHECK:      1f 20 03 d5 nop
+# CHECK:      00 00 80 d2 movz  x0, #0
+# CHECK:      1f 20 03 d5 nop
+# CHECK:      1f 20 03 d5 nop
+# CHECK:      1f 20 03 d5 nop

test/mach-o/dtrace-armv7s.yaml

+# REQUIRES: arm
+#
+# RUN: lld -flavor darwin -arch armv7s %p/Inputs/dtrace-armv7s.yaml -o %t %p/Inputs/libSystem.yaml
+# RUN: llvm-objdump -macho -d %t | FileCheck %s
+#
+# RUN: lld -flavor darwin -arch armv7s %p/Inputs/dtrace-armv7s-thumb.yaml -o %t %p/Inputs/libSystem.yaml
+# RUN: llvm-objdump -macho -d %t | FileCheck --check-prefix CHECK-THUMB %s
+
+# CHECK:    00 00 a0 e1   mov  r0, r0
+# CHECK:    00 00 a0 e1   mov  r0, r0
+# CHECK:    00 00 20 e0   eor  r0, r0, r0
+# CHECK:    00 00 a0 e1   mov  r0, r0
+# CHECK:    00 00 a0 e1   mov  r0, r0
+# CHECK:    00 00 a0 e1   mov  r0, r0
+
+# CHECK-THUMB:       c0 46    mov  r8, r8
+# CHECK-THUMB-NEXT:  c0 46    mov  r8, r8
+
+# CHECK-THUMB:       c0 46    mov  r8, r8
+# CHECK-THUMB-NEXT:  c0 46    mov  r8, r8
+
+# CHECK-THUMB:       40 40    eors r0, r0
+# CHECK-THUMB-NEXT:  c0 46    mov  r8, r8
+
+# CHECK-THUMB:       c0 46    mov  r8, r8
+# CHECK-THUMB-NEXT:  c0 46    mov  r8, r8
+
+# CHECK-THUMB:       c0 46    mov  r8, r8
+# CHECK-THUMB-NEXT:  c0 46    mov  r8, r8
+
+# CHECK-THUMB:       c0 46    mov  r8, r8
+# CHECK-THUMB-NEXT:  c0 46    mov  r8, r8

test/mach-o/dtrace-x86.yaml

+# REQUIRES: x86
+#
+# RUN: lld -flavor darwin -arch i386 %p/Inputs/dtrace-x86.yaml -o %t %p/Inputs/libSystem.yaml
+# RUN: llvm-objdump -macho -d %t | FileCheck %s
+
+# CHECK:      90          nop
+# CHECK-NEXT: 0f 1f 40 00 nopl  (%eax)
+
+# CHECK:      90          nop
+# CHECK-NEXT: 0f 1f 40 00 nopl  (%eax)
+
+# CHECK:      33 c0 xorl  %eax, %eax
+# CHECK-NEXT: 90    nop
+# CHECK-NEXT: 90    nop
+# CHECK-NEXT: 90    nop
+
+# CHECK:      90           nop
+# CHECK-NEXT: 0f 1f 40 00  nopl (%eax)
+
+# CHECK:      90           nop
+# CHECK-NEXT: 0f 1f 40 00  nopl (%eax)
+
+# CHECK:      90           nop
+# CHECK-NEXT: 0f 1f 40 00  nopl (%eax)

test/mach-o/dtrace-x86_64.yaml

+# REQUIRES: x86
+#
+# RUN: lld -flavor darwin -arch x86_64 %p/Inputs/dtrace-x86_64.yaml -o %t %p/Inputs/libSystem.yaml
+# RUN: llvm-objdump -macho -d %t | FileCheck %s
+
+# CHECK:      90          nop
+# CHECK-NEXT: 0f 1f 40 00 nopl  (%rax)
+
+# CHECK:      90          nop
+# CHECK-NEXT: 0f 1f 40 00 nopl  (%rax)
+
+# CHECK:      33 c0 xorl  %eax, %eax
+# CHECK-NEXT: 90    nop
+# CHECK-NEXT: 90    nop
+# CHECK-NEXT: 90    nop
+
+# CHECK:      90           nop
+# CHECK-NEXT: 0f 1f 40 00  nopl (%rax)
+
+# CHECK:      90           nop
+# CHECK-NEXT: 0f 1f 40 00  nopl (%rax)
+
+# CHECK:      90           nop
+# CHECK-NEXT: 0f 1f 40 00  nopl (%rax)

test/mach-o/parse-dtrace.yaml

+# Check we properly generate dtrace references for dtrace symbols
+
+# RUN: lld -flavor darwin -arch i386 -r -print_atoms %p/Inputs/dtrace-x86.yaml -o %t | FileCheck %s
+# RUN: llvm-objdump -macho -r %t | FileCheck --check-prefix X86 %s
+# X86: RELOCATION RECORDS FOR [__text]:
+# X86-NEXT: GENERIC_RELOC_VANILLA ___dtrace_probe$provider_with_long_name$foo$v1
+# X86-NEXT: GENERIC_RELOC_VANILLA ___dtrace_probe$std$foo$v1
+# X86-NEXT: GENERIC_RELOC_VANILLA ___dtrace_isenabled$std$bar$v1
+# X86-NEXT: GENERIC_RELOC_VANILLA ___dtrace_probe$std$bar$v1$696e7436345f74
+# X86-NEXT: GENERIC_RELOC_VANILLA ___dtrace_probe$std$foo$v1
+# X86-NEXT: GENERIC_RELOC_VANILLA ___dtrace_probe$provider_with_long_name_too$foo$v1
+
+# RUN: lld -flavor darwin -arch x86_64 -r -print_atoms %p/Inputs/dtrace-x86_64.yaml -o %t | FileCheck %s
+# RUN: llvm-objdump -macho -r %t | FileCheck --check-prefix X86_64 %s
+# X86_64: RELOCATION RECORDS FOR [__text]:
+# X86_64-NEXT: X86_64_RELOC_BRANCH ___dtrace_probe$provider_with_long_name$foo$v1
+# X86_64-NEXT: X86_64_RELOC_BRANCH ___dtrace_probe$std$foo$v1
+# X86_64-NEXT: X86_64_RELOC_BRANCH ___dtrace_isenabled$std$bar$v1
+# X86_64-NEXT: X86_64_RELOC_BRANCH ___dtrace_probe$std$bar$v1$696e7436345f74
+# X86_64-NEXT: X86_64_RELOC_BRANCH ___dtrace_probe$std$foo$v1
+# X86_64-NEXT: X86_64_RELOC_BRANCH ___dtrace_probe$provider_with_long_name_too$foo$v1
+
+# RUN: lld -flavor darwin -arch armv7s -r -print_atoms %p/Inputs/dtrace-armv7s.yaml -o %t | FileCheck %s
+# RUN: llvm-objdump -macho -r %t | FileCheck --check-prefix ARM %s
+# ARM: RELOCATION RECORDS FOR [__text]:
+# ARM-NEXT: ARM_RELOC_BR24 ___dtrace_probe$provider_with_long_name$foo$v1
+# ARM-NEXT: ARM_RELOC_BR24 ___dtrace_probe$std$foo$v1
+# ARM-NEXT: ARM_RELOC_BR24 ___dtrace_isenabled$std$bar$v1
+# ARM-NEXT: ARM_RELOC_BR24 ___dtrace_probe$std$bar$v1$696e7436345f74
+# ARM-NEXT: ARM_RELOC_BR24 ___dtrace_probe$std$foo$v1
+# ARM-NEXT: ARM_RELOC_BR24 ___dtrace_probe$provider_with_long_name_too$foo$v1
+
+# RUN: lld -flavor darwin -arch armv7s -r -print_atoms %p/Inputs/dtrace-armv7s-thumb.yaml -o %t | FileCheck %s
+# RUN: llvm-objdump -macho -r %t | FileCheck --check-prefix THUMB %s
+# THUMB: RELOCATION RECORDS FOR [__text]:
+# THUMB-NEXT: ARM_THUMB_RELOC_BR22 ___dtrace_probe$provider_with_long_name$foo$v1
+# THUMB-NEXT: ARM_THUMB_RELOC_BR22 ___dtrace_probe$std$foo$v1
+# THUMB-NEXT: ARM_THUMB_RELOC_BR22 ___dtrace_isenabled$std$bar$v1
+# THUMB-NEXT: ARM_THUMB_RELOC_BR22 ___dtrace_probe$std$bar$v1$696e7436345f74
+# THUMB-NEXT: ARM_THUMB_RELOC_BR22 ___dtrace_probe$std$foo$v1
+# THUMB-NEXT: ARM_THUMB_RELOC_BR22 ___dtrace_probe$provider_with_long_name_too$foo$v1
+
+# RUN: lld -flavor darwin -arch arm64 -r -print_atoms %p/Inputs/dtrace-arm64.yaml -o %t | FileCheck %s
+# RUN: llvm-objdump -macho -r %t | FileCheck --check-prefix ARM64 %s
+# ARM64: RELOCATION RECORDS FOR [__text]:
+# ARM64-NEXT: ARM64_RELOC_BRANCH26 ___dtrace_probe$provider_with_long_name$foo$v1
+# ARM64-NEXT: ARM64_RELOC_BRANCH26 ___dtrace_probe$std$foo$v1
+# ARM64-NEXT: ARM64_RELOC_BRANCH26 ___dtrace_isenabled$std$bar$v1
+# ARM64-NEXT: ARM64_RELOC_BRANCH26 ___dtrace_probe$std$bar$v1$696e7436345f74
+# ARM64-NEXT: ARM64_RELOC_BRANCH26 ___dtrace_probe$std$foo$v1
+# ARM64-NEXT: ARM64_RELOC_BRANCH26 ___dtrace_probe$provider_with_long_name_too$foo$v1
+
+# CHECK: kind: dtraceProbe
+# CHECK-NEXT: offset: {{[0-9]+}}
+# CHECK-NEXT: '___dtrace_probe$provider_with_long_name$foo$v1'
+
+# CHECK: kind: dtraceProbe
+# CHECK-NEXT: offset: {{[0-9]+}}
+# CHECK-NEXT: '___dtrace_probe$std$foo$v1'
+
+# CHECK: kind: dtraceIsEnabled
+# CHECK-NEXT: offset: {{[0-9]+}}
+# CHECK-NEXT: '___dtrace_isenabled$std$bar$v1'
+
+# CHECK: kind: dtraceProbe
+# CHECK-NEXT: offset: {{[0-9]+}}
+# CHECK-NEXT: '___dtrace_probe$std$bar$v1$696e7436345f74'
+
+# CHECK: kind: dtraceProbe
+# CHECK-NEXT: offset: {{[0-9]+}}
+# CHECK-NEXT: '___dtrace_probe$std$foo$v1'
+
+# CHECK: kind: dtraceProbe
+# CHECK-NEXT: offset: {{[0-9]+}}
+# CHECK-NEXT: '___dtrace_probe$provider_with_long_name_too$foo$v1'