[BPF] Generate array dimension size properly for zero-size elements

[yonghong-song]

Summary

Currently, if an array element type size is 0, the number of
array elements will be set to 0, regardless of what user
specified. This implementation is done in the beginning where
BTF is mostly used to calculate the member offset.

For example,

struct s {}; 
struct s1 {
      int b;
      struct s a[2];
};  
struct s1 s1;

The BTF will have struct "s1" member "a" with element count 0.

Now BTF types are used for compile-once and run-everywhere
relocations and we need more precise type representation
for type comparison. Andrii reported the issue as there
are differences between original structure and BTF-generated
structure.

This patch made the change to correctly assign "2"
as the number elements of member "a".
Some dead codes related to ElemSize compuation are also removed.

[anakryiko]

Looks good, thanks for fixing so fast!

llvm/trunk/lib/Target/BPF/BTFDebug.cpp

void BTFDebug::visitStructType(const DICompositeType *CTy, bool IsStruct,
 
   // Visit all struct members.
   for (const auto *Element : Elements)
     visitTypeEntry(cast<DIDerivedType>(Element));
 }
 
 void BTFDebug::visitArrayType(const DICompositeType *CTy, uint32_t &TypeId) {
   // Visit array element type.
-  uint32_t ElemTypeId, ElemSize;
+  uint32_t ElemTypeId;
   const DIType *ElemType = CTy->getBaseType();
   visitTypeEntry(ElemType, ElemTypeId, false, false);
 
-  // Strip qualifiers from element type to get accurate element size.
-  ElemSize = ElemType->getSizeInBits() >> 3;
-
-  if (!CTy->getSizeInBits()) {
-    auto TypeEntry = std::make_unique<BTFTypeArray>(ElemTypeId, 0);
-    ElemTypeId = addType(std::move(TypeEntry), CTy);
-  } else {
-    // 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]))
-        if (Element->getTag() == dwarf::DW_TAG_subrange_type) {
-          const DISubrange *SR = cast<DISubrange>(Element);
-          auto *CI = SR->getCount().dyn_cast<ConstantInt *>();
-          int64_t Count = CI->getSExtValue();
 
-          auto TypeEntry =
-              std::make_unique<BTFTypeArray>(ElemTypeId, Count);
-          if (I == 0)
-            ElemTypeId = addType(std::move(TypeEntry), CTy);
-          else
-            ElemTypeId = addType(std::move(TypeEntry));
-          ElemSize = ElemSize * Count;
-        }
+        // For struct s { int b; char c[]; }, the c[] will be represented
+        // as an array with Count = -1.
+            std::make_unique<BTFTypeArray>(ElemTypeId,
+                Count >= 0 ? Count : 0);
       }
   }
 
   // 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) {

llvm/trunk/test/CodeGen/BPF/BTF/array-size-0.ll

 ; CHECK-NEXT:        .long   1                       # BTF_KIND_STRUCT(id = 1)
 ; CHECK-NEXT:        .long   67108864                # 0x4000000
 ; CHECK-NEXT:        .long   0
 ; CHECK-NEXT:        .long   0                       # BTF_KIND_ARRAY(id = 2)
 ; CHECK-NEXT:        .long   50331648                # 0x3000000
 ; CHECK-NEXT:        .long   0
 ; CHECK-NEXT:        .long   1
 ; CHECK-NEXT:        .long   3
-; CHECK-NEXT:        .long   0
+; CHECK-NEXT:        .long   10
 ; CHECK-NEXT:        .long   3                       # BTF_KIND_INT(id = 3)
 ; CHECK-NEXT:        .long   16777216                # 0x1000000
 ; CHECK-NEXT:        .long   4
 ; CHECK-NEXT:        .long   32                      # 0x20
 ; CHECK-NEXT:        .byte   0                       # string offset=0
 ; CHECK-NEXT:        .byte   116                     # string offset=1
 ; CHECK-NEXT:        .byte   0
 ; CHECK-NEXT:        .ascii  "__ARRAY_SIZE_TYPE__"   # string offset=3