Add alignment argument to the byval attribute (prototype)

[chill]

Summary

*This is a DRAFT*

Problem statement:

We have up to three relevant alignment properties for a parameter:

• the alignment of the parameter itself (if it happens to be passed in memory)
• if it's a pointer, the actual alignment of the pointed to memory (as an optimisation aid)
• if it's a byval or a byref argument, the minimum alignment of the storage, allocated

for the original argument value (ABI affecting).

For non-pointer arguments alignstack(N) gives stack slot alignment.
For pointer arguments, we retain that use of alignstack(N) and also
have align(M) to give the actual alignment of the contained pointer.

Now when we add byval or byref to the above, there is no attribute
left to give the alignment of the allocated memory. We thought of
using alignstack(N), but that would leave us without a way to
specify the pointer alignment itself.

Proposed solution:

Extend the byval(Ty) attribute to byval(Ty [, Align]) (same for
byref` and preallocated).

(Most of the attributes take zero or one parameters, but there's a
precedent with allocsize(<EltSizeParam>[, <NumEltsParam>]))

So we end up with :

• align(N) for pointer content
• stackalign(N) for the minimum alignment for of the actual argument, if it ends up in memory
• byval(Ty[, N]) and byref(Ty[, N]) for the original argument value

This patch is the prototype implementation, which changes only byval.

clang/lib/CodeGen/CGBuiltin.cpp

if (NumArgs == 4) {
       auto Info =
           CGM.getOpenCLRuntime().emitOpenCLEnqueuedBlock(*this, E->getArg(3));
       llvm::Value *Kernel =
           Builder.CreatePointerCast(Info.Kernel, GenericVoidPtrTy);
       llvm::Value *Block =
           Builder.CreatePointerCast(Info.BlockArg, GenericVoidPtrTy);
 
       AttrBuilder B;
-      B.addByValAttr(NDRangeL.getAddress(*this).getElementType());
+      B.addByValAttr(NDRangeL.getAddress(*this).getElementType(), {});
       llvm::AttributeList ByValAttrSet =
           llvm::AttributeList::get(CGM.getModule().getContext(), 3U, B);
 
       auto RTCall =
           EmitRuntimeCall(CGM.CreateRuntimeFunction(FTy, Name, ByValAttrSet),
                           {Queue, Flags, Range, Kernel, Block});
       RTCall->setAttributes(ByValAttrSet);
       return RValue::get(RTCall);

clang/lib/CodeGen/CGCall.cpp

case ABIArgInfo::Direct:
       else if (AI.getInReg())
         Attrs.addAttribute(llvm::Attribute::InReg);
       break;
 
     case ABIArgInfo::Indirect: {
       if (AI.getInReg())
         Attrs.addAttribute(llvm::Attribute::InReg);
 
-      if (AI.getIndirectByVal())
-        Attrs.addByValAttr(getTypes().ConvertTypeForMem(ParamType));
 
       auto *Decl = ParamType->getAsRecordDecl();
       if (CodeGenOpts.PassByValueIsNoAlias && Decl &&
           Decl->getArgPassingRestrictions() == RecordDecl::APK_CanPassInRegs)
         // When calling the function, the pointer passed in will be the only
         // reference to the underlying object. Mark it accordingly.
         Attrs.addAttribute(llvm::Attribute::NoAlias);
 
case ABIArgInfo::Indirect: {
       //
       // This is different from indirect *not* byval, where the object
       // exists already, and the align attribute is purely
       // informative.
       assert(!Align.isZero());
 
       // For now, only add this when we have a byval argument.
       // TODO: be less lazy about updating test cases.
-      if (AI.getIndirectByVal())
+      if (AI.getIndirectByVal()) {
+        Attrs.addByValAttr(getTypes().ConvertTypeForMem(ParamType), {}); // FIXME(chill): fold the following `align`
         Attrs.addAlignmentAttr(Align.getQuantity());
+      }
     
       // byval disables readnone and readonly.
       FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
         .removeAttribute(llvm::Attribute::ReadNone);
 
       break;
     }
     case ABIArgInfo::IndirectAliased: {
       CharUnits Align = AI.getIndirectAlign();

clang/lib/CodeGen/TargetInfo.cpp

static void addX86InterruptAttrs(const FunctionDecl *FD, llvm::GlobalValue *GV,
 
   llvm::Function *Fn = cast<llvm::Function>(GV);
   Fn->setCallingConv(llvm::CallingConv::X86_INTR);
   if (FD->getNumParams() == 0)
     return;
 
   auto PtrTy = cast<PointerType>(FD->getParamDecl(0)->getType());
   llvm::Type *ByValTy = CGM.getTypes().ConvertType(PtrTy->getPointeeType());
-  llvm::Attribute NewAttr = llvm::Attribute::getWithByValType(
-    Fn->getContext(), ByValTy);
+  llvm::Attribute NewAttr = llvm::Attribute::getWithByValArgs(
+    Fn->getContext(), ByValTy, {});
   Fn->addParamAttr(0, NewAttr);
 }
 
 void X86_32TargetCodeGenInfo::setTargetAttributes(
     const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &CGM) const {
   if (GV->isDeclaration())
     return;
   if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {

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;
+    MaybeAlign ByValAlignment;
     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/Argument.h

public:
   /// FIXME: Remove this function once transition to Align is over.
   /// Use getParamAlign() instead.
   unsigned getParamAlignment() const;
 
   /// If this is a byval or inalloca argument, return its alignment.
   MaybeAlign getParamAlign() const;
 
   /// If this is a byval argument, return its type.
-  Type *getParamByValType() const;
+  std::pair<Type *, MaybeAlign> getParamByValArgs() const;
   
   /// If this is an sret argument, return its type.
   Type *getParamStructRetType() const;
 
   /// If this is a byref argument, return its type.
   Type *getParamByRefType() const;
 
   /// If this is an inalloca argument, return its type.
   Type *getParamInAllocaType() const;

llvm/include/llvm/IR/Attributes.h

public:
   //===--------------------------------------------------------------------===//
   // Attribute Construction
   //===--------------------------------------------------------------------===//
 
   /// Return a uniquified Attribute object.
   static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val = 0);
   static Attribute get(LLVMContext &Context, StringRef Kind,
                        StringRef Val = StringRef());
-  static Attribute get(LLVMContext &Context, AttrKind Kind, Type *Ty);
+  static Attribute get(LLVMContext &Context, AttrKind Kind, Type *Ty,
+                       MaybeAlign A = {});
 
   /// Return a uniquified Attribute object that has the specific
   /// alignment set.
   static Attribute getWithAlignment(LLVMContext &Context, Align Alignment);
   static Attribute getWithStackAlignment(LLVMContext &Context, Align Alignment);
   static Attribute getWithDereferenceableBytes(LLVMContext &Context,
                                               uint64_t Bytes);
   static Attribute getWithDereferenceableOrNullBytes(LLVMContext &Context,
                                                      uint64_t Bytes);
   static Attribute getWithAllocSizeArgs(LLVMContext &Context,
                                         unsigned ElemSizeArg,
                                         const Optional<unsigned> &NumElemsArg);
   static Attribute getWithVScaleRangeArgs(LLVMContext &Context,
                                           unsigned MinValue, unsigned MaxValue);
-  static Attribute getWithByValType(LLVMContext &Context, Type *Ty);
+  static Attribute getWithByValArgs(LLVMContext &Context, Type *Ty,
+                                     MaybeAlign Align);
   static Attribute getWithStructRetType(LLVMContext &Context, Type *Ty);
   static Attribute getWithByRefType(LLVMContext &Context, Type *Ty);
   static Attribute getWithPreallocatedType(LLVMContext &Context, Type *Ty);
   static Attribute getWithInAllocaType(LLVMContext &Context, Type *Ty);
 
   /// For a typed attribute, return the equivalent attribute with the type
   /// changed to \p ReplacementTy.
   Attribute getWithNewType(LLVMContext &Context, Type *ReplacementTy) {
     assert(isTypeAttribute() && "this requires a typed attribute");
-    return get(Context, getKindAsEnum(), ReplacementTy);
+    auto TyArgs = getTypedAttrArgs();
+    return get(Context, getKindAsEnum(), ReplacementTy, TyArgs.second);
   }
 
   static Attribute::AttrKind getAttrKindFromName(StringRef AttrName);
 
   static StringRef getNameFromAttrKind(Attribute::AttrKind AttrKind);
 
   /// Return true if and only if the attribute has an Argument.
   static bool doesAttrKindHaveArgument(Attribute::AttrKind AttrKind);
public:
   /// Return the attribute's kind as a string. This requires the
   /// attribute to be a string attribute.
   StringRef getKindAsString() const;
 
   /// Return the attribute's value as a string. This requires the
   /// attribute to be a string attribute.
   StringRef getValueAsString() const;
 
+  std::pair<Type *, MaybeAlign> getTypedAttrArgs() const;
+
   /// Return the attribute's value as a Type. This requires the attribute to be
   /// a type attribute.
-  Type *getValueAsType() const;
+  // Type *getValueAsType() const;
   
   /// Returns the alignment field of an attribute as a byte alignment
   /// value.
   MaybeAlign getAlignment() const;
 
   /// Returns the stack alignment field of an attribute as a byte
   /// alignment value.
   MaybeAlign getStackAlignment() const;
 
public:
 
   /// Return the target-dependent attribute object.
   Attribute getAttribute(StringRef Kind) const;
 
   MaybeAlign getAlignment() const;
   MaybeAlign getStackAlignment() const;
   uint64_t getDereferenceableBytes() const;
   uint64_t getDereferenceableOrNullBytes() const;
-  Type *getByValType() const;
+  std::pair<Type *, MaybeAlign> getByValArgs() const;
   Type *getStructRetType() const;
   Type *getByRefType() const;
   Type *getPreallocatedType() const;
   Type *getInAllocaType() const;
   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
   std::pair<unsigned, unsigned> getVScaleRangeArgs() const;
   std::string getAsString(bool InAttrGrp = false) const;
 
public:
   /// Add the dereferenceable_or_null attribute to the attribute set at
   /// the given arg index. Returns a new list because attribute lists are
   /// immutable.
   LLVM_NODISCARD AttributeList addDereferenceableOrNullParamAttr(
       LLVMContext &C, unsigned ArgNo, uint64_t Bytes) const {
     return addDereferenceableOrNullAttr(C, ArgNo + FirstArgIndex, Bytes);
   }
 
+  // FIXME(chill): How about ByVal attribute
   /// Add the allocsize attribute to the attribute set at the given index.
   /// Returns a new list because attribute lists are immutable.
   LLVM_NODISCARD AttributeList
   addAllocSizeAttr(LLVMContext &C, unsigned Index, unsigned ElemSizeArg,
                    const Optional<unsigned> &NumElemsArg);
 
   /// Add the allocsize attribute to the attribute set at the given arg index.
   /// Returns a new list because attribute lists are immutable.
public:
 
   /// Return the alignment of the return value.
   MaybeAlign getRetAlignment() const;
 
   /// Return the alignment for the specified function parameter.
   MaybeAlign getParamAlignment(unsigned ArgNo) const;
 
   /// Return the byval type for the specified function parameter.
-  Type *getParamByValType(unsigned ArgNo) const;
+  std::pair<Type *, MaybeAlign> getParamByValArgs(unsigned ArgNo) const;
 
   /// Return the sret type for the specified function parameter.
   Type *getParamStructRetType(unsigned ArgNo) const;
 
   /// Return the byref type for the specified function parameter.
   Type *getParamByRefType(unsigned ArgNo) const;
 
   /// Return the preallocated type for the specified function parameter.

 /// create an Attribute object. The object itself is uniquified. The Builder's
 /// value, however, is not. So this can be used as a quick way to test for
 /// equality, presence of attributes, etc.
 class AttrBuilder {
   std::bitset<Attribute::EndAttrKinds> Attrs;
   std::map<SmallString<32>, SmallString<32>, std::less<>> TargetDepAttrs;
   MaybeAlign Alignment;
   MaybeAlign StackAlignment;
+  MaybeAlign ByValAlignment;
   uint64_t DerefBytes = 0;
   uint64_t DerefOrNullBytes = 0;
   uint64_t AllocSizeArgs = 0;
   uint64_t VScaleRangeArgs = 0;
   Type *ByValType = nullptr;
   Type *StructRetType = nullptr;
   Type *ByRefType = nullptr;
   Type *PreallocatedType = nullptr;
public:
   /// dereferenceable attribute exists (zero is returned otherwise).
   uint64_t getDereferenceableBytes() const { return DerefBytes; }
 
   /// Retrieve the number of dereferenceable_or_null bytes, if the
   /// dereferenceable_or_null attribute exists (zero is returned otherwise).
   uint64_t getDereferenceableOrNullBytes() const { return DerefOrNullBytes; }
 
   /// Retrieve the byval type.
-  Type *getByValType() const { return ByValType; }
+  std::pair<Type *, MaybeAlign> getByValArgs() const {
+    return {ByValType, ByValAlignment};
+  }
   
   /// Retrieve the sret type.
   Type *getStructRetType() const { return StructRetType; }
 
   /// Retrieve the byref type.
   Type *getByRefType() const { return ByRefType; }
 
   /// Retrieve the preallocated type.
   Type *getPreallocatedType() const { return PreallocatedType; }
public:
   /// This turns one (or two) ints into the form used internally in Attribute.
   AttrBuilder &addAllocSizeAttr(unsigned ElemSizeArg,
                                 const Optional<unsigned> &NumElemsArg);
 
   /// This turns two ints into the form used internally in Attribute.
   AttrBuilder &addVScaleRangeAttr(unsigned MinValue, unsigned MaxValue);
 
   /// This turns a byval type into the form used internally in Attribute.
-  AttrBuilder &addByValAttr(Type *Ty);
+  AttrBuilder &addByValAttr(Type *Ty, MaybeAlign Alignment);
 
   /// This turns a sret type into the form used internally in Attribute.
   AttrBuilder &addStructRetAttr(Type *Ty);
 
   /// This turns a byref type into the form used internally in Attribute.
   AttrBuilder &addByRefAttr(Type *Ty);
 
   /// This turns a preallocated type into the form used internally in Attribute.

llvm/include/llvm/IR/Function.h

unsigned getParamAlignment(unsigned ArgNo) const {
     return 0;
   }
 
   MaybeAlign getParamAlign(unsigned ArgNo) const {
     return AttributeSets.getParamAlignment(ArgNo);
   }
 
   /// Extract the byval type for a parameter.
-  Type *getParamByValType(unsigned ArgNo) const {
-    return AttributeSets.getParamByValType(ArgNo);
+  std::pair<Type *, MaybeAlign> getParamByValArgs(unsigned ArgNo) const {
+    return AttributeSets.getParamByValArgs(ArgNo);
   }
 
   /// Extract the sret type for a parameter.
   Type *getParamStructRetType(unsigned ArgNo) const {
     return AttributeSets.getParamStructRetType(ArgNo);
   }
 
   /// Extract the inalloca type for a parameter.

llvm/include/llvm/IR/InstrTypes.h

public:
   }
 
   /// Extract the alignment for a call or parameter (0=unknown).
   MaybeAlign getParamAlign(unsigned ArgNo) const {
     return Attrs.getParamAlignment(ArgNo);
   }
 
   /// 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();
+  std::pair<Type *, MaybeAlign> getParamByValArgs(unsigned ArgNo) const {
+    auto ByValArgs = Attrs.getParamByValArgs(ArgNo);
+    if (ByValArgs.first == nullptr)
+      ByValArgs.first =
+          getArgOperand(ArgNo)->getType()->getPointerElementType();
+    return ByValArgs;
   }
 
   /// 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();
   }
 

llvm/lib/Analysis/StackSafetyAnalysis.cpp

for (const Use &UI : V->uses()) {
         if (!CB.isArgOperand(&UI)) {
           US.updateRange(UnknownRange);
           return false;
         }
 
         unsigned ArgNo = CB.getArgOperandNo(&UI);
         if (CB.isByValArgument(ArgNo)) {
           US.updateRange(getAccessRange(
-              UI, Ptr, DL.getTypeStoreSize(CB.getParamByValType(ArgNo))));
+              UI, Ptr, DL.getTypeStoreSize(CB.getParamByValArgs(ArgNo).first)));
           break;
         }
 
         // FIXME: consult devirt?
         // Do not follow aliases, otherwise we could inadvertently follow
         // dso_preemptable aliases or aliases with interposable linkage.
         const GlobalValue *Callee =
             dyn_cast<GlobalValue>(CB.getCalledOperand()->stripPointerCasts());

llvm/lib/AsmParser/LLParser.h

private:
     bool parseStandaloneMetadata();
     bool parseNamedMetadata();
     bool parseMDString(MDString *&Result);
     bool parseMDNodeID(MDNode *&Result);
     bool parseUnnamedAttrGrp();
     bool parseFnAttributeValuePairs(AttrBuilder &B,
                                     std::vector<unsigned> &FwdRefAttrGrps,
                                     bool inAttrGrp, LocTy &BuiltinLoc);
-    bool parseRequiredTypeAttr(Type *&Result, lltok::Kind AttrName);
+    bool parseRequiredTypeAttr(Type *&Result, MaybeAlign &Alignment,
+                               lltok::Kind AttrName);
     bool parsePreallocated(Type *&Result);
     bool parseInalloca(Type *&Result);
     bool parseByRef(Type *&Result);
 
     // Module Summary Index Parsing.
     bool skipModuleSummaryEntry();
     bool parseSummaryEntry();
     bool parseModuleEntry(unsigned ID);

llvm/lib/AsmParser/LLParser.cpp

case lltok::kw_align: {
       MaybeAlign Alignment;
       if (parseOptionalAlignment(Alignment, true))
         return true;
       B.addAlignmentAttr(Alignment);
       continue;
     }
     case lltok::kw_byval: {
       Type *Ty;
-      if (parseRequiredTypeAttr(Ty, lltok::kw_byval))
+      MaybeAlign A;
+      if (parseRequiredTypeAttr(Ty, A, lltok::kw_byval))
         return true;
-      B.addByValAttr(Ty);
+      B.addByValAttr(Ty, A);
       continue;
     }
     case lltok::kw_sret: {
       Type *Ty;
-      if (parseRequiredTypeAttr(Ty, lltok::kw_sret))
+      MaybeAlign A; // FIXME(chill): Ignored
+      if (parseRequiredTypeAttr(Ty, A, lltok::kw_sret))
         return true;
       B.addStructRetAttr(Ty);
       continue;
     }
     case lltok::kw_preallocated: {
       Type *Ty;
       if (parsePreallocated(Ty))
         return true;
if (IsMustTailCall && InVarArgsFunc)
     return tokError("expected '...' at end of argument list for musttail call "
                     "in varargs function");
 
   Lex.Lex();  // Lex the ')'.
   return false;
 }
 
 /// parseRequiredTypeAttr
-///   ::= attrname(<ty>)
-bool LLParser::parseRequiredTypeAttr(Type *&Result, lltok::Kind AttrName) {
+///   ::= attrname(<ty> [, align])
+bool LLParser::parseRequiredTypeAttr(Type *&Result, MaybeAlign &Alignment,
+                                     lltok::Kind AttrName) {
   Result = nullptr;
   if (!EatIfPresent(AttrName))
     return true;
   if (!EatIfPresent(lltok::lparen))
     return error(Lex.getLoc(), "expected '('");
   if (parseType(Result))
     return true;
+  if (EatIfPresent(lltok::comma)) {
+    auto AlignAt = Lex.getLoc();
+    unsigned A;
+    if (parseUInt32(A))
+      return true;
+    if (A <= 1)
+      return error(AlignAt, "alignment must be > 1");
+    Alignment = Align(A);
+  } else
+    Alignment = None;
+
   if (!EatIfPresent(lltok::rparen))
     return error(Lex.getLoc(), "expected ')'");
   return false;
 }
 
 /// parsePreallocated
 ///   ::= preallocated(<ty>)
 bool LLParser::parsePreallocated(Type *&Result) {
-  return parseRequiredTypeAttr(Result, lltok::kw_preallocated);
+  MaybeAlign A;
+  return parseRequiredTypeAttr(Result, A, lltok::kw_preallocated);
 }
 
 /// parseInalloca
 ///   ::= inalloca(<ty>)
 bool LLParser::parseInalloca(Type *&Result) {
-  return parseRequiredTypeAttr(Result, lltok::kw_inalloca);
+  MaybeAlign A;
+  return parseRequiredTypeAttr(Result, A, lltok::kw_inalloca);
 }
 
 /// parseByRef
 ///   ::= byref(<type>)
 bool LLParser::parseByRef(Type *&Result) {
-  return parseRequiredTypeAttr(Result, lltok::kw_byref);
+  MaybeAlign A;
+  return parseRequiredTypeAttr(Result, A, lltok::kw_byref);
 }
 
 /// parseOptionalOperandBundles
 ///    ::= /*empty*/
 ///    ::= '[' OperandBundle [, OperandBundle ]* ']'
 ///
 /// OperandBundle
 ///    ::= bundle-tag '(' ')'

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...]
           Attribute::AttrKind Kind;
           if (Error Err = parseAttrKind(Record[++i], &Kind))
             return Err;
 
           // Upgrade old-style byval attribute to one with a type, even if it's
           // nullptr. We will have to insert the real type when we associate
           // this AttributeList with a function.
           if (Kind == Attribute::ByVal)
-            B.addByValAttr(nullptr);
+            B.addByValAttr(nullptr, {});
           else if (Kind == Attribute::StructRet)
             B.addStructRetAttr(nullptr);
           else if (Kind == Attribute::InAlloca)
             B.addInAllocaAttr(nullptr);
 
           B.addAttribute(Kind);
         } else if (Record[i] == 1) { // Integer attribute
           Attribute::AttrKind Kind;
case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...]
             assert(Record[i] == 0 && "Value string not null terminated");
           }
 
           B.addAttribute(KindStr.str(), ValStr.str());
         } else {
           assert((Record[i] == 5 || Record[i] == 6) &&
                  "Invalid attribute group entry");
           bool HasType = Record[i] == 6;
+          bool HasAlign = Record[i] == 7;
+          assert(HasType || !HasAlign);
           Attribute::AttrKind Kind;
           if (Error Err = parseAttrKind(Record[++i], &Kind))
             return Err;
           if (Kind == Attribute::ByVal) {
-            B.addByValAttr(HasType ? getTypeByID(Record[++i]) : nullptr);
+            Type *Ty = HasType ? getTypeByID(Record[++i]) : nullptr;
+            MaybeAlign A;
+            if (HasAlign)
+              A =Align(Record[++i]);
+            B.addByValAttr(Ty, A);
           } else if (Kind == Attribute::StructRet) {
             B.addStructRetAttr(HasType ? getTypeByID(Record[++i]) : nullptr);
           } else if (Kind == Attribute::ByRef) {
             B.addByRefAttr(getTypeByID(Record[++i]));
           } else if (Kind == Attribute::Preallocated) {
             B.addPreallocatedAttr(getTypeByID(Record[++i]));
           } else if (Kind == Attribute::InAlloca) {
             B.addInAllocaAttr(HasType ? getTypeByID(Record[++i]) : nullptr);
for (Attribute::AttrKind Kind : {Attribute::ByVal, Attribute::StructRet,
 
       Func->removeParamAttr(i, Kind);
 
       Type *PTy = cast<FunctionType>(FullFTy)->getParamType(i);
       Type *PtrEltTy = getPointerElementFlatType(PTy);
       Attribute NewAttr;
       switch (Kind) {
       case Attribute::ByVal:
-        NewAttr = Attribute::getWithByValType(Context, PtrEltTy);
+        NewAttr = Attribute::getWithByValArgs(Context, PtrEltTy, {}); // FIXME(chill): get alignment from `align` ?
         break;
       case Attribute::StructRet:
         NewAttr = Attribute::getWithStructRetType(Context, PtrEltTy);
         break;
       case Attribute::InAlloca:
         NewAttr = Attribute::getWithInAllocaType(Context, PtrEltTy);
         break;
       default:
for (Attribute::AttrKind Kind : {Attribute::ByVal, Attribute::StructRet,
         continue;
 
       CB->removeParamAttr(i, Kind);
 
       Type *PtrEltTy = getPointerElementFlatType(ArgsFullTys[i]);
       Attribute NewAttr;
       switch (Kind) {
       case Attribute::ByVal:
-        NewAttr = Attribute::getWithByValType(Context, PtrEltTy);
+        NewAttr = Attribute::getWithByValArgs(Context, PtrEltTy, {});
         break;
       case Attribute::StructRet:
         NewAttr = Attribute::getWithStructRetType(Context, PtrEltTy);
         break;
       case Attribute::InAlloca:
         NewAttr = Attribute::getWithInAllocaType(Context, PtrEltTy);
         break;
       default:

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

for (Attribute Attr : AS) {
         Record.append(Kind.begin(), Kind.end());
         Record.push_back(0);
         if (!Val.empty()) {
           Record.append(Val.begin(), Val.end());
           Record.push_back(0);
         }
       } else {
         assert(Attr.isTypeAttribute());
-        Type *Ty = Attr.getValueAsType();
-        Record.push_back(Ty ? 6 : 5);
+        Type *Ty;
+        MaybeAlign A;
+        std::tie(Ty, A) = Attr.getTypedAttrArgs();
+        assert(Ty != nullptr || !A.hasValue());
+        Record.push_back(5 + (Ty != nullptr) + A.hasValue());
         Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
-        if (Ty)
-          Record.push_back(VE.getTypeID(Attr.getValueAsType()));
+        if (Ty) {
+          Record.push_back(VE.getTypeID(Ty));
+          if (A.hasValue())
+            Record.push_back(A->value());
+        }
       }
     }
 
     Stream.EmitRecord(bitc::PARAMATTR_GRP_CODE_ENTRY, Record);
     Record.clear();
   }
 
   Stream.ExitBlock();

llvm/lib/Bitcode/Writer/ValueEnumerator.cpp

void ValueEnumerator::incorporateFunction(const Function &F) {
   // Add global metadata to the function block.  This doesn't include
   // LocalAsMetadata.
   incorporateFunctionMetadata(F);
 
   // Adding function arguments to the value table.
   for (const auto &I : F.args()) {
     EnumerateValue(&I);
     if (I.hasAttribute(Attribute::ByVal))
-      EnumerateType(I.getParamByValType());
+      EnumerateType(I.getParamByValArgs().first);
     else if (I.hasAttribute(Attribute::StructRet))
       EnumerateType(I.getParamStructRetType());
     else if (I.hasAttribute(Attribute::ByRef))
       EnumerateType(I.getParamByRefType());
   }
   FirstFuncConstantID = Values.size();
 
   // Add all function-level constants to the value table.

llvm/lib/CodeGen/GlobalISel/CallLowering.cpp

void CallLowering::setArgFlags(CallLowering::ArgInfo &Arg, unsigned OpIdx,
                                const FuncInfoTy &FuncInfo) const {
   auto &Flags = Arg.Flags[0];
   const AttributeList &Attrs = FuncInfo.getAttributes();
   addArgFlagsFromAttributes(Flags, Attrs, OpIdx);
 
   if (Flags.isByVal() || Flags.isInAlloca() || Flags.isPreallocated()) {
     Type *ElementTy = cast<PointerType>(Arg.Ty)->getElementType();
 
-    auto Ty = Attrs.getAttribute(OpIdx, Attribute::ByVal).getValueAsType();
+    Type *Ty;
+    MaybeAlign A;
+    std::tie(Ty, A) =
+        Attrs.getAttribute(OpIdx, Attribute::ByVal).getTypedAttrArgs();
     Flags.setByValSize(DL.getTypeAllocSize(Ty ? Ty : 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.
     Align FrameAlign;
-    if (auto ParamAlign = FuncInfo.getParamAlign(OpIdx - 1))
+    if (A.hasValue())
+      FrameAlign = *A;
+    else if (auto ParamAlign = FuncInfo.getParamAlign(OpIdx - 1))
       FrameAlign = *ParamAlign;
     else
       FrameAlign = Align(getTLI()->getByValTypeAlignment(ElementTy, DL));
     Flags.setByValAlign(FrameAlign);
   }
   Flags.setOrigAlign(DL.getABITypeAlign(Arg.Ty));
 
   // Don't try to use the returned attribute if the argument is marked as

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

void SelectionDAGISel::LowerArguments(const Function &F) {
   for (const Argument &Arg : F.args()) {
     unsigned ArgNo = Arg.getArgNo();
     SmallVector<EVT, 4> ValueVTs;
     ComputeValueVTs(*TLI, DAG.getDataLayout(), Arg.getType(), ValueVTs);
     bool isArgValueUsed = !Arg.use_empty();
     unsigned PartBase = 0;
     Type *FinalType = Arg.getType();
     if (Arg.hasAttribute(Attribute::ByVal))
-      FinalType = Arg.getParamByValType();
+      std::tie(FinalType, std::ignore) = Arg.getParamByValArgs(); // FIXME(chill): alignment
     bool NeedsRegBlock = TLI->functionArgumentNeedsConsecutiveRegisters(
         FinalType, F.getCallingConv(), F.isVarArg());
     for (unsigned Value = 0, NumValues = ValueVTs.size();
          Value != NumValues; ++Value) {
       EVT VT = ValueVTs[Value];
       Type *ArgTy = VT.getTypeForEVT(*DAG.getContext());
       ISD::ArgFlagsTy Flags;
 

llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp

void TargetLoweringBase::ArgListEntry::setAttributes(const CallBase *Call,
   IsPreallocated = Call->paramHasAttr(ArgIdx, Attribute::Preallocated);
   IsInAlloca = Call->paramHasAttr(ArgIdx, Attribute::InAlloca);
   IsReturned = Call->paramHasAttr(ArgIdx, Attribute::Returned);
   IsSwiftSelf = Call->paramHasAttr(ArgIdx, Attribute::SwiftSelf);
   IsSwiftError = Call->paramHasAttr(ArgIdx, Attribute::SwiftError);
   Alignment = Call->getParamAlign(ArgIdx);
   ByValType = nullptr;
   if (IsByVal)
-    ByValType = Call->getParamByValType(ArgIdx);
+    std::tie(ByValType, ByValAlignment) = Call->getParamByValArgs(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>

llvm/lib/IR/AsmWriter.cpp

void AssemblyWriter::writeAttribute(const Attribute &Attr, bool InAttrGroup) {
   } else if (Attr.hasAttribute(Attribute::Preallocated)) {
     Out << "preallocated";
   } else if (Attr.hasAttribute(Attribute::InAlloca)) {
     Out << "inalloca";
   } else {
     llvm_unreachable("unexpected type attr");
   }
 
-  if (Type *Ty = Attr.getValueAsType()) {
+  Type *Ty;
+  MaybeAlign A;
+  std::tie(Ty, A) = Attr.getTypedAttrArgs();
+  assert(!A.hasValue() || Attr.hasAttribute(Attribute::ByVal));
+  if (Ty != nullptr) {
     Out << '(';
     TypePrinter.print(Ty, Out);
+    if (A.hasValue())
+      Out << ", " << A->value();
     Out << ')';
   }
 }
 
 void AssemblyWriter::writeAttributeSet(const AttributeSet &AttrSet,
                                        bool InAttrGroup) {
   bool FirstAttr = true;
   for (const auto &Attr : AttrSet) {

llvm/lib/IR/AttributeImpl.h

public:
   bool hasAttribute(StringRef Kind) const;
 
   Attribute::AttrKind getKindAsEnum() const;
   uint64_t getValueAsInt() const;
 
   StringRef getKindAsString() const;
   StringRef getValueAsString() const;
 
-  Type *getValueAsType() const;
+  std::pair<Type *, MaybeAlign> getTypedAttrArgs() const;
 
   /// Used when sorting the attributes.
   bool operator<(const AttributeImpl &AI) const;
 
   void Profile(FoldingSetNodeID &ID) const {
     if (isEnumAttribute())
       Profile(ID, getKindAsEnum(), static_cast<uint64_t>(0));
     else if (isIntAttribute())
       Profile(ID, getKindAsEnum(), getValueAsInt());
     else if (isStringAttribute())
       Profile(ID, getKindAsString(), getValueAsString());
-    else
-      Profile(ID, getKindAsEnum(), getValueAsType());
+    else {
+      Type *Ty;
+      MaybeAlign A;
+      std::tie(Ty, A) = getTypedAttrArgs();
+      Profile(ID, getKindAsEnum(), Ty, A);
+    }
   }
 
   static void Profile(FoldingSetNodeID &ID, Attribute::AttrKind Kind,
                       uint64_t Val) {
     ID.AddInteger(Kind);
     if (Val) ID.AddInteger(Val);
   }
 
   static void Profile(FoldingSetNodeID &ID, StringRef Kind, StringRef Values) {
     ID.AddString(Kind);
     if (!Values.empty()) ID.AddString(Values);
   }
 
   static void Profile(FoldingSetNodeID &ID, Attribute::AttrKind Kind,
-                      Type *Ty) {
+                      Type *Ty, MaybeAlign A) {
     ID.AddInteger(Kind);
     ID.AddPointer(Ty);
+    ID.AddInteger(A.valueOrOne().value());
   }
 };
 
 static_assert(std::is_trivially_destructible<AttributeImpl>::value,
               "AttributeImpl should be trivially destructible");
 
 //===----------------------------------------------------------------------===//
 /// \class
public:
   static size_t totalSizeToAlloc(StringRef Kind, StringRef Val) {
     return TrailingObjects::totalSizeToAlloc<char>(Kind.size() + 1 +
                                                    Val.size() + 1);
   }
 };
 
 class TypeAttributeImpl : public EnumAttributeImpl {
   Type *Ty;
+  MaybeAlign Alignment;
 
 public:
-  TypeAttributeImpl(Attribute::AttrKind Kind, Type *Ty)
-      : EnumAttributeImpl(TypeAttrEntry, Kind), Ty(Ty) {}
+  TypeAttributeImpl(Attribute::AttrKind Kind, Type *Ty, MaybeAlign A)
+      : EnumAttributeImpl(TypeAttrEntry, Kind), Ty(Ty), Alignment(A) {}
 
   Type *getTypeValue() const { return Ty; }
+  MaybeAlign getTypeAlignment() const { return Alignment; }
 };
 
 class AttributeBitSet {
   /// Bitset with a bit for each available attribute Attribute::AttrKind.
   uint8_t AvailableAttrs[12] = {};
   static_assert(Attribute::EndAttrKinds <= sizeof(AvailableAttrs) * CHAR_BIT,
                 "Too many attributes");
 
public:
 
   MaybeAlign getAlignment() const;
   MaybeAlign getStackAlignment() const;
   uint64_t getDereferenceableBytes() const;
   uint64_t getDereferenceableOrNullBytes() const;
   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
   std::pair<unsigned, unsigned> getVScaleRangeArgs() const;
   std::string getAsString(bool InAttrGrp) const;
-  Type *getByValType() const;
+  std::pair<Type *, MaybeAlign> getByValArgs() const;
   Type *getStructRetType() const;
   Type *getByRefType() const;
   Type *getPreallocatedType() const;
   Type *getInAllocaType() const;
 
   using iterator = const Attribute *;
 
   iterator begin() const { return getTrailingObjects<Attribute>(); }

llvm/lib/IR/Attributes.cpp

if (!PA) {
     pImpl->AttrsSet.InsertNode(PA, InsertPoint);
   }
 
   // Return the Attribute that we found or created.
   return Attribute(PA);
 }
 
 Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind,
-                         Type *Ty) {
+                         Type *Ty, MaybeAlign A) {
   LLVMContextImpl *pImpl = Context.pImpl;
   FoldingSetNodeID ID;
   ID.AddInteger(Kind);
   ID.AddPointer(Ty);
+  ID.AddInteger(A.getValueOr(Align{}).value());
+  
 
   void *InsertPoint;
   AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint);
 
   if (!PA) {
     // If we didn't find any existing attributes of the same shape then create a
     // new one and insert it.
-    PA = new (pImpl->Alloc) TypeAttributeImpl(Kind, Ty);
+    PA = new (pImpl->Alloc) TypeAttributeImpl(Kind, Ty, A);
     pImpl->AttrsSet.InsertNode(PA, InsertPoint);
   }
 
   // Return the Attribute that we found or created.
   return Attribute(PA);
 }
 
 Attribute Attribute::getWithAlignment(LLVMContext &Context, Align A) {

 }
 
 Attribute Attribute::getWithDereferenceableOrNullBytes(LLVMContext &Context,
                                                        uint64_t Bytes) {
   assert(Bytes && "Bytes must be non-zero.");
   return get(Context, DereferenceableOrNull, Bytes);
 }
 
-Attribute Attribute::getWithByValType(LLVMContext &Context, Type *Ty) {
-  return get(Context, ByVal, Ty);
+Attribute Attribute::getWithByValArgs(LLVMContext &Context, Type *Ty,
+                                      MaybeAlign A) {
+  return get(Context, ByVal, Ty, A);
 }
 
 Attribute Attribute::getWithStructRetType(LLVMContext &Context, Type *Ty) {
   return get(Context, StructRet, Ty);
 }
 
 Attribute Attribute::getWithByRefType(LLVMContext &Context, Type *Ty) {
   return get(Context, ByRef, Ty);

 
 StringRef Attribute::getValueAsString() const {
   if (!pImpl) return {};
   assert(isStringAttribute() &&
          "Invalid attribute type to get the value as a string!");
   return pImpl->getValueAsString();
 }
 
-Type *Attribute::getValueAsType() const {
+std::pair<Type *, MaybeAlign> Attribute::getTypedAttrArgs() const {
   if (!pImpl) return {};
   assert(isTypeAttribute() &&
          "Invalid attribute type to get the value as a type!");
-  return pImpl->getValueAsType();
+  return pImpl->getTypedAttrArgs();
 }
 
 
 bool Attribute::hasAttribute(AttrKind Kind) const {
   return (pImpl && pImpl->hasAttribute(Kind)) || (!pImpl && Kind == None);
 }
 
 bool Attribute::hasAttribute(StringRef Kind) const {
   if (!isStringAttribute()) return false;
   return pImpl && pImpl->hasAttribute(Kind);
 }
if (isTypeAttribute()) {
     case Attribute::InAlloca:
       Result += "inalloca";
       break;
     default:
       llvm_unreachable("unhandled type attribute");
     }
 
     Result += '(';
-    getValueAsType()->print(OS, false, true);
+    Type *Ty;
+    MaybeAlign A;
+    std::tie(Ty, A) = getTypedAttrArgs();
+    Ty->print(OS, false, true);
     OS.flush();
+    if (A.hasValue()) {
+      Result += ", ";
+      Result += utostr(A->value());
+    }
     Result += ')';
     return Result;
   }
 
   // FIXME: These should be output like this:
   //
   //   align=4
   //   alignstack=8
StringRef AttributeImpl::getKindAsString() const {
   return static_cast<const StringAttributeImpl *>(this)->getStringKind();
 }
 
 StringRef AttributeImpl::getValueAsString() const {
   assert(isStringAttribute());
   return static_cast<const StringAttributeImpl *>(this)->getStringValue();
 }
 
-Type *AttributeImpl::getValueAsType() const {
+std::pair<Type *, MaybeAlign> AttributeImpl::getTypedAttrArgs() const {
   assert(isTypeAttribute());
-  return static_cast<const TypeAttributeImpl *>(this)->getTypeValue();
+  auto TyAttr = static_cast<const TypeAttributeImpl *>(this);
+  return {TyAttr->getTypeValue(), TyAttr->getTypeAlignment()};
 }
 
 bool AttributeImpl::operator<(const AttributeImpl &AI) const {
   if (this == &AI)
     return false;
   // This sorts the attributes with Attribute::AttrKinds coming first (sorted
   // relative to their enum value) and then strings.
   if (isEnumAttribute()) {

 uint64_t AttributeSet::getDereferenceableOrNullBytes() const {
   return SetNode ? SetNode->getDereferenceableOrNullBytes() : 0;
 }
 
 Type *AttributeSet::getByRefType() const {
   return SetNode ? SetNode->getByRefType() : nullptr;
 }
 
-Type *AttributeSet::getByValType() const {
-  return SetNode ? SetNode->getByValType() : nullptr;
+std::pair<Type *, MaybeAlign> AttributeSet::getByValArgs() const {
+  return SetNode ? SetNode->getByValArgs()
+                 : std::pair<Type *, MaybeAlign>(nullptr, {});
 }
 
 Type *AttributeSet::getStructRetType() const {
   return SetNode ? SetNode->getStructRetType() : nullptr;
 }
 
 Type *AttributeSet::getPreallocatedType() const {
   return SetNode ? SetNode->getPreallocatedType() : nullptr;
AttributeSetNode *AttributeSetNode::get(LLVMContext &C, const AttrBuilder &B) {
   SmallVector<Attribute, 8> Attrs;
   for (Attribute::AttrKind Kind = Attribute::None;
        Kind != Attribute::EndAttrKinds; Kind = Attribute::AttrKind(Kind + 1)) {
     if (!B.contains(Kind))
       continue;
 
     Attribute Attr;
     switch (Kind) {
-    case Attribute::ByVal:
-      Attr = Attribute::getWithByValType(C, B.getByValType());
+    case Attribute::ByVal: {
+      auto ByValArgs = B.getByValArgs();
+      Attr = Attribute::getWithByValArgs(C, ByValArgs.first, ByValArgs.second);
       break;
+    }
     case Attribute::StructRet:
       Attr = Attribute::getWithStructRetType(C, B.getStructRetType());
       break;
     case Attribute::ByRef:
       Attr = Attribute::getWithByRefType(C, B.getByRefType());
       break;
     case Attribute::Preallocated:
       Attr = Attribute::getWithPreallocatedType(C, B.getPreallocatedType());

 }
 
 MaybeAlign AttributeSetNode::getStackAlignment() const {
   if (auto A = findEnumAttribute(Attribute::StackAlignment))
     return A->getStackAlignment();
   return None;
 }
 
-Type *AttributeSetNode::getByValType() const {
+std::pair<Type *, MaybeAlign> AttributeSetNode::getByValArgs() const {
   if (auto A = findEnumAttribute(Attribute::ByVal))
-    return A->getValueAsType();
-  return nullptr;
+    return A->getTypedAttrArgs();
+  return {};
 }
 
 Type *AttributeSetNode::getStructRetType() const {
-  if (auto A = findEnumAttribute(Attribute::StructRet))
-    return A->getValueAsType();
+  if (auto A = findEnumAttribute(Attribute::StructRet)) {
+    Type *Ty;
+    std::tie(Ty, std::ignore) = A->getTypedAttrArgs();
+    return Ty;
+  }
   return nullptr;
 }
 
 Type *AttributeSetNode::getByRefType() const {
-  if (auto A = findEnumAttribute(Attribute::ByRef))
-    return A->getValueAsType();
+  if (auto A = findEnumAttribute(Attribute::ByRef)) {
+    Type *Ty;
+    std::tie(Ty, std::ignore) = A->getTypedAttrArgs();
+    return Ty;
+  }
   return nullptr;
 }
 
 Type *AttributeSetNode::getPreallocatedType() const {
-  if (auto A = findEnumAttribute(Attribute::Preallocated))
-    return A->getValueAsType();
+  if (auto A = findEnumAttribute(Attribute::Preallocated)) {
+    Type *Ty;
+    std::tie(Ty, std::ignore) = A->getTypedAttrArgs();
+    return Ty;
+  }
   return nullptr;
 }
 
 Type *AttributeSetNode::getInAllocaType() const {
-  if (auto A = findEnumAttribute(Attribute::InAlloca))
-    return A->getValueAsType();
+  if (auto A = findEnumAttribute(Attribute::InAlloca)) {
+    Type *Ty;
+    std::tie(Ty, std::ignore) = A->getTypedAttrArgs();
+    return Ty;
+  }
   return nullptr;
 }
 
 uint64_t AttributeSetNode::getDereferenceableBytes() const {
   if (auto A = findEnumAttribute(Attribute::Dereferenceable))
     return A->getDereferenceableBytes();
   return 0;
 }

 MaybeAlign AttributeList::getRetAlignment() const {
   return getAttributes(ReturnIndex).getAlignment();
 }
 
 MaybeAlign AttributeList::getParamAlignment(unsigned ArgNo) const {
   return getAttributes(ArgNo + FirstArgIndex).getAlignment();
 }
 
-Type *AttributeList::getParamByValType(unsigned Index) const {
-  return getAttributes(Index+FirstArgIndex).getByValType();
+std::pair<Type *, MaybeAlign> AttributeList::getParamByValArgs(unsigned Index) const {
+  return getAttributes(Index+FirstArgIndex).getByValArgs();
 }
 
 Type *AttributeList::getParamStructRetType(unsigned Index) const {
   return getAttributes(Index + FirstArgIndex).getStructRetType();
 }
 
 Type *AttributeList::getParamByRefType(unsigned Index) const {
   return getAttributes(Index + FirstArgIndex).getByRefType();
AttrBuilder &AttrBuilder::addAttribute(Attribute Attr) {
 
   Attribute::AttrKind Kind = Attr.getKindAsEnum();
   Attrs[Kind] = true;
 
   if (Kind == Attribute::Alignment)
     Alignment = Attr.getAlignment();
   else if (Kind == Attribute::StackAlignment)
     StackAlignment = Attr.getStackAlignment();
-  else if (Kind == Attribute::ByVal)
-    ByValType = Attr.getValueAsType();
+  else if (Kind == Attribute::ByVal) {
+    std::tie(ByValType, ByValAlignment) = Attr.getTypedAttrArgs();
+  }
   else if (Kind == Attribute::StructRet)
-    StructRetType = Attr.getValueAsType();
+    std::tie(StructRetType, std::ignore) = Attr.getTypedAttrArgs();
   else if (Kind == Attribute::ByRef)
-    ByRefType = Attr.getValueAsType();
+    std::tie(ByRefType, std::ignore) = Attr.getTypedAttrArgs();
   else if (Kind == Attribute::Preallocated)
-    PreallocatedType = Attr.getValueAsType();
+    std::tie(PreallocatedType, std::ignore) = Attr.getTypedAttrArgs();
   else if (Kind == Attribute::Dereferenceable)
     DerefBytes = Attr.getDereferenceableBytes();
   else if (Kind == Attribute::DereferenceableOrNull)
     DerefOrNullBytes = Attr.getDereferenceableOrNullBytes();
   else if (Kind == Attribute::AllocSize)
     AllocSizeArgs = Attr.getValueAsInt();
   else if (Kind == Attribute::VScaleRange)
     VScaleRangeArgs = Attr.getValueAsInt();
   else if (Kind == Attribute::InAlloca)
-    InAllocaType = Attr.getValueAsType();
+    std::tie(InAllocaType, std::ignore) = Attr.getTypedAttrArgs();
 
   return *this;
 }
 
 AttrBuilder &AttrBuilder::addAttribute(StringRef A, StringRef V) {
   TargetDepAttrs[A] = V;
   return *this;
 }
AttrBuilder &AttrBuilder::addVScaleRangeAttrFromRawRepr(uint64_t RawArgs) {
 
   Attrs[Attribute::VScaleRange] = true;
   // Reuse existing machinery to store this as a single 64-bit integer so we can
   // save a few bytes over using a pair<unsigned, unsigned>.
   VScaleRangeArgs = RawArgs;
   return *this;
 }
 
-AttrBuilder &AttrBuilder::addByValAttr(Type *Ty) {
+AttrBuilder &AttrBuilder::addByValAttr(Type *Ty, MaybeAlign A) {
   Attrs[Attribute::ByVal] = true;
   ByValType = Ty;
+  ByValAlignment = A;
   return *this;
 }
 
 AttrBuilder &AttrBuilder::addStructRetAttr(Type *Ty) {
   Attrs[Attribute::StructRet] = true;
   StructRetType = Ty;
   return *this;
 }
Incompatible.addAttribute(Attribute::Nest)
         .addAlignmentAttr(1)             // the int here is ignored
         .addDereferenceableAttr(1)       // the int here is ignored
         .addDereferenceableOrNullAttr(1) // the int here is ignored
         .addAttribute(Attribute::ReadNone)
         .addAttribute(Attribute::ReadOnly)
         .addAttribute(Attribute::InAlloca)
         .addPreallocatedAttr(Ty)
         .addInAllocaAttr(Ty)
-        .addByValAttr(Ty)
+        .addByValAttr(Ty, {})
         .addStructRetAttr(Ty)
         .addByRefAttr(Ty);
 
   // Some attributes can apply to all "values" but there are no `void` values.
   if (Ty->isVoidTy())
     Incompatible.addAttribute(Attribute::NoUndef);
 
   return Incompatible;

llvm/lib/IR/AutoUpgrade.cpp

void llvm::UpgradeFunctionAttributes(Function &F) {
   if (!F.isDeclaration() && !F.hasFnAttribute(Attribute::StrictFP)) {
     StrictFPUpgradeVisitor SFPV;
     SFPV.visit(F);
   }
 
   if (F.getCallingConv() == CallingConv::X86_INTR &&
       !F.arg_empty() && !F.hasParamAttribute(0, Attribute::ByVal)) {
     Type *ByValTy = cast<PointerType>(F.getArg(0)->getType())->getElementType();
-    Attribute NewAttr = Attribute::getWithByValType(F.getContext(), ByValTy);
+    Attribute NewAttr = Attribute::getWithByValArgs(F.getContext(), ByValTy, {});
     F.addParamAttr(0, NewAttr);
   }
 }
 
 static bool isOldLoopArgument(Metadata *MD) {
   auto *T = dyn_cast_or_null<MDTuple>(MD);
   if (!T)
     return false;

llvm/lib/IR/Core.cpp

 LLVMAttributeRef LLVMCreateEnumAttribute(LLVMContextRef C, unsigned KindID,
                                          uint64_t Val) {
   auto &Ctx = *unwrap(C);
   auto AttrKind = (Attribute::AttrKind)KindID;
 
   if (AttrKind == Attribute::AttrKind::ByVal) {
     // After r362128, byval attributes need to have a type attribute. Provide a
     // NULL one until a proper API is added for this.
-    return wrap(Attribute::getWithByValType(Ctx, NULL));
+    return wrap(Attribute::getWithByValArgs(Ctx, NULL, {}));
   }
 
   if (AttrKind == Attribute::AttrKind::StructRet) {
     // Same as byval.
     return wrap(Attribute::getWithStructRetType(Ctx, NULL));
   }
 
   return wrap(Attribute::get(Ctx, AttrKind, Val));
LLVMAttributeRef LLVMCreateTypeAttribute(LLVMContextRef C, unsigned KindID,
                                          LLVMTypeRef type_ref) {
   auto &Ctx = *unwrap(C);
   auto AttrKind = (Attribute::AttrKind)KindID;
   return wrap(Attribute::get(Ctx, AttrKind, unwrap(type_ref)));
 }
 
 LLVMTypeRef LLVMGetTypeAttributeValue(LLVMAttributeRef A) {
   auto Attr = unwrap(A);
-  return wrap(Attr.getValueAsType());
+  Type *Ty;
+  std::tie(Ty, std::ignore) = Attr.getTypedAttrArgs();
+  return wrap(Ty);
 }
 
 LLVMAttributeRef LLVMCreateStringAttribute(LLVMContextRef C,
                                            const char *K, unsigned KLength,
                                            const char *V, unsigned VLength) {
   return wrap(Attribute::get(*unwrap(C), StringRef(K, KLength),
                              StringRef(V, VLength)));
 }

llvm/lib/IR/Function.cpp

return Attrs.hasParamAttribute(getArgNo(), Attribute::ByVal) ||
          Attrs.hasParamAttribute(getArgNo(), Attribute::ByRef);
 }
 
 /// For a byval, sret, inalloca, or preallocated parameter, get the in-memory
 /// parameter type.
 static Type *getMemoryParamAllocType(AttributeSet ParamAttrs, Type *ArgTy) {
   // FIXME: All the type carrying attributes are mutually exclusive, so there
   // should be a single query to get the stored type that handles any of them.
-  if (Type *ByValTy = ParamAttrs.getByValType())
+  if (Type *ByValTy = ParamAttrs.getByValArgs().first)
     return ByValTy;
   if (Type *ByRefTy = ParamAttrs.getByRefType())
     return ByRefTy;
   if (Type *PreAllocTy = ParamAttrs.getPreallocatedType())
     return PreAllocTy;
   if (Type *InAllocaTy = ParamAttrs.getInAllocaType())
     return InAllocaTy;
 
unsigned Argument::getParamAlignment() const {
   return getParent()->getParamAlignment(getArgNo());
 }
 
 MaybeAlign Argument::getParamAlign() const {
   assert(getType()->isPointerTy() && "Only pointers have alignments");
   return getParent()->getParamAlign(getArgNo());
 }
 
-Type *Argument::getParamByValType() const {
+std::pair<Type *, MaybeAlign> Argument::getParamByValArgs() const {
   assert(getType()->isPointerTy() && "Only pointers have byval types");
-  return getParent()->getParamByValType(getArgNo());
+  return getParent()->getParamByValArgs(getArgNo());
 }
 
 Type *Argument::getParamStructRetType() const {
   assert(getType()->isPointerTy() && "Only pointers have sret types");
   return getParent()->getParamStructRetType(getArgNo());
 }
 
 Type *Argument::getParamByRefType() const {

llvm/lib/IR/Verifier.cpp

if (!isa<PointerType>(PTy->getElementType()))
              "with pointer to pointer type!",
              V);
 
     if (Attrs.hasAttribute(Attribute::ByRef)) {
       Assert(Attrs.getByRefType() == PTy->getElementType(),
              "Attribute 'byref' type does not match parameter!", V);
     }
 
-    if (Attrs.hasAttribute(Attribute::ByVal) && Attrs.getByValType()) {
-      Assert(Attrs.getByValType() == PTy->getElementType(),
+    if (Attrs.hasAttribute(Attribute::ByVal) && Attrs.getByValArgs().first) {
+      Assert(Attrs.getByValArgs().first == PTy->getElementType(),
              "Attribute 'byval' type does not match parameter!", V);
     }
 
     if (Attrs.hasAttribute(Attribute::Preallocated)) {
       Assert(Attrs.getPreallocatedType() == PTy->getElementType(),
              "Attribute 'preallocated' type does not match parameter!", V);
     }
 

llvm/lib/Linker/IRMover.cpp

 }
 
 AttributeList IRLinker::mapAttributeTypes(LLVMContext &C, AttributeList Attrs) {
   for (unsigned i = 0; i < Attrs.getNumAttrSets(); ++i) {
     for (Attribute::AttrKind TypedAttr :
          {Attribute::ByVal, Attribute::StructRet, Attribute::ByRef,
           Attribute::InAlloca}) {
       if (Attrs.hasAttribute(i, TypedAttr)) {
-        if (Type *Ty = Attrs.getAttribute(i, TypedAttr).getValueAsType()) {
+        Type *Ty;
+        std::tie(Ty, std::ignore) = Attrs.getAttribute(i, TypedAttr).getTypedAttrArgs();
+        if (Ty != nullptr) {
           Attrs = Attrs.replaceAttributeType(C, i, TypedAttr, TypeMap.get(Ty));
           break;
         }
       }
     }
   }
   return Attrs;
 }

llvm/lib/Transforms/IPO/ArgumentPromotion.cpp

if (isSelfRecursive) {
         bool RecursiveType =
             llvm::is_contained(STy->elements(), PtrArg->getType());
         if (RecursiveType)
           continue;
       }
     }
 
     // Otherwise, see if we can promote the pointer to its value.
-    Type *ByValTy =
-        PtrArg->hasByValAttr() ? PtrArg->getParamByValType() : nullptr;
+    Type *ByValTy = nullptr;
+    if (PtrArg->hasByValAttr())
+      std::tie(ByValTy, std::ignore) = PtrArg->getParamByValArgs();
     if (isSafeToPromoteArgument(PtrArg, ByValTy, AAR, MaxElements))
       ArgsToPromote.insert(PtrArg);
   }
 
   // No promotable pointer arguments.
   if (ArgsToPromote.empty() && ByValArgsToTransform.empty())
     return nullptr;
 

llvm/lib/Transforms/IPO/GlobalOpt.cpp

for (User *U : F->users()) {
     if (isa<BlockAddress>(U))
       continue;
     CallInst* CI = dyn_cast<CallInst>(U);
     if (!CI)
       continue;
 
     if (CI->isMustTailCall())
       return false;
   }
 
   for (BasicBlock &BB : *F)
     if (BB.getTerminatingMustTailCall())
       return false;
 
   return true;
 }
 
for (auto *User : PreallocatedArgs) {
       uint64_t AllocArgIndex =
           cast<ConstantInt>(UseCall->getArgOperand(1))->getZExtValue();
       Value *AllocaReplacement = ArgAllocas[AllocArgIndex];
       if (!AllocaReplacement) {
         auto AddressSpace = UseCall->getType()->getPointerAddressSpace();
         auto *ArgType = UseCall
                             ->getAttribute(AttributeList::FunctionIndex,
                                            Attribute::Preallocated)
-                            .getValueAsType();
+                            .getTypedAttrArgs().first;
         auto *InsertBefore = PreallocatedSetup->getNextNonDebugInstruction();
         Builder.SetInsertPoint(InsertBefore);
         auto *Alloca =
             Builder.CreateAlloca(ArgType, AddressSpace, nullptr, "paarg");
         auto *BitCast = Builder.CreateBitCast(
             Alloca, Type::getInt8PtrTy(M->getContext()), UseCall->getName());
         ArgAllocas[AllocArgIndex] = BitCast;
         AllocaReplacement = BitCast;

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

static bool isSafeToEliminateVarargsCast(const CallBase &Call,
   // can't change to a type with a different size.  If the size were
   // passed explicitly we could avoid this check.
   if (!Call.isPassPointeeByValueArgument(ix))
     return true;
 
   Type* SrcTy =
             cast<PointerType>(CI->getOperand(0)->getType())->getElementType();
   Type *DstTy = Call.isByValArgument(ix)
-                    ? Call.getParamByValType(ix)
+                    ? Call.getParamByValArgs(ix).first
                     : cast<PointerType>(CI->getType())->getElementType();
   if (!SrcTy->isSized() || !DstTy->isSized())
     return false;
   if (DL.getTypeAllocSize(SrcTy) != DL.getTypeAllocSize(DstTy))
     return false;
   return true;
 }
 
for (auto I = Call.arg_begin() + FTy->getNumParams(), E = Call.arg_end();
       CastInst *CI = dyn_cast<CastInst>(*I);
       if (CI && isSafeToEliminateVarargsCast(Call, DL, CI, ix)) {
         replaceUse(*I, CI->getOperand(0));
 
         // Update the byval type to match the argument type.
         if (Call.isByValArgument(ix)) {
           Call.removeParamAttr(ix, Attribute::ByVal);
           Call.addParamAttr(
-              ix, Attribute::getWithByValType(
-                      Call.getContext(),
-                      CI->getOperand(0)->getType()->getPointerElementType()));
+              ix,
+              Attribute::getWithByValArgs(
+                  CI->getOperand(0)->getType()->getPointerElementType(), {}));
         }
         Changed = true;
       }
     }
   }
 
   if (isa<InlineAsm>(Callee) && !Call.doesNotThrow()) {
     // Inline asm calls cannot throw - mark them 'nounwind'.
for (unsigned i = 0, e = NumCommonArgs; i != e; ++i, ++AI) {
 
     // If the parameter is passed as a byval argument, then we have to have a
     // sized type and the sized type has to have the same size as the old type.
     if (ParamTy != ActTy && CallerPAL.hasParamAttribute(i, Attribute::ByVal)) {
       PointerType *ParamPTy = dyn_cast<PointerType>(ParamTy);
       if (!ParamPTy || !ParamPTy->getElementType()->isSized())
         return false;
 
-      Type *CurElTy = Call.getParamByValType(i);
+      Type *CurElTy = Call.getParamByValArgs(i).first;
       if (DL.getTypeAllocSize(CurElTy) !=
           DL.getTypeAllocSize(ParamPTy->getElementType()))
         return false;
     }
   }
 
   if (Callee->isDeclaration()) {
     // Do not delete arguments unless we have a function body.
for (unsigned i = 0; i != NumCommonArgs; ++i, ++AI) {
     Value *NewArg = *AI;
     if ((*AI)->getType() != ParamTy)
       NewArg = Builder.CreateBitOrPointerCast(*AI, ParamTy);
     Args.push_back(NewArg);
 
     // Add any parameter attributes.
     if (CallerPAL.hasParamAttribute(i, Attribute::ByVal)) {
       AttrBuilder AB(CallerPAL.getParamAttributes(i));
-      AB.addByValAttr(NewArg->getType()->getPointerElementType());
+      AB.addByValAttr(NewArg->getType()->getPointerElementType(), {});
       ArgAttrs.push_back(AttributeSet::get(Ctx, AB));
     } else
       ArgAttrs.push_back(CallerPAL.getParamAttributes(i));
   }
 
   // If the function takes more arguments than the call was taking, add them
   // now.
   for (unsigned i = NumCommonArgs; i != FT->getNumParams(); ++i) {

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

if (F && (F->getName().startswith("llvm.masked.load.") ||
         Alignment = Op->getMaybeAlignValue();
       Value *Mask = CI->getOperand(2 + OpOffset);
       Interesting.emplace_back(I, OpOffset, IsWrite, Ty, Alignment, Mask);
     } else {
       for (unsigned ArgNo = 0; ArgNo < CI->getNumArgOperands(); ArgNo++) {
         if (!ClInstrumentByval || !CI->isByValArgument(ArgNo) ||
             ignoreAccess(CI->getArgOperand(ArgNo)))
           continue;
-        Type *Ty = CI->getParamByValType(ArgNo);
-        Interesting.emplace_back(I, ArgNo, false, Ty, Align(1));
+        Type *Ty;
+        MaybeAlign A;
+        std::tie(Ty, A) = CI->getParamByValArgs(ArgNo);
+        Interesting.emplace_back(I, ArgNo, false, Ty, A.valueOrOne());
       }
     }
   }
 }
 
 static bool isPointerOperand(Value *V) {
   return V->getType()->isPointerTy() || isa<PtrToIntInst>(V);
 }
if (CopyInsertPoint == ASan.LocalDynamicShadow) {
     // Insert after the dynamic shadow location is determined
     CopyInsertPoint = CopyInsertPoint->getNextNode();
     assert(CopyInsertPoint);
   }
   IRBuilder<> IRB(CopyInsertPoint);
   const DataLayout &DL = F.getParent()->getDataLayout();
   for (Argument &Arg : F.args()) {
     if (Arg.hasByValAttr()) {
-      Type *Ty = Arg.getParamByValType();
-      const Align Alignment =
-          DL.getValueOrABITypeAlignment(Arg.getParamAlign(), Ty);
+      Type *Ty;
+      MaybeAlign A;
+      std::tie(Ty, A) = Arg.getParamByValArgs();
+      const Align Alignment = DL.getValueOrABITypeAlignment(
+          A.hasValue() ? *A : Arg.getParamAlign(), Ty);
 
       AllocaInst *AI = IRB.CreateAlloca(
           Ty, nullptr,
           (Arg.hasName() ? Arg.getName() : "Arg" + Twine(Arg.getArgNo())) +
               ".byval");
       AI->setAlignment(Alignment);
       Arg.replaceAllUsesWith(AI);
 

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

if (!ClInstrumentAtomics || ignoreAccess(XCHG->getPointerOperand()))
       return;
     Interesting.emplace_back(I, XCHG->getPointerOperandIndex(), true,
                              XCHG->getCompareOperand()->getType(), None);
   } else if (auto CI = dyn_cast<CallInst>(I)) {
     for (unsigned ArgNo = 0; ArgNo < CI->getNumArgOperands(); ArgNo++) {
       if (!ClInstrumentByval || !CI->isByValArgument(ArgNo) ||
           ignoreAccess(CI->getArgOperand(ArgNo)))
         continue;
-      Type *Ty = CI->getParamByValType(ArgNo);
-      Interesting.emplace_back(I, ArgNo, false, Ty, Align(1));
+      Type *Ty;
+      MaybeAlign A;
+      std::tie(Ty, A) = CI->getParamByValArgs(ArgNo);
+      Interesting.emplace_back(I, ArgNo, false, Ty, A.valueOrOne());
     }
   }
 }
 
 static unsigned getPointerOperandIndex(Instruction *I) {
   if (LoadInst *LI = dyn_cast<LoadInst>(I))
     return LI->getPointerOperandIndex();
   if (StoreInst *SI = dyn_cast<StoreInst>(I))

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

if (Argument *A = dyn_cast<Argument>(V)) {
           continue;
         }
 
         bool FArgByVal = FArg.hasByValAttr();
         bool FArgNoUndef = FArg.hasAttribute(Attribute::NoUndef);
         bool FArgEagerCheck = ClEagerChecks && !FArgByVal && FArgNoUndef;
         unsigned Size =
             FArg.hasByValAttr()
-                ? DL.getTypeAllocSize(FArg.getParamByValType())
+                ? DL.getTypeAllocSize(FArg.getParamByValArgs().first)
                 : DL.getTypeAllocSize(FArg.getType());
 
         if (A == &FArg) {
           bool Overflow = ArgOffset + Size > kParamTLSSize;
           if (FArgEagerCheck) {
             *ShadowPtr = getCleanShadow(V);
             setOrigin(A, getCleanOrigin());
             continue;
           } else if (FArgByVal) {
             Value *Base = getShadowPtrForArgument(&FArg, EntryIRB, ArgOffset);
             // ByVal pointer itself has clean shadow. We copy the actual
             // argument shadow to the underlying memory.
             // Figure out maximal valid memcpy alignment.
-            const Align ArgAlign = DL.getValueOrABITypeAlignment(
-                MaybeAlign(FArg.getParamAlignment()), FArg.getParamByValType());
+            Type *Ty;
+            MaybeAlign A;
+            std::tie(Ty, A) = FArg.getParamByValArgs();
+            if (!A.hasValue())
+              A = FArg.getParamAlign();
+            const Align ArgAlign = DL.getValueOrABITypeAlignment(A, Ty);
             Value *CpShadowPtr =
                 getShadowOriginPtr(V, EntryIRB, EntryIRB.getInt8Ty(), ArgAlign,
                                    /*isStore*/ true)
                     .first;
             // TODO(glider): need to copy origins.
             if (Overflow) {
               // ParamTLS overflow.
               EntryIRB.CreateMemSet(
for (auto ArgIt = CB.arg_begin(), End = CB.arg_end(); ArgIt != End;
         insertShadowCheck(A, &CB);
         continue;
       }
       if (ByVal) {
         // ByVal requires some special handling as it's too big for a single
         // load
         assert(A->getType()->isPointerTy() &&
                "ByVal argument is not a pointer!");
-        Size = DL.getTypeAllocSize(CB.getParamByValType(i));
+        Type *ByValTy;
+        MaybeAlign ByValAlign;
+        std::tie(ByValTy, ByValAlign) = CB.getParamByValArgs(i);
+        Size = DL.getTypeAllocSize(ByValTy);
         if (ArgOffset + Size > kParamTLSSize) break;
-        const MaybeAlign ParamAlignment(CB.getParamAlign(i));
+        const MaybeAlign ParamAlignment(
+            ByValAlign.hasValue() ? ByValAlign : CB.getParamAlign(i));
         MaybeAlign Alignment = llvm::None;
         if (ParamAlignment)
           Alignment = std::min(*ParamAlignment, kShadowTLSAlignment);
         Value *AShadowPtr =
             getShadowOriginPtr(A, IRB, IRB.getInt8Ty(), Alignment,
                                /*isStore*/ false)
                 .first;
 
for (auto ArgIt = CB.arg_begin(), End = CB.arg_end(); ArgIt != End;
       bool IsByVal = CB.paramHasAttr(ArgNo, Attribute::ByVal);
       if (IsByVal) {
         // ByVal arguments always go to the overflow area.
         // Fixed arguments passed through the overflow area will be stepped
         // over by va_start, so don't count them towards the offset.
         if (IsFixed)
           continue;
         assert(A->getType()->isPointerTy());
-        Type *RealTy = CB.getParamByValType(ArgNo);
+        Type *RealTy = CB.getParamByValArgs(ArgNo).first;
         uint64_t ArgSize = DL.getTypeAllocSize(RealTy);
         Value *ShadowBase = getShadowPtrForVAArgument(
             RealTy, IRB, OverflowOffset, alignTo(ArgSize, 8));
         Value *OriginBase = nullptr;
         if (MS.TrackOrigins)
           OriginBase = getOriginPtrForVAArgument(RealTy, IRB, OverflowOffset);
         OverflowOffset += alignTo(ArgSize, 8);
         if (!ShadowBase)
void visitCallBase(CallBase &CB, IRBuilder<> &IRB) override {
     for (auto ArgIt = CB.arg_begin(), End = CB.arg_end(); ArgIt != End;
          ++ArgIt) {
       Value *A = *ArgIt;
       unsigned ArgNo = CB.getArgOperandNo(ArgIt);
       bool IsFixed = ArgNo < CB.getFunctionType()->getNumParams();
       bool IsByVal = CB.paramHasAttr(ArgNo, Attribute::ByVal);
       if (IsByVal) {
         assert(A->getType()->isPointerTy());
-        Type *RealTy = CB.getParamByValType(ArgNo);
+        Type *RealTy;
+        MaybeAlign RealAlign;
+        std::tie(RealTy, RealAlign) = CB.getParamByValArgs(ArgNo);
         uint64_t ArgSize = DL.getTypeAllocSize(RealTy);
-        MaybeAlign ArgAlign = CB.getParamAlign(ArgNo);
+        MaybeAlign ArgAlign =
+            RealAlign.hasValue() ? *RealAlign : CB.getParamAlign(ArgNo);
         if (!ArgAlign || *ArgAlign < Align(8))
           ArgAlign = Align(8);
         VAArgOffset = alignTo(VAArgOffset, ArgAlign);
         if (!IsFixed) {
           Value *Base = getShadowPtrForVAArgument(
               RealTy, IRB, VAArgOffset - VAArgBase, ArgSize);
           if (Base) {
             Value *AShadowPtr, *AOriginPtr;

llvm/lib/Transforms/Utils/CallPromotionUtils.cpp

 
 #include "llvm/Transforms/Utils/CallPromotionUtils.h"
 #include "llvm/Analysis/Loads.h"
 #include "llvm/Analysis/TypeMetadataUtils.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 
+#include <tuple>
+
 using namespace llvm;
 
 #define DEBUG_TYPE "call-promotion-utils"
 
 /// Fix-up phi nodes in an invoke instruction's normal destination.
 ///
 /// After versioning an invoke instruction, values coming from the original
 /// block will now be coming from the "merge" block. For example, in the code
if (FormalTy != ActualTy) {
       CB.setArgOperand(ArgNo, Cast);
 
       // Remove any incompatible attributes for the argument.
       AttrBuilder ArgAttrs(CallerPAL.getParamAttributes(ArgNo));
       ArgAttrs.remove(AttributeFuncs::typeIncompatible(FormalTy));
 
       // If byval is used, this must be a pointer type, and the byval type must
       // match the element type. Update it if present.
-      if (ArgAttrs.getByValType()) {
-        Type *NewTy = Callee->getParamByValType(ArgNo);
+      Type *OldTy;
+      std::tie(OldTy, std::ignore) = ArgAttrs.getByValArgs();
+      if (OldTy) {
+        Type *NewTy;
+        MaybeAlign ByValAlign;
+        std::tie(NewTy, ByValAlign) = Callee->getParamByValArgs(ArgNo);
         ArgAttrs.addByValAttr(
-            NewTy ? NewTy : cast<PointerType>(FormalTy)->getElementType());
+            NewTy ? NewTy : cast<PointerType>(FormalTy)->getElementType(), ByValAlign);
       }
 
       NewArgAttrs.push_back(AttributeSet::get(Ctx, ArgAttrs));
       AttributeChanged = true;
     } else
       NewArgAttrs.push_back(CallerPAL.getParamAttributes(ArgNo));
   }
 

llvm/lib/Transforms/Utils/FunctionComparator.cpp

for (unsigned i = L.index_begin(), e = L.index_end(); i != e; ++i) {
     AttributeSet::iterator RI = RAS.begin(), RE = RAS.end();
     for (; LI != LE && RI != RE; ++LI, ++RI) {
       Attribute LA = *LI;
       Attribute RA = *RI;
       if (LA.isTypeAttribute() && RA.isTypeAttribute()) {
         if (LA.getKindAsEnum() != RA.getKindAsEnum())
           return cmpNumbers(LA.getKindAsEnum(), RA.getKindAsEnum());
 
-        Type *TyL = LA.getValueAsType();
-        Type *TyR = RA.getValueAsType();
+        Type *TyL, *TyR;
+        MaybeAlign AlignL, AlignR;
+        std::tie(TyL, AlignL) = LA.getTypedAttrArgs();
+        std::tie(TyR, AlignR) = RA.getTypedAttrArgs();
         if (TyL && TyR) {
           if (int Res = cmpTypes(TyL, TyR))
             return Res;
+          if (int Res = cmpNumbers(AlignL.valueOrOne().value(),
+                                   AlignR.valueOrOne().value()))
+            return Res;
           continue;
         }
 
         // Two pointers, at least one null, so the comparison result is
         // independent of the value of a real pointer.
         if (int Res = cmpNumbers((uint64_t)TyL, (uint64_t)TyR))
           return Res;
+        if (int Res = cmpNumbers(AlignL.valueOrOne().value(),
+                                 AlignR.valueOrOne().value()))
+          return Res;
         continue;
       }
       if (LA < RA)
         return -1;
       if (RA < LA)
         return 1;
     }
     if (LI != LE)

llvm/lib/Transforms/Utils/ValueMapper.cpp

CB->mutateFunctionType(FunctionType::get(
         TypeMapper->remapType(I->getType()), Tys, FTy->isVarArg()));
 
     LLVMContext &C = CB->getContext();
     AttributeList Attrs = CB->getAttributes();
     for (unsigned i = 0; i < Attrs.getNumAttrSets(); ++i) {
       for (Attribute::AttrKind TypedAttr :
              {Attribute::ByVal, Attribute::StructRet, Attribute::ByRef,
               Attribute::InAlloca}) {
-        if (Type *Ty = Attrs.getAttribute(i, TypedAttr).getValueAsType()) {
+        Type *Ty;
+        MaybeAlign A;
+        std::tie(Ty, A) = Attrs.getAttribute(i, TypedAttr).getTypedAttrArgs();
+        if (Ty != nullptr) {
           Attrs = Attrs.replaceAttributeType(C, i, TypedAttr,
                                              TypeMapper->remapType(Ty));
           break;
         }
       }
     }
     CB->setAttributes(Attrs);
     return;

llvm/unittests/IR/AttributesTest.cpp

TEST(Attributes, OverflowGet) {
   EXPECT_EQ(2U, AL.getNumAttrSets());
 }
 
 TEST(Attributes, StringRepresentation) {
   LLVMContext C;
   StructType *Ty = StructType::create(Type::getInt32Ty(C), "mystruct");
 
   // Insufficiently careful printing can result in byval(%mystruct = { i32 })
-  Attribute A = Attribute::getWithByValType(C, Ty);
+  Attribute A = Attribute::getWithByValArgs(C, Ty, {});
   EXPECT_EQ(A.getAsString(), "byval(%mystruct)");
 
-  A = Attribute::getWithByValType(C, Type::getInt32Ty(C));
+  A = Attribute::getWithByValArgs(C, Type::getInt32Ty(C), {});
   EXPECT_EQ(A.getAsString(), "byval(i32)");
 }
 
+TEST(Attributes, ByValAlignment) {
+  LLVMContext C;
+  StructType *Ty = StructType::create(Type::getInt32Ty(C), "mystruct");
+  
+  Attribute A = Attribute::getWithByValArgs(C, Ty, Align(4));
+  EXPECT_EQ(A.getAsString(), "byval(%mystruct, 4)");
+}
+
 } // end anonymous namespace