BPF: Add more relocation kinds

[yonghong-song]

Summary

Currently, BPF only contains three relocations:

R_BPF_NONE   for no relocation
R_BPF_64_64  for LD_imm64 and normal 64-bit data relocation
R_BPF_64_32  for call insn and normal 32-bit data relocation

Also .BTF and .BTF.ext sections contain symbols in allocated
program and data sections. These two sections reserved 32bit
space to hold the offset relative to the symbol's section.
When LLVM JIT is used, the LLVM ExecutionEngine RuntimeDyld
may attempt to resolve relocations for .BTF and .BTF.ext,
which we want to prevent. So we used R_BPF_NONE for such relocations.

This all works fine until when we try to do linking of
multiple objects.

. R_BPF_64_64 handling of LD_imm64 vs. normal 64-bit data
  is different, so lld target->relocate() needs more context
  to do a correct job.
. The same for R_BPF_64_32. More context is needed for
  lld target->relocate() to differentiate call insn vs.
  normal 32-bit data relocation.
. Since relocations in .BTF and .BTF.ext are set to R_BPF_NONE,
  they will not be relocated properly when multiple .BTF/.BTF.ext
  sections are merged by lld.

This patch intends to address this issue by adding additional
relocation kinds:

R_BPF_64_ABS64          for normal 64-bit data relocation
R_BPF_64_ABS32          for normal 32-bit data relocation
R_BPF_64_NODYLD32  for .BTF and .BTF.ext style relocations.

The old R_BPF_64_{64,32} semantics:

R_BPF_64_64       for LD_imm64 relocation
R_BPF_64_32       for call insn relocation

The existing R_BPF_64_64/R_BPF_64_32 mapping to numeric values
is maintained. They are the most common use cases for
bpf programs and we want to maintain backward compatibility
as much as possible.

ExecutionEngine RuntimeDyld BPF relocations are adjusted as well.
R_BPF_64_{ABS64,ABS32} relocations will be resolved properly and
other relocations will be ignored.
Two tests are added for RuntimeDyld. Not handling R_BPF_64_NODYLD32 in
RuntimeDyldELF.cpp will result in "Relocation type not implemented yet!"
fatal error.

FK_SecRel_4 usages in BPFAsmBackend.cpp and BPFELFObjectWriter.cpp
are removed as they are not triggered in BPF backend.
BPF backend used FK_SecRel_8 for LD_imm64 instruction operands.

[yonghong-song]

This patch will require bpf-next libbpf patch like below:

diff --git a/tools/lib/bpf/libbpf_internal.h b/tools/lib/bpf/libbpf_internal.h
index ee426226928f..ccc5d4591801 100644
--- a/tools/lib/bpf/libbpf_internal.h
+++ b/tools/lib/bpf/libbpf_internal.h
@@ -28,6 +28,12 @@
 #ifndef R_BPF_64_64
 #define R_BPF_64_64 1
 #endif
+#ifndef R_BPF_64_LD64
+#define R_BPF_64_LD64 2
+#endif
+#ifndef R_BPF_64_PC32
+#define R_BPF_64_PC32 3
+#endif
 #ifndef R_BPF_64_32
 #define R_BPF_64_32 10
 #endif
