[X86][ELF][LLD] Add R_X86_64_PCNEXT32 relocation and MO_PCNEXT32 flag for code prefetching

This adds support for the proposed R_X86_64_PCNEXT32 relocation and the @PCNEXT32 (MO_PCNEXT32) target operand flag in LLVM and LLD, including MC and LLD test coverage.

x86-64 psABI proposal discussion: https://groups.google.com/g/x86-64-abi/c/v_alXxMCTgI

## Relocation Behavior & Calculation

| Symbol State | Calculation | Notes |
| ------------ | ----------- | ----- |
| Defined      | S + A - P   | Identical to R_X86_64_PC32 |
| Undefined    | 0           | No diagnostic error reported |

A 0 PC-relative displacement targets the instruction immediately following the relocated field. Consequently, an undefined reference degrades cleanly to a harmless, position-independent reference to the next instruction (a valid instruction boundary).

## Motivation

LLVM's Code-prefetch insertion (#166324) inserts prefetchit1 target(%rip) ahead of an anticipated instruction cache or front-end miss:

    prefetchit1 __llvm_prefetch_target_<fn>_<bbid>_<cs>(%rip)

The target is an address inside a callee (often in another translation unit), so the compiler synthesizes a target symbol at that address and uses a PC-relative reference resolved by the linker.

However, the referenced target symbol may be undefined in the final build if the profile's <function, bb_id, callsite_index> triple fails to match the final image (due to function renaming, block structure changes, or altered callsite counts), or if the target is simply not linked in.

Previously, avoiding an undefined-symbol error required emitting a weak fallback definition immediately after the prefetch:

    prefetchit1 __llvm_prefetch_target_foo_x_y(%rip)
    .weak __llvm_prefetch_target_foo_x_y
    __llvm_prefetch_target_foo_x_y:

While this allows standard ELF resolution without linker modifications (a real STB_GLOBAL overrides the weak fallback, and an absent target degrades to the fallback immediately following the instruction), it prevents the prefetch target itself from being a weak definition—the linker may mistakenly resolve against an undesired weak fallback rather than the desired weak target in another translation unit.

With R_X86_64_PCNEXT32, undefined targets resolve directly to displacement 0 (pointing to the next instruction without linker errors), removing the need for fallback definitions and allowing weak target definitions to function correctly.

Author: rlavaee

lld/ELF/Arch/X86_64.cpp

