[XRay] Make xray_fn_idx entries PC-relative

[MaskRay]

Summary

As mentioned by commit c5d38924dc6688c15b3fa133abeb3626e8f0767c (Apr 2020),
PC-relative entries avoid dynamic relocations and can therefore make the
section read-only.

This is similar to D78082 and D78590. We cannot commit to support
compiler/runtime built at different versions, so just don't play with versions.

For Mach-O support (incomplete yet), we use non-temporary lxray_fn_idx[0-9]+
symbols. Label differences are represented as a pair of UNSIGNED and SUBTRACTOR
relocations. The SUBTRACTOR external relocation requires r_extern==1 (needs to
reference a symbol table entry) which can be satisfied by lxray_fn_idx[0-9]+.
A lxray_fn_idx[0-9]+ symbol also serves as the atom for this dead-strippable
section (follow-up to commit b9a134aa629de23a1dcf4be32e946e4e308fc64d).

[ilammy]

In D145850#4412388, @MaskRay wrote:

xray_fn_idx entries should use PC-relative relocations as well, but I never get around to fix it. I wonder whether the change may make this patch unneeded or we are going to find other Mach-O relocation related issues.

D145850 is isolation fixes the linker issue for me even with -fxray-function-index.

---

D152661 – this change – applied in isolation still causes the same error:

ld: in section __DATA,xray_instr_map reloc 0: X86_64_RELOC_SUBTRACTOR must have r_extern=1 file '/var/folders/hv/h2_fjzgx1fl2mh85t65xsv6m0000gn/T/main-5630d5.o' for architecture x86_64

with the linker not being able to handle relocations in xray_instr_map specifically.

---

When if I apply D145850 and then D152661 on top of it, assembly appears to fail:

hello.s:53:8: error: expected relocatable expression
        .quad   (lxray_sleds_end0-lxray_sleds_start0)>>4
                ^

Assembler can't emit a relocation for this expression involving references to local symbols.

EDIT: No idea why it wants it to be relocatable though, since it's effectively a constant. And you can't do relocations with divisions anyway...

EDIT#2: And if I replace it with a literal:

.quad   12

the linker is now offended by xray_instr_idx section:

ld: in section __DATA,xray_fn_idx reloc 0: X86_64_RELOC_SUBTRACTOR must have r_extern=1 file '/var/folders/hv/h2_fjzgx1fl2mh85t65xsv6m0000gn/T/hello-8f349d.o' for architecture x86_64

since it can't find any extern symbol to latch onto for relocations in xray_fn_idx, with all of them referencing local or temporary symbols.

[MaskRay]

In D152661#4430847, @ilammy wrote:

In D145850#4412388, @MaskRay wrote:

xray_fn_idx entries should use PC-relative relocations as well, but I never get around to fix it. I wonder whether the change may make this patch unneeded or we are going to find other Mach-O relocation related issues.

D145850 is isolation fixes the linker issue for me even with -fxray-function-index.

---

D152661 – this change – applied in isolation still causes the same error:

ld: in section __DATA,xray_instr_map reloc 0: X86_64_RELOC_SUBTRACTOR must have r_extern=1 file '/var/folders/hv/h2_fjzgx1fl2mh85t65xsv6m0000gn/T/main-5630d5.o' for architecture x86_64

with the linker not being able to handle relocations in xray_instr_map specifically.

---

When if I apply D145850 and then D152661 on top of it, assembly appears to fail:

hello.s:53:8: error: expected relocatable expression
        .quad   (lxray_sleds_end0-lxray_sleds_start0)>>4
                ^

Assembler can't emit a relocation for this expression involving references to local symbols.

EDIT: No idea why it wants it to be relocatable though, since it's effectively a constant. And you can't do relocations with divisions anyway...

EDIT#2: And if I replace it with a literal:

.quad   12

the linker is now offended by xray_instr_idx section:

ld: in section __DATA,xray_fn_idx reloc 0: X86_64_RELOC_SUBTRACTOR must have r_extern=1 file '/var/folders/hv/h2_fjzgx1fl2mh85t65xsv6m0000gn/T/hello-8f349d.o' for architecture x86_64

since it can't find any extern symbol to latch onto for relocations in xray_fn_idx, with all of them referencing local or temporary symbols.

I think we should apply this patch and change D145850 to stick with Lxray_sleds_start0. The error you see is due to NOT using L (private label prefix).

        .section        __DATA,xray_instr_map
lxray_sleds_start0:
        .space  13     # MCFillFragment
lxray_sleds_end0:

        .section        __DATA,xray_fn_idx
        .p2align        4, 0x90
        .quad   (lxray_sleds_end0-lxray_sleds_start0)>>4
.subsections_via_symbols

/tmp/x-5cd5fc.s:15:8: error: expected relocatable expression
 .quad (lxray_sleds_end0-lxray_sleds_start0)>>4

Due to .subsections_via_symbols, non-L symbols are used as atoms to split subsections. ld -dead_strip may discard lxray_sleds_start0's content or lxray_sleds_end0's content independently.
For some reason the assembler decides not to fold the label difference expression.
However, if we replace .space with .byte/.quad/etc, the assembler will fold this label difference. This may look strange, but I'll call it Mach-O's quirk:)

---

If we stick with .quad (Lxray_sleds_end0-Lxray_sleds_start0)>>4, this expression can be resolved at assembly time, leaving no relocation to the linker:)

[MaskRay]

rebase
The Mach-O label difference issue has been fixed by my previous commit 507efbcce03d8c2c5dbea3028bc39f02c88fea79

[MaskRay]

rebase after b9a134aa629de23a1dcf4be32e946e4e308fc64d

[MaskRay]

Clarify terminology

[MaskRay]

I'll land this as PC-relative relocations have been agreed on as the future direction, we currently lack review resource in this area, and I am a de-facto maintainer of XRay for many years.

[MaskRay]

fix clang/test/CodeGen/xray-function-index.c

[MaskRay]

