[BPF] Don't fetch alignment of llvm.preserve.union.access.index argument

[nikic]

Summary

The way the alignment is determined here is not compatible with opaque pointers -- we'd have to thread it through using either align or elementtype attributes.

However, as far as I can tell this alignment is actually never used for this particular intrinsic, so I've dropped the assignment entirely and converted RecordAlignment to MaybeAlign, so we get an assertion failure if it does end up being used.

[yonghong-song]

Indeed, alignment is not used for union type. Your change looks good to me.

llvm/lib/Target/BPF/BPFAbstractMemberAccess.cpp

 public:
   BPFAbstractMemberAccess(BPFTargetMachine *TM) : TM(TM) {}
 
   bool run(Function &F);
 
   struct CallInfo {
     uint32_t Kind;
     uint32_t AccessIndex;
-    Align RecordAlignment;
+    MaybeAlign RecordAlignment;
     MDNode *Metadata;
     Value *Base;
   };
   typedef std::stack<std::pair<CallInst *, CallInfo>> CallInfoStack;
 
 private:
   enum : uint32_t {
     BPFPreserveArrayAI = 1,
private:
   bool removePreserveAccessIndexIntrinsic(Function &F);
   void replaceWithGEP(std::vector<CallInst *> &CallList,
                       uint32_t NumOfZerosIndex, uint32_t DIIndex);
   bool HasPreserveFieldInfoCall(CallInfoStack &CallStack);
   void GetStorageBitRange(DIDerivedType *MemberTy, Align RecordAlignment,
                           uint32_t &StartBitOffset, uint32_t &EndBitOffset);
   uint32_t GetFieldInfo(uint32_t InfoKind, DICompositeType *CTy,
                         uint32_t AccessIndex, uint32_t PatchImm,
-                        Align RecordAlignment);
+                        MaybeAlign RecordAlignment);
 
   Value *computeBaseAndAccessKey(CallInst *Call, CallInfo &CInfo,
                                  std::string &AccessKey, MDNode *&BaseMeta);
   MDNode *computeAccessKey(CallInst *Call, CallInfo &CInfo,
                            std::string &AccessKey, bool &IsInt32Ret);
   uint64_t getConstant(const Value *IndexValue);
   bool transformGEPChain(CallInst *Call, CallInfo &CInfo);
 };
