[BPF] Support external globals

[yonghong-song]

Summary

[BPF] Support external globals

Previously, only types for external variables and globals without
section names are omitted.
This patch emitted types for all non-common-linkage globals.
From https://llvm.org/docs/LangRef.html,

common
  “common” linkage is most similar to “weak” linkage,
  but they are used for tentative definitions in C,
  such as “int X;” at global scope. ...

It is not clear what are "common"/"weak" semantics for bpf programs,
so omit them for now.

For non-extern global variables without section names,

• a BTF_KIND_VAR will be generated.
• the BTF_KIND_VAR will be put into .bss/.data DataSec based on whether they are zero initialized or not.

For extern globals:

• A BTF_KIND_VAR will be generated.
• if with section name, a DataSec with that section name will be created containing that global variable.
• external globals do not have types in BTF_KIND_VAR since clang does not generate debug info type for external variables.
• the in-section offset for extern variables will be all 0 since these variables are not allocated in current ELF.

[anakryiko]

llvm/lib/Target/BPF/BTF.h

183–184

what's the difference between EXTERNAL and TENTATIVE?

llvm/lib/Target/BPF/BTFDebug.cpp

1066

I remember there were problems figuring out datasec size when emitting BTF. Is this still the case? Does the same problem prevent readonly flag in DATASEC or you are trying to not put redundant information into BTF that can be derived from ELF?

1117

we'll just ignore externs with GlobalValue::CommonLinkage, right? Should we just assign a special section name to them instead? feels bad to only have a partial list of externs.

[yonghong-song]

llvm/lib/Target/BPF/BTF.h

183–184

TENTATIVE is for .common symbols. Just do "int g;" and compile, you will find out.

llvm/lib/Target/BPF/BTFDebug.cpp

1066

Yes this is still the case. The debugging info is emitted earlier and we do not know the data section until very end of compilation which is too late.

The section readonly thing is marked by ELF object writer. The BPF backend can only detect readonly variables through type inspection, so it MAY mark the container DataSec as readonly section. Let us do it now with ELF checking since the ELF section inspection is required to get the readonly data.

1117

No, all externs will emitted with their special section name.
CommonLinkage is not an extern.

[yonghong-song]

do not recognize section names for extern variables in llvm and leave it to bpf loader
upgrade and add test cases

[anakryiko]

if there is no type information available for extern variables, there is little benefit in having them as DATASEC+VAR. No size, no type. We can get the same information from ELF itself without having to teach verifier and libbpf how to handle these new types. Let's drop this for now? The only potential benefit is having a section name associated with extern, but we can either add that later, or even add it in a way that will require no verifier changes - BTF.ext.

[yonghong-song]

Yes, we can drop it now. There is no rush if there is no real need. The extern variables are not used yet. Let us revisit this once we have some concrete use cases.

[yonghong-song]

Actually, there is 'size' but no 'type'. And 'size' can be used to do cross checking. But anyway, we can delay this until there is a concrete thing we need to implement.

[yonghong-song]

Also, another thing. we COULD emit debug info type for externs for BPF in clang. We just have to think whether this is really necessary or not.

[anakryiko]

hm... size is useful, actually. Ok, let me play with it, it's hard to get a good idea of BTF from LLVM tests. Verifier will definitely reject such variables, though, so we'll need to do sanitization for sure.

[anakryiko]

In D68822#1717603, @yonghong-song wrote:

Also, another thing. we COULD emit debug info type for externs for BPF in clang. We just have to think whether this is really necessary or not.

I think it's extremely useful. Think about exposing some internal kernel stuff. This is going to be a requirement for BPF verifier, I think. I'll let @ast confirm, though.

[yonghong-song]

This patch is not needed any more.

llvm/lib/Target/BPF/BTF.h

