[LLD][BPF] Add bpf support

[yonghong-song]

Summary

This patch added BPF support to LLD. BPF
program does not have a defined entry point.
But LLD can still help do linking different
BPF objects into one object.

The simplest way is to link different objects
in a relocatable way.

clang -target bpf -g -O2 -c t1.c t2.c
ld.lld -r t1.o t2.o -o final.o

The drawback is that .BTF section is not deduplicated
as lld just simply merged all .BTF sections and
didn't do deduplication so a post-linker tool
is needed to do deduplication.

But we can build a relocable object file
through LTO. LTO puts all IRs in the same module so
deduplication is automatically done by the compiler.

clang -target bpf -flto -O2 -g -c t1.c -o t1.bc
clang -target bpf -flto -O2 -g -c t2.c -o t2.bc
ld.lld -r t1.bc t2.bc -o final.o

Currently, lld unconditionally emits a section per function/datum
with LTO. The bpf loader library, libbpf, expects only
one .text or .data section. Some other bpf loader tools may
have similar assumptions. To make downstream bpf tools less
complicated, per function/datum sections will not be emited
if LTO is compiled for BPF relocatable object.

The BPF relocation documentation:

https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/tree/Documentation/bpf/llvm_reloc.rst

[yonghong-song]

add tests/docs and target hook emitFuncDataSections(). Removed WIP tag.
@MaskRay Could you take a look? Thanks!

[ast]

I think addition of emitFuncDataSections is justified.
The rest is bpf specific.

[MaskRay]

I will come to this, but want to make sure this is in a "need review" state.

[yonghong-song]

handling static functions (int a different section) properly. static variables should be similar.

[MaskRay]

lld/ELF/Arch/BPF.cpp

50

R_NONE if no dynamic relocation is expected

54