@@ -576,6 +576,8 @@ RelExpr X86_64::getRelExpr(RelType type, const Symbol &s,
   case R_X86_64_PC32:
   case R_X86_64_PC64:
     return R_PC;
+  case R_X86_64_PCNEXT32:
+    return RE_X86_64_PCNEXT32;
   case R_X86_64_GOTOFF64:
     return R_GOTPLTREL;
   case R_X86_64_GOTPC32:
@@ -654,7 +656,7 @@ void X86_64::scanSectionImpl(InputSectionBase &sec, Relocs<RelTy> rels,
     Symbol &sym = sec.getFile<ELFT>()->getSymbol(symIdx);
     uint64_t offset = rel.r_offset;
     RelType type = rel.getType(false);
-    if (sym.isUndefined() && symIdx != 0 &&
+    if (sym.isUndefined() && symIdx != 0 && type != R_X86_64_PCNEXT32 &&
         rs.maybeReportUndefined(cast<Undefined>(sym), offset))
       continue;
     int64_t addend = rs.getAddend<ELFT>(rel, type);
@@ -682,6 +684,9 @@ void X86_64::scanSectionImpl(InputSectionBase &sec, Relocs<RelTy> rels,
     case R_X86_64_PC64:
       rs.processR_PC(type, offset, addend, sym);
       continue;
+    case R_X86_64_PCNEXT32:
+      rs.process(RE_X86_64_PCNEXT32, type, offset, sym, addend);
+      continue;
 
       // GOT-generating relocations:
     case R_X86_64_GOTPC32:
@@ -1182,6 +1187,7 @@ void X86_64::relocate(uint8_t *loc, const Relocation &rel, uint64_t val) const {
   case R_X86_64_GOTPC32:
   case R_X86_64_GOTPCREL:
   case R_X86_64_PC32:
+  case R_X86_64_PCNEXT32:
   case R_X86_64_PLT32:
   case R_X86_64_DTPOFF32:
   case R_X86_64_SIZE32:

lld/ELF/InputSection.cpp

@@ -921,6 +921,10 @@ uint64_t InputSectionBase::getRelocTargetVA(Ctx &ctx, const Relocation &r,
   }
   case RE_LOONGARCH_PAGE_PC:
     return getLoongArchPageDelta(r.sym->getVA(ctx, a), p, r.type);
+  case RE_X86_64_PCNEXT32:
+    if (r.sym->isUndefined() || r.sym->isShared())
+      return 0;
+    return r.sym->getVA(ctx, a) - p;
   case R_PC:
   case RE_ARM_PCA: {
     uint64_t dest;

lld/ELF/Relocations.cpp

@@ -846,7 +846,8 @@ bool RelocScan::isStaticLinkTimeConstant(RelExpr e, RelType type,
             R_GOTPLTONLY_PC, R_PLT_PC, R_PLT_GOTREL, R_PLT_GOTPLT,
             R_GOTPLT_GOTREL, R_GOTPLT_PC, RE_PPC32_PLTREL, RE_PPC64_CALL_PLT,
             RE_RISCV_ADD, RE_AARCH64_GOT_PAGE, RE_LOONGARCH_PLT_PAGE_PC,
-            RE_LOONGARCH_GOT, RE_LOONGARCH_GOT_PAGE_PC>(e))
+            RE_LOONGARCH_GOT, RE_LOONGARCH_GOT_PAGE_PC,
+            RE_X86_64_PCNEXT32>(e))
     return true;
 
   // These never do, except if the entire file is position dependent or if

lld/ELF/Relocations.h

@@ -126,6 +126,7 @@ enum RelExpr {
   RE_LOONGARCH_PC_INDIRECT,
   RE_LOONGARCH_TLSGD_PAGE_PC,
   RE_LOONGARCH_TLSDESC_PAGE_PC,
+  RE_X86_64_PCNEXT32,
 };
 
 // Architecture-neutral representation of relocation.

lld/test/ELF/x86-64-reloc-pcnext32.s

@@ -0,0 +1,37 @@
+# REQUIRES: x86
+# RUN: rm -rf %t && split-file %s %t
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %t/so.s -o %t/so.o
+# RUN: ld.lld -shared %t/so.o -o %t/libso.so
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %t/main.s -o %t/main.o
+# RUN: ld.lld --image-base=0x1000 --section-start=.text=0x1000 %t/main.o %t/libso.so -o %t/out
+# RUN: llvm-readelf -x .text %t/out | FileCheck %s
+
+# CHECK: Hex dump of section '.text':
+# CHECK-NEXT: 0x00001000 0c000000 00000000 00000000 c3
+
+#--- so.s
+.global shared_sym
+shared_sym:
+  ret
+
+#--- main.s
+.globl _start
+_start:
+  # R_X86_64_PCNEXT32 to defined local symbol at 0x100c (place is 0x1000, 0x100c - 0x1000 = 0x0c)
+  .reloc ., R_X86_64_PCNEXT32, local_sym
+  .byte 0x00, 0x00, 0x00, 0x00
+
+  # R_X86_64_PCNEXT32 to shared symbol (resolves to 0)
+  .reloc ., R_X86_64_PCNEXT32, shared_sym
+  .byte 0x00, 0x00, 0x00, 0x00
+
+  # R_X86_64_PCNEXT32 to undefined weak symbol (resolves to 0)
+  .reloc ., R_X86_64_PCNEXT32, undef_sym
+  .byte 0x00, 0x00, 0x00, 0x00
+
+local_sym:
+  ret
+
+.weak undef_sym

llvm/docs/Extensions.md

@@ -764,6 +764,17 @@ is also not the same as `cmpb $foo, %dil`, which is an 8-bit comparison.
 the assembler emits an `R_X86_64_GOTPCREL` relocation instead of a relaxable
 `R_X86_64[_REX]_GOTPCRELX` relocation.
 
+
+**@PCNEXT32** can be used on symbol references to indicate that the immediate
+operand is an offset to the target symbol from the next code location, causing
+the assembler to emit an `R_X86_64_PCNEXT32` relocation. If the target symbol
+is defined, the relocation resolves identically to `R_X86_64_PC32` (`S + A - P`).
+If the target symbol is undefined or in a shared library, it resolves to zero
+displacement (`0`) without generating a linker diagnostic. This allows
+undefined code prefetch targets (e.g. `prefetchit1 target@PCNEXT32(%rip)`) to
+gracefully degrade to a harmless prefetch of the immediately following
+instruction.
+
 ### Windows on ARM
 
 #### Stack Probe Emission

llvm/include/llvm/BinaryFormat/ELFRelocs/x86_64.def

@@ -46,4 +46,5 @@ ELF_RELOC(R_X86_64_REX_GOTPCRELX,    42)
 ELF_RELOC(R_X86_64_CODE_4_GOTPCRELX,    43)
 ELF_RELOC(R_X86_64_CODE_4_GOTTPOFF,    44)
 ELF_RELOC(R_X86_64_CODE_4_GOTPC32_TLSDESC,    45)
+ELF_RELOC(R_X86_64_PCNEXT32,                  46)
 ELF_RELOC(R_X86_64_CODE_6_GOTTPOFF,    50)

llvm/lib/Target/X86/MCTargetDesc/X86BaseInfo.h

@@ -394,6 +394,11 @@ enum TOF {
   /// See the X86-64 ELF ABI supplement for more details.
   ///    SYMBOL_LABEL @PLT
   MO_PLT,
+  /// MO_PCNEXT32 - On a symbol operand this indicates that the immediate is
+  /// offset to the prefetch target symbol name from the next code location.
+  /// If the target symbol is undefined, it will resolve to zero displacement.
+  ///    SYMBOL_LABEL @PCNEXT32
+  MO_PCNEXT32,
   /// MO_TLSGD - On a symbol operand this indicates that the immediate is
   /// the offset of the GOT entry with the TLS index structure that contains
   /// the module number and variable offset for the symbol. Used in the

llvm/lib/Target/X86/MCTargetDesc/X86ELFObjectWriter.cpp

@@ -212,6 +212,9 @@ unsigned X86ELFObjectWriter::getRelocType64(SMLoc Loc, X86::Specifier Specifier,
   case X86::S_PLT:
     checkIs32(Loc, Type);
     return ELF::R_X86_64_PLT32;
+  case X86::S_PCNEXT32:
+    checkIs32(Loc, Type);
+    return ELF::R_X86_64_PCNEXT32;
   case X86::S_GOTPCREL:
     checkIs32(Loc, Type);
     // Older versions of ld.bfd/ld.gold/lld

llvm/lib/Target/X86/MCTargetDesc/X86MCAsmInfo.cpp

@@ -49,6 +49,7 @@ const MCAsmInfo::AtSpecifier atSpecifiers[] = {
     {X86::S_INDNTPOFF, "INDNTPOFF"},
     {MCSymbolRefExpr::VK_COFF_IMGREL32, "IMGREL"},
     {X86::S_NTPOFF, "NTPOFF"},
+    {X86::S_PCNEXT32, "PCNEXT32"},
     {X86::S_PCREL, "PCREL"},
     {X86::S_PLT, "PLT"},
     {X86::S_PLTOFF, "PLTOFF"},