Tested on aarch64-linux-gnu and powerpc64le-linux-gnu.

I'll use createLinkerPrivateSymbol instead of createLinkerPrivateTempSymbol since the symbol is not considered IsTemporary by MC...

clang/test/CodeGen/xray-function-index.c

 // REQUIRES: x86-registered-target
 // RUN: %clang_cc1 -S -triple x86_64 -fxray-instrument -fxray-instruction-threshold=1 %s -o - | FileCheck %s
 // RUN: %clang_cc1 -S -triple x86_64 -fxray-instrument -fxray-instruction-threshold=1 -fno-xray-function-index %s -o - | FileCheck %s --check-prefix=NO
 
-// CHECK: .section xray_fn_idx,"awo",@progbits,foo
+// CHECK: .section xray_fn_idx,"ao",@progbits,foo
 // NO-NOT: .section xray_fn_idx
 
 void foo(void) {}

compiler-rt/lib/xray/xray_interface.cpp

bool patchSled(const XRaySledEntry &Sled, bool Enable,
   return Success;
 }
 
 const XRayFunctionSledIndex
 findFunctionSleds(int32_t FuncId,
                   const XRaySledMap &InstrMap) XRAY_NEVER_INSTRUMENT {
   int32_t CurFn = 0;
   uint64_t LastFnAddr = 0;
-  XRayFunctionSledIndex Index = {nullptr, nullptr};
+  XRayFunctionSledIndex Index = {nullptr, 0};
 
   for (std::size_t I = 0; I < InstrMap.Entries && CurFn <= FuncId; I++) {
     const auto &Sled = InstrMap.Sleds[I];
     const auto Function = Sled.function();
     if (Function != LastFnAddr) {
       CurFn++;
       LastFnAddr = Function;
     }
 
     if (CurFn == FuncId) {
       if (Index.Begin == nullptr)
         Index.Begin = &Sled;
-      Index.End = &Sled;
+      Index.Size = &Sled - Index.Begin + 1;
     }
   }
 
-  Index.End += 1;
-
   return Index;
 }
 
 XRayPatchingStatus patchFunction(int32_t FuncId,
                                  bool Enable) XRAY_NEVER_INSTRUMENT {
   if (!atomic_load(&XRayInitialized,
                                 memory_order_acquire))
     return XRayPatchingStatus::NOT_INITIALIZED; // Not initialized.
XRayPatchingStatus patchFunction(int32_t FuncId,
   // FuncId must be a positive number, less than the number of functions
   // instrumented.
   if (FuncId <= 0 || static_cast<size_t>(FuncId) > InstrMap.Functions) {
     Report("Invalid function id provided: %d\n", FuncId);
     return XRayPatchingStatus::FAILED;
   }
 
   // Now we patch ths sleds for this specific function.
-  auto SledRange = InstrMap.SledsIndex ? InstrMap.SledsIndex[FuncId - 1]
-                                       : findFunctionSleds(FuncId, InstrMap);
+  XRayFunctionSledIndex SledRange;
+  if (InstrMap.SledsIndex) {
+    SledRange = {InstrMap.SledsIndex[FuncId - 1].fromPCRelative(),
+                 InstrMap.SledsIndex[FuncId - 1].Size};
+  } else {
+    SledRange = findFunctionSleds(FuncId, InstrMap);
+  }
   auto *f = SledRange.Begin;
-  auto *e = SledRange.End;
   bool SucceedOnce = false;
-  while (f != e)
-    SucceedOnce |= patchSled(*f++, Enable, FuncId);
+  for (size_t i = 0; i != SledRange.Size; ++i)
+    SucceedOnce |= patchSled(f[i], Enable, FuncId);
 
   atomic_store(&XRayPatching, false,
                             memory_order_release);
 
   if (!SucceedOnce) {
     Report("Failed patching any sled for function '%d'.", FuncId);
     return XRayPatchingStatus::FAILED;
   }
const size_t PageSize = flags()->xray_page_size_override > 0
                               : GetPageSizeCached();
   if ((PageSize == 0) || ((PageSize & (PageSize - 1)) != 0)) {
     Report("Provided page size is not a power of two: %zu\n", PageSize);
     return XRayPatchingStatus::FAILED;
   }
 
   // Here we compute the minimum sled and maximum sled associated with a
   // particular function ID.
-  auto SledRange = InstrMap.SledsIndex ? InstrMap.SledsIndex[FuncId - 1]
-                                       : findFunctionSleds(FuncId, InstrMap);
+  XRayFunctionSledIndex SledRange;
+  if (InstrMap.SledsIndex) {
+    SledRange = {InstrMap.SledsIndex[FuncId - 1].fromPCRelative(),
+                 InstrMap.SledsIndex[FuncId - 1].Size};
+  } else {
+    SledRange = findFunctionSleds(FuncId, InstrMap);
+  }
   auto *f = SledRange.Begin;
-  auto *e = SledRange.End;
+  auto *e = SledRange.Begin + SledRange.Size;
   auto *MinSled = f;
-  auto *MaxSled = (SledRange.End - 1);
+  auto *MaxSled = e - 1;
   while (f != e) {
     if (f->address() < MinSled->address())
       MinSled = f;
     if (f->address() > MaxSled->address())
       MaxSled = f;
     ++f;
   }
 
uintptr_t __xray_function_address(int32_t FuncId) XRAY_NEVER_INSTRUMENT {
   XRaySledMap InstrMap;
   {
     SpinMutexLock Guard(&XRayInstrMapMutex);
     InstrMap = XRayInstrMap;
   }
 
   if (FuncId <= 0 || static_cast<size_t>(FuncId) > InstrMap.Functions)
     return 0;
-  const XRaySledEntry *Sled = InstrMap.SledsIndex
-                                  ? InstrMap.SledsIndex[FuncId - 1].Begin
-                                  : findFunctionSleds(FuncId, InstrMap).Begin;
+  const XRaySledEntry *Sled =
+      InstrMap.SledsIndex ? InstrMap.SledsIndex[FuncId - 1].fromPCRelative()
   return Sled->function()
 // On PPC, function entries are always aligned to 16 bytes. The beginning of a
 // sled might be a local entry, which is always +8 based on the global entry.
 // Always return the global entry.
 #ifdef __PPC__
          & ~0xf
 #endif
       ;
 }
 
 size_t __xray_max_function_id() XRAY_NEVER_INSTRUMENT {
   SpinMutexLock Guard(&XRayInstrMapMutex);
   return XRayInstrMap.Functions;
 }

compiler-rt/lib/xray/xray_interface_internal.h

#elif SANITIZER_WORDSIZE == 32
   }
 #else
 #error "Unsupported word size."
 #endif
 };
 
 struct XRayFunctionSledIndex {
   const XRaySledEntry *Begin;
-  const XRaySledEntry *End;
+  size_t Size;
+  // For an entry in the xray_fn_idx section, the address is relative to the
+  // location of the Begin variable.
+  const XRaySledEntry *fromPCRelative() const {
+    return reinterpret_cast<const XRaySledEntry *>(uintptr_t(&Begin) +
+                                                   uintptr_t(Begin));
+  }
 };
 }
 
 namespace __xray {
 
 struct XRaySledMap {
   const XRaySledEntry *Sleds;
   size_t Entries;

llvm/include/llvm/MC/MCContext.h

public:
   /// \name McInst Management
 
   /// Create and return a new MC instruction.
   MCInst *createMCInst();
 
   /// \name Symbol Management
   /// @{
 
-  /// Create and return a new linker temporary symbol with a unique but
-  /// unspecified name.
+  /// Create a new linker temporary symbol with the specified prefix (Name) or
+  /// "tmp". This creates a "l"-prefixed symbol for Mach-O and is identical to
+  /// createNamedTempSymbol for other object file formats.
   MCSymbol *createLinkerPrivateTempSymbol();
+  MCSymbol *createLinkerPrivateSymbol(const Twine &Name);
 
   /// Create a temporary symbol with a unique name. The name will be omitted
   /// in the symbol table if UseNamesOnTempLabels is false (default except
   /// MCAsmStreamer). The overload without Name uses an unspecified name.
   MCSymbol *createTempSymbol();
   MCSymbol *createTempSymbol(const Twine &Name, bool AlwaysAddSuffix = true);
 
   /// Create a temporary symbol with a unique name whose name cannot be

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

if (F.hasComdat()) {
       GroupName = F.getComdat()->getName();
     }
     InstMap = OutContext.getELFSection("xray_instr_map", ELF::SHT_PROGBITS,
                                        Flags, 0, GroupName, F.hasComdat(),
                                        MCSection::NonUniqueID, LinkedToSym);
 
     if (TM.Options.XRayFunctionIndex)
       FnSledIndex = OutContext.getELFSection(
-          "xray_fn_idx", ELF::SHT_PROGBITS, Flags | ELF::SHF_WRITE, 0,
-          GroupName, F.hasComdat(), MCSection::NonUniqueID, LinkedToSym);
+          "xray_fn_idx", ELF::SHT_PROGBITS, Flags, 0, GroupName, F.hasComdat(),
+          MCSection::NonUniqueID, LinkedToSym);
   } else if (MF->getSubtarget().getTargetTriple().isOSBinFormatMachO()) {
     InstMap = OutContext.getMachOSection("__DATA", "xray_instr_map",
                                          MachO::S_ATTR_LIVE_SUPPORT,
                                          SectionKind::getReadOnlyWithRel());
     if (TM.Options.XRayFunctionIndex)
-      FnSledIndex = OutContext.getMachOSection(
-          "__DATA", "xray_fn_idx", MachO::S_ATTR_LIVE_SUPPORT,
-          SectionKind::getReadOnlyWithRel());
+      FnSledIndex = OutContext.getMachOSection("__DATA", "xray_fn_idx",
+                                               MachO::S_ATTR_LIVE_SUPPORT,
+                                               SectionKind::getReadOnly());
   } else {
     llvm_unreachable("Unsupported target");
   }
 
   auto WordSizeBytes = MAI->getCodePointerSize();
 
   // Now we switch to the instrumentation map section. Because this is done
   // per-function, we are able to create an index entry that will represent the