struct BTFParam {
   uint32_t NameOff;
   uint32_t Type;
 };
 
 /// Variable scoping information.
 enum : uint8_t {
   VAR_STATIC = 0,           ///< Linkage: InternalLinkage
   VAR_GLOBAL_ALLOCATED = 1, ///< Linkage: ExternalLinkage
-  VAR_GLOBAL_TENTATIVE = 2, ///< Linkage: CommonLinkage
-  VAR_GLOBAL_EXTERNAL = 3,  ///< Linkage: ExternalLinkage
+  VAR_GLOBAL_EXTERNAL = 2,  ///< Linkage: ExternalLinkage
 };
 
 /// BTF_KIND_DATASEC are followed by multiple "struct BTFDataSecVar".
 /// The exist number of BTFDataSec is stored in the vlen (of the info
 /// in "struct CommonType").
 struct BTFDataSec {
   uint32_t Type;   ///< A BTF_KIND_VAR type
   uint32_t Offset; ///< In-section offset
   uint32_t Size;   ///< Occupied memory size

llvm/lib/Target/BPF/BTFDebug.cpp

void BTFDebug::beginInstruction(const MachineInstr *MI) {
   LineInfoGenerated = true;
   PrevInstLoc = DL;
 }
 
 void BTFDebug::processGlobals(bool ProcessingMapDef) {
   // Collect all types referenced by globals.
   const Module *M = MMI->getModule();
   for (const GlobalVariable &Global : M->globals()) {
-    // Ignore external globals for now.
-    if (!Global.hasInitializer() && Global.hasExternalLinkage())
+    // Ignore BPF internally created globals.
+    if (Global.hasAttribute(BPFCoreSharedInfo::AmaAttr))
       continue;
 
+    // Support globals:
+    //   . static: VAR_STATIC, in DataSec.
+    //   . initialized global (0 or non-0): VAR_GLOBAL_ALLOCATED, in DataSec.
+    //   . external global: VAR_GLOBAL_EXTERNAL, in DataSec if w/ section name.
+    // Whether DataSec is readonly or not can be found from the
+    // corresponding ELF section flags.
+
     // Decide the section name.
     StringRef SecName;
+    uint32_t GVarInfo = 0;
+    auto Linkage = Global.getLinkage();
+    if (Global.hasInitializer()) {
       if (Global.hasSection()) {
         SecName = Global.getSection();
       } else {
         // data, bss, or readonly sections
         if (Global.isConstant())
           SecName = ".rodata";
         else
           SecName = Global.getInitializer()->isZeroValue() ? ".bss" : ".data";
       }
+      if (Linkage == GlobalValue::InternalLinkage)
+        GVarInfo = BTF::VAR_STATIC;
+      else
+        GVarInfo = BTF::VAR_GLOBAL_ALLOCATED;
+    } else if (Linkage == GlobalValue::ExternalLinkage) {
+      GVarInfo = BTF::VAR_GLOBAL_EXTERNAL;
+      SecName = Global.getSection();
+    } else if (Linkage != GlobalValue::CommonLinkage) {
+        continue;
+    }
 
     if (ProcessingMapDef != SecName.startswith(".maps"))
       continue;
 
     SmallVector<DIGlobalVariableExpression *, 1> GVs;
     Global.getDebugInfo(GVs);
     uint32_t GVTypeId = 0;
     for (auto *GVE : GVs) {
       if (SecName.startswith(".maps"))
         visitMapDefType(GVE->getVariable()->getType(), GVTypeId);
       else
         visitTypeEntry(GVE->getVariable()->getType(), GVTypeId, false, false);
       break;
     }
 
-    // Only support the following globals:
-    //  . static variables
-    //  . non-static global variables with section attributes
-    // Essentially means:
-    //  . .bcc/.data/.rodata DataSec entities only contain static data
-    //  . Other DataSec entities contain static or initialized global data.
-    //    Initialized global data are mostly used for finding map key/value type
-    //    id's. Whether DataSec is readonly or not can be found from
-    //    corresponding ELF section flags.
-    auto Linkage = Global.getLinkage();
-    if (Linkage != GlobalValue::InternalLinkage &&
-        (Linkage != GlobalValue::ExternalLinkage || !Global.hasSection()))
+    // Do not generate variables for Common Linkage yet until we
+    // know how to use them.
+    if (Linkage == GlobalValue::CommonLinkage)
       continue;
 
-    uint32_t GVarInfo = Linkage == GlobalValue::ExternalLinkage
-                            ? BTF::VAR_GLOBAL_ALLOCATED
-                            : BTF::VAR_STATIC;
     auto VarEntry =
         std::make_unique<BTFKindVar>(Global.getName(), GVTypeId, GVarInfo);
     uint32_t VarId = addType(std::move(VarEntry));
 
+    if (SecName.empty())
+      continue;
+
     // Find or create a DataSec
     if (DataSecEntries.find(SecName) == DataSecEntries.end()) {
       DataSecEntries[SecName] = std::make_unique<BTFKindDataSec>(Asm, SecName);
     }
 
     // Calculate symbol size
     const DataLayout &DL = Global.getParent()->getDataLayout();
     uint32_t Size = DL.getTypeAllocSize(Global.getType()->getElementType());

llvm/test/CodeGen/BPF/BTF/extern-global-var-sec.ll

+; RUN: llc -march=bpfel -filetype=asm -o - %s | FileCheck -check-prefixes=CHECK %s
+; RUN: llc -march=bpfeb -filetype=asm -o - %s | FileCheck -check-prefixes=CHECK %s
+;
+; Source code:
+;   extern char a1 __attribute__((section("abc")));
+;   extern char a2 __attribute__((section("abc")));
+;   int foo() { return a1 + a2; }
+; Compilation flag:
+;   clang -target bpf -O2 -g -S -emit-llvm test.c
+
+@a1 = external dso_local local_unnamed_addr global i8, section "abc", align 1
+@a2 = external dso_local local_unnamed_addr global i8, section "abc", align 1
+
+; Function Attrs: norecurse nounwind readonly
+define dso_local i32 @foo() local_unnamed_addr #0 !dbg !7 {
+entry:
+  %0 = load i8, i8* @a1, align 1, !dbg !11, !tbaa !12
+  %conv = sext i8 %0 to i32, !dbg !11
+  %1 = load i8, i8* @a2, align 1, !dbg !15, !tbaa !12
+  %conv1 = sext i8 %1 to i32, !dbg !15
+  %add = add nsw i32 %conv1, %conv, !dbg !16
+  ret i32 %add, !dbg !17
+}
+
+; CHECK:             .section        .BTF,"",@progbits
+; CHECK-NEXT:        .short  60319                   # 0xeb9f
+; CHECK-NEXT:        .byte   1
+; CHECK-NEXT:        .byte   0
+; CHECK-NEXT:        .long   24
+; CHECK-NEXT:        .long   0
+; CHECK-NEXT:        .long   108
+; CHECK-NEXT:        .long   108
+; CHECK-NEXT:        .long   62
+; CHECK-NEXT:        .long   0                       # BTF_KIND_FUNC_PROTO(id = 1)
+; CHECK-NEXT:        .long   218103808               # 0xd000000
+; CHECK-NEXT:        .long   2
+; CHECK-NEXT:        .long   1                       # BTF_KIND_INT(id = 2)
+; CHECK-NEXT:        .long   16777216                # 0x1000000
+; CHECK-NEXT:        .long   4
+; CHECK-NEXT:        .long   16777248                # 0x1000020
+; CHECK-NEXT:        .long   5                       # BTF_KIND_FUNC(id = 3)
+; CHECK-NEXT:        .long   201326592               # 0xc000000
+; CHECK-NEXT:        .long   1
+; CHECK-NEXT:        .long   52                      # BTF_KIND_VAR(id = 4)
+; CHECK-NEXT:        .long   234881024               # 0xe000000
+; CHECK-NEXT:        .long   0
+; CHECK-NEXT:        .long   2
+; CHECK-NEXT:        .long   55                      # BTF_KIND_VAR(id = 5)
+; CHECK-NEXT:        .long   234881024               # 0xe000000
+; CHECK-NEXT:        .long   0
+; CHECK-NEXT:        .long   2
+; CHECK-NEXT:        .long   58                      # BTF_KIND_DATASEC(id = 6)
+; CHECK-NEXT:        .long   251658242               # 0xf000002
+; CHECK-NEXT:        .long   0
+; CHECK-NEXT:        .long   4
+; CHECK-NEXT:        .long   a1
+; CHECK-NEXT:        .long   1
+; CHECK-NEXT:        .long   5
+; CHECK-NEXT:        .long   a2
+; CHECK-NEXT:        .long   1
+; CHECK-NEXT:        .byte   0                       # string offset=0
+; CHECK-NEXT:        .ascii  "int"                   # string offset=1
+; CHECK-NEXT:        .byte   0
+; CHECK-NEXT:        .ascii  "foo"                   # string offset=5
+; CHECK-NEXT:        .byte   0
+; CHECK-NEXT:        .ascii  ".text"                 # string offset=9
+; CHECK-NEXT:        .byte   0
+; CHECK-NEXT:        .ascii  "/tmp/home/yhs/work/tests/core/test.c" # string offset=15
+; CHECK-NEXT:        .byte   0
+; CHECK-NEXT:        .ascii  "a1"                    # string offset=52
+; CHECK-NEXT:        .byte   0
+; CHECK-NEXT:        .ascii  "a2"                    # string offset=55
+; CHECK-NEXT:        .byte   0
+; CHECK-NEXT:        .ascii  "abc"                   # string offset=58
+; CHECK-NEXT:        .byte   0
+
+attributes #0 = { norecurse nounwind readonly "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "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 10.0.0 (https://github.com/llvm/llvm-project.git aad6a5e3062a2bc7feaf733ba3140a47333f0fc4)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
+!1 = !DIFile(filename: "test.c", directory: "/tmp/home/yhs/work/tests/core")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 10.0.0 (https://github.com/llvm/llvm-project.git aad6a5e3062a2bc7feaf733ba3140a47333f0fc4)"}
+!7 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 3, type: !8, scopeLine: 3, isDefinition: true, isOptimized: true, unit: !0, retainedNodes: !2)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !DILocation(line: 3, column: 20, scope: !7)
+!12 = !{!13, !13, i64 0}
+!13 = !{!"omnipotent char", !14, i64 0}
+!14 = !{!"Simple C/C++ TBAA"}
+!15 = !DILocation(line: 3, column: 25, scope: !7)
+!16 = !DILocation(line: 3, column: 23, scope: !7)
+!17 = !DILocation(line: 3, column: 13, scope: !7)

llvm/test/CodeGen/BPF/BTF/extern-global-var.ll

 }
 
 ; CHECK:             .section        .BTF,"",@progbits
 ; CHECK-NEXT:        .short  60319                   # 0xeb9f
 ; CHECK-NEXT:        .byte   1
 ; CHECK-NEXT:        .byte   0
 ; CHECK-NEXT:        .long   24
 ; CHECK-NEXT:        .long   0
-; CHECK-NEXT:        .long   40
-; CHECK-NEXT:        .long   40
-; CHECK-NEXT:        .long   52
+; CHECK-NEXT:        .long   56
+; CHECK-NEXT:        .long   56
+; CHECK-NEXT:        .long   54
 ; CHECK-NEXT:        .long   0                       # BTF_KIND_FUNC_PROTO(id = 1)
 ; CHECK-NEXT:        .long   218103808               # 0xd000000
 ; CHECK-NEXT:        .long   2
 ; CHECK-NEXT:        .long   1                       # BTF_KIND_INT(id = 2)
 ; CHECK-NEXT:        .long   16777216                # 0x1000000
 ; CHECK-NEXT:        .long   4
 ; CHECK-NEXT:        .long   16777248                # 0x1000020
 ; CHECK-NEXT:        .long   5                       # BTF_KIND_FUNC(id = 3)
 ; CHECK-NEXT:        .long   201326592               # 0xc000000
 ; CHECK-NEXT:        .long   1
+; CHECK-NEXT:        .long   52                      # BTF_KIND_VAR(id = 4)
+; CHECK-NEXT:        .long   234881024               # 0xe000000
+; CHECK-NEXT:        .long   0
+; CHECK-NEXT:        .long   2
 ; CHECK-NEXT:        .byte   0                       # string offset=0
 ; CHECK-NEXT:        .ascii  "int"                   # string offset=1
 ; CHECK-NEXT:        .byte   0
 ; CHECK-NEXT:        .ascii  "foo"                   # string offset=5
 ; CHECK-NEXT:        .byte   0
 ; CHECK-NEXT:        .ascii  ".text"                 # string offset=9
 ; CHECK-NEXT:        .byte   0
 ; CHECK-NEXT:        .ascii  "/home/yhs/work/tests/llvm/bug/test.c" # string offset=15
 ; CHECK-NEXT:        .byte   0
+; CHECK-NEXT:        .byte   97                      # string offset=52
+; CHECK-NEXT:        .byte   0
 
 attributes #0 = { norecurse nounwind readonly "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "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.20181009 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)

llvm/test/CodeGen/BPF/BTF/global-var-inited.ll

 ; RUN: llc -march=bpfel -filetype=asm -o - %s | FileCheck -check-prefixes=CHECK %s
 ; RUN: llc -march=bpfeb -filetype=asm -o - %s | FileCheck -check-prefixes=CHECK %s
 
 ; Source code:
 ;   int a = 3;
 ; Compilation flag:
 ;   clang -target bpf -O2 -g -S -emit-llvm test.c
 
 @a = dso_local local_unnamed_addr global i32 3, align 4, !dbg !0
 
 ; CHECK:             .section        .BTF,"",@progbits
 ; CHECK-NEXT:        .short  60319                   # 0xeb9f
 ; CHECK-NEXT:        .byte   1
 ; CHECK-NEXT:        .byte   0
 ; CHECK-NEXT:        .long   24
 ; CHECK-NEXT:        .long   0
-; CHECK-NEXT:        .long   16
-; CHECK-NEXT:        .long   16
-; CHECK-NEXT:        .long   5
+; CHECK-NEXT:        .long   56
+; CHECK-NEXT:        .long   56
+; CHECK-NEXT:        .long   13
 ; CHECK-NEXT:        .long   1                       # BTF_KIND_INT(id = 1)
 ; CHECK-NEXT:        .long   16777216                # 0x1000000
 ; CHECK-NEXT:        .long   4
 ; CHECK-NEXT:        .long   16777248                # 0x1000020
+; CHECK-NEXT:        .long   5                       # BTF_KIND_VAR(id = 2)
+; CHECK-NEXT:        .long   234881024               # 0xe000000
+; CHECK-NEXT:        .long   1
+; CHECK-NEXT:        .long   1
+; CHECK-NEXT:        .long   7                       # BTF_KIND_DATASEC(id = 3)
+; CHECK-NEXT:        .long   251658241               # 0xf000001
+; CHECK-NEXT:        .long   0
+; CHECK-NEXT:        .long   2
+; CHECK-NEXT:        .long   a
+; CHECK-NEXT:        .long   4
 ; CHECK-NEXT:        .byte   0                       # string offset=0
 ; CHECK-NEXT:        .ascii  "int"                   # string offset=1
 ; CHECK-NEXT:        .byte   0
+; CHECK-NEXT:        .byte   97                      # string offset=5
+; CHECK-NEXT:        .byte   0
+; CHECK-NEXT:        .ascii  ".data"                 # string offset=7
+; CHECK-NEXT:        .byte   0
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!7, !8, !9}
 !llvm.ident = !{!10}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "a", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 8.0.20181009 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, nameTableKind: None)
 !3 = !DIFile(filename: "test.c", directory: "/home/yhs/work/tests/llvm/bug")
 !4 = !{}
 !5 = !{!0}
 !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !7 = !{i32 2, !"Dwarf Version", i32 4}
 !8 = !{i32 2, !"Debug Info Version", i32 3}
 !9 = !{i32 1, !"wchar_size", i32 4}
 !10 = !{!"clang version 8.0.20181009 "}