diff --git a/tools/lib/bpf/linker.c b/tools/lib/bpf/linker.c
index b594a88620ce..3e3cd64025dd 100644
--- a/tools/lib/bpf/linker.c
+++ b/tools/lib/bpf/linker.c
@@ -892,7 +892,8 @@ static int linker_sanity_check_elf_relos(struct src_obj *obj, struct src_sec *se
                size_t sym_idx = ELF64_R_SYM(relo->r_info);
                size_t sym_type = ELF64_R_TYPE(relo->r_info);
 
-               if (sym_type != R_BPF_64_64 && sym_type != R_BPF_64_32) {
+               if (sym_type != R_BPF_64_64 && sym_type != R_BPF_64_32 &&
+                    sym_type != R_BPF_64_LD64 && sym_type != R_BPF_64_PC32) {
                        pr_warn("ELF relo #%d in section #%zu has unexpected type %zu in %s\n",
                                i, sec->sec_idx, sym_type, obj->filename);
                        return -EINVAL;

[MaskRay]

These ELF flags should be documented somewhere. Even a draft will help.

For example, riscv is using https://github.com/riscv/riscv-elf-psabi-doc/blob/master/riscv-elf.md#relocations , though not as sophisticated as other psABIs (x86-64,aarch64,ppc64 ELFv2)

[MaskRay]

llvm/test/CodeGen/BPF/reloc-2.ll

2

For REL -r is not sufficient for testing. You should check the implicit addends as well.

[yonghong-song]

In D102712#2767238, @MaskRay wrote:

These ELF flags should be documented somewhere. Even a draft will help.

For example, riscv is using https://github.com/riscv/riscv-elf-psabi-doc/blob/master/riscv-elf.md#relocations , though not as sophisticated as other psABIs (x86-64,aarch64,ppc64 ELFv2)

This is a good suggestion. Currently, the main bpf compiler/instruction set related doc is living in the kernel tree

https://www.kernel.org/doc/Documentation/networking/filter.rst

I think that is not a good place to put relocation as kernel people really don't care relocations much and
compiler/tool people may not be interested to check the kernel doc.

We need to find a different place to document some bpf compiler/tool internal stuff. I will add a little bit more
documentation in the code and in the commit message at this time. Will consider to put relocation description (maybe others)
in a public accessible document as a followup.

[yonghong-song]

llvm/test/CodeGen/BPF/reloc-2.ll

2

okay. Will check the instruction as well.

[yonghong-song]

• add more comments and descriptions for relocations.

[yonghong-song]

• removed FK_SecRel_8 and used FK_SecRel_4 for LD_imm64 fixup kind which reflects better that fact only the first 4-byte insn->off is allowed for storing the section offset.

[yonghong-song]

• rename R_BPF_64_D{32,64} to R_BPF_64_ABS{32,64} to better reflect the intention of relocation. *ABS{32,64} names have been used by arm, aarch64 and amdgpu.

[MaskRay]

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

954

This needs an ExecutionEngine test. Otherwise, don't touch the file in this patch.

llvm/lib/Target/BPF/MCTargetDesc/BPFELFObjectWriter.cpp

45–46

FK_SecRel_4 is used by PE-COFF to represent SECREL relocation types.

"The 32-bit offset of the target from the beginning of its section. This is used to support debugging information and static thread local storage."

Why does it map to a regular looking R_BPF_64_64?

72

This doesn't make sense to me. The relocation type names shouldn't be aware of SHF_ALLOC/non-SHF_ALLOC.

[yonghong-song]

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

954

I will add a test for this.

llvm/lib/Target/BPF/MCTargetDesc/BPFELFObjectWriter.cpp

45–46

In AMDGPU/MCTargetDesc/R600MCCodeEmitter.cpp, I see

Fixups.push_back(MCFixup::create(offset, MO.getExpr(), FK_SecRel_4, MI.getLoc()));

It looks like backend can choose create a MCFixup with FK_SecRel_4. Do we have restrictions that we have to use a different one? Use FK_SecRel_4 seems a good fit here as only 4 bytes are permitted to write anyway.

72

I just wanted to choose a best-fit name. How about R_BPF_64_NODYLD_32 implying no runtime dynamic linking?

[yonghong-song]

llvm/lib/Target/BPF/MCTargetDesc/BPFELFObjectWriter.cpp

45–46

I can certainly go back with FK_SecRel_8, but want to understand why I cannot use FK_SecRel_4.

[yonghong-song]

• add a test for ExecutionEngine/RuntimeDyld for added BPF relocation case. Without the patch in RuntimeDyldELF.cpp, the test will crash
• rename R_BPF_64_ALLOC32 to R_BPF_64_NODYLD32.
• added @MaskRay as the reviewer
• remaining known issues to be resolved:
  • can BPF backend use FK_SecRel_4 for R_BPF_64_64?
  • Is the relocation name R_BPF_64_NODYLD32 okay or we could have a better one?

[MaskRay]

llvm/lib/Target/BPF/MCTargetDesc/BPFELFObjectWriter.cpp

45–46

My concern here is that FK_SecRel_* is no overloaded for entirely different semantics. Other targets use different variant kinds for such cases.

[yonghong-song]

llvm/lib/Target/BPF/MCTargetDesc/BPFELFObjectWriter.cpp

45–46

Ok. Sounds reasonable since they are all related to similar tls use case. I will switch to FK_SecRel_8 in the next version. Thanks!

[yonghong-song]

• use FK_SecRel_8 Fixup kind for LD_imm64 operands instead of FK_SecRel_4.

[yonghong-song]

• enumerate all relocations in RuntimeDyld.c such that R_BPF_64_{ABS64,ABS32} relocations will be resolved and others will be ignored.
• added one more test case that R_BPF_64_ABS64 is properly resolved.

[yonghong-song]

• add one test case to generate R_BPF_64_ABS64 relocation for global data.

llvm/include/llvm/BinaryFormat/ELFRelocs/BPF.def

 #ifndef ELF_RELOC
 #error "ELF_RELOC must be defined"
 #endif
 
 // No relocation
 ELF_RELOC(R_BPF_NONE,        0)
 ELF_RELOC(R_BPF_64_64,       1)
+ELF_RELOC(R_BPF_64_ABS64,    2)
+ELF_RELOC(R_BPF_64_ABS32,    3)
+ELF_RELOC(R_BPF_64_NODYLD32, 4)
 ELF_RELOC(R_BPF_64_32,      10)

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

void RuntimeDyldELF::resolveBPFRelocation(const SectionEntry &Section,
                                           uint32_t Type, int64_t Addend) {
   bool isBE = Arch == Triple::bpfeb;
 
   switch (Type) {
   default:
     report_fatal_error("Relocation type not implemented yet!");
     break;
   case ELF::R_BPF_NONE:
+  case ELF::R_BPF_64_64:
+  case ELF::R_BPF_64_32:
+  case ELF::R_BPF_64_NODYLD32:
     break;
-  case ELF::R_BPF_64_64: {
+  case ELF::R_BPF_64_ABS64: {
     write(isBE, Section.getAddressWithOffset(Offset), Value + Addend);
     LLVM_DEBUG(dbgs() << "Writing " << format("%p", (Value + Addend)) << " at "
                       << format("%p\n", Section.getAddressWithOffset(Offset)));
     break;
   }
-  case ELF::R_BPF_64_32: {
+  case ELF::R_BPF_64_ABS32: {
     Value += Addend;
     assert(Value <= UINT32_MAX);
     write(isBE, Section.getAddressWithOffset(Offset), static_cast<uint32_t>(Value));
     LLVM_DEBUG(dbgs() << "Writing " << format("%p", Value) << " at "
                       << format("%p\n", Section.getAddressWithOffset(Offset)));
     break;
   }
   }

llvm/lib/Target/BPF/MCTargetDesc/BPFAsmBackend.cpp

bool BPFAsmBackend::writeNopData(raw_ostream &OS, uint64_t Count) const {
   return true;
 }
 
 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) {
+  if (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);

llvm/lib/Target/BPF/MCTargetDesc/BPFELFObjectWriter.cpp

 
 unsigned BPFELFObjectWriter::getRelocType(MCContext &Ctx, const MCValue &Target,
                                           const MCFixup &Fixup,
                                           bool IsPCRel) const {
   // determine the type of the relocation
   switch (Fixup.getKind()) {
   default:
     llvm_unreachable("invalid fixup kind!");
   case FK_SecRel_8:
+    // LD_imm64 instruction.
     return ELF::R_BPF_64_64;
   case FK_PCRel_4:
-  case FK_SecRel_4:
+    // CALL instruction.
     return ELF::R_BPF_64_32;
   case FK_Data_8:
-    return ELF::R_BPF_64_64;
+    return ELF::R_BPF_64_ABS64;
   case FK_Data_4:
     if (const MCSymbolRefExpr *A = Target.getSymA()) {
       const MCSymbol &Sym = A->getSymbol();
 
       if (Sym.isDefined()) {
         MCSection &Section = Sym.getSection();
         const MCSectionELF *SectionELF = dyn_cast<MCSectionELF>(&Section);
         assert(SectionELF && "Null section for reloc symbol");
 
         unsigned Flags = SectionELF->getFlags();
 
         if (Sym.isTemporary()) {
           // .BTF.ext generates FK_Data_4 relocations for
           // insn offset by creating temporary labels.
-          // The insn offset is within the code section and
-          // already been fulfilled by applyFixup(). No
-          // further relocation is needed.
           // The reloc symbol should be in text section.
+          // Use a different relocation to instruct ExecutionEngine
+          // RuntimeDyld not to do relocation for it, yet still to
+          // allow lld to do proper adjustment when merging sections.
           if ((Flags & ELF::SHF_ALLOC) && (Flags & ELF::SHF_EXECINSTR))
-            return ELF::R_BPF_NONE;
+            return ELF::R_BPF_64_NODYLD32;
         } else {
           // .BTF generates FK_Data_4 relocations for variable
-          // offset in DataSec kind. Similar to the above .BTF.ext
-          // insn offset, no further relocation is needed.
+          // offset in DataSec kind.
           // The reloc symbol should be in data section.
           if ((Flags & ELF::SHF_ALLOC) && (Flags & ELF::SHF_WRITE))
-            return ELF::R_BPF_NONE;
+            return ELF::R_BPF_64_NODYLD32;
         }
       }
     }
-    return ELF::R_BPF_64_32;
+    return ELF::R_BPF_64_ABS32;
   }
 }
 
 std::unique_ptr<MCObjectTargetWriter>
 llvm::createBPFELFObjectWriter(uint8_t OSABI) {
   return std::make_unique<BPFELFObjectWriter>(OSABI);
 }

llvm/test/CodeGen/BPF/reloc-2.ll

+; RUN: llc -march=bpfel -filetype=obj -o %t.el < %s
+; RUN: llvm-objdump -r %t.el | FileCheck --check-prefix=RELOC %s
+; RUN: llvm-objdump -d --no-show-raw-insn %t.el | FileCheck --check-prefix=DUMP %s
+; RUN: llc -march=bpfeb -filetype=obj -o %t.eb < %s
+; RUN: llvm-objdump -r %t.eb | FileCheck --check-prefix=RELOC %s
+; RUN: llvm-objdump -d --no-show-raw-insn %t.eb | FileCheck --check-prefix=DUMP %s
+
+; source code:
+;   static __attribute__((noinline)) __attribute__((section("sec1")))
+;   int add(int a, int b) {
+;     return a + b;
+;   }
+;   static __attribute__((noinline))
+;   int sub(int a, int b) {
+;     return a - b;
+;   }
+;   int test(int a, int b) {
+;     return add(a, b) + sub(a, b);
+;   }
+; compilation flag:
+;   clang -target bpf -O2 -emit-llvm -S test.c
+
+define dso_local i32 @test(i32 %a, i32 %b) local_unnamed_addr #0 {
+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
+}
+
+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 {
+entry:
+  %sub = sub nsw i32 %a, %b
+  ret i32 %sub
+}
+
+; DUMP:       .text:
+; DUMP-EMPTY:
+; DUMP-NEXT:  <test>
+; DUMP-NEXT:  r[[#]] = r[[#]]
+; DUMP-NEXT:  r[[#]] = r[[#]]
+; DUMP-NEXT:  call -1
+
+; DUMP:       sec1:
+; DUMP-EMPTY:
+; DUMP-NEXT:  <add>
+
+; RELOC:      RELOCATION RECORDS FOR [.text]:
+; RELOC:      R_BPF_64_32            sec1
+; RELOC-NOT:  R_BPF_64_32
+
+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/test/CodeGen/BPF/reloc-3.ll

+; RUN: llc -march=bpfel -filetype=obj -o %t.el < %s
+; RUN: llvm-readelf -r %t.el | FileCheck %s
+; RUN: llc -march=bpfeb -filetype=obj -o %t.eb < %s
+; RUN: llvm-readelf -r %t.eb | FileCheck %s
+
+; source code:
+;   int g() { return 0; }
+;   struct t { void *p; } gbl = { g };
+; compilation flag:
+;   clang -target bpf -O2 -emit-llvm -S test.c
+
+%struct.t = type { i8* }
+
+@gbl = dso_local local_unnamed_addr global %struct.t { i8* bitcast (i32 ()* @g to i8*) }, align 8
+
+; CHECK: '.rel.data'
+; CHECK: 0000000000000000  0000000200000002 R_BPF_64_ABS64         0000000000000000 g
+
+; Function Attrs: nofree norecurse nosync nounwind readnone willreturn mustprogress
+define dso_local i32 @g() #0 {
+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" }

llvm/test/CodeGen/BPF/reloc-btf-2.ll

define dso_local i32 @test() local_unnamed_addr #0 !dbg !14 {
   %1 = load i32, i32* @g, align 4, !dbg !17, !tbaa !18
   %2 = load volatile i32, i32* @s, align 4, !dbg !22, !tbaa !18
   %3 = add nsw i32 %2, %1, !dbg !23
   ret i32 %3, !dbg !24
 }
 
 ; CHECK-RELOC: file format elf64-bpf
 ; CHECK-RELOC: RELOCATION RECORDS FOR [.BTF]:
-; CHECK-RELOC: R_BPF_NONE .bss
-; CHECK-RELOC: R_BPF_NONE g
+; CHECK-RELOC: R_BPF_64_NODYLD32 .bss
+; CHECK-RELOC: R_BPF_64_NODYLD32 g
 ; CHECK-RELOC: RELOCATION RECORDS FOR [.BTF.ext]:
 
 attributes #0 = { norecurse nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "frame-pointer"="all" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!10, !11, !12}
 !llvm.ident = !{!13}
 

llvm/test/CodeGen/BPF/reloc-btf.ll

 ; RUN: llc -march=bpfel -filetype=obj < %s | llvm-objdump -r - | FileCheck --check-prefix=CHECK-RELOC %s
 
 ; Function Attrs: norecurse nounwind readnone
 define dso_local i32 @test() local_unnamed_addr #0 !dbg !7 {
 entry:
   ret i32 0, !dbg !11
 }
 
 ; CHECK-RELOC: file format elf64-bpf
 ; CHECK-RELOC: RELOCATION RECORDS FOR [.debug_info]:
-; CHECK-RELOC: R_BPF_64_32 .debug_abbrev
-; CHECK-RELOC: R_BPF_64_64 .text
+; CHECK-RELOC: R_BPF_64_ABS32 .debug_abbrev
+; CHECK-RELOC: R_BPF_64_ABS64 .text
 ; CHECK-RELOC: RELOCATION RECORDS FOR [.BTF.ext]:
-; CHECK-RELOC: R_BPF_NONE .text
+; CHECK-RELOC: R_BPF_64_NODYLD32 .text
 
 attributes #0 = { norecurse nounwind readnone "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "frame-pointer"="all" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3, !4, !5}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 8.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)

llvm/test/CodeGen/BPF/reloc.ll

; <label>:10                                      ; preds = %0
   %12 = call i32 (i8*, i32, ...) inttoptr (i64 11 to i32 (i8*, i32, ...)*)(i8* %11, i32 15, %struct.sk_buff* %4, i8* %7) #1
   br label %13
 
 ; <label>:13                                      ; preds = %10, %0
   ret i32 0
 
 ; CHECK-RELOC: file format elf64-bpf
 ; CHECK-RELOC: RELOCATION RECORDS FOR [.eh_frame]:
-; CHECK-RELOC: R_BPF_64_64 events/net/netif_receive_skb
+; CHECK-RELOC: R_BPF_64_ABS64 events/net/netif_receive_skb
 }
 
 ; Function Attrs: nounwind
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) #1
 
 attributes #0 = { norecurse }

llvm/test/ExecutionEngine/RuntimeDyld/BPF/abs64-relocation.s

+# RUN: rm -rf %t && mkdir -p %t
+# RUN: llvm-mc -triple=bpfel -filetype=obj -o %t/test_reloc_abs64.o %s
+# RUN: llvm-rtdyld -triple=bpfel -verify -check=%s %t/test_reloc_abs64.o
+
+# test R_BPF_64_ABS64 which should have relocation resolved properly.
+
+  .text
+  .file "t1.c"
+  .globl  g                               # -- Begin function g
+  .p2align  3
+  .type g,@function
+g:                                      # @g
+  r0 = 0
+  exit
+.Lfunc_end0:
+  .size g, .Lfunc_end0-g
+                                        # -- End function
+  .type gbl,@object                     # @gbl
+  .data
+  .globl  gbl
+  .p2align  3
+gbl:
+  .quad g
+  .size gbl, 8
+
+# rtdyld-check: *{8}gbl = section_addr(test_reloc_abs64.o, .text)

llvm/test/ExecutionEngine/RuntimeDyld/BPF/lit.local.cfg

+if not 'BPF' in config.root.targets:
+    config.unsupported = True

llvm/test/ExecutionEngine/RuntimeDyld/BPF/nodyld32-64-relocations.s

+# RUN: llvm-mc -triple=bpfel -filetype=obj -o %t %s
+# RUN: llvm-rtdyld -triple=bpfel -verify -check=%s %t
+
+# test R_BPF_64_64 and R_BPF_64_NODYLD32 relocations, both should be ignored.
+
+  .globl  _main
+  .p2align  3
+  .type _main,@function
+_main:                                  # @_main
+  r1 = a ll
+
+# rtdyld-check: decode_operand(_main, 1)[31:0] = 0x0
+
+  r0 = *(u32 *)(r1 + 0)
+  exit
+.Lfunc_end0:
+  .size _main, .Lfunc_end0-_main
+                                        # -- End function
+
+  .type a,@object                       # @a
+  .section  .bss,"aw",@nobits
+  .globl  a
+  .p2align  2
+a:
+  .long 0                               # 0x0
+  .size a, 4
+
+# rtdyld-check: *{4}a = 0
+
+  .section  .BTF,"",@progbits
+  .short  60319                           # 0xeb9f
+  .byte 1
+  .byte 0
+  .long 24
+  .long 0
+  .long 80
+  .long 80
+  .long 87
+  .long 0                               # BTF_KIND_FUNC_PROTO(id = 1)
+  .long 218103808                       # 0xd000000
+  .long 2
+  .long 1                               # BTF_KIND_INT(id = 2)
+  .long 16777216                        # 0x1000000
+  .long 4
+  .long 16777248                        # 0x1000020
+  .long 5                               # BTF_KIND_FUNC(id = 3)
+  .long 201326593                       # 0xc000001
+  .long 1
+  .long 80                              # BTF_KIND_VAR(id = 4)
+  .long 234881024                       # 0xe000000
+  .long 2
+  .long 1
+  .long 82                              # BTF_KIND_DATASEC(id = 5)
+  .long 251658241                       # 0xf000001
+  .long 0
+  .long 4
+btf_a:
+  .long a
+
+# rtdyld-check: *{4}btf_a = 0
+
+  .long 4
+  .byte 0                               # string offset=0
+  .ascii  "int"                           # string offset=1
+  .byte 0
+  .ascii  "_main"                         # string offset=5
+  .byte 0
+  .ascii  ".text"                         # string offset=11
+  .byte 0
+  .ascii  "/home/yhs/work/tests/llvm/rtdyld/t.c" # string offset=17
+  .byte 0
+  .ascii  "int _main() { return a; }"     # string offset=54
+  .byte 0
+  .byte 97                              # string offset=80
+  .byte 0
+  .ascii  ".bss"                          # string offset=82
+  .byte 0