See other Arch/*.cpp: add switch in getRelExpr and add error

lld/ELF/LTO.cpp

87–90

Remove the abstraction: emitFuncDataSections.

Just test config->emachine and config->relocatable.

lld/test/ELF/bpf-basic.s

3

Use split-file %s %t

5

See riscv-*.s how I organize the little-endian and big-endian RUN lines.

7

-relocatable => -r

lld/test/ELF/bpf-lto-basic.s

1 ↗

(On Diff #344635)

move to test/ELF/lto

Use .bc for bitcode file extension.

10 ↗

(On Diff #344635)

[[#]]

17 ↗

(On Diff #344635)

Add a comment what the magic value is.

[yonghong-song]

• Addressed @MaskRay's comments. Thanks for quick reviewing!

[MaskRay]

Does BPF have a Processor Supplement ABI? I think we really should have raised our bar to allow targets which have defined the ABI.
This was also requested in 2018: https://patchwork.ozlabs.org/project/glibc/patch/[e-mail]/

I don't understand the if (config->emachine != EM_BPF && type != target->noneRel) change as
it feels wrong that "BPF llvm target already wrote the section offset in each relocation instruction"

0000000000000000 <test2>:
       0:       18 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 r0 = 0 ll
                0000000000000000:  R_BPF_64_64  sec3
       2:       95 00 00 00 00 00 00 00 exit

If I drop the special case, I will get

0000000000000000 <test2>:
       0:       00 00 00 00 00 00 00 00 <unknown>
                0000000000000000:  R_BPF_64_64  sec3
                ...
       2:       95 00 00 00 00 00 00 00 exit

Why is this <unknown>?

I would suggest that you try figuring out how other REL tests work (by commenting out some !RelTy::IsRela code and seeing what tests would fail).

I am also very concerned with potentially other differently interpreted concepts, e.g. the re-defined STV_INTERNAL (https://lists.llvm.org/pipermail/cfe-dev/2021-May/068134.html).
This would potentially diverge from other implementations and add some symbol resolution complexity to the generic code (say, we would have to check STV_INTERNAL in Symbols.cpp just for BPF)

lld/ELF/Arch/BPF.cpp

57

See other getRelExpr implementations. The allowed relocation types must be listed.

lld/test/ELF/lto/bpf-diff-sec.ll

2

The auxiliary file is only used once. Please use split-file

[yonghong-song]

For this Why is this <unknown>? if you remove if (config->emachine != EM_BPF && type != target->noneRel), this is because I didn't implement BPF target relocate properly. In current llvm BPF backend, BPFAsmBackend.cpp file, we have

void BPFAsmBackend::applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
                               const MCValue &Target,
                               MutableArrayRef<char> Data, uint64_t Value,
                               bool IsResolved,
                               const MCSubtargetInfo *STI) const {
  if (Fixup.getKind() == FK_SecRel_4 || Fixup.getKind() == FK_SecRel_8) {
    // The Value is 0 for global variables, and the in-section offset
    // for static variables. Write to the immediate field of the inst.
    assert(Value <= UINT32_MAX);
    support::endian::write<uint32_t>(&Data[Fixup.getOffset() + 4],
                                     static_cast<uint32_t>(Value),
                                     Endian);
  } else if (Fixup.getKind() == FK_Data_4) {
    support::endian::write<uint32_t>(&Data[Fixup.getOffset()], Value, Endian);
  } else if (Fixup.getKind() == FK_Data_8) {
    support::endian::write<uint64_t>(&Data[Fixup.getOffset()], Value, Endian);
  } else if (Fixup.getKind() == FK_PCRel_4) {
    Value = (uint32_t)((Value - 8) / 8);
    if (Endian == support::little) {
      Data[Fixup.getOffset() + 1] = 0x10;
      support::endian::write32le(&Data[Fixup.getOffset() + 4], Value);
    } else {
      Data[Fixup.getOffset() + 1] = 0x1;
      support::endian::write32be(&Data[Fixup.getOffset() + 4], Value);
    } 
  } else {
    assert(Fixup.getKind() == FK_PCRel_2);
    Value = (uint16_t)((Value - 8) / 8);
    support::endian::write<uint16_t>(&Data[Fixup.getOffset() + 2], Value,
                                     Endian);
  }                                  
}

You can see some relocation data is written at the instruction offset 2 or 4. In my current relocate() function, the start of the insn (which include insn opcode) is written instead of offset 4. That is why you will see "<unknown>" here.

For

I would suggest that you try figuring out how other REL tests work (by commenting out some !RelTy::IsRela code and seeing what tests would fail).

That is a good suggestion, I am certainly not a ldd expert. I will look at the related codes, remove the above hack and resubmit the patch again.

lld/ELF/Arch/BPF.cpp

57

will do.

lld/test/ELF/lto/bpf-diff-sec.ll

2

will do.

[yonghong-song]

For

I am also very concerned with potentially other differently interpreted concepts, e.g. the re-defined STV_INTERNAL (https://lists.llvm.org/pipermail/cfe-dev/2021-May/068134.html).

This would potentially diverge from other implementations and add some symbol resolution complexity to the generic code (say, we would have to check STV_INTERNAL in Symbols.cpp just for BPF)

I agree that BPF interpretation of STV_INTERNAL might be different from the standard. This is not a blocker though so we are fine without it.

[yonghong-song]

• removed hack in InputSection.cpp to prevent emitting relocations for relocatable BPF.
• added two new target hooks to differentiate between ALLOC and non-ALLOC as BPF targets need them to take different actions.
• implement target relocate*() and getImplicitAddend*() properly.

[yonghong-song]

@alessandrod FYI. This is to support BPF in lld. Maybe this may help your rust bpf-linker work?

[MaskRay]

The REL handling and BPF::relocateAlloc look like hacks to me. Once they are fixed, I think the patch will be in a good state. Thanks!
It looks wrong that relocateAlloc is different from relocate.

[yonghong-song]

Discussed with Alexei, we are going to add more relocations in BPF backend. Here is the patch https://reviews.llvm.org/D102712. You can take a look if you are interested.
Once it or its variant is merged, I will remove getImplicitAddendAlloc() and relocateAlloc(). Then we will have no non-target changes except disabling -ffunction-sections for BPF LTO relocatable mode. Thanks!

[yonghong-song]

• https://reviews.llvm.org/D102712 made llvm BPF relocations more lld friendly. The patch has landed. Now redo the lld patch with new relocations.
• Per early Fangrui's suggestion, I submitted the following llvm relocation patch https://lore.kernel.org/bpf/[e-mail]/ to linux kernel mailing list and if accepted it will be in kernel bpf docs.

[yonghong-song]

@MaskRay Did you get some time to look at the new revision?

[yonghong-song]

Just updated the summary to include a link to bpf relocation documentation. Later on, once this is integrated into Linus tree (https://github.com/torvalds/linux), and built and placed in kernel/doc bpf relocation information should be very easily searchable (https://www.kernel.org/doc/html/latest/bpf/index.html).

Added Rui Ueyama (@ruiu), Rafael Espindola (@respindola) and George Rimar (@grimar) as reviewers too to get more perspective on how to move forward.

Currently, the patch is stuck as Fangrui (@MaskRay) really wants to rename some of bpf relocations, specifically R_BPF_64_64 and R_BPF_64_32.
See the detailed discussions here:

https://lore.kernel.org/bpf/CAADnVQJa=b=[e-mail]/T/#t

I completely agree that these names are not really good and not reflect what the underlying relocation is doing. See the above discussion. That is why we added bpf relocations into kernel doc so people can easily check and find out what these relocations are for. BTW, the idea to create a bpf relocation documentation is from
Fangrui.

But relocation names R_BPF_64_64 and R_BPF_64_32 has been in BPF community since Nov 2016 with commit

7ab125dbf344 ([bpf] fix dwarf elf relocs and line numbers)

Before that there is only one relocation called R_BPF_MAP_FD. The renaming happens because bpf is still in its infant stage at that time and not many users.

Now bpf has a large community and R_BPF_64_64/R_BPF_64_32 is in elfutils and glibc_headers and libbpf and possibly other tools. Event the latest ebpf-for-windows mentioning these relocation names. From https://github.com/microsoft/ebpf-for-windows.git,

$ egrep -r R_BPF
docs/tutorial.md:0000000000000000 R_BPF_64_64 .data
docs/tutorial.md:0000000000000040 R_BPF_64_64 map

Changing these names will confuse users as the llvm-objdump -r and llvm-readobj -r output will have different names than the code or *existing* documentation. I think having a ready documentation (https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/tree/Documentation/bpf/llvm_reloc.rst) should be a reasonable step if anybody wants to understand what the relocation intends to do. I think in most cases, for people cares the relocation implementation details, looking at names almost always not enough for any architecture, you need to look at the code or detailed documentations, at least for me.

It would be good if @ruiu, @respindola) and @grimar or any other people interested in discussion can share their perspective. Thanks!

[yonghong-song]

@ruiu @respindola @grimar Pinging. Do you have any comments for this patch?

[alessandrod]

I'd love to see this merged. I am now involved in a project that maintains a lld fork with this patch, and also maintain bpf-linker for the rust ecosystem. Ideally I'd like to see both disappear. Fwiw, I definitely agree with @yonghong-song that renaming the (admittedly bad) relocation types would cause a lot of unnecessary confusion in the ecosystem as there are now so many projects that use those names.

What needs to happen to move this forward?

lld/ELF/Arch/BPF.cpp

+//===---- BPF.cpp ---------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "Target.h"
+#include "llvm/Object/ELF.h"
+
+using namespace llvm;
+using namespace llvm::ELF;
+using namespace lld;
+using namespace lld::elf;
+
+namespace {
+class BPF final : public TargetInfo {
+public:
+  BPF();
+  int64_t getImplicitAddend(const uint8_t *buf, RelType type) const override;
+  int64_t getImplicitAddendAlloc(const uint8_t *buf,
+                                 RelType type) const override;
+  void relocate(uint8_t *loc, const Relocation &rel,
+                uint64_t val) const override;
+  void relocateAlloc(uint8_t *loc, const Relocation &rel,
+                     uint64_t val) const override;
+  RelType getDynRel(RelType type) const override;
+  RelExpr getRelExpr(RelType type, const Symbol &s,
+                     const uint8_t *loc) const override;
+};
+} // namespace
+
+BPF::BPF() { noneRel = R_BPF_NONE; }
+
+int64_t BPF::getImplicitAddend(const uint8_t *buf, RelType type) const {
+  switch (type) {
+  case R_BPF_NONE:
+    return 0;
+  case R_BPF_64_64:
+    return read64(buf);
+  case R_BPF_64_32:
+    return read32(buf);
+  default:
+    llvm_unreachable("unknown relocation");
+  }
+}
+
+void BPF::relocate(uint8_t *loc, const Relocation &rel, uint64_t val) const {
+  switch (rel.type) {
+  case R_BPF_NONE:
+    break;
+  case R_BPF_64_64:
+    write64(loc, val);
+    break;
+  case R_BPF_64_32:
+    write32(loc, (uint32_t)val);
+    break;
+  default:
+    llvm_unreachable("unknown relocation");
+  }
+}
+
+int64_t BPF::getImplicitAddendAlloc(const uint8_t *buf,
+                                    RelType type) const {
+  switch (type) {
+  case R_BPF_NONE:
+    return 0;
+  case R_BPF_64_64:
+    return read32(buf + 4);
+  case R_BPF_64_32:
+    // The addend is the (sec_offset/8 - 1) which could be negative.
+    return (int32_t)(uint32_t)(read32(buf + 4) * 8);
+  default:
+    llvm_unreachable("unknown relocation");
+  }
+}
+
+void BPF::relocateAlloc(uint8_t *loc, const Relocation &rel,
+                        uint64_t val) const {
+  switch (rel.type) {
+  case R_BPF_NONE:
+    break;
+  case R_BPF_64_64:
+    write32(loc + 4, (uint32_t)val);
+    break;
+  case R_BPF_64_32:
+    write32(loc + 4, (uint32_t)(val / 8));
+    break;
+  default:
+    llvm_unreachable("unknown relocation");
+  }
+}
+
+RelType BPF::getDynRel(RelType type) const { return R_BPF_NONE; }
+
+RelExpr BPF::getRelExpr(RelType type, const Symbol &s,
+                        const uint8_t *loc) const {
+  switch (type) {
+  case R_BPF_NONE:
+    return R_NONE;
+  case R_BPF_64_32:
+  case R_BPF_64_64:
+    return R_ABS;
+  default:
+    llvm_unreachable("unknown relocation");
+  }
+}
+
+TargetInfo *elf::getBPFTargetInfo() {
+  static BPF target;
+  return ⌖
+}

lld/ELF/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(ELFOptionsTableGen)
 
 add_lld_library(lldELF
   AArch64ErrataFix.cpp
   Arch/AArch64.cpp
   Arch/AMDGPU.cpp
   Arch/ARM.cpp
   Arch/AVR.cpp
+  Arch/BPF.cpp
   Arch/Hexagon.cpp
   Arch/Mips.cpp
   Arch/MipsArchTree.cpp
   Arch/MSP430.cpp
   Arch/PPC.cpp
   Arch/PPC64.cpp
   Arch/RISCV.cpp
   Arch/SPARCV9.cpp

lld/ELF/InputFiles.cpp

static uint16_t getBitcodeMachineKind(StringRef path, const Triple &t) {
   case Triple::amdgcn:
   case Triple::r600:
     return EM_AMDGPU;
   case Triple::arm:
   case Triple::thumb:
     return EM_ARM;
   case Triple::avr:
     return EM_AVR;
+  case Triple::bpfel:
+  case Triple::bpfeb:
+    return EM_BPF;
   case Triple::mips:
   case Triple::mipsel:
   case Triple::mips64:
   case Triple::mips64el:
     return EM_MIPS;
   case Triple::msp430:
     return EM_MSP430;
   case Triple::ppc:

lld/ELF/InputSection.cpp

if (sym.type == STT_SECTION) {
       SectionBase *section = d->section->repl;
       if (!section->isLive()) {
         p->setSymbolAndType(0, 0, false);
         continue;
       }
 
       int64_t addend = getAddend<ELFT>(rel);
       const uint8_t *bufLoc = sec->data().begin() + rel.r_offset;
-      if (!RelTy::IsRela)
+      if (!RelTy::IsRela) {
+        if (sec->flags & SHF_ALLOC)
+          addend = target->getImplicitAddendAlloc(bufLoc, type);
+        else
           addend = target->getImplicitAddend(bufLoc, type);
+      }
 
       if (config->emachine == EM_MIPS &&
           target->getRelExpr(type, sym, bufLoc) == R_MIPS_GOTREL) {
         // Some MIPS relocations depend on "gp" value. By default,
         // this value has 0x7ff0 offset from a .got section. But
         // relocatable files produced by a compiler or a linker
         // might redefine this default value and we must use it
         // for a calculation of the relocation result. When we
for (const Relocation &rel : relocations) {
     case R_PPC64_RELAX_TOC:
       // rel.sym refers to the STT_SECTION symbol associated to the .toc input
       // section. If an R_PPC64_TOC16_LO (.toc + addend) references the TOC
       // entry, there may be R_PPC64_TOC16_HA not paired with
       // R_PPC64_TOC16_LO_DS. Don't relax. This loses some relaxation
       // opportunities but is safe.
       if (ppc64noTocRelax.count({rel.sym, rel.addend}) ||
           !tryRelaxPPC64TocIndirection(rel, bufLoc))
-        target->relocate(bufLoc, rel, targetVA);
+        target->relocateAlloc(bufLoc, rel, targetVA);
       break;
     case R_RELAX_TLS_IE_TO_LE:
       target->relaxTlsIeToLe(bufLoc, rel, targetVA);
       break;
     case R_RELAX_TLS_LD_TO_LE:
     case R_RELAX_TLS_LD_TO_LE_ABS:
       target->relaxTlsLdToLe(bufLoc, rel, targetVA);
       break;
case R_PPC64_CALL:
           // Use substr(6) to remove the "__plt_" prefix.
           errorOrWarn(getErrorLocation(bufLoc) + "call to " +
                       lld::toString(*rel.sym).substr(6) +
                       " lacks nop, can't restore toc");
           break;
         }
         write32(bufLoc + 4, 0xe8410018); // ld %r2, 24(%r1)
       }
-      target->relocate(bufLoc, rel, targetVA);
+      target->relocateAlloc(bufLoc, rel, targetVA);
       break;
     default:
-      target->relocate(bufLoc, rel, targetVA);
+      target->relocateAlloc(bufLoc, rel, targetVA);
       break;
     }
   }
 
   // Apply jumpInstrMods.  jumpInstrMods are created when the opcode of
   // a jmp insn must be modified to shrink the jmp insn or to flip the jmp
   // insn.  This is primarily used to relax and optimize jumps created with
   // basic block sections.

lld/ELF/LTO.cpp

 static lto::Config createConfig() {
   lto::Config c;
 
   // LLD supports the new relocations and address-significance tables.
   c.Options = initTargetOptionsFromCodeGenFlags();
   c.Options.RelaxELFRelocations = true;
   c.Options.EmitAddrsig = true;
 
-  // Always emit a section per function/datum with LTO.
+  if (config->emachine != EM_BPF || !config->relocatable) {
     c.Options.FunctionSections = true;
     c.Options.DataSections = true;
+  }
 
   // Check if basic block sections must be used.
   // Allowed values for --lto-basic-block-sections are "all", "labels",
   // "<file name specifying basic block ids>", or none.  This is the equivalent
   // of -fbasic-block-sections= flag in clang.
   if (!config->ltoBasicBlockSections.empty()) {
     if (config->ltoBasicBlockSections == "all") {
       c.Options.BBSections = BasicBlockSection::All;

lld/ELF/Target.h

public:
   virtual RelExpr getRelExpr(RelType type, const Symbol &s,
                              const uint8_t *loc) const = 0;
   virtual RelType getDynRel(RelType type) const { return 0; }
   virtual void writeGotPltHeader(uint8_t *buf) const {}
   virtual void writeGotHeader(uint8_t *buf) const {}
   virtual void writeGotPlt(uint8_t *buf, const Symbol &s) const {};
   virtual void writeIgotPlt(uint8_t *buf, const Symbol &s) const {}
   virtual int64_t getImplicitAddend(const uint8_t *buf, RelType type) const;
+  virtual int64_t getImplicitAddendAlloc(const uint8_t *buf,
+                                         RelType type) const {
+     return getImplicitAddend(buf, type);
+  }
   virtual int getTlsGdRelaxSkip(RelType type) const { return 1; }
 
   // If lazy binding is supported, the first entry of the PLT has code
   // to call the dynamic linker to resolve PLT entries the first time
   // they are called. This function writes that code.
   virtual void writePltHeader(uint8_t *buf) const {}
 
   virtual void writePlt(uint8_t *buf, const Symbol &sym,
public:
   virtual bool inBranchRange(RelType type, uint64_t src,
                              uint64_t dst) const;
 
   virtual void relocate(uint8_t *loc, const Relocation &rel,
                         uint64_t val) const = 0;
   void relocateNoSym(uint8_t *loc, RelType type, uint64_t val) const {
     relocate(loc, Relocation{R_NONE, type, 0, 0, nullptr}, val);
   }
+  virtual void relocateAlloc(uint8_t *loc, const Relocation &rel,
+                             uint64_t val) const {
+    relocate(loc, rel, val);
+  }
 
   virtual void applyJumpInstrMod(uint8_t *loc, JumpModType type,
                                  JumpModType val) const {}
 
   virtual ~TargetInfo();
 
   // This deletes a jump insn at the end of the section if it is a fall thru to
   // the next section.  Further, if there is a conditional jump and a direct
protected:
   // Given that, the smallest value that can be used in here is 0x10000.
   uint64_t defaultImageBase = 0x10000;
 };
 
 TargetInfo *getAArch64TargetInfo();
 TargetInfo *getAMDGPUTargetInfo();
 TargetInfo *getARMTargetInfo();
 TargetInfo *getAVRTargetInfo();
+TargetInfo *getBPFTargetInfo();
 TargetInfo *getHexagonTargetInfo();
 TargetInfo *getMSP430TargetInfo();
 TargetInfo *getPPC64TargetInfo();
 TargetInfo *getPPCTargetInfo();
 TargetInfo *getRISCVTargetInfo();
 TargetInfo *getSPARCV9TargetInfo();
 TargetInfo *getX86TargetInfo();
 TargetInfo *getX86_64TargetInfo();

lld/ELF/Target.cpp

TargetInfo *elf::getTarget() {
   case EM_AARCH64:
     return getAArch64TargetInfo();
   case EM_AMDGPU:
     return getAMDGPUTargetInfo();
   case EM_ARM:
     return getARMTargetInfo();
   case EM_AVR:
     return getAVRTargetInfo();
+  case EM_BPF:
+    return getBPFTargetInfo();
   case EM_HEXAGON:
     return getHexagonTargetInfo();
   case EM_MIPS:
     switch (config->ekind) {
     case ELF32LEKind:
       return getMipsTargetInfo<ELF32LE>();
     case ELF32BEKind:
       return getMipsTargetInfo<ELF32BE>();

lld/docs/index.rst

- LLD is a drop-in replacement for the GNU linkers that accepts the
   can link approximately 95% of the ports collection on AMD64. For the
   details, see `FreeBSD quarterly status report
   <https://www.freebsd.org/news/status/report-2016-10-2016-12.html#Using-LLVM%27s-LLD-Linker-as-FreeBSD%27s-System-Linker>`_.
 
 - LLD is very fast. When you link a large program on a multicore
   machine, you can expect that LLD runs more than twice as fast as the GNU
   gold linker. Your mileage may vary, though.
 
-- It supports various CPUs/ABIs including AArch64, AMDGPU, ARM, Hexagon, MIPS
-  32/64 big/little-endian, PowerPC, PowerPC64, RISC-V, SPARC V9, x86-32 and
+- It supports various CPUs/ABIs including AArch64, AMDGPU, ARM, BPF, Hexagon,
+  MIPS 32/64 big/little-endian, PowerPC, PowerPC64, RISC-V, SPARC V9, x86-32 and
   x86-64. Among these, AArch64, ARM (>= v6), PowerPC, PowerPC64, x86-32 and
   x86-64 have production quality. MIPS seems decent too.
 
 - It is always a cross-linker, meaning that it always supports all the
   above targets however it was built. In fact, we don't provide a
   build-time option to enable/disable each target. This should make it
   easy to use our linker as part of a cross-compile toolchain.
 

lld/docs/ld.lld.1

 references between them.
 .Pp
 .Nm
 is a drop-in replacement for the GNU BFD and gold linkers.
 It accepts most of the same command line arguments and linker scripts
 as GNU linkers.
 .Pp
 .Nm
-currently supports i386, x86-64, ARM, AArch64, PowerPC32, PowerPC64,
+currently supports i386, x86-64, ARM, AArch64, BPF, PowerPC32, PowerPC64,
 MIPS32, MIPS64, RISC-V, AMDGPU, Hexagon and SPARC V9 targets.
 .Nm
 acts as a Microsoft link.exe-compatible linker if invoked as
 .Nm lld-link
 and as macOS's ld if invoked as
 .Nm ld.ld64.
 All these targets are always supported however
 .Nm

lld/test/ELF/bpf-basic.s

+// REQUIRES: bpf
+// RUN: split-file %s %t
+// RUN: llc -filetype=obj -mtriple=bpfel %t/a.ll -o %t1.el.o
+// RUN: llc -filetype=obj -mtriple=bpfel %t/b.ll -o %t2.el.o
+// RUN: ld.lld -r %t1.el.o %t2.el.o -o %t3.el
+// RUN: llvm-objdump -d --no-show-raw-insn %t3.el | FileCheck %s
+// RUN: llc -filetype=obj -mtriple=bpfeb %t/a.ll -o %t1.eb.o
+// RUN: llc -filetype=obj -mtriple=bpfeb %t/b.ll -o %t2.eb.o
+// RUN: ld.lld -r %t1.eb.o %t2.eb.o -o %t3.eb
+// RUN: llvm-objdump -d --no-show-raw-insn %t5.eb | FileCheck %s
+
+// CHECK:  <foo>:
+// CHECK:  r0 = 0
+// CHECK:  exit
+
+// CHECK:  <bar>:
+// CHECK:  r0 = 1
+// CHECK:  exit
+
+//--- a.ll
+define dso_local i32 @foo() local_unnamed_addr { entry: ret i32 0 }
+
+//--- b.ll
+define dso_local i32 @bar() local_unnamed_addr { entry: ret i32 1 }

lld/test/ELF/lto/bpf-diff-sec.ll

+; REQUIRES: bpf
+; RUN: split-file %s %t
+; RUN: llvm-as %t/a.ll -o %t1.bc
+; RUN: llvm-as %t/b.ll -o %t2.bc
+; RUN: ld.lld -r %t1.bc %t2.bc -o %t3
+; RUN: llvm-objdump -d --no-show-raw-insn %t3 | FileCheck %s
+; RUN: llvm-readelf -r %t3 | FileCheck -check-prefix=RELOC %s
+
+; CHECK:       section .text:
+; CHECK:       r0 = 0 ll
+; CHECK:       section sec2:
+; CHECK:       call -1
+; CHECK:       call 2
+
+; RELOC:       .rel.text
+; RELOC:       R_BPF_64_64 {{[0-9a-f]+}} sec3
+; RELOC:       .relsec2
+; RELOC:       R_BPF_64_32 {{[0-9a-f]+}} sec1
+; RELOC:       R_BPF_64_32 {{[0-9a-f]+}} sec1
+
+;--- a.ll
+; Source code:
+;   static __attribute__((noinline)) __attribute__((section("sec1")))
+;   int add(int a, int b) {
+;     return a + b;
+;   }
+;   static __attribute__((noinline)) __attribute__((section("sec1")))
+;   int sub(int a, int b) {
+;     return a - b;
+;   }
+;   __attribute__((section("sec2")))
+;   int bar(int a, int b) {
+;     return add(a, b) + sub(a, b);
+;   }
+; Compilation flags:
+;   clang -target bpfel -flto -O2 -S t1.c -o t1.ll
+
+; ModuleID = 't1.c'
+source_filename = "t1.c"
+target datalayout = "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128"
+target triple = "bpfel"
+
+; Function Attrs: nofree norecurse nosync nounwind readnone willreturn mustprogress
+define dso_local i32 @bar(i32 %a, i32 %b) local_unnamed_addr #0 section "sec2" {
+entry:
+  %call = tail call fastcc i32 @add(i32 %a, i32 %b)
+  %call1 = tail call fastcc i32 @sub(i32 %a, i32 %b)
+  %add = add nsw i32 %call1, %call
+  ret i32 %add
+}
+
+; Function Attrs: nofree noinline norecurse nosync nounwind readnone willreturn mustprogress
+define internal fastcc i32 @add(i32 %a, i32 %b) unnamed_addr #1 section "sec1" {
+entry:
+  %add = add nsw i32 %b, %a
+  ret i32 %add
+}
+
+; Function Attrs: nofree noinline norecurse nosync nounwind readnone willreturn mustprogress
+define internal fastcc i32 @sub(i32 %a, i32 %b) unnamed_addr #1 section "sec1" {
+entry:
+  %sub = sub nsw i32 %a, %b
+  ret i32 %sub
+}
+
+attributes #0 = { nofree norecurse nosync nounwind readnone willreturn mustprogress "frame-pointer"="all" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+attributes #1 = { nofree noinline norecurse nosync nounwind readnone willreturn mustprogress "frame-pointer"="all" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+
+!llvm.module.flags = !{!0, !1}
+!llvm.ident = !{!2}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{i32 7, !"frame-pointer", i32 2}
+!2 = !{!"clang version 13.0.0 (https://github.com/llvm/llvm-project.git c16909d7d1000413a32d3fcbc765dc082e8b62c0)"}
+
+;--- b.ll
+; Source code:
+;   static __attribute__((noinline)) __attribute__((section("sec3")))
+;   int test() {
+;     return 0;
+;   }
+;   long test2() { return (long)&test; }
+; Compilation flags:
+;   clang -target bpfel -flto -O2 -S t2.c -o t2.ll
+
+; ModuleID = 't2.c'
+source_filename = "t2.c"
+target datalayout = "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128"
+target triple = "bpfel"
+
+; Function Attrs: nofree norecurse nosync nounwind readnone willreturn mustprogress
+define dso_local i64 @test2() local_unnamed_addr #0 {
+entry:
+  ret i64 ptrtoint (i32 ()* @test to i64)
+}
+
+; Function Attrs: nofree noinline norecurse nosync nounwind readnone willreturn mustprogress
+define internal i32 @test() #1 section "sec3" {
+entry:
+  ret i32 0
+}
+
+attributes #0 = { nofree norecurse nosync nounwind readnone willreturn mustprogress "frame-pointer"="all" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+attributes #1 = { nofree noinline norecurse nosync nounwind readnone willreturn mustprogress "frame-pointer"="all" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+
+!llvm.module.flags = !{!0, !1}
+!llvm.ident = !{!2}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{i32 7, !"frame-pointer", i32 2}
+!2 = !{!"clang version 13.0.0 (https://github.com/llvm/llvm-project.git c16909d7d1000413a32d3fcbc765dc082e8b62c0)"}

lld/test/ELF/lto/bpf-same-sec.ll

+; REQUIRES: bpf
+; RUN: split-file %s %t
+; RUN: llvm-as %t/a.ll -o %t1.bc
+; RUN: llvm-as %t/b.ll -o %t2.bc
+; RUN: ld.lld -r %t1.bc %t2.bc -o %t3
+; RUN: llvm-objdump -d --no-show-raw-insn %t3 | FileCheck %s
+; RUN: llvm-readelf -r %t3 | FileCheck -check-prefix=RELOC %s
+; RUN: llvm-readelf -x ".BTF" %t3 | FileCheck -check-prefix=BTF %s
+
+; CHECK:       <bar>:
+; CHECK:       call [[#]]
+; CHECK:       call -1
+; CHECK:       <add>:
+; CHECK:       <foo>:
+
+; RELOC:       R_BPF_64_32 {{[0-9a-f]+}} foo
+
+; '9feb0100' below is the first 4 bytes of the .BTF section,
+; representing BTF Magic value (0x9feb in little endian format),
+; version (0x1) and flags (0x0).
+
+; BTF:         9feb0100
+; BTF-NOT:     9feb0100
+
+;--- a.ll
+; Source code:
+;   struct s {
+;     int a;
+;     int b;
+;   };
+;   extern int foo(int);
+;   static __attribute__((noinline)) int add(int a, int b) {
+;     return a + b;
+;   }
+;   int bar(struct s *arg) {
+;     return add(arg->a, arg->b) + foo(arg->a);
+;   }
+; Compilation flags:
+;   clang -target bpfel -flto -O2 -g -S t1.c -o t1.ll
+
+; ModuleID = 't1.c'
+source_filename = "t1.c"
+target datalayout = "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128"
+target triple = "bpfel"
+
+%struct.s = type { i32, i32 }
+
+; Function Attrs: nounwind
+define dso_local i32 @bar(%struct.s* nocapture readonly %arg) local_unnamed_addr #0 !dbg !8 {
+entry:
+  call void @llvm.dbg.value(metadata %struct.s* %arg, metadata !18, metadata !DIExpression()), !dbg !19
+  %a = getelementptr inbounds %struct.s, %struct.s* %arg, i64 0, i32 0, !dbg !20
+  %0 = load i32, i32* %a, align 4, !dbg !20, !tbaa !21
+  %b = getelementptr inbounds %struct.s, %struct.s* %arg, i64 0, i32 1, !dbg !26
+  %1 = load i32, i32* %b, align 4, !dbg !26, !tbaa !27
+  %call = tail call fastcc i32 @add(i32 %0, i32 %1), !dbg !28
+  %call2 = tail call i32 @foo(i32 %0) #4, !dbg !29
+  %add = add nsw i32 %call2, %call, !dbg !30
+  ret i32 %add, !dbg !31
+}
+
+; Function Attrs: nofree noinline norecurse nosync nounwind readnone willreturn mustprogress
+define internal fastcc i32 @add(i32 %a, i32 %b) unnamed_addr #1 !dbg !32 {
+entry:
+  call void @llvm.dbg.value(metadata i32 %a, metadata !36, metadata !DIExpression()), !dbg !38
+  call void @llvm.dbg.value(metadata i32 %b, metadata !37, metadata !DIExpression()), !dbg !38
+  %add = add nsw i32 %b, %a, !dbg !39
+  ret i32 %add, !dbg !40
+}
+
+declare !dbg !41 dso_local i32 @foo(i32) local_unnamed_addr #2
+
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata) #3
+
+attributes #0 = { nounwind "frame-pointer"="all" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+attributes #1 = { nofree noinline norecurse nosync nounwind readnone willreturn mustprogress "frame-pointer"="all" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+attributes #2 = { "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+attributes #3 = { nofree nosync nounwind readnone speculatable willreturn }
+attributes #4 = { nounwind }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5, !6}
+!llvm.ident = !{!7}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 13.0.0 (https://github.com/llvm/llvm-project.git 433a5046a139601b86ac0f5a8ce89c79e153ff06)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "t1.c", directory: "/tmp/home/yhs/work/tests/llvm/lto")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{i32 7, !"frame-pointer", i32 2}
+!7 = !{!"clang version 13.0.0 (https://github.com/llvm/llvm-project.git 433a5046a139601b86ac0f5a8ce89c79e153ff06)"}
+!8 = distinct !DISubprogram(name: "bar", scope: !1, file: !1, line: 9, type: !9, scopeLine: 9, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !17)
+!9 = !DISubroutineType(types: !10)
+!10 = !{!11, !12}
+!11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!12 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !13, size: 64)
+!13 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "s", file: !1, line: 1, size: 64, elements: !14)
+!14 = !{!15, !16}
+!15 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !13, file: !1, line: 2, baseType: !11, size: 32)
+!16 = !DIDerivedType(tag: DW_TAG_member, name: "b", scope: !13, file: !1, line: 3, baseType: !11, size: 32, offset: 32)
+!17 = !{!18}
+!18 = !DILocalVariable(name: "arg", arg: 1, scope: !8, file: !1, line: 9, type: !12)
+!19 = !DILocation(line: 0, scope: !8)
+!20 = !DILocation(line: 10, column: 19, scope: !8)
+!21 = !{!22, !23, i64 0}
+!22 = !{!"s", !23, i64 0, !23, i64 4}
+!23 = !{!"int", !24, i64 0}
+!24 = !{!"omnipotent char", !25, i64 0}
+!25 = !{!"Simple C/C++ TBAA"}
+!26 = !DILocation(line: 10, column: 27, scope: !8)
+!27 = !{!22, !23, i64 4}
+!28 = !DILocation(line: 10, column: 10, scope: !8)
+!29 = !DILocation(line: 10, column: 32, scope: !8)
+!30 = !DILocation(line: 10, column: 30, scope: !8)
+!31 = !DILocation(line: 10, column: 3, scope: !8)
+!32 = distinct !DISubprogram(name: "add", scope: !1, file: !1, line: 6, type: !33, scopeLine: 6, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !35)
+!33 = !DISubroutineType(types: !34)
+!34 = !{!11, !11, !11}
+!35 = !{!36, !37}
+!36 = !DILocalVariable(name: "a", arg: 1, scope: !32, file: !1, line: 6, type: !11)
+!37 = !DILocalVariable(name: "b", arg: 2, scope: !32, file: !1, line: 6, type: !11)
+!38 = !DILocation(line: 0, scope: !32)
+!39 = !DILocation(line: 7, column: 12, scope: !32)
+!40 = !DILocation(line: 7, column: 3, scope: !32)
+!41 = !DISubprogram(name: "foo", scope: !1, file: !1, line: 5, type: !42, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!42 = !DISubroutineType(types: !43)
+!43 = !{!11, !11}
+
+;--- b.ll
+; Source code:
+;   int __attribute__((noinline)) foo(int a) {
+;     return a * a;
+;   }
+; Compilation flags:
+;   clang -target bpfel -flto -O2 -g -S t2.c -o t2.ll
+
+; ModuleID = 't2.c'
+source_filename = "t2.c"
+target datalayout = "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128"
+target triple = "bpfel"
+
+; Function Attrs: nofree noinline norecurse nosync nounwind readnone willreturn mustprogress
+define dso_local i32 @foo(i32 %a) local_unnamed_addr #0 !dbg !8 {
+entry:
+  call void @llvm.dbg.value(metadata i32 %a, metadata !13, metadata !DIExpression()), !dbg !14
+  %mul = mul nsw i32 %a, %a, !dbg !15
+  ret i32 %mul, !dbg !16
+}
+
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata) #1
+
+attributes #0 = { nofree noinline norecurse nosync nounwind readnone willreturn mustprogress "frame-pointer"="all" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+attributes #1 = { nofree nosync nounwind readnone speculatable willreturn }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5, !6}
+!llvm.ident = !{!7}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 13.0.0 (https://github.com/llvm/llvm-project.git 433a5046a139601b86ac0f5a8ce89c79e153ff06)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "t2.c", directory: "/tmp/home/yhs/work/tests/llvm/lto")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{i32 7, !"frame-pointer", i32 2}
+!7 = !{!"clang version 13.0.0 (https://github.com/llvm/llvm-project.git 433a5046a139601b86ac0f5a8ce89c79e153ff06)"}
+!8 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !9, scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
+!9 = !DISubroutineType(types: !10)
+!10 = !{!11, !11}
+!11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!12 = !{!13}
+!13 = !DILocalVariable(name: "a", arg: 1, scope: !8, file: !1, line: 1, type: !11)
+!14 = !DILocation(line: 0, scope: !8)
+!15 = !DILocation(line: 2, column: 12, scope: !8)
+!16 = !DILocation(line: 2, column: 3, scope: !8)

lld/test/lit.cfg.py

 
 llvm_config.feature_config(
     [('--build-mode', {'DEBUG': 'debug'}),
      ('--assertion-mode', {'ON': 'asserts'}),
      ('--targets-built', {'AArch64': 'aarch64',
                           'AMDGPU': 'amdgpu',
                           'ARM': 'arm',
                           'AVR': 'avr',
+                          'BPF': 'bpf',
                           'Hexagon': 'hexagon',
                           'Mips': 'mips',
                           'MSP430': 'msp430',
                           'PowerPC': 'ppc',
                           'RISCV': 'riscv',
                           'Sparc': 'sparc',
                           'WebAssembly': 'wasm',
                           'X86': 'x86'})