bool BPFAbstractMemberAccess::IsPreserveDIAccessIndexCall(const CallInst *Call,
   }
   if (GV->getName().startswith("llvm.preserve.union.access.index")) {
     CInfo.Kind = BPFPreserveUnionAI;
     CInfo.Metadata = Call->getMetadata(LLVMContext::MD_preserve_access_index);
     if (!CInfo.Metadata)
       report_fatal_error("Missing metadata for llvm.preserve.union.access.index intrinsic");
     CInfo.AccessIndex = getConstant(Call->getArgOperand(1));
     CInfo.Base = Call->getArgOperand(0);
-    CInfo.RecordAlignment =
-        DL->getABITypeAlign(CInfo.Base->getType()->getPointerElementType());
     return true;
   }
   if (GV->getName().startswith("llvm.preserve.struct.access.index")) {
     CInfo.Kind = BPFPreserveStructAI;
     CInfo.Metadata = Call->getMetadata(LLVMContext::MD_preserve_access_index);
     if (!CInfo.Metadata)
       report_fatal_error("Missing metadata for llvm.preserve.struct.access.index intrinsic");
     CInfo.AccessIndex = getConstant(Call->getArgOperand(2));
report_fatal_error("Unsupported field expression for llvm.bpf.preserve.field.info, "
                        "cross alignment boundary");
   EndBitOffset = StartBitOffset + AlignBits;
 }
 
 uint32_t BPFAbstractMemberAccess::GetFieldInfo(uint32_t InfoKind,
                                                DICompositeType *CTy,
                                                uint32_t AccessIndex,
                                                uint32_t PatchImm,
-                                               Align RecordAlignment) {
+                                               MaybeAlign RecordAlignment) {
   if (InfoKind == BPFCoreSharedInfo::FIELD_EXISTENCE)
       return 1;
 
   uint32_t Tag = CTy->getTag();
   if (InfoKind == BPFCoreSharedInfo::FIELD_BYTE_OFFSET) {
     if (Tag == dwarf::DW_TAG_array_type) {
       auto *EltTy = stripQualifiers(CTy->getBaseType());
       PatchImm += AccessIndex * calcArraySize(CTy, 1) *
                   (EltTy->getSizeInBits() >> 3);
     } else if (Tag == dwarf::DW_TAG_structure_type) {
       auto *MemberTy = cast<DIDerivedType>(CTy->getElements()[AccessIndex]);
       if (!MemberTy->isBitField()) {
         PatchImm += MemberTy->getOffsetInBits() >> 3;
       } else {
         unsigned SBitOffset, NextSBitOffset;
-        GetStorageBitRange(MemberTy, RecordAlignment, SBitOffset,
+        GetStorageBitRange(MemberTy, *RecordAlignment, SBitOffset,
                            NextSBitOffset);
         PatchImm += SBitOffset >> 3;
       }
     }
     return PatchImm;
   }
 
   if (InfoKind == BPFCoreSharedInfo::FIELD_BYTE_SIZE) {
     if (Tag == dwarf::DW_TAG_array_type) {
       auto *EltTy = stripQualifiers(CTy->getBaseType());
       return calcArraySize(CTy, 1) * (EltTy->getSizeInBits() >> 3);
     } else {
       auto *MemberTy = cast<DIDerivedType>(CTy->getElements()[AccessIndex]);
       uint32_t SizeInBits = MemberTy->getSizeInBits();
       if (!MemberTy->isBitField())
         return SizeInBits >> 3;
 
       unsigned SBitOffset, NextSBitOffset;
-      GetStorageBitRange(MemberTy, RecordAlignment, SBitOffset, NextSBitOffset);
+      GetStorageBitRange(MemberTy, *RecordAlignment, SBitOffset,
+                         NextSBitOffset);
       SizeInBits = NextSBitOffset - SBitOffset;
       if (SizeInBits & (SizeInBits - 1))
         report_fatal_error("Unsupported field expression for llvm.bpf.preserve.field.info");
       return SizeInBits >> 3;
     }
   }
 
   if (InfoKind == BPFCoreSharedInfo::FIELD_SIGNEDNESS) {
if (InfoKind == BPFCoreSharedInfo::FIELD_LSHIFT_U64) {
 
     if (!IsBitField) {
       if (SizeInBits > 64)
         report_fatal_error("too big field size for llvm.bpf.preserve.field.info");
       return 64 - SizeInBits;
     }
 
     unsigned SBitOffset, NextSBitOffset;
-    GetStorageBitRange(MemberTy, RecordAlignment, SBitOffset, NextSBitOffset);
+    GetStorageBitRange(MemberTy, *RecordAlignment, SBitOffset, NextSBitOffset);
     if (NextSBitOffset - SBitOffset > 64)
       report_fatal_error("too big field size for llvm.bpf.preserve.field.info");
 
     unsigned OffsetInBits = MemberTy->getOffsetInBits();
     if (Triple.getArch() == Triple::bpfel)
       return SBitOffset + 64 - OffsetInBits - SizeInBits;
     else
       return OffsetInBits + 64 - NextSBitOffset;
if (InfoKind == BPFCoreSharedInfo::FIELD_RSHIFT_U64) {
 
     if (!IsBitField) {
       if (SizeInBits > 64)
         report_fatal_error("too big field size for llvm.bpf.preserve.field.info");
       return 64 - SizeInBits;
     }
 
     unsigned SBitOffset, NextSBitOffset;
-    GetStorageBitRange(MemberTy, RecordAlignment, SBitOffset, NextSBitOffset);
+    GetStorageBitRange(MemberTy, *RecordAlignment, SBitOffset, NextSBitOffset);
     if (NextSBitOffset - SBitOffset > 64)
       report_fatal_error("too big field size for llvm.bpf.preserve.field.info");
 
     return 64 - SizeInBits;
   }
 
   llvm_unreachable("Unknown llvm.bpf.preserve.field.info info kind");
 }