void AsmPrinter::emitXRayTable() {
   // We then emit a single entry in the index per function. We use the symbols
   // that bound the instrumentation map as the range for a specific function.
   // Each entry here will be 2 * word size aligned, as we're writing down two
   // pointers. This should work for both 32-bit and 64-bit platforms.
   if (FnSledIndex) {
     OutStreamer->switchSection(FnSledIndex);
     OutStreamer->emitCodeAlignment(Align(2 * WordSizeBytes),
                                    &getSubtargetInfo());
-    OutStreamer->emitSymbolValue(SledsStart, WordSizeBytes, false);
-    OutStreamer->emitSymbolValue(SledsEnd, WordSizeBytes, false);
+    // For Mach-O, use an "l" symbol as the atom of this subsection. The label
+    // difference uses a SUBTRACTOR external relocation which references the
+    // symbol.
+    MCSymbol *Dot = Ctx.createLinkerPrivateSymbol("xray_fn_idx");
+    OutStreamer->emitLabel(Dot);
+    OutStreamer->emitValueImpl(
+        MCBinaryExpr::createSub(MCSymbolRefExpr::create(SledsStart, Ctx),
+                                MCSymbolRefExpr::create(Dot, Ctx), Ctx),
+        WordSizeBytes);
+    OutStreamer->emitValueImpl(MCConstantExpr::create(Sleds.size(), Ctx),
+                               WordSizeBytes);
     OutStreamer->switchSection(PrevSection);
   }
   Sleds.clear();
 }
 
 void AsmPrinter::recordSled(MCSymbol *Sled, const MachineInstr &MI,
                             SledKind Kind, uint8_t Version) {
   const Function &F = MI.getMF()->getFunction();

llvm/lib/MC/MCContext.cpp

 
 MCSymbol *MCContext::createNamedTempSymbol(const Twine &Name) {
   SmallString<128> NameSV;
   raw_svector_ostream(NameSV) << MAI->getPrivateGlobalPrefix() << Name;
   return createSymbol(NameSV, true, false);
 }
 
 MCSymbol *MCContext::createLinkerPrivateTempSymbol() {
+  return createLinkerPrivateSymbol("tmp");
+}
+
+MCSymbol *MCContext::createLinkerPrivateSymbol(const Twine &Name) {
   SmallString<128> NameSV;
-  raw_svector_ostream(NameSV) << MAI->getLinkerPrivateGlobalPrefix() << "tmp";
+  raw_svector_ostream(NameSV) << MAI->getLinkerPrivateGlobalPrefix() << Name;
   return createSymbol(NameSV, true, false);
 }
 
 MCSymbol *MCContext::createTempSymbol() { return createTempSymbol("tmp"); }
 
 MCSymbol *MCContext::createNamedTempSymbol() {
   return createNamedTempSymbol("tmp");
 }

llvm/test/CodeGen/AArch64/xray-tail-call-sled.ll

 
 ; CHECK-LINUX-LABEL: .section xray_instr_map,"ao",@progbits,callee{{$}}
 ; CHECK-LINUX-LABEL: .Lxray_sleds_start0:
 ; CHECK-LINUX-NEXT:  [[TMP:.Ltmp[0-9]+]]:
 ; CHECK-LINUX:         .xword .Lxray_sled_0-[[TMP]]
 ; CHECK-LINUX:       [[TMP:.Ltmp[0-9]+]]:
 ; CHECK-LINUX-NEXT:    .xword .Lxray_sled_1-[[TMP]]
 ; CHECK-LINUX-LABEL: Lxray_sleds_end0:
-; CHECK-LINUX-LABEL: .section xray_fn_idx,"awo",@progbits,callee{{$}}
+; CHECK-LINUX-LABEL: .section xray_fn_idx,"ao",@progbits,callee{{$}}
 ; CHECK-LINUX:         .xword .Lxray_sleds_start0
-; CHECK-LINUX-NEXT:    .xword .Lxray_sleds_end0
+; CHECK-LINUX-NEXT:    .xword 2
 
 ; CHECK-MACOS-LABEL: .section __DATA,xray_instr_map,regular,live_support{{$}}
 ; CHECK-MACOS-LABEL: Lxray_sleds_start0:
 ; CHECK-MACOS-NEXT:  [[TMP:Ltmp[0-9]+]]:
 ; CHECK-MACOS:         .quad Lxray_sled_0-[[TMP]]
 ; CHECK-MACOS:       [[TMP:Ltmp[0-9]+]]:
 ; CHECK-MACOS-NEXT:    .quad Lxray_sled_1-[[TMP]]
 ; CHECK-MACOS-LABEL: Lxray_sleds_end0:
 ; CHECK-MACOS-LABEL: .section __DATA,xray_fn_idx,regular,live_support{{$}}
-; CHECK-MACOS:         .quad Lxray_sleds_start0
-; CHECK-MACOS-NEXT:    .quad Lxray_sleds_end0
+; CHECK-MACOS:       [[IDX:lxray_fn_idx[0-9]+]]:
+; CHECK-MACOS-NEXT:    .quad Lxray_sleds_start0-[[IDX]]
+; CHECK-MACOS-NEXT:    .quad 2
 
 define i32 @caller() nounwind noinline uwtable "function-instrument"="xray-always" {
 ; CHECK:       .p2align 2
 ; CHECK-LABEL: Lxray_sled_2:
 ; CHECK-NEXT:  b  #32
 ; CHECK-COUNT-7:  nop
 ; CHECK-NEXT:  Ltmp[[#]]:
 ; CHECK:       .p2align 2
 ; CHECK-LABEL: Lxray_sled_3:
 ; CHECK-NEXT:  b  #32
 ; CHECK-COUNT-7:  nop
 ; CHECK-NEXT:  Ltmp[[#]]:
   %retval = tail call i32 @callee()
 ; CHECK-LINUX: b  callee
 ; CHECK-MACOS: b  _callee
   ret i32 %retval
 }
 
 ; CHECK-LINUX-LABEL: .section xray_instr_map,"ao",@progbits,caller{{$}}
 ; CHECK-LINUX-LABEL: Lxray_sleds_start1:
 ; CHECK-LINUX:         .xword .Lxray_sled_2
 ; CHECK-LINUX:         .xword .Lxray_sled_3
 ; CHECK-LINUX-LABEL: Lxray_sleds_end1:
-; CHECK-LINUX-LABEL: .section xray_fn_idx,"awo",@progbits,caller{{$}}
-; CHECK-LINUX:         .xword .Lxray_sleds_start1
-; CHECK-LINUX-NEXT:    .xword .Lxray_sleds_end1
+; CHECK-LINUX-LABEL: .section xray_fn_idx,"ao",@progbits,caller{{$}}
+; CHECK-LINUX:       [[IDX:\.Lxray_fn_idx[0-9]+]]:
+; CHECK-LINUX-NEXT:    .xword .Lxray_sleds_start1-[[IDX]]
+; CHECK-LINUX-NEXT:    .xword 2
 
 ; CHECK-MACOS-LABEL: .section __DATA,xray_instr_map,regular,live_support{{$}}
 ; CHECK-MACOS-LABEL: Lxray_sleds_start1:
 ; CHECK-MACOS:         .quad Lxray_sled_2
 ; CHECK-MACOS:         .quad Lxray_sled_3
 ; CHECK-MACOS-LABEL: Lxray_sleds_end1:
 ; CHECK-MACOS-LABEL: .section __DATA,xray_fn_idx,regular,live_support{{$}}
-; CHECK-MACOS:         .quad Lxray_sleds_start1
-; CHECK-MACOS-NEXT:    .quad Lxray_sleds_end1
+; CHECK-MACOS:       [[IDX:lxray_fn_idx[0-9]+]]:
+; CHECK-MACOS-NEXT:    .quad Lxray_sleds_start1-[[IDX]]
+; CHECK-MACOS-NEXT:    .quad 2

llvm/test/CodeGen/ARM/xray-armv6-attribute-instrumentation.ll

 ; CHECK-NEXT:  bx lr
 }
 
 ; CHECK-LINUX-LABEL: .section xray_instr_map,"ao",%progbits,foo{{$}}
 ; CHECK-LINUX-LABEL: .Lxray_sleds_start0:
 ; CHECK-LINUX:         .long .Lxray_sled_0
 ; CHECK-LINUX:         .long .Lxray_sled_1
 ; CHECK-LINUX-LABEL: .Lxray_sleds_end0:
-; CHECK-LINUX-LABEL: .section xray_fn_idx,"awo",%progbits,foo{{$}}
-; CHECK-LINUX:         .long .Lxray_sleds_start0
-; CHECK-LINUX-NEXT:    .long .Lxray_sleds_end0
+; CHECK-LINUX-LABEL: .section xray_fn_idx,"ao",%progbits,foo{{$}}
+; CHECK-LINUX:         .long .Lxray_sleds_start0-.Lxray_fn_idx0
+; CHECK-LINUX-NEXT:    .long 2
 
 ; CHECK-IOS-LABEL: .section __DATA,xray_instr_map,regular,live_support{{$}}
 ; CHECK-IOS-LABEL: Lxray_sleds_start0:
 ; CHECK-IOS:         .long Lxray_sled_0
 ; CHECK-IOS:         .long Lxray_sled_1
 ; CHECK-IOS-LABEL: Lxray_sleds_end0:
 ; CHECK-IOS-LABEL: .section __DATA,xray_fn_idx,regular,live_support{{$}}
-; CHECK-IOS:         .long Lxray_sleds_start0
-; CHECK-IOS-NEXT:    .long Lxray_sleds_end0
+; CHECK-IOS:         .long Lxray_sleds_start0-lxray_fn_idx0
+; CHECK-IOS-NEXT:    .long 2

llvm/test/CodeGen/ARM/xray-armv7-attribute-instrumentation.ll

 ; CHECK-NEXT:  bx lr
 }
 
 ; CHECK-LINUX-LABEL: .section xray_instr_map,"ao",%progbits,foo{{$}}
 ; CHECK-LINUX-LABEL: .Lxray_sleds_start0:
 ; CHECK-LINUX:         .long .Lxray_sled_0
 ; CHECK-LINUX:         .long .Lxray_sled_1
 ; CHECK-LINUX-LABEL: .Lxray_sleds_end0:
-; CHECK-LINUX-LABEL: .section xray_fn_idx,"awo",%progbits,foo{{$}}
-; CHECK-LINUX:         .long .Lxray_sleds_start0
-; CHECK-LINUX-NEXT:    .long .Lxray_sleds_end0
+; CHECK-LINUX-LABEL: .section xray_fn_idx,"ao",%progbits,foo{{$}}
+; CHECK-LINUX:       .Lxray_fn_idx0:
+; CHECK-LINUX-NEXT:    .long .Lxray_sleds_start0-.Lxray_fn_idx0
+; CHECK-LINUX-NEXT:    .long 2
 
 ; CHECK-IOS-LABEL: .section __DATA,xray_instr_map,regular,live_support{{$}}
 ; CHECK-IOS-LABEL: Lxray_sleds_start0:
 ; CHECK-IOS:         .long Lxray_sled_0
 ; CHECK-IOS:         .long Lxray_sled_1
 ; CHECK-IOS-LABEL: Lxray_sleds_end0:
 ; CHECK-IOS-LABEL: .section __DATA,xray_fn_idx,regular,live_support{{$}}
-; CHECK-IOS:         .long Lxray_sleds_start0
-; CHECK-IOS-NEXT:    .long Lxray_sleds_end0
+; CHECK-IOS:       lxray_fn_idx0:
+; CHECK-IOS:         .long Lxray_sleds_start0-lxray_fn_idx0
+; CHECK-IOS-NEXT:    .long 2

llvm/test/CodeGen/Hexagon/xray.ll

 ; CHECK-NEXT:  .word .Lxray_sled_0-[[TMP]]
 ; CHECK-NEXT:  .word .Lfunc_begin0-([[TMP]]+4)
 ; CHECK-NEXT:  .byte 0x00
 ; CHECK-NEXT:  .byte 0x01
 ; CHECK-NEXT:  .byte 0x02
 ; CHECK-NEXT:  .space 5
 ; CHECK-LABEL: .Lxray_sleds_end0:
 ; CHECK-LABEL: xray_fn_idx
-; CHECK:       .word .Lxray_sleds_start0{{$}}
-; CHECK-NEXT:  .word .Lxray_sleds_end0{{$}}
+; CHECK:       .word .Lxray_sleds_start0-.Lxray_fn_idx[[#]]
+; CHECK-NEXT:  .word 2

llvm/test/CodeGen/PowerPC/xray-attribute-instrumentation.ll

 ; CHECK-NEXT: [[TMP:.Ltmp[0-9]+]]:
 ; CHECK-NEXT:         .quad   .Ltmp[[#l+2]]-[[TMP]]
 ; CHECK-NEXT:         .quad   .Lfunc_begin0-([[TMP]]+8)
 ; CHECK-NEXT:         .byte   0x01
 ; CHECK-NEXT:         .byte   0x01
 ; CHECK-NEXT:         .byte   0x02
 ; CHECK-NEXT:         .space  13
 ; CHECK-NEXT: .Lxray_sleds_end0:
-; CHECK-LABEL: xray_fn_idx,"awo",@progbits,foo{{$}}
+; CHECK-LABEL: xray_fn_idx,"ao",@progbits,foo{{$}}
 ; CHECK:              .p2align        4
-; CHECK-NEXT:         .quad   .Lxray_sleds_start0
-; CHECK-NEXT:         .quad   .Lxray_sleds_end0
+; CHECK-NEXT: [[IDX:.Lxray_fn_idx[0-9]+]]:
+; CHECK-NEXT:         .quad .Lxray_sleds_start0-[[IDX]]
+; CHECK-NEXT:         .quad 2
 ; CHECK-NEXT:         .text

llvm/test/CodeGen/X86/xray-attribute-instrumentation.ll

 ; CHECK-NEXT:  nopw %cs:512(%rax,%rax)
 }
 
 ; CHECK-LINUX-LABEL: .section xray_instr_map,"ao",@progbits,foo{{$}}
 ; CHECK-LINUX-LABEL: .Lxray_sleds_start0:
 ; CHECK-LINUX:         .quad .Lxray_sled_0
 ; CHECK-LINUX:         .quad .Lxray_sled_1
 ; CHECK-LINUX-LABEL: .Lxray_sleds_end0:
-; CHECK-LINUX-LABEL: .section xray_fn_idx,"awo",@progbits,foo{{$}}
-; CHECK-LINUX:         .quad .Lxray_sleds_start0
-; CHECK-LINUX-NEXT:    .quad .Lxray_sleds_end0
+; CHECK-LINUX-LABEL: .section xray_fn_idx,"ao",@progbits,foo{{$}}
+; CHECK-LINUX:       [[IDX:\.Lxray_fn_idx[0-9]+]]:
+; CHECK-LINUX-NEXT:    .quad .Lxray_sleds_start0-[[IDX]]
+; CHECK-LINUX-NEXT:    .quad 2
 
 ; CHECK-MACOS-LABEL: .section __DATA,xray_instr_map,regular,live_support{{$}}
 ; CHECK-MACOS-LABEL: Lxray_sleds_start0:
 ; CHECK-MACOS:         .quad Lxray_sled_0
 ; CHECK-MACOS:         .quad Lxray_sled_1
 ; CHECK-MACOS-LABEL: Lxray_sleds_end0:
 ; CHECK-MACOS-LABEL: .section __DATA,xray_fn_idx,regular,live_support{{$}}
-; CHECK-MACOS:         .quad Lxray_sleds_start0
-; CHECK-MACOS-NEXT:    .quad Lxray_sleds_end0
+; CHECK-MACOS:       [[IDX:lxray_fn_idx[0-9]+]]:
+; CHECK-MACOS-NEXT:    .quad Lxray_sleds_start0-[[IDX]]
+; CHECK-MACOS-NEXT:    .quad 2
 
 
 ; We test multiple returns in a single function to make sure we're getting all
 ; of them with XRay instrumentation.
 define i32 @bar(i32 %i) nounwind noinline uwtable "function-instrument"="xray-always" {
 ; CHECK:       .p2align 1, 0x90
 ; CHECK-LABEL: Lxray_sled_2:
 ; CHECK:       .ascii "\353\t"

 ; CHECK-LINUX-LABEL: .Lxray_sleds_start1:
 ; CHECK-LINUX:       [[TMP:.Ltmp[0-9]+]]:
 ; CHECK-LINUX-NEXT:    .quad .Lxray_sled_2-[[TMP]]
 ; CHECK-LINUX:       [[TMP:.Ltmp[0-9]+]]:
 ; CHECK-LINUX-NEXT:    .quad .Lxray_sled_3-[[TMP]]
 ; CHECK-LINUX:       [[TMP:.Ltmp[0-9]+]]:
 ; CHECK-LINUX-NEXT:    .quad .Lxray_sled_4-[[TMP]]
 ; CHECK-LINUX-LABEL: .Lxray_sleds_end1:
-; CHECK-LINUX-LABEL: .section xray_fn_idx,"awo",@progbits,bar{{$}}
-; CHECK-LINUX:         .quad .Lxray_sleds_start1
-; CHECK-LINUX-NEXT:    .quad .Lxray_sleds_end1
+; CHECK-LINUX-LABEL: .section xray_fn_idx,"ao",@progbits,bar{{$}}
+; CHECK-LINUX:       [[IDX:\.Lxray_fn_idx[0-9]+]]:
+; CHECK-LINUX-NEXT:    .quad .Lxray_sleds_start1-[[IDX]]
+; CHECK-LINUX-NEXT:    .quad 3
 
 ; CHECK-MACOS-LABEL: .section __DATA,xray_instr_map,regular,live_support{{$}}
 ; CHECK-MACOS-LABEL: Lxray_sleds_start1:
 ; CHECK-MACOS:       [[TMP:Ltmp[0-9]+]]:
 ; CHECK-MACOS-NEXT:    .quad Lxray_sled_2-[[TMP]]
 ; CHECK-MACOS:       [[TMP:Ltmp[0-9]+]]:
 ; CHECK-MACOS-NEXT:    .quad Lxray_sled_3-[[TMP]]
 ; CHECK-MACOS:       [[TMP:Ltmp[0-9]+]]:
 ; CHECK-MACOS-NEXT:    .quad Lxray_sled_4-[[TMP]]
 ; CHECK-MACOS-LABEL: Lxray_sleds_end1:
 ; CHECK-MACOS-LABEL: .section __DATA,xray_fn_idx,regular,live_support{{$}}
-; CHECK-MACOS:         .quad Lxray_sleds_start1
-; CHECK-MACOS-NEXT:    .quad Lxray_sleds_end1
+; CHECK-MACOS:       [[IDX:lxray_fn_idx[0-9]+]]:
+; CHECK-MACOS-NEXT:    .quad Lxray_sleds_start1-[[IDX]]
+; CHECK-MACOS-NEXT:    .quad 3

llvm/test/CodeGen/X86/xray-partial-instrumentation-skip-entry.ll

 ; CHECK:       retq
 ; CHECK-NEXT:  nopw %cs:512(%rax,%rax)
 }
 
 ; CHECK-LINUX-LABEL: .section xray_instr_map,"ao",@progbits,foo{{$}}
 ; CHECK-LINUX-LABEL: .Lxray_sleds_start0:
 ; CHECK-LINUX:         .quad .Lxray_sled_0
 ; CHECK-LINUX-LABEL: .Lxray_sleds_end0:
-; CHECK-LINUX-LABEL: .section xray_fn_idx,"awo",@progbits,foo{{$}}
-; CHECK-LINUX:         .quad .Lxray_sleds_start0
-; CHECK-LINUX-NEXT:    .quad .Lxray_sleds_end0
+; CHECK-LINUX-LABEL: .section xray_fn_idx,"ao",@progbits,foo{{$}}
+; CHECK-LINUX:       [[IDX:\.Lxray_fn_idx[0-9]+]]:
+; CHECK-LINUX-NEXT:    .quad .Lxray_sleds_start0-[[IDX]]
+; CHECK-LINUX-NEXT:    .quad 1
 
 ; CHECK-MACOS-LABEL: .section __DATA,xray_instr_map,regular,live_support{{$}}
 ; CHECK-MACOS-LABEL: Lxray_sleds_start0:
 ; CHECK-MACOS:         .quad Lxray_sled_0
 ; CHECK-MACOS-LABEL: Lxray_sleds_end0:
 ; CHECK-MACOS-LABEL: .section __DATA,xray_fn_idx,regular,live_support{{$}}
-; CHECK-MACOS:         .quad Lxray_sleds_start0
-; CHECK-MACOS-NEXT:    .quad Lxray_sleds_end0
+; CHECK-MACOS:       [[IDX:lxray_fn_idx[0-9]+]]:
+; CHECK-MACOS-NEXT:    .quad Lxray_sleds_start0-[[IDX]]
+; CHECK-MACOS-NEXT:    .quad 1
 
 
 ; We test multiple returns in a single function to make sure we're getting all
 ; of them with XRay instrumentation.
 define i32 @bar(i32 %i) nounwind noinline uwtable "function-instrument"="xray-always" "xray-skip-entry" {
 ; CHECK-NOT: Lxray_sled_1:
 Test:
   %cond = icmp eq i32 %i, 0

 ; CHECK-NEXT:  nopw %cs:512(%rax,%rax)
 }
 
 ; CHECK-LINUX-LABEL: .section xray_instr_map,"ao",@progbits,bar{{$}}
 ; CHECK-LINUX-LABEL: .Lxray_sleds_start1:
 ; CHECK-LINUX:         .quad .Lxray_sled_1
 ; CHECK-LINUX:         .quad .Lxray_sled_2
 ; CHECK-LINUX-LABEL: .Lxray_sleds_end1:
-; CHECK-LINUX-LABEL: .section xray_fn_idx,"awo",@progbits,bar{{$}}
-; CHECK-LINUX:         .quad .Lxray_sleds_start1
-; CHECK-LINUX-NEXT:    .quad .Lxray_sleds_end1
+; CHECK-LINUX-LABEL: .section xray_fn_idx,"ao",@progbits,bar{{$}}
+; CHECK-LINUX:       [[IDX:\.Lxray_fn_idx[0-9]+]]:
+; CHECK-LINUX-NEXT:    .quad .Lxray_sleds_start1-[[IDX]]
+; CHECK-LINUX-NEXT:    .quad 2
 
 ; CHECK-MACOS-LABEL: .section __DATA,xray_instr_map,regular,live_support{{$}}
 ; CHECK-MACOS-LABEL: Lxray_sleds_start1:
 ; CHECK-MACOS:         .quad Lxray_sled_1
 ; CHECK-MACOS:         .quad Lxray_sled_2
 ; CHECK-MACOS-LABEL: Lxray_sleds_end1:
 ; CHECK-MACOS-LABEL: .section __DATA,xray_fn_idx,regular,live_support{{$}}
-; CHECK-MACOS:         .quad Lxray_sleds_start1
-; CHECK-MACOS-NEXT:    .quad Lxray_sleds_end1
+; CHECK-MACOS:       [[IDX:lxray_fn_idx[0-9]+]]:
+; CHECK-MACOS-NEXT:    .quad Lxray_sleds_start1-[[IDX]]
+; CHECK-MACOS-NEXT:    .quad 2

llvm/test/CodeGen/X86/xray-partial-instrumentation-skip-exit.ll

 ; CHECK:       retq
 }
 
 ; CHECK-LINUX-LABEL: .section xray_instr_map,"ao",@progbits,bar{{$}}
 ; CHECK-LINUX-LABEL: .Lxray_sleds_start1:
 ; CHECK-LINUX:         .quad .Lxray_sled_1
 ; CHECK-LINUX-LABEL: .Lxray_sleds_end1:
 ; CHECK-LINUX-LABEL: .section xray_fn_idx,"awo",@progbits,bar{[$}}
-; CHECK-LINUX:         .quad .Lxray_sleds_start1
+; CHECK-LINUX:       .Lxray_fn_idx0:
+; CHECK-LINUX-NEXT:    .quad .Lxray_sleds_start1-.Lxray_fn_idx0
 ; CHECK-LINUX-NEXT:    .quad .Lxray_sleds_end1
 
 ; CHECK-MACOS-LABEL: .section __DATA,xray_instr_map,regular,live_support{{$}}
 ; CHECK-MACOS-LABEL: Lxray_sleds_start1:
 ; CHECK-MACOS:         .quad Lxray_sled_1
 ; CHECK-MACOS-LABEL: Lxray_sleds_end1:
 ; CHECK-MACOS-LABEL: .section __DATA,xray_fn_idx,regular,live_support{{$}}
-; CHECK-MACOS:         .quad Lxray_sleds_start1
+; CHECK-MACOS:       Lxray_fn_idx0:
+; CHECK-MACOS-NEXT:    .quad Lxray_sleds_start1-Lxray_fn_idx0
 ; CHECK-MACOS-NEXT:    .quad Lxray_sleds_end1

llvm/test/CodeGen/X86/xray-tail-call-sled.ll

 ; CHECK-NEXT:  nopw %cs:512(%rax,%rax)
 }
 
 ; CHECK-LINUX-LABEL: .section xray_instr_map,"ao",@progbits,callee{{$}}
 ; CHECK-LINUX-LABEL: .Lxray_sleds_start0:
 ; CHECK-LINUX:         .quad .Lxray_sled_0
 ; CHECK-LINUX:         .quad .Lxray_sled_1
 ; CHECK-LINUX-LABEL: .Lxray_sleds_end0:
-; CHECK-LINUX-LABEL: .section xray_fn_idx,"awo",@progbits,callee{{$}}
-; CHECK-LINUX:         .quad .Lxray_sleds_start0
-; CHECK-LINUX-NEXT:    .quad .Lxray_sleds_end0
+; CHECK-LINUX-LABEL: .section xray_fn_idx,"ao",@progbits,callee{{$}}
+; CHECK-LINUX:       [[IDX:\.Lxray_fn_idx[0-9]+]]:
+; CHECK-LINUX-NEXT:    .quad .Lxray_sleds_start0-[[IDX]]
+; CHECK-LINUX-NEXT:    .quad 2
 
 ; CHECK-MACOS-LABEL: .section __DATA,xray_instr_map,regular,live_support{{$}}
 ; CHECK-MACOS-LABEL: Lxray_sleds_start0:
 ; CHECK-MACOS:         .quad Lxray_sled_0
 ; CHECK-MACOS:         .quad Lxray_sled_1
 ; CHECK-MACOS-LABEL: Lxray_sleds_end0:
 ; CHECK-MACOS-LABEL: .section __DATA,xray_fn_idx,regular,live_support{{$}}
-; CHECK-MACOS:         .quad Lxray_sleds_start0
-; CHECK-MACOS-NEXT:    .quad Lxray_sleds_end0
+; CHECK-MACOS:       [[IDX:lxray_fn_idx[0-9]+]]:
+; CHECK-MACOS-NEXT:    .quad Lxray_sleds_start0-[[IDX]]
+; CHECK-MACOS-NEXT:    .quad 2
 
 define dso_local i32 @caller() nounwind noinline uwtable "function-instrument"="xray-always" {
 ; CHECK:       .p2align 1, 0x90
 ; CHECK-LABEL: Lxray_sled_2:
 ; CHECK:       .ascii "\353\t"
 ; CHECK-NEXT:  nopw 512(%rax,%rax)
 ; CHECK:       .p2align 1, 0x90
 ; CHECK-LABEL: Lxray_sled_3:
 ; CHECK-NEXT:  .ascii "\353\t"
 ; CHECK-NEXT:  nopw 512(%rax,%rax)
   %retval = tail call i32 @callee()
 ; CHECK:       jmp {{.*}}callee {{.*}}# TAILCALL
   ret i32 %retval
 }
 
 ; CHECK-LINUX-LABEL: .section xray_instr_map,"ao",@progbits,caller{{$}}
 ; CHECK-LINUX-LABEL: .Lxray_sleds_start1:
 ; CHECK-LINUX:         .quad .Lxray_sled_2
 ; CHECK-LINUX:         .quad .Lxray_sled_3
 ; CHECK-LINUX-LABEL: .Lxray_sleds_end1:
-; CHECK-LINUX-LABEL: .section xray_fn_idx,"awo",@progbits,caller{{$}}
-; CHECK-LINUX:         .quad .Lxray_sleds_start1
-; CHECK-LINUX:         .quad .Lxray_sleds_end1
+; CHECK-LINUX-LABEL: .section xray_fn_idx,"ao",@progbits,caller{{$}}
+; CHECK-LINUX:       [[IDX:\.Lxray_fn_idx[0-9]+]]:
+; CHECK-LINUX-NEXT:    .quad .Lxray_sleds_start1-[[IDX]]
+; CHECK-LINUX-NEXT:    .quad 2
 
 ; CHECK-MACOS-LABEL: .section __DATA,xray_instr_map,regular,live_support{{$}}
 ; CHECK-MACOS-LABEL: Lxray_sleds_start1:
 ; CHECK-MACOS:         .quad Lxray_sled_2
 ; CHECK-MACOS:         .quad Lxray_sled_3
 ; CHECK-MACOS-LABEL: Lxray_sleds_end1:
 ; CHECK-MACOS-LABEL: .section __DATA,xray_fn_idx,regular,live_support{{$}}
-; CHECK-MACOS:         .quad Lxray_sleds_start1
-; CHECK-MACOS:         .quad Lxray_sleds_end1
+; CHECK-MACOS:       [[IDX:lxray_fn_idx[0-9]+]]:
+; CHECK-MACOS-NEXT:    .quad Lxray_sleds_start1-[[IDX]]
+; CHECK-MACOS-NEXT:    .quad 2

llvm/test/DebugInfo/X86/xray-split-dwarf-interaction.ll

 ;   for (;;)
 ;     ;
 ; }
 ;
 ; In this test we want to make sure that the xray_instr_map section for
 ; `a::b()` is actually associated with the function's symbol instead of the
 ; .debug_types.dwo section.
 ;
-; CHECK-ASM: xray_fn_idx,"awo",@progbits,_ZN1a1bEv{{$}}
+; CHECK-ASM: xray_fn_idx,"ao",@progbits,_ZN1a1bEv{{$}}
 ;
 ; CHECK-ELF-DAG: [[FSECT:[0-9]+]]] .text._ZN1a1bEv PROGBITS
 ; CHECK-ELF-DAG: [{{.*}}] .debug_types.dwo PROGBITS
 ; CHECK-ELF-DAG: [{{.*}}] xray_instr_map PROGBITS {{.*}} {{.*}} {{.*}} {{.*}} AL [[FSECT]]
 target triple = "x86_64-pc-linux"
 
 %class.a = type { i8 }