include/llvm/CodeGen/FastISel.h

@@ -41,11 +41,13 @@ class FastISel {
     bool IsInAlloca : 1;
     bool IsReturned : 1;
     uint16_t Alignment;
+    uint64_t IndirectSize;
 
     ArgListEntry()
         : Val(nullptr), Ty(nullptr), IsSExt(false), IsZExt(false),
           IsInReg(false), IsSRet(false), IsNest(false), IsByVal(false),
-          IsInAlloca(false), IsReturned(false), Alignment(0) {}
+          IsInAlloca(false), IsReturned(false), Alignment(0),
+          IndirectSize(0) {}
 
     /// \brief Set CallLoweringInfo attribute flags based on a call instruction
     /// and called function attributes.

include/llvm/IR/Attributes.h

@@ -32,8 +32,10 @@ class AttributeImpl;
 class AttributeSetImpl;
 class AttributeSetNode;
 class Constant;
+class DataLayout;
 template<typename T> struct DenseMapInfo;
 class Function;
+class FunctionType;
 class LLVMContext;
 class Type;
 
@@ -267,6 +269,33 @@ class AttributeSet {
   AttributeSet addDereferenceableOrNullAttr(LLVMContext &C, unsigned Index,
                                             uint64_t Bytes) const;
 
+  /// \brief Add dereferenceable(sizeof(T)) and align(alignof(T))
+  /// attributes to each T* byval or inalloca argument.
+  /// Because attribute sets are immutable, this returns a new set.
+  template <typename ArgTypesIter>
+  AttributeSet fixupSizeAndAlignForIndirectAttrs(ArgTypesIter ArgTypes,
+                                                 const DataLayout *DL) const {
+    AttributeSet NewAttrs = *this;
+    // We require a DataLayout to perform any fixups.
+    if (!DL)
+      return NewAttrs;
+
+    unsigned AttrIdx = 1;
+    for (Type *ArgTy : ArgTypes) {
+      if (hasAttribute(AttrIdx, Attribute::ByVal) ||
+          hasAttribute(AttrIdx, Attribute::InAlloca))
+        NewAttrs = NewAttrs.fixupSizeAndAlignForIndirectAttr(AttrIdx, ArgTy, *DL);
+      ++AttrIdx;
+    }
+    return NewAttrs;
+  }
+
+  /// \brief Add dereferenceable(sizeof(T)) and align(alignof(T)) attributes
+  /// to the T* byval or inalloca argument at the given index.
+  /// Because attribute sets are immutable, this returns a new set.
+  AttributeSet fixupSizeAndAlignForIndirectAttr(unsigned Index, Type *Ty,
+                                                const DataLayout &DL) const;
+
   //===--------------------------------------------------------------------===//
   // AttributeSet Accessors
   //===--------------------------------------------------------------------===//

include/llvm/IR/Function.h

@@ -81,6 +81,7 @@ class Function : public GlobalObject, public ilist_node<Function> {
   }
 
   friend class SymbolTableListTraits<Function>;
+  friend class Module;
 
   void setParent(Module *parent);
 
@@ -165,7 +166,7 @@ class Function : public GlobalObject, public ilist_node<Function> {
   AttributeSet getAttributes() const { return AttributeSets; }
 
   /// @brief Set the attribute list for this Function.
-  void setAttributes(AttributeSet attrs) { AttributeSets = attrs; }
+  void setAttributes(AttributeSet attrs);
 
   /// @brief Add function attributes to this function.
   void addFnAttr(Attribute::AttrKind N) {

include/llvm/IR/Instruction.h

@@ -511,6 +511,8 @@ class Instruction : public User,
   }
 
   friend class SymbolTableListTraits<Instruction>;
+  friend class BasicBlock;
+  friend class Function;
   void setParent(BasicBlock *P);
 protected:
   // Instruction subclasses can stick up to 15 bits of stuff into the

include/llvm/IR/Instructions.h

@@ -1605,7 +1605,7 @@ class CallInst : public Instruction,
 
   /// setAttributes - Set the parameter attributes for this call.
   ///
-  void setAttributes(const AttributeSet &Attrs) { AttributeList = Attrs; }
+  void setAttributes(const AttributeSet &Attrs);
 
   /// addAttribute - adds the attribute to the list of attributes.
   void addAttribute(unsigned i, Attribute::AttrKind attr);
@@ -1654,21 +1654,15 @@ class CallInst : public Instruction,
   bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind A) const;
 
   /// \brief Extract the alignment for a call or parameter (0=unknown).
-  unsigned getParamAlignment(unsigned i) const {
-    return AttributeList.getParamAlignment(i);
-  }
+  unsigned getParamAlignment(unsigned i) const;
 
   /// \brief Extract the number of dereferenceable bytes for a call or
   /// parameter (0=unknown).
-  uint64_t getDereferenceableBytes(unsigned i) const {
-    return AttributeList.getDereferenceableBytes(i);
-  }
+  uint64_t getDereferenceableBytes(unsigned i) const;
 
   /// \brief Extract the number of dereferenceable_or_null bytes for a call or
   /// parameter (0=unknown).
-  uint64_t getDereferenceableOrNullBytes(unsigned i) const {
-    return AttributeList.getDereferenceableOrNullBytes(i);
-  }
+  uint64_t getDereferenceableOrNullBytes(unsigned i) const;
 
   /// @brief Determine if the parameter or return value is marked with NoAlias
   /// attribute.
@@ -3529,7 +3523,7 @@ class InvokeInst : public TerminatorInst,
 
   /// setAttributes - Set the parameter attributes for this invoke.
   ///
-  void setAttributes(const AttributeSet &Attrs) { AttributeList = Attrs; }
+  void setAttributes(const AttributeSet &Attrs);
 
   /// addAttribute - adds the attribute to the list of attributes.
   void addAttribute(unsigned i, Attribute::AttrKind attr);
@@ -3576,21 +3570,15 @@ class InvokeInst : public TerminatorInst,
   bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind A) const;
 
   /// \brief Extract the alignment for a call or parameter (0=unknown).
-  unsigned getParamAlignment(unsigned i) const {
-    return AttributeList.getParamAlignment(i);
-  }
+  unsigned getParamAlignment(unsigned i) const;
 
   /// \brief Extract the number of dereferenceable bytes for a call or
   /// parameter (0=unknown).
-  uint64_t getDereferenceableBytes(unsigned i) const {
-    return AttributeList.getDereferenceableBytes(i);
-  }
+  uint64_t getDereferenceableBytes(unsigned i) const;
 
   /// \brief Extract the number of dereferenceable_or_null bytes for a call or
   /// parameter (0=unknown).
-  uint64_t getDereferenceableOrNullBytes(unsigned i) const {
-    return AttributeList.getDereferenceableOrNullBytes(i);
-  }
+  uint64_t getDereferenceableOrNullBytes(unsigned i) const;
 
   /// @brief Determine if the parameter or return value is marked with NoAlias
   /// attribute.

include/llvm/Target/TargetLowering.h

@@ -746,11 +746,6 @@ class TargetLoweringBase {
     return getValueType(DL, Ty, AllowUnknown).getSimpleVT();
   }
 
-  /// Return the desired alignment for ByVal or InAlloca aggregate function
-  /// arguments in the caller parameter area.  This is the actual alignment, not
-  /// its logarithm.
-  virtual unsigned getByValTypeAlignment(Type *Ty, const DataLayout &DL) const;
-
   /// Return the type of registers that this ValueType will eventually require.
   MVT getRegisterType(MVT VT) const {
     assert((unsigned)VT.SimpleTy < array_lengthof(RegisterTypeForVT));
@@ -2323,10 +2318,11 @@ class TargetLowering : public TargetLoweringBase {
     bool isInAlloca : 1;
     bool isReturned : 1;
     uint16_t Alignment;
+    uint64_t IndirectSize;
 
     ArgListEntry() : isSExt(false), isZExt(false), isInReg(false),
       isSRet(false), isNest(false), isByVal(false), isInAlloca(false),
-      isReturned(false), Alignment(0) { }
+      isReturned(false), Alignment(0), IndirectSize(0) { }
 
     void setAttributes(ImmutableCallSite *CS, unsigned AttrIdx);
   };

lib/Analysis/MemoryBuiltins.cpp

@@ -448,8 +448,7 @@ SizeOffsetType ObjectSizeOffsetVisitor::visitArgument(Argument &A) {
     ++ObjectVisitorArgument;
     return unknown();
   }
-  PointerType *PT = cast<PointerType>(A.getType());
-  APInt Size(IntTyBits, DL.getTypeAllocSize(PT->getPointerElementType()));
+  APInt Size(IntTyBits, A.getDereferenceableBytes());
   return std::make_pair(align(Size, A.getParamAlignment()), Zero);
 }
 

lib/Analysis/ValueTracking.cpp

@@ -1573,17 +1573,13 @@ static unsigned getAlignment(const Value *V, const DataLayout &DL) {
       }
     }
   } else if (const Argument *A = dyn_cast<Argument>(V)) {
-    Align = A->getType()->isPointerTy() ? A->getParamAlignment() : 0;
-
-    if (!Align && A->hasStructRetAttr()) {
-      // An sret parameter has at least the ABI alignment of the return type.
-      Type *EltTy = cast<PointerType>(A->getType())->getPointerElementType();
-      if (EltTy->isSized())
-        Align = DL.getABITypeAlignment(EltTy);
-    }
-  } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(V))
+    if (A->getType()->isPointerTy())
+      Align = A->getParamAlignment();
+  } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
     Align = AI->getAlignment();
