[BPF] Add support for floats and doubles

[iii]

Summary

Some BPF programs compiled on s390 fail to load, because s390
arch-specific linux headers contain float and double types. At the
moment there is no BTF_KIND for floats and doubles, so the release
version of LLVM ends up emitting type id 0 for them, which the
in-kernel verifier does not accept.

Introduce support for such types to libbpf by representing them using
the new BTF_KIND_FLOAT.

[yonghong-song]

@iii Thanks for the patch. Looks like you also addressed the issue for larger vlen for struct/union/enum/func_proto. Currently, we mostly just ignored these types. We issued fatal error for unhandled types (mostly non-C types). Such a compiler sanitization should be fine. I am thinking whether we should issue a compiler warning for such unsupported type or not. If we did, we will need an option to silence them. Not sure whether it is worth it or not since we did not issue warning right now for these types.

For the code itself, is it possible to keep all visit function as void type and do unknown type generation whenever it hits (e.g., float/double, large vlen)?
For unknown types, I still like to keep it as fatal error. If it did happen, we will see how to deal with it. I just do not want to silently convert it.

[iii]

Thanks for the review!

I've changed the return types back to void and added addUnknownType()
calls where needed. I've also restored llvm_unreachable() for unknown
DIType subclasses.

[iamkafai]

I don't have strong opinion on whether using int for float/double or byte array or completely skip emitting BTF for those members. I would slightly prefer the later (skip emitting BTF) for now until we figure out a real use case that the bpf prog needs to read them. I think the bpf program is not supposed to access the float/double anyway, right?.

I would prefer a warning. especially for >64k members which should not happen, right?

[yonghong-song]

Thanks for the change. LGTM. Could you add some warnings for these unsupported types (using llvm::errs())? Without this patch, BTF will be rejected. This patch will make them pass
verifier. Warning will let user know the program has unsupported types or certain limitations and these types and limitations are worked around by the compiler. People may report
these types and limitations back to bpf community so we can evaluate whether we need to extend BTF to have proper support.

[iii]

I've added the warning. On my s390 it looks like this when building
kselftests:

CLANG    kselftest/bpf/tools/build/bpftool/pid_iter.bpf.o

Type float is not supported by BTF, emitting unsigned char[4] instead
Type double is not supported by BTF, emitting unsigned char[8] instead

I don't think existing progs are using any of these fields, but it
might be beneficial to be able to at least memcpy their contents to
e.g. a perf event buffer for later inspection.

[ast]

does pahole convert float/double to int ? Is it really the case?
I think it's better to skip float/double when they are part of a struct and leave a hole in there.
I worry that representing them as 'char' array may cause backward compatibility issues later.
If pahole is doing such hack now it probably should be fixed too.

As far as structs with >64k members I think the hard error is better.

[anakryiko]

pahole does a sensible thing, it represents it as BTF_KIND_INT (which maps to DWARF's DW_TAG_base_type), but with no encoding (so it's effectively unsigned integer with proper size).

I've been advocating for adding one extra encoding bit to BTF_KIND_INT's encoding field to represent floating-point numbers, in addition to existing CHAR, SIGNED, and BOOL. This would make sense (float is indivisible set of bytes with particular interpretation, which is what BTF_KIND_INT is), it's easy to support in kernel, it's easy to sanitize in libbpf.

The only downside is a bit mismatched INT name (DWARF uses more generic BASE_TYPE name for this), which I think is very-very minor (and one can argue that all the primitive types are integers).

[yonghong-song]

For structs with >64k members, currently, it is ignored (with type id 0), no compilation error. That is why I recommend to issue a warning. I worried maybe some codes there with such huge struct/enum (esp. enum), which is not used by bpf program directly, but present in the bpf code. The fatal error may break them. But I agree such cases should be really rare, so maybe fatal error is okay.

Using hole instead of representing float as another type may make it complicated to handle cases like

const float ...
float * ...
float a[100];

some may be struct members, some other may be pointee's, some may be function arguments, etc....
Or we only care about float member in a structure, which is the motivation for this patch, and all
other potential use of float should be ignored (as of today)?

[anakryiko]

I concur with @yonghong-song, making float disappear is much bigger pain.

But I also think we should go with encoding and actually also fix encoding interpretation in kernel. Right now it allows only one of SIGNED, CHAR, or BOOL to be specified, which makes it impossible to correctly represent signed char type, as you can see from this:

$ cat test.c
struct s {
        signed char wat;
};

int main() {
        static struct s s = { .wat = -2 };
        return s.wat;
}
$ cc -g test.c -o test

