[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/BTFDebug.h

class BTFDebug : public DebugHandlerBase {
   std::map<uint32_t, std::vector<BTFFieldReloc>> FieldRelocTable;
   StringMap<std::vector<std::string>> FileContent;
   std::map<std::string, std::unique_ptr<BTFKindDataSec>> DataSecEntries;
   std::vector<BTFTypeStruct *> StructTypes;
   std::map<const GlobalVariable *, uint32_t> PatchImms;
   std::map<StringRef, std::pair<bool, std::vector<BTFTypeDerived *>>>
       FixupDerivedTypes;
   std::set<const Function *>ProtoFunctions;
+  uint32_t ByteTypeId;
 
   /// Add types to TypeEntries.
   /// @{
   /// Add types to TypeEntries and DIToIdMap.
   uint32_t addType(std::unique_ptr<BTFTypeBase> TypeEntry, const DIType *Ty);
   /// Add types to TypeEntries only and return type id.
   uint32_t addType(std::unique_ptr<BTFTypeBase> TypeEntry);
+  /// Add unknown types to TypeEntries and DIToIdMap.
+  uint32_t addUnknownType(const DIType *Ty);
   /// @}
 
   /// IR type visiting functions.
   /// @{
   void visitTypeEntry(const DIType *Ty);
   void visitTypeEntry(const DIType *Ty, uint32_t &TypeId, bool CheckPointer,
                       bool SeenPointer);
-  void visitBasicType(const DIBasicType *BTy, uint32_t &TypeId);
-  void visitSubroutineType(
+  bool visitBasicType(const DIBasicType *BTy, uint32_t &TypeId);
+  bool visitSubroutineType(
       const DISubroutineType *STy, bool ForSubprog,
       const std::unordered_map<uint32_t, StringRef> &FuncArgNames,
       uint32_t &TypeId);
-  void visitFwdDeclType(const DICompositeType *CTy, bool IsUnion,
+  bool visitFwdDeclType(const DICompositeType *CTy, bool IsUnion,
                         uint32_t &TypeId);
-  void visitCompositeType(const DICompositeType *CTy, uint32_t &TypeId);
-  void visitStructType(const DICompositeType *STy, bool IsStruct,
+  bool visitCompositeType(const DICompositeType *CTy, uint32_t &TypeId);
+  bool visitStructType(const DICompositeType *STy, bool IsStruct,
                        uint32_t &TypeId);
-  void visitArrayType(const DICompositeType *ATy, uint32_t &TypeId);
-  void visitEnumType(const DICompositeType *ETy, uint32_t &TypeId);
-  void visitDerivedType(const DIDerivedType *DTy, uint32_t &TypeId,
+  bool visitArrayType(const DICompositeType *ATy, uint32_t &TypeId);
+  bool visitEnumType(const DICompositeType *ETy, uint32_t &TypeId);
+  bool visitDerivedType(const DIDerivedType *DTy, uint32_t &TypeId,
                         bool CheckPointer, bool SeenPointer);
   void visitMapDefType(const DIType *Ty, uint32_t &TypeId);
   /// @}
 
   /// Get the file content for the subprogram. Certain lines of the file
   /// later may be put into string table and referenced by line info.
   std::string populateFileContent(const DISubprogram *SP);
 
class BTFDebug : public DebugHandlerBase {
   void emitCommonHeader();
 
   /// Emit the .BTF section.
   void emitBTFSection();
 
   /// Emit the .BTF.ext section.
   void emitBTFExtSection();
 
+  /// Generate ArrayIndexTypeId unless it's already generated.
+  void generateArrayIndexTypeId();
+
 protected:
   /// Gather pre-function debug information.
   void beginFunctionImpl(const MachineFunction *MF) override;
 
   /// Post process after all instructions in this function are processed.
   void endFunctionImpl(const MachineFunction *MF) override;
 
 public:

llvm/lib/Target/BPF/BTFDebug.cpp

uint32_t BTFStringTable::addString(StringRef S) {
   Table.push_back(std::string(S));
   Size += S.size() + 1;
   return Offset;
 }
 
 BTFDebug::BTFDebug(AsmPrinter *AP)
     : DebugHandlerBase(AP), OS(*Asm->OutStreamer), SkipInstruction(false),
       LineInfoGenerated(false), SecNameOff(0), ArrayIndexTypeId(0),
-      MapDefNotCollected(true) {
+      MapDefNotCollected(true), ByteTypeId(0) {
   addString("\0");
 }
 
 uint32_t BTFDebug::addType(std::unique_ptr<BTFTypeBase> TypeEntry,
                            const DIType *Ty) {
   TypeEntry->setId(TypeEntries.size() + 1);
   uint32_t Id = TypeEntry->getId();
   DIToIdMap[Ty] = Id;
   TypeEntries.push_back(std::move(TypeEntry));
   return Id;
 }
 
 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) {
+uint32_t BTFDebug::addUnknownType(const DIType *Ty) {
+  uint64_t SizeInBits = Ty->getSizeInBits();
+  assert(SizeInBits % 8 == 0);
+  if (ByteTypeId == 0) {
+    auto ByteTypeEntry = std::make_unique<BTFTypeInt>(
+        dwarf::DW_ATE_unsigned_char, 8, 0, "__BYTE_TYPE__");
+    ByteTypeId = addType(std::move(ByteTypeEntry));
+  }
+  auto TypeEntry = std::make_unique<BTFTypeArray>(ByteTypeId, SizeInBits / 8);
+  generateArrayIndexTypeId();
+  return addType(std::move(TypeEntry), Ty);
+}
+
+bool BTFDebug::visitBasicType(const DIBasicType *BTy, uint32_t &TypeId) {
   // Only int 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;
+    return false;
 
   // Create a BTF type instance for this DIBasicType and put it into
   // DIToIdMap for cross-type reference check.
   auto TypeEntry = std::make_unique<BTFTypeInt>(
       Encoding, BTy->getSizeInBits(), BTy->getOffsetInBits(), BTy->getName());
   TypeId = addType(std::move(TypeEntry), BTy);
+  return true;
 }
 
 /// Handle subprogram or subroutine types.
-void BTFDebug::visitSubroutineType(
+bool BTFDebug::visitSubroutineType(
     const DISubroutineType *STy, bool ForSubprog,
     const std::unordered_map<uint32_t, StringRef> &FuncArgNames,
     uint32_t &TypeId) {
   DITypeRefArray Elements = STy->getTypeArray();
   uint32_t VLen = Elements.size() - 1;
   if (VLen > BTF::MAX_VLEN)
-    return;
+    return false;
 
   // Subprogram has a valid non-zero-length name, and the pointee of
   // a function pointer has an empty name. The subprogram type will
   // not be added to DIToIdMap as it should not be referenced by
   // any other types.
   auto TypeEntry = std::make_unique<BTFTypeFuncProto>(STy, VLen, FuncArgNames);
   if (ForSubprog)
     TypeId = addType(std::move(TypeEntry)); // For subprogram
   else
     TypeId = addType(std::move(TypeEntry), STy); // For func ptr
 
   // Visit return type and func arg types.
   for (const auto Element : Elements) {
     visitTypeEntry(Element);
   }
+  return true;
 }
 
 /// Handle structure/union types.
-void BTFDebug::visitStructType(const DICompositeType *CTy, bool IsStruct,
+bool BTFDebug::visitStructType(const DICompositeType *CTy, bool IsStruct,
                                uint32_t &TypeId) {
   const DINodeArray Elements = CTy->getElements();
   uint32_t VLen = Elements.size();
   if (VLen > BTF::MAX_VLEN)
-    return;
+    return false;
 
   // Check whether we have any bitfield members or not
   bool HasBitField = false;
   for (const auto *Element : Elements) {
     auto E = cast<DIDerivedType>(Element);
     if (E->isBitField()) {
       HasBitField = true;
       break;
     }
   }
 
   auto TypeEntry =
       std::make_unique<BTFTypeStruct>(CTy, IsStruct, HasBitField, VLen);
   StructTypes.push_back(TypeEntry.get());
   TypeId = addType(std::move(TypeEntry), CTy);
 
   // Visit all struct members.
   for (const auto *Element : Elements)
     visitTypeEntry(cast<DIDerivedType>(Element));
+  return true;
 }
 
-void BTFDebug::visitArrayType(const DICompositeType *CTy, uint32_t &TypeId) {
+bool BTFDebug::visitArrayType(const DICompositeType *CTy, uint32_t &TypeId) {
   // Visit array element type.
   uint32_t ElemTypeId;
   const DIType *ElemType = CTy->getBaseType();
   visitTypeEntry(ElemType, ElemTypeId, false, false);
 
   // Visit array dimensions.
   DINodeArray Elements = CTy->getElements();
   for (int I = Elements.size() - 1; I >= 0; --I) {
if (auto *Element = dyn_cast_or_null<DINode>(Elements[I]))
       }
   }
 
   // The array TypeId is the type id of the outermost dimension.
   TypeId = ElemTypeId;
 
   // The IR does not have a type for array index while BTF wants one.
   // So create an array index type if there is none.
-  if (!ArrayIndexTypeId) {
-    auto TypeEntry = std::make_unique<BTFTypeInt>(dwarf::DW_ATE_unsigned, 32,
-                                                   0, "__ARRAY_SIZE_TYPE__");
-    ArrayIndexTypeId = addType(std::move(TypeEntry));
-  }
+  generateArrayIndexTypeId();
+
+  return true;
+
+void BTFDebug::generateArrayIndexTypeId() {
+  if (ArrayIndexTypeId)
+    return;
+  auto TypeEntry = std::make_unique<BTFTypeInt>(dwarf::DW_ATE_unsigned, 32, 0,
+                                                "__ARRAY_SIZE_TYPE__");
+  ArrayIndexTypeId = addType(std::move(TypeEntry));
 }
 
-void BTFDebug::visitEnumType(const DICompositeType *CTy, uint32_t &TypeId) {
+bool BTFDebug::visitEnumType(const DICompositeType *CTy, uint32_t &TypeId) {
   DINodeArray Elements = CTy->getElements();
   uint32_t VLen = Elements.size();
   if (VLen > BTF::MAX_VLEN)
-    return;
+    return false;
 
   auto TypeEntry = std::make_unique<BTFTypeEnum>(CTy, VLen);
   TypeId = addType(std::move(TypeEntry), CTy);
   // No need to visit base type as BTF does not encode it.
+  return true;
 }
 
 /// Handle structure/union forward declarations.
-void BTFDebug::visitFwdDeclType(const DICompositeType *CTy, bool IsUnion,
+bool BTFDebug::visitFwdDeclType(const DICompositeType *CTy, bool IsUnion,
                                 uint32_t &TypeId) {
   auto TypeEntry = std::make_unique<BTFTypeFwd>(CTy->getName(), IsUnion);
   TypeId = addType(std::move(TypeEntry), CTy);
+  return true;
 }
 
 /// Handle structure, union, array and enumeration types.
-void BTFDebug::visitCompositeType(const DICompositeType *CTy,
+bool BTFDebug::visitCompositeType(const DICompositeType *CTy,
                                   uint32_t &TypeId) {
   auto Tag = CTy->getTag();
   if (Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
     // Handle forward declaration differently as it does not have members.
     if (CTy->isForwardDecl())
-      visitFwdDeclType(CTy, Tag == dwarf::DW_TAG_union_type, TypeId);
+      return visitFwdDeclType(CTy, Tag == dwarf::DW_TAG_union_type, TypeId);
     else
-      visitStructType(CTy, Tag == dwarf::DW_TAG_structure_type, TypeId);
+      return visitStructType(CTy, Tag == dwarf::DW_TAG_structure_type, TypeId);
   } else if (Tag == dwarf::DW_TAG_array_type)
-    visitArrayType(CTy, TypeId);
+    return visitArrayType(CTy, TypeId);
   else if (Tag == dwarf::DW_TAG_enumeration_type)
-    visitEnumType(CTy, TypeId);
+    return visitEnumType(CTy, TypeId);
+  return false;
 }
 
 /// Handle pointer, typedef, const, volatile, restrict and member types.
-void BTFDebug::visitDerivedType(const DIDerivedType *DTy, uint32_t &TypeId,
+bool BTFDebug::visitDerivedType(const DIDerivedType *DTy, uint32_t &TypeId,
                                 bool CheckPointer, bool SeenPointer) {
   unsigned Tag = DTy->getTag();
 
   /// Try to avoid chasing pointees, esp. structure pointees which may
   /// unnecessary bring in a lot of types.
   if (CheckPointer && !SeenPointer) {
     SeenPointer = Tag == dwarf::DW_TAG_pointer_type;
   }
if (Base) {
           /// Find a candidate, generate a fixup. Later on the struct/union
           /// pointee type will be replaced with either a real type or
           /// a forward declaration.
           auto TypeEntry = std::make_unique<BTFTypeDerived>(DTy, Tag, true);
           auto &Fixup = FixupDerivedTypes[CTy->getName()];
           Fixup.first = CTag == dwarf::DW_TAG_union_type;
           Fixup.second.push_back(TypeEntry.get());
           TypeId = addType(std::move(TypeEntry), DTy);
-          return;
+          return true;
         }
       }
     }
   }
 
   if (Tag == dwarf::DW_TAG_pointer_type || Tag == dwarf::DW_TAG_typedef ||
       Tag == dwarf::DW_TAG_const_type || Tag == dwarf::DW_TAG_volatile_type ||
       Tag == dwarf::DW_TAG_restrict_type) {
     auto TypeEntry = std::make_unique<BTFTypeDerived>(DTy, Tag, false);
     TypeId = addType(std::move(TypeEntry), DTy);
   } else if (Tag != dwarf::DW_TAG_member) {
-    return;
+    return false;
   }
 
   // Visit base type of pointer, typedef, const, volatile, restrict or
   // struct/union member.
   uint32_t TempTypeId = 0;
   if (Tag == dwarf::DW_TAG_member)
     visitTypeEntry(DTy->getBaseType(), TempTypeId, true, false);
   else
     visitTypeEntry(DTy->getBaseType(), TempTypeId, CheckPointer, SeenPointer);
+  return true;
 }
 
 void BTFDebug::visitTypeEntry(const DIType *Ty, uint32_t &TypeId,
                               bool CheckPointer, bool SeenPointer) {
   if (!Ty || DIToIdMap.find(Ty) != DIToIdMap.end()) {
     TypeId = DIToIdMap[Ty];
 
     // To handle the case like the following:
if (Ty && (!CheckPointer || !SeenPointer)) {
                          SeenPointer);
         }
       }
     }
 
     return;
   }
 
+  bool IsKnown = false;
   if (const auto *BTy = dyn_cast<DIBasicType>(Ty))
-    visitBasicType(BTy, TypeId);
+    IsKnown = visitBasicType(BTy, TypeId);
   else if (const auto *STy = dyn_cast<DISubroutineType>(Ty))
-    visitSubroutineType(STy, false, std::unordered_map<uint32_t, StringRef>(),
-                        TypeId);
+    IsKnown = visitSubroutineType(
+        STy, false, std::unordered_map<uint32_t, StringRef>(), TypeId);
   else if (const auto *CTy = dyn_cast<DICompositeType>(Ty))
-    visitCompositeType(CTy, TypeId);
+    IsKnown = visitCompositeType(CTy, TypeId);
   else if (const auto *DTy = dyn_cast<DIDerivedType>(Ty))
-    visitDerivedType(DTy, TypeId, CheckPointer, SeenPointer);
-  else
-    llvm_unreachable("Unknown DIType");
+    IsKnown = visitDerivedType(DTy, TypeId, CheckPointer, SeenPointer);
+  if (!IsKnown)
+    TypeId = addUnknownType(Ty);
 }
 
 void BTFDebug::visitTypeEntry(const DIType *Ty) {
   uint32_t TypeId;
   visitTypeEntry(Ty, TypeId, false, false);
 }
 
 void BTFDebug::visitMapDefType(const DIType *Ty, 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 96
+; CHECK-NEXT:        .long 96
+; CHECK-NEXT:        .long 42
+; [1] __BYTE_TYPE__, int, size=1 byte, unsigned, 8 bits
+; CHECK-NEXT:        .long 1 # BTF_KIND_INT(id = 1)
+; CHECK-NEXT:        .long 16777216 # 0x1000000
+; CHECK-NEXT:        .long 1
+; CHECK-NEXT:        .long 8 # 0x8
+; [2] __ARRAY_SIZE_TYPE__, int, size=4 bytes, unsigned, 32 bits
+; CHECK-NEXT:        .long 15 # BTF_KIND_INT(id = 2)
+; CHECK-NEXT:        .long 16777216 # 0x1000000
+; CHECK-NEXT:        .long 4
+; CHECK-NEXT:        .long 32 # 0x20
+; [3] array, type=__BYTE_TYPE__, index_type=__ARRAY_SIZE_TYPE__, nelems=8
+; CHECK-NEXT:        .long 0 # BTF_KIND_ARRAY(id = 3)
+; CHECK-NEXT:        .long 50331648 # 0x3000000
+; CHECK-NEXT:        .long 0
+; CHECK-NEXT:        .long 1
+; CHECK-NEXT:        .long 2
+; CHECK-NEXT:        .long 8
+; [4] a, var, type=__BYTE_TYPE__[8], global
+; CHECK-NEXT:        .long 35 # BTF_KIND_VAR(id = 4)
+; CHECK-NEXT:        .long 234881024 # 0xe000000
+; CHECK-NEXT:        .long 3
+; CHECK-NEXT:        .long 1
+; [5] .bss, datasec, 1 var, {a, offset=&a, size=8 bytes}
+; CHECK-NEXT:        .long 37 # BTF_KIND_DATASEC(id = 5)
+; CHECK-NEXT:        .long 251658241 # 0xf000001
+; CHECK-NEXT:        .long 0
+; CHECK-NEXT:        .long 4
+; CHECK-NEXT:        .long a
+; CHECK-NEXT:        .long 8
+; CHECK-NEXT:        .byte 0 # string offset=0
+; CHECK-NEXT:        .ascii "__BYTE_TYPE__" # string offset=1
+; CHECK-NEXT:        .byte 0
+; CHECK-NEXT:        .ascii "__ARRAY_SIZE_TYPE__" # string offset=15
+; CHECK-NEXT:        .byte 0
+; CHECK-NEXT:        .byte 97 # string offset=35
+; CHECK-NEXT:        .byte 0
+; CHECK-NEXT:        .ascii ".bss" # string offset=37
+; 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 96
+; CHECK-NEXT:        .long 96
+; CHECK-NEXT:        .long 42
+; [1] __BYTE_TYPE__, int, size=1 byte, unsigned, 8 bits
+; CHECK-NEXT:        .long 1 # BTF_KIND_INT(id = 1)
+; CHECK-NEXT:        .long 16777216 # 0x1000000
+; CHECK-NEXT:        .long 1
+; CHECK-NEXT:        .long 8 # 0x8
+; [2] __ARRAY_SIZE_TYPE__, int, size=4 bytes, unsigned, 32 bits
+; CHECK-NEXT:        .long 15 # BTF_KIND_INT(id = 2)
+; CHECK-NEXT:        .long 16777216 # 0x1000000
+; CHECK-NEXT:        .long 4
+; CHECK-NEXT:        .long 32 # 0x20
+; [3] array, type=__BYTE_TYPE__, index_type=__ARRAY_SIZE_TYPE__, nelems=4
+; CHECK-NEXT:        .long 0 # BTF_KIND_ARRAY(id = 3)
+; CHECK-NEXT:        .long 50331648 # 0x3000000
+; CHECK-NEXT:        .long 0
+; CHECK-NEXT:        .long 1
+; CHECK-NEXT:        .long 2
+; CHECK-NEXT:        .long 4
+; [4] a, var, type=__BYTE_TYPE__[4], global
+; CHECK-NEXT:        .long 35 # BTF_KIND_VAR(id = 4)
+; CHECK-NEXT:        .long 234881024 # 0xe000000
+; CHECK-NEXT:        .long 3
+; CHECK-NEXT:        .long 1
+; [5] .bss, datasec, 1 var, {a, offset=&a, size=4 bytes}
+; CHECK-NEXT:        .long 37 # BTF_KIND_DATASEC(id = 5)
+; CHECK-NEXT:        .long 251658241 # 0xf000001
+; CHECK-NEXT:        .long 0
+; CHECK-NEXT:        .long 4
+; CHECK-NEXT:        .long a
+; CHECK-NEXT:        .long 4
+; CHECK-NEXT:        .byte 0 # string offset=0
+; CHECK-NEXT:        .ascii "__BYTE_TYPE__" # string offset=1
+; CHECK-NEXT:        .byte 0
+; CHECK-NEXT:        .ascii "__ARRAY_SIZE_TYPE__" # string offset=15
+; CHECK-NEXT:        .byte 0
+; CHECK-NEXT:        .byte 97 # string offset=35
+; CHECK-NEXT:        .byte 0
+; CHECK-NEXT:        .ascii ".bss" # string offset=37
+; 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 "}