[OpaquePtr] Use ArgListEntry indirect types more in ISel lowering

[aeubanks]

Summary

To avoid calling PointerType::getElementType().

Without also examining the callee in Call->getParam*Type(), we may end
up seeing that we have a byval attribute on the callee, but only looking
at the caller argument attributes which could be missing the byval
attribute.

[dblaikie]

llvm/include/llvm/IR/InstrTypes.h

1746–1747

When does the 'Ty' come back as null? Would that only be it older bitcode, that should be auto-upgraded when loading?

[aeubanks]

assume indirectly passed types are always available

[aeubanks]

llvm/include/llvm/IR/InstrTypes.h

1746–1747

ah you're right
there was one test that was failing when assuming the type was never null, turns out we need to check more closely for these attributes on the arguments, some tests were missing that: https://reviews.llvm.org/D101725

[dblaikie]

Looks good, contingent on D101725, thanks!

[aeubanks]

rebase

[aeubanks]

rebase
check callee for byval/preallocated/inalloca type

[aeubanks]

rebase

[rupprecht]

I don't see any messages in the reverts, but this change caused crashes both times it landed, in case that wasn't already the reason that it was reverted each time.

[aeubanks]

This was landed at some point

llvm/include/llvm/CodeGen/TargetLowering.h

public:
     bool IsInAlloca : 1;
     bool IsPreallocated : 1;
     bool IsReturned : 1;
     bool IsSwiftSelf : 1;
     bool IsSwiftError : 1;
     bool IsCFGuardTarget : 1;
     MaybeAlign Alignment = None;
     Type *ByValType = nullptr;
+    Type *InAllocaType = nullptr;
     Type *PreallocatedType = nullptr;
 
     ArgListEntry()
         : IsSExt(false), IsZExt(false), IsInReg(false), IsSRet(false),
           IsNest(false), IsByVal(false), IsByRef(false), IsInAlloca(false),
           IsPreallocated(false), IsReturned(false), IsSwiftSelf(false),
           IsSwiftError(false), IsCFGuardTarget(false) {}
 

llvm/include/llvm/IR/InstrTypes.h

public:
   }
 
   /// Extract the byval type for a call or parameter.
   Type *getParamByValType(unsigned ArgNo) const {
     Type *Ty = Attrs.getParamByValType(ArgNo);
     return Ty ? Ty : getArgOperand(ArgNo)->getType()->getPointerElementType();
   }
 
+  /// Extract the inalloca type for a call or parameter.
+  Type *getParamInAllocaType(unsigned ArgNo) const {
+    Type *Ty = Attrs.getParamInAllocaType(ArgNo);
+    return Ty ? Ty : getArgOperand(ArgNo)->getType()->getPointerElementType();
+  }
+
   /// Extract the preallocated type for a call or parameter.
   Type *getParamPreallocatedType(unsigned ArgNo) const {
     Type *Ty = Attrs.getParamPreallocatedType(ArgNo);
     return Ty ? Ty : getArgOperand(ArgNo)->getType()->getPointerElementType();
   }
 
   /// Extract the number of dereferenceable bytes for a call or
   /// parameter (0=unknown).

llvm/lib/CodeGen/SelectionDAG/FastISel.cpp