$ readelf -wi test | rg 'signed char'
    <48>   DW_AT_encoding    : 6        (signed char)
    <49>   DW_AT_name        : (indirect string, offset: 0x50): signed char

$ pahole -JV test | rg 'signed char'
[2] INT signed char size=1 bit_offset=0 nr_bits=8 encoding=(none)

$ clang -g -target bpf -c test.c -o test.bpf.o

$ bpftool btf dump file test.bpf.o | rg 'signed char'
[5] INT 'signed char' size=1 bits_offset=0 nr_bits=8 encoding=SIGNED

DWARF gets it right. pahole does the same thing as for float, just emits no encoding. clang emits it as signed, but not a char.

BTW, I couldn't make neither pahole nor clang to emit CHAR encoding for anything (char, unsigned char, signed char), what was it supposed to be used for originally?

So I'd say let's add BTF_INT_FLOATING and fix SIGNED CHAR and CHAR problem altogether? Libbpf can trivially sanitize BTF for older kernels.

Thoughts?

[ast]

'float *var;' in the struct won't be trivial to handle with a skip indeed.
My concern with float->char[] substitute is that the kernel decides on calling convention based on these types.
If there is a function fn(int a, float b); and pahole emits BTF for it as fn(int a, char b[4])
the kernel will let bpf progs to attach to it with wrong register passing.
Currently array is not allowed in btf_distill_func_proto(), so it's a theoretical issue, but still dangerous long term.
I think pahole/clang should either skip generating BTF for anything with float or BTF should be extended to encode it.
I think extending BTF would be easier.
I don't like KIND_INT_FLOATING though. KIND_FLOAT is better. Just like single KIND_INT that represents char/int/long
the KIND_FLOAT should be able to represent float/double/long double.

[yonghong-song]

I will experiment with proper float type support soon. new kind e.g., KIND_FLOAT proper cleanest based on current state of BTF.

[iii]

I'll close this change now. Thanks for the discussion; looking forward to the proper floating point support in BTF!

[yonghong-song]

@iii I probably won't have time to work on this in the near future. Since you have a use case here, can you help do a design and implementation here? This may involve llvm, libbpf, kernel and pahole changes. Thanks!

[iii]

@yonghong-song Sure, I will give it a try.

[yonghong-song]

Sounds good. Thanks!

[iii]

Hi, it has been a long time, but I've finally implemented the support
for the floating-point types in BTF. Here are the other pieces:

• verifier+libbpf: https://github.com/iii-i/linux/commit/wip
• just libbpf (same as the libbpf part of the above): https://github.com/iii-i/libbpf/commit/wip
• pahole: https://github.com/iii-i/dwarves/commit/wip

Could you please have a quick look regarding whether this all makes
sense and whether we want to go forward with this? I can then split
the commits and send them to the mailing lists for the proper review.

[anakryiko]

In D83289#2549050, @iii wrote:

Hi, it has been a long time, but I've finally implemented the support
for the floating-point types in BTF. Here are the other pieces:

• verifier+libbpf: https://github.com/iii-i/linux/commit/wip
• just libbpf (same as the libbpf part of the above): https://github.com/iii-i/libbpf/commit/wip

fyi, github.com/libbpf/libbpf is derived from kernel sources, so there is no need for separate Github parts

• pahole: https://github.com/iii-i/dwarves/commit/wip

Could you please have a quick look regarding whether this all makes
sense and whether we want to go forward with this? I can then split
the commits and send them to the mailing lists for the proper review.

I still think float/double doesn't deserve its own BTF_KIND_FLOAT kind and all the extra code (and APIs). Just like DWARF is doing just fine with just a DW_ATE_float encoding in base_type kind, so can BTF have BTF_KIND_INT (unfortunate name, but it corresponds to DWARF's base_type) with special FLOAT encoding. Having 'float'/'double' as BTF_KIND_INT (without extra encoding bits) would make all this work with vmlinux.h generation with absolutely no changes in kernel, libbpf, pahole, today. We could also add FLOAT encoding for kernel to deal with calling conventions, though. That would still require less changes across existing tool chains and whichever other users of BTF are out there.

Either way, libbpf as it is right now is missing BTF sanitization bits. You'd probably want to implement BTF_KIND_FLOAT -> BTF_KIND_INT substitution for that in bpf_object__sanitize_btf().

[iii]

Removed an unnecessary trailing u32.

[yonghong-song]

LGTM. But let us delay merging until kernel side patch is reasonable shape and ready to merge, then we can merge this patch to llvm. Thanks!