-  else if (auto CS = ImmutableCallSite(V))
+    if (Align == 0)
+      Align = DL.getABITypeAlignment(AI->getAllocatedType());
+  } else if (auto CS = ImmutableCallSite(V))
     Align = CS.getAttributes().getParamAlignment(AttributeSet::ReturnIndex);
   else if (const LoadInst *LI = dyn_cast<LoadInst>(V))
     if (MDNode *MD = LI->getMetadata(LLVMContext::MD_align)) {
@@ -3173,12 +3169,8 @@ static bool isAligned(const Value *Base, APInt Offset, unsigned Align,
                       const DataLayout &DL) {
   APInt BaseAlign(Offset.getBitWidth(), getAlignment(Base, DL));
 
-  if (!BaseAlign) {
-    Type *Ty = cast<PointerType>(Base->getType())->getPointerElementType();
-    if (!Ty->isSized())
-      return false;
-    BaseAlign = DL.getABITypeAlignment(Ty);
-  }
+  if (!BaseAlign)
+    return false;
 
   APInt Alignment(Offset.getBitWidth(), Align);
 

lib/CodeGen/SelectionDAG/FastISel.cpp

@@ -89,6 +89,7 @@ void FastISel::ArgListEntry::setAttributes(ImmutableCallSite *CS,
   IsInAlloca = CS->paramHasAttr(AttrIdx, Attribute::InAlloca);
   IsReturned = CS->paramHasAttr(AttrIdx, Attribute::Returned);
   Alignment = CS->getParamAlignment(AttrIdx);
+  IndirectSize = CS->getDereferenceableBytes(AttrIdx);
 }
 
 /// Set the current block to which generated machine instructions will be
@@ -948,11 +949,10 @@ bool FastISel::lowerCallTo(CallLoweringInfo &CLI) {
   // 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)->getPointerElementType();
-    bool NeedsRegBlock = TLI.functionArgumentNeedsConsecutiveRegisters(
-        FinalType, CLI.CallConv, CLI.IsVarArg);
+    bool NeedsRegBlock = false;
+    if (!Arg.IsByVal)
+      NeedsRegBlock = TLI.functionArgumentNeedsConsecutiveRegisters(
+          Arg.Ty, CLI.CallConv, CLI.IsVarArg);
 
     ISD::ArgFlagsTy Flags;
     if (Arg.IsZExt)
@@ -975,16 +975,8 @@ bool FastISel::lowerCallTo(CallLoweringInfo &CLI) {
       Flags.setByVal();
     }
     if (Arg.IsByVal || Arg.IsInAlloca) {
-      PointerType *Ty = cast<PointerType>(Arg.Ty);
-      Type *ElementTy = Ty->getPointerElementType();
-      unsigned FrameSize = DL.getTypeAllocSize(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.
-      unsigned FrameAlign = Arg.Alignment;
-      if (!FrameAlign)
-        FrameAlign = TLI.getByValTypeAlignment(ElementTy, DL);
-      Flags.setByValSize(FrameSize);
-      Flags.setByValAlign(FrameAlign);
+      Flags.setByValSize(Arg.IndirectSize);
+      Flags.setByValAlign(Arg.Alignment);
     }
     if (Arg.IsNest)
       Flags.setNest();

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

@@ -7101,11 +7101,12 @@ TargetLowering::LowerCallTo(TargetLowering::CallLoweringInfo &CLI) const {
   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
     SmallVector<EVT, 4> ValueVTs;
     ComputeValueVTs(*this, DL, Args[i].Ty, ValueVTs);
-    Type *FinalType = Args[i].Ty;
-    if (Args[i].isByVal)
-      FinalType = cast<PointerType>(Args[i].Ty)->getPointerElementType();
-    bool NeedsRegBlock = functionArgumentNeedsConsecutiveRegisters(
-        FinalType, CLI.CallConv, CLI.IsVarArg);
+
+    bool NeedsRegBlock = false;
+    if (!Args[i].isByVal)
+      NeedsRegBlock = functionArgumentNeedsConsecutiveRegisters(
+          Args[i].Ty, CLI.CallConv, CLI.IsVarArg);
+
     for (unsigned Value = 0, NumValues = ValueVTs.size(); Value != NumValues;
          ++Value) {
       EVT VT = ValueVTs[Value];
@@ -7135,17 +7136,8 @@ TargetLowering::LowerCallTo(TargetLowering::CallLoweringInfo &CLI) const {
         Flags.setByVal();
       }
       if (Args[i].isByVal || Args[i].isInAlloca) {
-        PointerType *Ty = cast<PointerType>(Args[i].Ty);
-        Type *ElementTy = Ty->getPointerElementType();
-        Flags.setByValSize(DL.getTypeAllocSize(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.
-        unsigned FrameAlign;
-        if (Args[i].Alignment)
-          FrameAlign = Args[i].Alignment;
-        else
-          FrameAlign = getByValTypeAlignment(ElementTy, DL);
-        Flags.setByValAlign(FrameAlign);
+        Flags.setByValSize(Args[i].IndirectSize);
+        Flags.setByValAlign(Args[i].Alignment);
       }
       if (Args[i].isNest)
         Flags.setNest();
@@ -7383,11 +7375,12 @@ void SelectionDAGISel::LowerArguments(const Function &F) {
     ComputeValueVTs(*TLI, DAG.getDataLayout(), I->getType(), ValueVTs);
     bool isArgValueUsed = !I->use_empty();
     unsigned PartBase = 0;
-    Type *FinalType = I->getType();
-    if (F.getAttributes().hasAttribute(Idx, Attribute::ByVal))
-      FinalType = cast<PointerType>(FinalType)->getPointerElementType();
-    bool NeedsRegBlock = TLI->functionArgumentNeedsConsecutiveRegisters(
-        FinalType, F.getCallingConv(), F.isVarArg());
+
+    bool NeedsRegBlock = false;
+    if (!F.getAttributes().hasAttribute(Idx, Attribute::ByVal))
+      NeedsRegBlock = TLI->functionArgumentNeedsConsecutiveRegisters(
+        I->getType(), F.getCallingConv(), F.isVarArg());
+
     for (unsigned Value = 0, NumValues = ValueVTs.size();
          Value != NumValues; ++Value) {
       EVT VT = ValueVTs[Value];
@@ -7420,17 +7413,8 @@ void SelectionDAGISel::LowerArguments(const Function &F) {
           Flags.setByVal();
       }
       if (Flags.isByVal() || Flags.isInAlloca()) {
-        PointerType *Ty = cast<PointerType>(I->getType());
-        Type *ElementTy = Ty->getPointerElementType();
-        Flags.setByValSize(DL.getTypeAllocSize(ElementTy));
-        // For ByVal, alignment should be passed from FE.  BE will guess if
-        // this info is not there but there are cases it cannot get right.
-        unsigned FrameAlign;
-        if (F.getParamAlignment(Idx))
-          FrameAlign = F.getParamAlignment(Idx);
-        else
-          FrameAlign = TLI->getByValTypeAlignment(ElementTy, DL);
-        Flags.setByValAlign(FrameAlign);
+        Flags.setByValSize(F.getDereferenceableBytes(Idx));
+        Flags.setByValAlign(F.getParamAlignment(Idx));
       }
       if (F.getAttributes().hasAttribute(Idx, Attribute::Nest))
         Flags.setNest();

lib/CodeGen/SelectionDAG/TargetLowering.cpp

@@ -78,6 +78,7 @@ void TargetLowering::ArgListEntry::setAttributes(ImmutableCallSite *CS,
   isInAlloca = CS->paramHasAttr(AttrIdx, Attribute::InAlloca);
   isReturned = CS->paramHasAttr(AttrIdx, Attribute::Returned);
   Alignment  = CS->getParamAlignment(AttrIdx);
+  IndirectSize = CS->getDereferenceableBytes(AttrIdx);
 }
 
 /// Generate a libcall taking the given operands as arguments and returning a

lib/CodeGen/TargetLoweringBase.cpp

@@ -1523,14 +1523,6 @@ void llvm::GetReturnInfo(Type *ReturnType, AttributeSet attr,
   }
 }
 
-/// getByValTypeAlignment - Return the desired alignment for ByVal aggregate
-/// function arguments in the caller parameter area.  This is the actual
-/// alignment, not its logarithm.
-unsigned TargetLoweringBase::getByValTypeAlignment(Type *Ty,
-                                                   const DataLayout &DL) const {
-  return DL.getABITypeAlignment(Ty);
-}
-
 bool TargetLoweringBase::allowsMemoryAccess(LLVMContext &Context,
                                             const DataLayout &DL, EVT VT,
                                             unsigned AddrSpace,