for (unsigned I = 0, E = RetTys.size(); I != E; ++I) {
     }
   }
 
   // Handle all of the outgoing arguments.
   CLI.clearOuts();
   for (auto &Arg : CLI.getArgs()) {
     Type *FinalType = Arg.Ty;
     if (Arg.IsByVal)
-      FinalType = cast<PointerType>(Arg.Ty)->getElementType();
+      FinalType = Arg.ByValType;
     bool NeedsRegBlock = TLI.functionArgumentNeedsConsecutiveRegisters(
         FinalType, CLI.CallConv, CLI.IsVarArg);
 
     ISD::ArgFlagsTy Flags;
     if (Arg.IsZExt)
       Flags.setZExt();
     if (Arg.IsSExt)
       Flags.setSExt();
if (Arg.IsPreallocated) {
       // preallocated. This way we can know how many bytes we should've
       // allocated and how many bytes a callee cleanup function will pop.  If we
       // port preallocated to more targets, we'll have to add custom
       // preallocated handling in the various CC lowering callbacks.
       Flags.setByVal();
     }
     MaybeAlign MemAlign = Arg.Alignment;
     if (Arg.IsByVal || Arg.IsInAlloca || Arg.IsPreallocated) {
-      PointerType *Ty = cast<PointerType>(Arg.Ty);
-      Type *ElementTy = Ty->getElementType();
+      Type *ElementTy;
+      if (Arg.IsByVal)
+        ElementTy = Arg.ByValType;
+      else if (Arg.IsInAlloca)
+        ElementTy = Arg.InAllocaType;
+      else
+        ElementTy = Arg.PreallocatedType;
+      assert(ElementTy && "Indirect type not set in ArgListEntry");
+
       unsigned FrameSize =
           DL.getTypeAllocSize(Arg.ByValType ? Arg.ByValType : ElementTy);
 
       // For ByVal, alignment should come from FE. BE will guess if this info
       // is not there, but there are cases it cannot get right.
       if (!MemAlign)
         MemAlign = Align(TLI.getByValTypeAlignment(ElementTy, DL));
       Flags.setByValSize(FrameSize);

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

TargetLowering::LowerCallTo(TargetLowering::CallLoweringInfo &CLI) const {
   // Handle all of the outgoing arguments.
   CLI.Outs.clear();
   CLI.OutVals.clear();
   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
     SmallVector<EVT, 4> ValueVTs;
     ComputeValueVTs(*this, DL, Args[i].Ty, ValueVTs);
     // FIXME: Split arguments if CLI.IsPostTypeLegalization
     Type *FinalType = Args[i].Ty;
-    if (Args[i].IsByVal)
-      FinalType = cast<PointerType>(Args[i].Ty)->getElementType();
+    if (Args[i].ByValType)
+      FinalType = Args[i].ByValType;
     bool NeedsRegBlock = functionArgumentNeedsConsecutiveRegisters(
         FinalType, CLI.CallConv, CLI.IsVarArg);
     for (unsigned Value = 0, NumValues = ValueVTs.size(); Value != NumValues;
          ++Value) {
       EVT VT = ValueVTs[Value];
       Type *ArgTy = VT.getTypeForEVT(CLI.RetTy->getContext());
       SDValue Op = SDValue(Args[i].Node.getNode(),
                            Args[i].Node.getResNo() + Value);
for (unsigned Value = 0, NumValues = ValueVTs.size(); Value != NumValues;
         // inalloca.  This way we can know how many bytes we should've allocated
         // and how many bytes a callee cleanup function will pop.  If we port
         // inalloca to more targets, we'll have to add custom inalloca handling
         // in the various CC lowering callbacks.
         Flags.setByVal();
       }
       Align MemAlign;
       if (Args[i].IsByVal || Args[i].IsInAlloca || Args[i].IsPreallocated) {
-        PointerType *Ty = cast<PointerType>(Args[i].Ty);
-        Type *ElementTy = Ty->getElementType();
+        Type *ElementTy;
+        if (Args[i].IsByVal)
+          ElementTy = Args[i].ByValType;
+        else if (Args[i].IsInAlloca)
+          ElementTy = Args[i].InAllocaType;
+        else
+          ElementTy = Args[i].PreallocatedType;
+        assert(ElementTy && "Indirect type not set in ArgListEntry");
 
         unsigned FrameSize = DL.getTypeAllocSize(
             Args[i].ByValType ? Args[i].ByValType : ElementTy);
         Flags.setByValSize(FrameSize);
 
         // info is not there but there are cases it cannot get right.
         if (auto MA = Args[i].Alignment)
           MemAlign = *MA;

llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp

void TargetLoweringBase::ArgListEntry::setAttributes(const CallBase *Call,
   IsSwiftError = Call->paramHasAttr(ArgIdx, Attribute::SwiftError);
   Alignment = Call->getParamStackAlign(ArgIdx);
   ByValType = nullptr;
   if (IsByVal) {
     ByValType = Call->getParamByValType(ArgIdx);
     if (!Alignment)
       Alignment = Call->getParamAlign(ArgIdx);
   }
+  InAllocaType = nullptr;
+  if (IsInAlloca)
+    InAllocaType = Call->getParamInAllocaType(ArgIdx);
   PreallocatedType = nullptr;
   if (IsPreallocated)
     PreallocatedType = Call->getParamPreallocatedType(ArgIdx);
 }
 
 /// Generate a libcall taking the given operands as arguments and returning a
 /// result of type RetVT.
 std::pair<SDValue, SDValue>