[yonghong-song]

@iii if you have write permission, can you merge the patch by yourself? Otherwise, I can do that. Let me know. Thanks!

llvm/lib/Target/BPF/BTF.def

 HANDLE_BTF_KIND(8, TYPEDEF)
 HANDLE_BTF_KIND(9, VOLATILE)
 HANDLE_BTF_KIND(10, CONST)
 HANDLE_BTF_KIND(11, RESTRICT)
 HANDLE_BTF_KIND(12, FUNC)
 HANDLE_BTF_KIND(13, FUNC_PROTO)
 HANDLE_BTF_KIND(14, VAR)
 HANDLE_BTF_KIND(15, DATASEC)
+HANDLE_BTF_KIND(16, FLOAT)
 
 #undef HANDLE_BTF_KIND

llvm/lib/Target/BPF/BTFDebug.h

public:
   void addVar(uint32_t Id, const MCSymbol *Sym, uint32_t Size) {
     Vars.push_back(std::make_tuple(Id, Sym, Size));
   }
   std::string getName() { return Name; }
   void completeType(BTFDebug &BDebug) override;
   void emitType(MCStreamer &OS) override;
 };
 
+/// Handle binary floating point type.
+class BTFTypeFloat : public BTFTypeBase {
+  StringRef Name;
+
+public:
+  BTFTypeFloat(uint32_t SizeInBits, StringRef TypeName);
+  void completeType(BTFDebug &BDebug) override;
+};
+
 /// String table.
 class BTFStringTable {
   /// String table size in bytes.
   uint32_t Size;
   /// A mapping from string table offset to the index
   /// of the Table. It is used to avoid putting
   /// duplicated strings in the table.
   std::map<uint32_t, uint32_t> OffsetToIdMap;

llvm/lib/Target/BPF/BTFDebug.cpp

void BTFKindDataSec::emitType(MCStreamer &OS) {
 
   for (const auto &V : Vars) {
     OS.emitInt32(std::get<0>(V));
     Asm->emitLabelReference(std::get<1>(V), 4);
     OS.emitInt32(std::get<2>(V));
   }
 }
 
+BTFTypeFloat::BTFTypeFloat(uint32_t SizeInBits, StringRef TypeName)
+    : Name(TypeName) {
+  Kind = BTF::BTF_KIND_FLOAT;
+  BTFType.Info = Kind << 24;
+  BTFType.Size = roundupToBytes(SizeInBits);
+}
+
+void BTFTypeFloat::completeType(BTFDebug &BDebug) {
+  if (IsCompleted)
+    return;
+  IsCompleted = true;
+
+  BTFType.NameOff = BDebug.addString(Name);
+}
+
 uint32_t BTFStringTable::addString(StringRef S) {
   // Check whether the string already exists.
   for (auto &OffsetM : OffsetToIdMap) {
     if (Table[OffsetM.second] == S)
       return OffsetM.first;
   }
   // Not find, add to the string table.
   uint32_t Offset = Size;

 uint32_t BTFDebug::addType(std::unique_ptr<BTFTypeBase> TypeEntry) {
   TypeEntry->setId(TypeEntries.size() + 1);
   uint32_t Id = TypeEntry->getId();
   TypeEntries.push_back(std::move(TypeEntry));
   return Id;
 }
 
 void BTFDebug::visitBasicType(const DIBasicType *BTy, uint32_t &TypeId) {
-  // Only int types are supported in BTF.
+  // Only int and binary floating point types are supported in BTF.
   uint32_t Encoding = BTy->getEncoding();
-  if (Encoding != dwarf::DW_ATE_boolean && Encoding != dwarf::DW_ATE_signed &&
-      Encoding != dwarf::DW_ATE_signed_char &&
-      Encoding != dwarf::DW_ATE_unsigned &&
-      Encoding != dwarf::DW_ATE_unsigned_char)
-    return;
-
+  std::unique_ptr<BTFTypeBase> TypeEntry;
+  switch (Encoding) {
+  case dwarf::DW_ATE_boolean:
+  case dwarf::DW_ATE_signed:
+  case dwarf::DW_ATE_signed_char:
+  case dwarf::DW_ATE_unsigned:
+  case dwarf::DW_ATE_unsigned_char:
     // Create a BTF type instance for this DIBasicType and put it into
     // DIToIdMap for cross-type reference check.
-  auto TypeEntry = std::make_unique<BTFTypeInt>(
+    TypeEntry = std::make_unique<BTFTypeInt>(
         Encoding, BTy->getSizeInBits(), BTy->getOffsetInBits(), BTy->getName());
+    break;
+  case dwarf::DW_ATE_float:
+    TypeEntry =
+        std::make_unique<BTFTypeFloat>(BTy->getSizeInBits(), BTy->getName());
+    break;
+  default:
+    return;
+  }
+
   TypeId = addType(std::move(TypeEntry), BTy);
 }
 
 /// Handle subprogram or subroutine types.
 void BTFDebug::visitSubroutineType(
     const DISubroutineType *STy, bool ForSubprog,
     const std::unordered_map<uint32_t, StringRef> &FuncArgNames,
     uint32_t &TypeId) {

llvm/test/CodeGen/BPF/BTF/double.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:
+;   double a;
+; Compilation flag:
+;   clang -target bpf -O2 -g -S -emit-llvm t.c
+
+@a = dso_local local_unnamed_addr global double 0.000000e+00, align 8, !dbg !0
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!7, !8, !9}
+!llvm.ident = !{!10}
+
+; 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 52
+; CHECK-NEXT:        .long 52
+; CHECK-NEXT:        .long 15
+; [1] double, size=8 bytes (64 bits)
+; CHECK-NEXT:        .long 1 # BTF_KIND_FLOAT(id = 1)
+; CHECK-NEXT:        .long 268435456 # 0x10000000
+; CHECK-NEXT:        .long 8
+; [2] a, type=double (1), global
+; CHECK-NEXT:        .long 8 # BTF_KIND_VAR(id = 2)
+; CHECK-NEXT:        .long 234881024 # 0xe000000
+; CHECK-NEXT:        .long 1
+; CHECK-NEXT:        .long 1
+; [3] .bss, 1 var, {a, offset=&a, size=8 bytes}
+; CHECK-NEXT:        .long 10 # 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 8
+; CHECK-NEXT:        .byte 0 # string offset=0
+; CHECK-NEXT:        .ascii "double" # string offset=1
+; CHECK-NEXT:        .byte 0
+; CHECK-NEXT:        .byte 97 # string offset=8
+; CHECK-NEXT:        .byte 0
+; CHECK-NEXT:        .ascii ".bss" # string offset=10
+; CHECK-NEXT:        .byte 0
+
+!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 11.0.0 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "t.c", directory: "/home/yhs/tmp")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIBasicType(name: "double", size: 64, encoding: DW_ATE_float)
+!7 = !{i32 7, !"Dwarf Version", i32 4}
+!8 = !{i32 2, !"Debug Info Version", i32 3}
+!9 = !{i32 1, !"wchar_size", i32 4}
+!10 = !{!"clang version 11.0.0 "}

llvm/test/CodeGen/BPF/BTF/float.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:
+;   float a;
+; Compilation flag:
+;   clang -target bpf -O2 -g -S -emit-llvm t.c
+
+@a = dso_local local_unnamed_addr global float 0.000000e+00, align 4, !dbg !0
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!7, !8, !9}
+!llvm.ident = !{!10}
+
+; 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 52
+; CHECK-NEXT:        .long 52
+; CHECK-NEXT:        .long 14
+; [1] float, size=4 bytes (32 bits)
+; CHECK-NEXT:        .long 1 # BTF_KIND_FLOAT(id = 1)
+; CHECK-NEXT:        .long 268435456 # 0x10000000
+; CHECK-NEXT:        .long 4
+; [2] a, type=float (1), global
+; CHECK-NEXT:        .long 7 # BTF_KIND_VAR(id = 2)
+; CHECK-NEXT:        .long 234881024 # 0xe000000
+; CHECK-NEXT:        .long 1
+; CHECK-NEXT:        .long 1
+; [3] .bss, 1 var, {a, offset=&a, size=4 bytes}
+; CHECK-NEXT:        .long 9 # 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 "float" # string offset=1
+; CHECK-NEXT:        .byte 0
+; CHECK-NEXT:        .byte 97 # string offset=7
+; CHECK-NEXT:        .byte 0
+; CHECK-NEXT:        .ascii ".bss" # string offset=9
+; CHECK-NEXT:        .byte 0
+
+!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 11.0.0 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "t.c", directory: "/home/yhs/tmp")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIBasicType(name: "float", size: 32, encoding: DW_ATE_float)
+!7 = !{i32 7, !"Dwarf Version", i32 4}
+!8 = !{i32 2, !"Debug Info Version", i32 3}
+!9 = !{i32 1, !"wchar_size", i32 4}
+!10 = !{!"clang version 11.0.0 "}