[llvm] [IR] Do not inherit ABI attributes from the callee (PR #207173)

Nikita Popov via llvm-commits llvm-commits at lists.llvm.org
Thu Jul 2 06:01:21 PDT 2026


https://github.com/nikic updated https://github.com/llvm/llvm-project/pull/207173

>From 12a3e6cf4ebd2546a1c653107fa9cfbe464206ff Mon Sep 17 00:00:00 2001
From: Nikita Popov <npopov at redhat.com>
Date: Wed, 1 Jul 2026 16:43:01 +0200
Subject: [PATCH] [IR] Do not inherit ABI attributes from the callee

Usually attributes that are missing on the call-site are inherited
form the callee instead. This is fine for optional optimization
attributes, but problematic for ABI-affecting attributes.

ABI attributes generally must be placed at the call-site as well,
because there is no callee to inherit from for indirect calls.
Failing to specify ABI attributes at the call-site generally
indicates a bug.

The motivation for being stricter about this (apart from just
being the right thing to do) is to properly support cases where
the attributes at the call-site and the callee actually differ.
Two examples I'm aware of are:

 * During cross-language LTO, it's possible to have one side use
   a `ptr` argument and the other a `ptr byval(ptr)` argument.
   Both represent the same ABI using different IR encodings, but
   you can't just inherit the `byval` attribute from one to the
   other (because the byval case requires an additional level of
   indirect in use of the argument).
 * To fix our incompatibility with the x86-64 psABI, I believe
   we'll want to do something like emit zeroext/signext at
   function returns and call-site arguments only, so that we both
   don't assume incoming values are zero/sign-extended, but still
   zero/sign-extend outgoing values. This makes sure we still
   remain compatible with old Clang-generated object files.

We've attempted to make a change like this previously, but ran
into substantial issues with missing call-site attributes on
compiler-inserted calls. The issue was particularly severed on
s390x, which requires zeroext/signext on more values than other
architectures. I believe that the situation here has approved a
lot in the meantime, with libcalls not inferring mandatory ABI
attributes, and s390x also using a noext attribute plus validation
logic in the backend to detect cases where the necessary attributes
are missing.
---
 llvm/include/llvm/CodeGen/FastISel.h          | 12 ++--
 llvm/include/llvm/CodeGen/TargetLowering.h    |  6 +-
 llvm/include/llvm/IR/Attributes.h             |  3 +
 llvm/include/llvm/IR/InstrTypes.h             | 72 +++++++++----------
 .../CodeGen/AssignmentTrackingAnalysis.cpp    |  2 +-
 llvm/lib/CodeGen/GlobalISel/CallLowering.cpp  |  9 +--
 .../SelectionDAG/FunctionLoweringInfo.cpp     |  4 +-
 .../CodeGen/SelectionDAG/TargetLowering.cpp   | 24 +++----
 llvm/lib/CodeGen/TypePromotion.cpp            |  4 +-
 llvm/lib/IR/Attributes.cpp                    | 22 ++++++
 llvm/lib/IR/Instructions.cpp                  |  1 +
 llvm/lib/IR/Verifier.cpp                      |  8 +--
 llvm/lib/IR/VerifierAMDGPU.cpp                |  8 +--
 .../Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp    |  6 +-
 llvm/lib/Target/ARM/ARMFastISel.cpp           | 16 ++---
 llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp     |  2 +-
 .../WebAssembly/WebAssemblyFastISel.cpp       |  4 +-
 llvm/lib/Target/X86/X86FastISel.cpp           |  4 +-
 llvm/lib/Target/X86/X86ISelLoweringCall.cpp   |  2 +-
 llvm/lib/Transforms/IPO/ExpandVariadics.cpp   |  4 +-
 .../Instrumentation/MemorySanitizer.cpp       | 16 ++---
 .../Transforms/Utils/CallPromotionUtils.cpp   |  2 +-
 llvm/lib/Transforms/Utils/InlineFunction.cpp  |  2 +-
 llvm/test/Analysis/BasicAA/call-attrs.ll      |  4 +-
 .../call-translator-tail-call-sret.ll         | 12 ++--
 .../AArch64/GlobalISel/call-translator.ll     | 16 ++---
 .../CodeGen/AArch64/GlobalISel/swifterror.ll  |  4 +-
 .../CodeGen/AArch64/GlobalISel/swiftself.ll   |  4 +-
 .../irtranslator-call-return-values.ll        | 12 ++--
 .../GlobalISel/irtranslator-call-sret.ll      |  2 +-
 .../AMDGPU/GlobalISel/irtranslator-call.ll    |  2 +-
 .../test/CodeGen/AMDGPU/fncall-implicitdef.ll |  2 +-
 .../CodeGen/AMDGPU/swdev504645-global-fold.ll |  2 +-
 .../AMDGPU/waterfall-call-inreg-agpr.ll       |  2 +-
 llvm/test/CodeGen/ARM/returned-ext.ll         |  4 +-
 llvm/test/CodeGen/ARM/struct-byval-loop.ll    |  4 +-
 llvm/test/CodeGen/NVPTX/forward-ld-param.ll   |  2 +-
 llvm/test/CodeGen/RISCV/rvv/shrinkwrap.ll     |  4 +-
 llvm/test/CodeGen/RISCV/shrinkwrap.ll         | 14 ++--
 llvm/test/CodeGen/SPARC/64abi.ll              |  8 +--
 llvm/test/CodeGen/SystemZ/args-14.ll          |  5 +-
 llvm/test/CodeGen/SystemZ/call-zos-01.ll      |  8 +--
 llvm/test/CodeGen/VE/Scalar/call.ll           |  2 +-
 llvm/test/CodeGen/VE/Scalar/va_callee.ll      | 24 +++----
 llvm/test/CodeGen/VE/Vector/fastcc_caller.ll  |  2 +-
 .../WebAssembly/signext-zeroext-callsite.ll   | 26 ++-----
 llvm/test/CodeGen/X86/bool-zext.ll            |  2 +-
 llvm/test/CodeGen/X86/return-ext.ll           |  6 +-
 .../ThreadSanitizer/tsan_basic.ll             |  2 +-
 .../Transforms/DeadArgElim/deadexternal.ll    |  2 +-
 .../Inline/access-attributes-prop.ll          |  6 +-
 .../Transforms/PhaseOrdering/pr64289-tce.ll   |  2 +-
 .../test/Transforms/SROA/readonlynocapture.ll |  4 +-
 .../hoist-sink-swifterror-store.ll            | 14 ++--
 .../Orc/IndirectionUtilsTest.cpp              |  4 +-
 llvm/unittests/IR/AttributesTest.cpp          | 10 +--
 56 files changed, 228 insertions(+), 222 deletions(-)

diff --git a/llvm/include/llvm/CodeGen/FastISel.h b/llvm/include/llvm/CodeGen/FastISel.h
index 454ed4126213f..2075ad7818e0e 100644
--- a/llvm/include/llvm/CodeGen/FastISel.h
+++ b/llvm/include/llvm/CodeGen/FastISel.h
@@ -107,12 +107,12 @@ class LLVM_ABI FastISel {
       RetTy = ResultTy;
       Callee = Target;
 
-      IsInReg = Call.hasRetAttr(Attribute::InReg);
+      IsInReg = Call.hasABIRetAttr(Attribute::InReg);
       DoesNotReturn = Call.doesNotReturn();
       IsVarArg = FuncTy->isVarArg();
       IsReturnValueUsed = !Call.use_empty();
-      RetSExt = Call.hasRetAttr(Attribute::SExt);
-      RetZExt = Call.hasRetAttr(Attribute::ZExt);
+      RetSExt = Call.hasABIRetAttr(Attribute::SExt);
+      RetZExt = Call.hasABIRetAttr(Attribute::ZExt);
 
       CallConv = Call.getCallingConv();
       Args = std::move(ArgsList);
@@ -131,12 +131,12 @@ class LLVM_ABI FastISel {
       Callee = Call.getCalledOperand();
       Symbol = Target;
 
-      IsInReg = Call.hasRetAttr(Attribute::InReg);
+      IsInReg = Call.hasABIRetAttr(Attribute::InReg);
       DoesNotReturn = Call.doesNotReturn();
       IsVarArg = FuncTy->isVarArg();
       IsReturnValueUsed = !Call.use_empty();
-      RetSExt = Call.hasRetAttr(Attribute::SExt);
-      RetZExt = Call.hasRetAttr(Attribute::ZExt);
+      RetSExt = Call.hasABIRetAttr(Attribute::SExt);
+      RetZExt = Call.hasABIRetAttr(Attribute::ZExt);
 
       CallConv = Call.getCallingConv();
       Args = std::move(ArgsList);
diff --git a/llvm/include/llvm/CodeGen/TargetLowering.h b/llvm/include/llvm/CodeGen/TargetLowering.h
index 09f522742da4e..6f7bfaba61dc5 100644
--- a/llvm/include/llvm/CodeGen/TargetLowering.h
+++ b/llvm/include/llvm/CodeGen/TargetLowering.h
@@ -4931,14 +4931,14 @@ class LLVM_ABI TargetLowering : public TargetLoweringBase {
                                 const CallBase &Call) {
       RetTy = OrigRetTy = ResultType;
 
-      IsInReg = Call.hasRetAttr(Attribute::InReg);
+      IsInReg = Call.hasABIRetAttr(Attribute::InReg);
       DoesNotReturn =
           Call.doesNotReturn() ||
           (!isa<InvokeInst>(Call) && isa<UnreachableInst>(Call.getNextNode()));
       IsVarArg = FTy->isVarArg();
       IsReturnValueUsed = !Call.use_empty();
-      RetSExt = Call.hasRetAttr(Attribute::SExt);
-      RetZExt = Call.hasRetAttr(Attribute::ZExt);
+      RetSExt = Call.hasABIRetAttr(Attribute::SExt);
+      RetZExt = Call.hasABIRetAttr(Attribute::ZExt);
       NoMerge = Call.hasFnAttr(Attribute::NoMerge);
 
       Callee = Target;
diff --git a/llvm/include/llvm/IR/Attributes.h b/llvm/include/llvm/IR/Attributes.h
index 049f699b2980b..73dceab6cd751 100644
--- a/llvm/include/llvm/IR/Attributes.h
+++ b/llvm/include/llvm/IR/Attributes.h
@@ -160,6 +160,9 @@ class Attribute {
   LLVM_ABI static bool intersectWithMin(AttrKind Kind);
   LLVM_ABI static bool intersectWithCustom(AttrKind Kind);
 
+  /// Whether this is an ABI attribute (for returns or arguments).
+  LLVM_ABI static bool isABIAttr(AttrKind Kind);
+
 private:
   AttributeImpl *pImpl = nullptr;
 
diff --git a/llvm/include/llvm/IR/InstrTypes.h b/llvm/include/llvm/IR/InstrTypes.h
index 5f7df6a4eb6f8..8d3ff9c996daa 100644
--- a/llvm/include/llvm/IR/InstrTypes.h
+++ b/llvm/include/llvm/IR/InstrTypes.h
@@ -1658,6 +1658,7 @@ class CallBase : public Instruction {
 
   /// Determine whether the return value has the given attribute.
   bool hasRetAttr(Attribute::AttrKind Kind) const {
+    assert(!Attribute::isABIAttr(Kind) && "Use hasABIRetAttr() instead");
     return hasRetAttrImpl(Kind);
   }
   /// Determine whether the return value has the given attribute.
@@ -1687,6 +1688,22 @@ class CallBase : public Instruction {
   LLVM_ABI bool paramHasNonNullAttr(unsigned ArgNo,
                                     bool AllowUndefOrPoison) const;
 
+  /// Determine whether the argument has the given ABI attribute. As this is
+  /// an ABI attribute, only check the call-site and do not inherit from the
+  /// callee.
+  bool hasABIParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
+    assert(Attribute::isABIAttr(Kind) && "Expected ABI attribute");
+    return Attrs.hasParamAttr(ArgNo, Kind);
+  }
+
+  /// Determine whether the return value has the given ABI attribute. As this
+  /// is an ABI attribute, only check the call-site and do not inherit from the
+  /// callee.
+  bool hasABIRetAttr(Attribute::AttrKind Kind) const {
+    assert(Attribute::isABIAttr(Kind) && "Expected ABI attribute");
+    return Attrs.hasRetAttr(Kind);
+  }
+
   /// Get the attribute of a given kind at a position.
   Attribute getAttributeAtIndex(unsigned i, Attribute::AttrKind Kind) const {
     return getAttributes().getAttributeAtIndex(i, Kind);
@@ -1776,20 +1793,20 @@ class CallBase : public Instruction {
 
   /// Determine whether this argument is passed by value.
   bool isByValArgument(unsigned ArgNo) const {
-    return paramHasAttr(ArgNo, Attribute::ByVal);
+    return hasABIParamAttr(ArgNo, Attribute::ByVal);
   }
 
   /// Determine whether this argument is passed in an alloca.
   bool isInAllocaArgument(unsigned ArgNo) const {
-    return paramHasAttr(ArgNo, Attribute::InAlloca);
+    return hasABIParamAttr(ArgNo, Attribute::InAlloca);
   }
 
   /// Determine whether this argument is passed by value, in an alloca, or is
   /// preallocated.
   bool isPassPointeeByValueArgument(unsigned ArgNo) const {
-    return paramHasAttr(ArgNo, Attribute::ByVal) ||
-           paramHasAttr(ArgNo, Attribute::InAlloca) ||
-           paramHasAttr(ArgNo, Attribute::Preallocated);
+    return hasABIParamAttr(ArgNo, Attribute::ByVal) ||
+           hasABIParamAttr(ArgNo, Attribute::InAlloca) ||
+           hasABIParamAttr(ArgNo, Attribute::Preallocated);
   }
 
   /// Determine whether passing undef to this argument is undefined behavior.
@@ -1806,7 +1823,7 @@ class CallBase : public Instruction {
   /// Determine if there are is an inalloca argument. Only the last argument can
   /// have the inalloca attribute.
   bool hasInAllocaArgument() const {
-    return !arg_empty() && paramHasAttr(arg_size() - 1, Attribute::InAlloca);
+    return !arg_empty() && hasABIParamAttr(arg_size() - 1, Attribute::InAlloca);
   }
 
   // FIXME: Once this API is no longer duplicated in `CallSite`, rename this to
@@ -1852,49 +1869,29 @@ class CallBase : public Instruction {
     return Attrs.getParamStackAlignment(ArgNo);
   }
 
-  /// Extract the byref type for a call or parameter.
+  /// Extract the byref type for a call argument.
   Type *getParamByRefType(unsigned ArgNo) const {
-    if (auto *Ty = Attrs.getParamByRefType(ArgNo))
-      return Ty;
-    if (const Function *F = getCalledFunction())
-      return F->getAttributes().getParamByRefType(ArgNo);
-    return nullptr;
+    return Attrs.getParamByRefType(ArgNo);
   }
 
-  /// Extract the byval type for a call or parameter.
+  /// Extract the byval type for a call argument.
   Type *getParamByValType(unsigned ArgNo) const {
-    if (auto *Ty = Attrs.getParamByValType(ArgNo))
-      return Ty;
-    if (const Function *F = getCalledFunction())
-      return F->getAttributes().getParamByValType(ArgNo);
-    return nullptr;
+    return Attrs.getParamByValType(ArgNo);
   }
 
-  /// Extract the preallocated type for a call or parameter.
+  /// Extract the preallocated type for a call argument.
   Type *getParamPreallocatedType(unsigned ArgNo) const {
-    if (auto *Ty = Attrs.getParamPreallocatedType(ArgNo))
-      return Ty;
-    if (const Function *F = getCalledFunction())
-      return F->getAttributes().getParamPreallocatedType(ArgNo);
-    return nullptr;
+    return Attrs.getParamPreallocatedType(ArgNo);
   }
 
-  /// Extract the inalloca type for a call or parameter.
+  /// Extract the inalloca type for a call argument.
   Type *getParamInAllocaType(unsigned ArgNo) const {
-    if (auto *Ty = Attrs.getParamInAllocaType(ArgNo))
-      return Ty;
-    if (const Function *F = getCalledFunction())
-      return F->getAttributes().getParamInAllocaType(ArgNo);
-    return nullptr;
+    return Attrs.getParamInAllocaType(ArgNo);
   }
 
-  /// Extract the sret type for a call or parameter.
+  /// Extract the sret type for a call argument.
   Type *getParamStructRetType(unsigned ArgNo) const {
-    if (auto *Ty = Attrs.getParamStructRetType(ArgNo))
-      return Ty;
-    if (const Function *F = getCalledFunction())
-      return F->getAttributes().getParamStructRetType(ArgNo);
-    return nullptr;
+    return Attrs.getParamStructRetType(ArgNo);
   }
 
   /// Extract the elementtype type for a parameter.
@@ -2043,8 +2040,7 @@ class CallBase : public Instruction {
     if (arg_empty())
       return false;
 
-    // Be friendly and also check the callee.
-    return paramHasAttr(0, Attribute::StructRet);
+    return hasABIParamAttr(0, Attribute::StructRet);
   }
 
   /// Determine if any call argument is an aggregate passed by value.
diff --git a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
index 4aebb4b9f37f6..0fe20977bc77e 100644
--- a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
+++ b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
@@ -2288,7 +2288,7 @@ static AssignmentTrackingLowering::OverlapMap buildOverlapMapAndRecordDeclares(
             CB->paramHasAttr(ArgIdx, Attribute::ReadNone))
           continue;
         // Skip byval args.  The callee gets a copy, not the original.
-        if (CB->paramHasAttr(ArgIdx, Attribute::ByVal))
+        if (CB->isByValArgument(ArgIdx))
           continue;
 
         auto *AI = dyn_cast<AllocaInst>(getUnderlyingObject(Arg));
diff --git a/llvm/lib/CodeGen/GlobalISel/CallLowering.cpp b/llvm/lib/CodeGen/GlobalISel/CallLowering.cpp
index a580b78462453..2993036697b6d 100644
--- a/llvm/lib/CodeGen/GlobalISel/CallLowering.cpp
+++ b/llvm/lib/CodeGen/GlobalISel/CallLowering.cpp
@@ -84,8 +84,11 @@ ISD::ArgFlagsTy CallLowering::getAttributesForArgIdx(const CallBase &Call,
   ISD::ArgFlagsTy Flags;
   const AttributeList &Attrs = Call.getAttributes();
   addFlagsFromAttrSet(Flags, Attrs.getParamAttrs(ArgIdx));
-  if (const Function *F = Call.getCalledFunction())
-    addFlagsFromAttrSet(Flags, F->getAttributes().getParamAttrs(ArgIdx));
+  if (const Function *F = Call.getCalledFunction()) {
+    // "returned" is not an ABI attribute, so we can inherit it from the callee.
+    if (F->hasParamAttribute(ArgIdx, Attribute::Returned))
+      Flags.setReturned();
+  }
   return Flags;
 }
 
@@ -93,8 +96,6 @@ ISD::ArgFlagsTy
 CallLowering::getAttributesForReturn(const CallBase &Call) const {
   ISD::ArgFlagsTy Flags;
   addFlagsFromAttrSet(Flags, Call.getAttributes().getRetAttrs());
-  if (const Function *F = Call.getCalledFunction())
-    addFlagsFromAttrSet(Flags, F->getAttributes().getRetAttrs());
   return Flags;
 }
 
diff --git a/llvm/lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp b/llvm/lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp
index 6ca0592644a08..7f9776fda5c0b 100644
--- a/llvm/lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp
@@ -73,8 +73,8 @@ static ISD::NodeType getPreferredExtendForValue(const Instruction *I) {
       if (!CallI->isArgOperand(&U))
         continue;
       unsigned ArgNo = CallI->getArgOperandNo(&U);
-      NumOfUnsigned += CallI->paramHasAttr(ArgNo, Attribute::ZExt);
-      NumOfSigned += CallI->paramHasAttr(ArgNo, Attribute::SExt);
+      NumOfUnsigned += CallI->hasABIParamAttr(ArgNo, Attribute::ZExt);
+      NumOfSigned += CallI->hasABIParamAttr(ArgNo, Attribute::SExt);
     }
   }
   if (NumOfSigned > NumOfUnsigned)
diff --git a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
index 00153ef66cf2c..d2e95e14e70df 100644
--- a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
@@ -119,19 +119,19 @@ bool TargetLowering::parametersInCSRMatch(const MachineRegisterInfo &MRI,
 /// and called function attributes.
 void TargetLoweringBase::ArgListEntry::setAttributes(const CallBase *Call,
                                                      unsigned ArgIdx) {
-  IsSExt = Call->paramHasAttr(ArgIdx, Attribute::SExt);
-  IsZExt = Call->paramHasAttr(ArgIdx, Attribute::ZExt);
-  IsNoExt = Call->paramHasAttr(ArgIdx, Attribute::NoExt);
-  IsInReg = Call->paramHasAttr(ArgIdx, Attribute::InReg);
-  IsSRet = Call->paramHasAttr(ArgIdx, Attribute::StructRet);
-  IsNest = Call->paramHasAttr(ArgIdx, Attribute::Nest);
-  IsByVal = Call->paramHasAttr(ArgIdx, Attribute::ByVal);
-  IsPreallocated = Call->paramHasAttr(ArgIdx, Attribute::Preallocated);
-  IsInAlloca = Call->paramHasAttr(ArgIdx, Attribute::InAlloca);
+  IsSExt = Call->hasABIParamAttr(ArgIdx, Attribute::SExt);
+  IsZExt = Call->hasABIParamAttr(ArgIdx, Attribute::ZExt);
+  IsNoExt = Call->hasABIParamAttr(ArgIdx, Attribute::NoExt);
+  IsInReg = Call->hasABIParamAttr(ArgIdx, Attribute::InReg);
+  IsSRet = Call->hasABIParamAttr(ArgIdx, Attribute::StructRet);
+  IsNest = Call->hasABIParamAttr(ArgIdx, Attribute::Nest);
+  IsByVal = Call->hasABIParamAttr(ArgIdx, Attribute::ByVal);
+  IsPreallocated = Call->hasABIParamAttr(ArgIdx, Attribute::Preallocated);
+  IsInAlloca = Call->hasABIParamAttr(ArgIdx, Attribute::InAlloca);
   IsReturned = Call->paramHasAttr(ArgIdx, Attribute::Returned);
-  IsSwiftSelf = Call->paramHasAttr(ArgIdx, Attribute::SwiftSelf);
-  IsSwiftAsync = Call->paramHasAttr(ArgIdx, Attribute::SwiftAsync);
-  IsSwiftError = Call->paramHasAttr(ArgIdx, Attribute::SwiftError);
+  IsSwiftSelf = Call->hasABIParamAttr(ArgIdx, Attribute::SwiftSelf);
+  IsSwiftAsync = Call->hasABIParamAttr(ArgIdx, Attribute::SwiftAsync);
+  IsSwiftError = Call->hasABIParamAttr(ArgIdx, Attribute::SwiftError);
   Alignment = Call->getParamStackAlign(ArgIdx);
   IndirectType = nullptr;
   assert(IsByVal + IsPreallocated + IsInAlloca + IsSRet <= 1 &&
diff --git a/llvm/lib/CodeGen/TypePromotion.cpp b/llvm/lib/CodeGen/TypePromotion.cpp
index 77f82b3851904..82f68611d318b 100644
--- a/llvm/lib/CodeGen/TypePromotion.cpp
+++ b/llvm/lib/CodeGen/TypePromotion.cpp
@@ -237,7 +237,7 @@ bool TypePromotionImpl::isSource(Value *V) {
   else if (isa<LoadInst>(V))
     return true;
   else if (auto *Call = dyn_cast<CallInst>(V))
-    return Call->hasRetAttr(Attribute::AttrKind::ZExt);
+    return Call->hasABIRetAttr(Attribute::AttrKind::ZExt);
   else if (auto *Trunc = dyn_cast<TruncInst>(V))
     return EqualTypeSize(Trunc);
   return false;
@@ -759,7 +759,7 @@ bool TypePromotionImpl::isSupportedValue(Value *V) {
       // can still be sinks.
       auto *Call = cast<CallInst>(I);
       return isSupportedType(Call) &&
-             Call->hasRetAttr(Attribute::AttrKind::ZExt);
+             Call->hasABIRetAttr(Attribute::AttrKind::ZExt);
     }
     }
   } else if (isa<Constant>(V) && !isa<ConstantExpr>(V)) {
diff --git a/llvm/lib/IR/Attributes.cpp b/llvm/lib/IR/Attributes.cpp
index 4087b25951a1c..0f9f0c572b2c7 100644
--- a/llvm/lib/IR/Attributes.cpp
+++ b/llvm/lib/IR/Attributes.cpp
@@ -842,6 +842,28 @@ bool Attribute::canUseAsRetAttr(AttrKind Kind) {
   return hasAttributeProperty(Kind, AttributeProperty::RetAttr);
 }
 
+bool Attribute::isABIAttr(AttrKind Kind) {
+  switch (Kind) {
+  case Attribute::ByRef:
+  case Attribute::ByVal:
+  case Attribute::InAlloca:
+  case Attribute::InReg:
+  case Attribute::Nest:
+  case Attribute::NoExt:
+  case Attribute::Preallocated:
+  case Attribute::SExt:
+  case Attribute::StackAlignment:
+  case Attribute::StructRet:
+  case Attribute::SwiftAsync:
+  case Attribute::SwiftError:
+  case Attribute::SwiftSelf:
+  case Attribute::ZExt:
+    return true;
+  default:
+    return false;
+  }
+}
+
 static bool hasIntersectProperty(Attribute::AttrKind Kind,
                                  AttributeProperty Prop) {
   assert((Prop == AttributeProperty::IntersectPreserve ||
diff --git a/llvm/lib/IR/Instructions.cpp b/llvm/lib/IR/Instructions.cpp
index faa046729aff6..94f164cca2c16 100644
--- a/llvm/lib/IR/Instructions.cpp
+++ b/llvm/lib/IR/Instructions.cpp
@@ -415,6 +415,7 @@ Value *CallBase::getArgOperandWithAttribute(Attribute::AttrKind Kind) const {
 /// Determine whether the argument or parameter has the given attribute.
 bool CallBase::paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
   assert(ArgNo < arg_size() && "Param index out of bounds!");
+  assert(!Attribute::isABIAttr(Kind) && "Use hasABIParamAttr() instead");
 
   if (Attrs.hasParamAttr(ArgNo, Kind))
     return true;
diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp
index 5f8b5e187bf14..a3a3bc35783c5 100644
--- a/llvm/lib/IR/Verifier.cpp
+++ b/llvm/lib/IR/Verifier.cpp
@@ -3861,7 +3861,7 @@ void Verifier::visitCallBase(CallBase &Call) {
   // make sure the underlying alloca/parameter it comes from has a swifterror as
   // well.
   for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
-    if (Call.paramHasAttr(i, Attribute::SwiftError)) {
+    if (Call.hasABIParamAttr(i, Attribute::SwiftError)) {
       Value *SwiftErrorArg = Call.getArgOperand(i);
       if (auto AI = dyn_cast<AllocaInst>(SwiftErrorArg->stripInBoundsOffsets())) {
         Check(AI->isSwiftError(),
@@ -3905,7 +3905,7 @@ void Verifier::visitCallBase(CallBase &Call) {
       }
     }
 
-    if (Call.paramHasAttr(i, Attribute::Preallocated)) {
+    if (Call.hasABIParamAttr(i, Attribute::Preallocated)) {
       Value *ArgVal = Call.getArgOperand(i);
       bool hasOB =
           Call.countOperandBundlesOfType(LLVMContext::OB_preallocated) != 0;
@@ -4586,7 +4586,7 @@ void Verifier::verifySwiftErrorCall(CallBase &Call,
                                     const Value *SwiftErrorVal) {
   for (const auto &I : llvm::enumerate(Call.args())) {
     if (I.value() == SwiftErrorVal) {
-      Check(Call.paramHasAttr(I.index(), Attribute::SwiftError),
+      Check(Call.hasABIParamAttr(I.index(), Attribute::SwiftError),
             "swifterror value when used in a callsite should be marked "
             "with swifterror attribute",
             SwiftErrorVal, Call);
@@ -6214,7 +6214,7 @@ void Verifier::visitIntrinsicCall(Intrinsic::ID ID, CallBase &Call) {
         FoundCall = true;
         size_t NumPreallocatedArgs = 0;
         for (unsigned i = 0; i < UseCall->arg_size(); i++) {
-          if (UseCall->paramHasAttr(i, Attribute::Preallocated)) {
+          if (UseCall->hasABIParamAttr(i, Attribute::Preallocated)) {
             ++NumPreallocatedArgs;
           }
         }
diff --git a/llvm/lib/IR/VerifierAMDGPU.cpp b/llvm/lib/IR/VerifierAMDGPU.cpp
index 04cb214ef2520..503cef418d335 100644
--- a/llvm/lib/IR/VerifierAMDGPU.cpp
+++ b/llvm/lib/IR/VerifierAMDGPU.cpp
@@ -171,9 +171,9 @@ void llvm::verifyAMDGPUIntrinsicCall(VerifierSupport &VS, Intrinsic::ID ID,
       break;
     }
 
-    Check(Call.paramHasAttr(2, Attribute::InReg),
+    Check(Call.hasABIParamAttr(2, Attribute::InReg),
           "SGPR arguments must have the `inreg` attribute", &Call);
-    Check(!Call.paramHasAttr(3, Attribute::InReg),
+    Check(!Call.hasABIParamAttr(3, Attribute::InReg),
           "VGPR arguments must not have the `inreg` attribute", &Call);
 
     ConstantInt *FlagsArg = cast<ConstantInt>(Call.getArgOperand(4));
@@ -211,7 +211,7 @@ void llvm::verifyAMDGPUIntrinsicCall(VerifierSupport &VS, Intrinsic::ID ID,
     }
 
     unsigned InactiveIdx = 1;
-    Check(!Call.paramHasAttr(InactiveIdx, Attribute::InReg),
+    Check(!Call.hasABIParamAttr(InactiveIdx, Attribute::InReg),
           "Value for inactive lanes must not have the `inreg` attribute",
           &Call);
     Check(isa<Argument>(Call.getArgOperand(InactiveIdx)),
@@ -241,7 +241,7 @@ void llvm::verifyAMDGPUIntrinsicCall(VerifierSupport &VS, Intrinsic::ID ID,
       Check(CallArg->getType() == FuncArg.getType(),
             "Argument types must match", &Call);
 
-      Check(Call.paramHasAttr(FuncArg.getArgNo(), Attribute::InReg) ==
+      Check(Call.hasABIParamAttr(FuncArg.getArgNo(), Attribute::InReg) ==
                 FuncArg.hasInRegAttr(),
             "Argument inreg attributes must match", &Call);
     }
diff --git a/llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp b/llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp
index 3ae1ae40ca34a..15ee8906810de 100644
--- a/llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp
+++ b/llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp
@@ -3356,10 +3356,10 @@ bool isArgPassedInSGPR(const CallBase *CB, unsigned ArgNo) {
   case CallingConv::AMDGPU_CS_ChainPreserve:
     // For non-compute shaders, SGPR inputs are marked with either inreg or
     // byval. Everything else is in VGPRs.
-    return CB->paramHasAttr(ArgNo, Attribute::InReg) ||
-           CB->paramHasAttr(ArgNo, Attribute::ByVal);
+    return CB->hasABIParamAttr(ArgNo, Attribute::InReg) ||
+           CB->isByValArgument(ArgNo);
   default:
-    return CB->paramHasAttr(ArgNo, Attribute::InReg);
+    return CB->hasABIParamAttr(ArgNo, Attribute::InReg);
   }
 }
 
diff --git a/llvm/lib/Target/ARM/ARMFastISel.cpp b/llvm/lib/Target/ARM/ARMFastISel.cpp
index 1cf0d98f690aa..6010f8f674c9e 100644
--- a/llvm/lib/Target/ARM/ARMFastISel.cpp
+++ b/llvm/lib/Target/ARM/ARMFastISel.cpp
@@ -2425,18 +2425,18 @@ bool ARMFastISel::SelectCall(const Instruction *I,
 
     ISD::ArgFlagsTy Flags;
     unsigned ArgIdx = ArgI - CI->arg_begin();
-    if (CI->paramHasAttr(ArgIdx, Attribute::SExt))
+    if (CI->hasABIParamAttr(ArgIdx, Attribute::SExt))
       Flags.setSExt();
-    if (CI->paramHasAttr(ArgIdx, Attribute::ZExt))
+    if (CI->hasABIParamAttr(ArgIdx, Attribute::ZExt))
       Flags.setZExt();
 
     // FIXME: Only handle *easy* calls for now.
-    if (CI->paramHasAttr(ArgIdx, Attribute::InReg) ||
-        CI->paramHasAttr(ArgIdx, Attribute::StructRet) ||
-        CI->paramHasAttr(ArgIdx, Attribute::SwiftSelf) ||
-        CI->paramHasAttr(ArgIdx, Attribute::SwiftError) ||
-        CI->paramHasAttr(ArgIdx, Attribute::Nest) ||
-        CI->paramHasAttr(ArgIdx, Attribute::ByVal))
+    if (CI->hasABIParamAttr(ArgIdx, Attribute::InReg) ||
+        CI->hasABIParamAttr(ArgIdx, Attribute::StructRet) ||
+        CI->hasABIParamAttr(ArgIdx, Attribute::SwiftSelf) ||
+        CI->hasABIParamAttr(ArgIdx, Attribute::SwiftError) ||
+        CI->hasABIParamAttr(ArgIdx, Attribute::Nest) ||
+        CI->hasABIParamAttr(ArgIdx, Attribute::ByVal))
       return false;
 
     Type *ArgTy = (*ArgI)->getType();
diff --git a/llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp b/llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp
index 94acde4b22b5e..a3cdb86d0d09c 100644
--- a/llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp
+++ b/llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp
@@ -361,7 +361,7 @@ void NVPTXAsmPrinter::emitCallPrototype(const CallBase &CB,
   auto MakeArg = [&](const unsigned I) {
     Type *Ty = CB.getArgOperand(I)->getType();
 
-    if (CB.paramHasAttr(I, Attribute::ByVal)) {
+    if (CB.isByValArgument(I)) {
       // Indirect calls need strict ABI alignment so we disable optimizations by
       // not providing a function to optimize.
       Type *ETy = CB.getParamByValType(I);
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp
index 95f4367f76cdf..52aec951a437c 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp
@@ -924,9 +924,9 @@ bool WebAssemblyFastISel::selectCall(const Instruction *I) {
 
     unsigned Reg;
 
-    if (Call->paramHasAttr(I, Attribute::SExt))
+    if (Call->hasABIParamAttr(I, Attribute::SExt))
       Reg = getRegForSignedValue(V);
-    else if (Call->paramHasAttr(I, Attribute::ZExt))
+    else if (Call->hasABIParamAttr(I, Attribute::ZExt))
       Reg = getRegForUnsignedValue(V);
     else
       Reg = getRegForValue(V);
diff --git a/llvm/lib/Target/X86/X86FastISel.cpp b/llvm/lib/Target/X86/X86FastISel.cpp
index 95d5cbe06da63..bf6c758b3ab23 100644
--- a/llvm/lib/Target/X86/X86FastISel.cpp
+++ b/llvm/lib/Target/X86/X86FastISel.cpp
@@ -3177,8 +3177,8 @@ static unsigned computeBytesPoppedByCalleeForSRet(const X86Subtarget *Subtarget,
     return 0;
 
   if (CB)
-    if (CB->arg_empty() || !CB->paramHasAttr(0, Attribute::StructRet) ||
-        CB->paramHasAttr(0, Attribute::InReg) || Subtarget->isTargetMCU())
+    if (CB->arg_empty() || !CB->hasStructRetAttr() ||
+        CB->hasABIParamAttr(0, Attribute::InReg) || Subtarget->isTargetMCU())
       return 0;
 
   return 4;
diff --git a/llvm/lib/Target/X86/X86ISelLoweringCall.cpp b/llvm/lib/Target/X86/X86ISelLoweringCall.cpp
index c42d81cd0d886..be44d66a9558a 100644
--- a/llvm/lib/Target/X86/X86ISelLoweringCall.cpp
+++ b/llvm/lib/Target/X86/X86ISelLoweringCall.cpp
@@ -2294,7 +2294,7 @@ X86TargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
            "parameter");
     SmallVector<size_t, 4> PreallocatedOffsets;
     for (size_t i = 0; i < CLI.OutVals.size(); ++i) {
-      if (CLI.CB->paramHasAttr(i, Attribute::Preallocated)) {
+      if (CLI.CB->hasABIParamAttr(i, Attribute::Preallocated)) {
         PreallocatedOffsets.push_back(ArgLocs[i].getLocMemOffset());
       }
     }
diff --git a/llvm/lib/Transforms/IPO/ExpandVariadics.cpp b/llvm/lib/Transforms/IPO/ExpandVariadics.cpp
index 2996657bc693a..41ad89e48ce36 100644
--- a/llvm/lib/Transforms/IPO/ExpandVariadics.cpp
+++ b/llvm/lib/Transforms/IPO/ExpandVariadics.cpp
@@ -680,8 +680,8 @@ bool ExpandVariadics::expandCall(Module &M, IRBuilder<> &Builder, CallBase *CB,
 
   for (unsigned I : seq(VarargFunctionType->getNumParams(), CB->arg_size())) {
     Value *ArgVal = CB->getArgOperand(I);
-    const bool IsByVal = CB->paramHasAttr(I, Attribute::ByVal);
-    const bool IsByRef = CB->paramHasAttr(I, Attribute::ByRef);
+    const bool IsByVal = CB->hasABIParamAttr(I, Attribute::ByVal);
+    const bool IsByRef = CB->hasABIParamAttr(I, Attribute::ByRef);
 
     // The type of the value being passed, decoded from byval/byref metadata if
     // required
diff --git a/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp b/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp
index cdce2e039154f..7a57d48a841a7 100644
--- a/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp
+++ b/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp
@@ -7504,7 +7504,7 @@ struct MemorySanitizerVisitor : public InstVisitor<MemorySanitizerVisitor> {
       unsigned Size = 0;
       const DataLayout &DL = F.getDataLayout();
 
-      bool ByVal = CB.paramHasAttr(i, Attribute::ByVal);
+      bool ByVal = CB.isByValArgument(i);
       bool NoUndef = CB.paramHasAttr(i, Attribute::NoUndef);
       bool EagerCheck = MayCheckCall && !ByVal && NoUndef;
 
@@ -8192,7 +8192,7 @@ struct VarArgAMD64Helper : public VarArgHelperBase {
 
     for (const auto &[ArgNo, A] : llvm::enumerate(CB.args())) {
       bool IsFixed = ArgNo < CB.getFunctionType()->getNumParams();
-      bool IsByVal = CB.paramHasAttr(ArgNo, Attribute::ByVal);
+      bool IsByVal = CB.isByValArgument(ArgNo);
       if (IsByVal) {
         // ByVal arguments always go to the overflow area.
         // Fixed arguments passed through the overflow area will be stepped
@@ -8621,7 +8621,7 @@ struct VarArgPowerPC64Helper : public VarArgHelperBase {
     const DataLayout &DL = F.getDataLayout();
     for (const auto &[ArgNo, A] : llvm::enumerate(CB.args())) {
       bool IsFixed = ArgNo < CB.getFunctionType()->getNumParams();
-      bool IsByVal = CB.paramHasAttr(ArgNo, Attribute::ByVal);
+      bool IsByVal = CB.isByValArgument(ArgNo);
       if (IsByVal) {
         assert(A->getType()->isPointerTy());
         Type *RealTy = CB.getParamByValType(ArgNo);
@@ -8751,7 +8751,7 @@ struct VarArgPowerPC32Helper : public VarArgHelperBase {
     unsigned IntptrSize = DL.getTypeStoreSize(MS.IntptrTy);
     for (const auto &[ArgNo, A] : llvm::enumerate(CB.args())) {
       bool IsFixed = ArgNo < CB.getFunctionType()->getNumParams();
-      bool IsByVal = CB.paramHasAttr(ArgNo, Attribute::ByVal);
+      bool IsByVal = CB.isByValArgument(ArgNo);
       if (IsByVal) {
         assert(A->getType()->isPointerTy());
         Type *RealTy = CB.getParamByValType(ArgNo);
@@ -8975,8 +8975,8 @@ struct VarArgSystemZHelper : public VarArgHelperBase {
     // 64-bit integer representing the same number, using sign or zero
     // extension". Shadow for an integer argument has the same type as the
     // argument itself, so it can be sign or zero extended as well.
-    bool ZExt = CB.paramHasAttr(ArgNo, Attribute::ZExt);
-    bool SExt = CB.paramHasAttr(ArgNo, Attribute::SExt);
+    bool ZExt = CB.hasABIParamAttr(ArgNo, Attribute::ZExt);
+    bool SExt = CB.hasABIParamAttr(ArgNo, Attribute::SExt);
     if (ZExt) {
       assert(!SExt);
       return ShadowExtension::Zero;
@@ -8997,7 +8997,7 @@ struct VarArgSystemZHelper : public VarArgHelperBase {
     for (const auto &[ArgNo, A] : llvm::enumerate(CB.args())) {
       bool IsFixed = ArgNo < CB.getFunctionType()->getNumParams();
       // SystemZABIInfo does not produce ByVal parameters.
-      assert(!CB.paramHasAttr(ArgNo, Attribute::ByVal));
+      assert(!CB.isByValArgument(ArgNo));
       Type *T = A->getType();
       ArgKind AK = classifyArgument(T);
       if (AK == ArgKind::Indirect) {
@@ -9214,7 +9214,7 @@ struct VarArgI386Helper : public VarArgHelperBase {
     unsigned VAArgOffset = 0;
     for (const auto &[ArgNo, A] : llvm::enumerate(CB.args())) {
       bool IsFixed = ArgNo < CB.getFunctionType()->getNumParams();
-      bool IsByVal = CB.paramHasAttr(ArgNo, Attribute::ByVal);
+      bool IsByVal = CB.isByValArgument(ArgNo);
       if (IsByVal) {
         assert(A->getType()->isPointerTy());
         Type *RealTy = CB.getParamByValType(ArgNo);
diff --git a/llvm/lib/Transforms/Utils/CallPromotionUtils.cpp b/llvm/lib/Transforms/Utils/CallPromotionUtils.cpp
index 1bfeea3b711f9..dd0c32dffcefb 100644
--- a/llvm/lib/Transforms/Utils/CallPromotionUtils.cpp
+++ b/llvm/lib/Transforms/Utils/CallPromotionUtils.cpp
@@ -470,7 +470,7 @@ bool llvm::isLegalToPromote(const CallBase &CB, Function *Callee,
   for (; I < NumArgs; I++) {
     // Vararg functions can have more arguments than parameters.
     assert(Callee->isVarArg());
-    if (CB.paramHasAttr(I, Attribute::StructRet)) {
+    if (CB.hasABIParamAttr(I, Attribute::StructRet)) {
       if (FailureReason)
         *FailureReason = "SRet arg to vararg function";
       return false;
diff --git a/llvm/lib/Transforms/Utils/InlineFunction.cpp b/llvm/lib/Transforms/Utils/InlineFunction.cpp
index c8fe3da956c76..a672387f007ee 100644
--- a/llvm/lib/Transforms/Utils/InlineFunction.cpp
+++ b/llvm/lib/Transforms/Utils/InlineFunction.cpp
@@ -1533,7 +1533,7 @@ static void AddParamAndFnBasicAttributes(const CallBase &CB,
         // attributes to byval arguments. Even if CalledFunction
         // doesn't e.g. write to the argument (readonly), the call to
         // NewInnerCB may write to its by-value copy.
-        if (NewInnerCB->paramHasAttr(I, Attribute::ByVal))
+        if (NewInnerCB->isByValArgument(I))
           continue;
 
         // Don't bother propagating attrs to constants.
diff --git a/llvm/test/Analysis/BasicAA/call-attrs.ll b/llvm/test/Analysis/BasicAA/call-attrs.ll
index f6e92dd34ff7f..aa5fd471c52ba 100644
--- a/llvm/test/Analysis/BasicAA/call-attrs.ll
+++ b/llvm/test/Analysis/BasicAA/call-attrs.ll
@@ -25,7 +25,7 @@ entry:
   call void @readnone_attr(ptr %p)
   call void @readnone_func(ptr %p)
 
-  call void @byval_attr(ptr %p)
+  call void @byval_attr(ptr byval(i32) %p)
 
   call void @read_write(ptr %p, ptr %p, ptr %p)
 
@@ -41,7 +41,7 @@ entry:
 ; CHECK:  Just Mod:  Ptr: i8* %p	<->  call void @writeonly_func(ptr %p)
 ; CHECK:  NoModRef:  Ptr: i8* %p	<->  call void @readnone_attr(ptr %p)
 ; CHECK:  NoModRef:  Ptr: i8* %p	<->  call void @readnone_func(ptr %p)
-; CHECK:  Just Ref:  Ptr: i8* %p	<->  call void @byval_attr(ptr %p)
+; CHECK:  Just Ref:  Ptr: i8* %p	<->  call void @byval_attr(ptr byval(i32) %p)
 ; CHECK:  Both ModRef:  Ptr: i8* %p	<->  call void @read_write(ptr %p, ptr %p, ptr %p)
 ; CHECK:  Just Ref:  Ptr: i8* %p	<->  call void @func() [ "deopt"(ptr %p) ]
 ; CHECK:  Both ModRef:  Ptr: i8* %p	<->  call void @writeonly_attr(ptr %p) [ "deopt"(ptr %p) ]
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/call-translator-tail-call-sret.ll b/llvm/test/CodeGen/AArch64/GlobalISel/call-translator-tail-call-sret.ll
index 545d854f047ec..c60b9e5cc840a 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/call-translator-tail-call-sret.ll
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/call-translator-tail-call-sret.ll
@@ -13,7 +13,7 @@ define void @can_tail_call_forwarded_explicit_sret_ptr(ptr sret(i64) %arg) {
   ; CHECK-NEXT:   [[COPY:%[0-9]+]]:_(p0) = COPY $x8
   ; CHECK-NEXT:   $x8 = COPY [[COPY]](p0)
   ; CHECK-NEXT:   TCRETURNdi @test_explicit_sret, 0, csr_darwin_aarch64_aapcs, implicit $sp, implicit $x8
-  tail call void @test_explicit_sret(ptr %arg)
+  tail call void @test_explicit_sret(ptr sret(i64) %arg)
   ret void
 }
 
@@ -29,7 +29,7 @@ define void @test_call_explicit_sret(ptr sret(i64) %arg) {
   ; CHECK-NEXT:   BL @test_explicit_sret, csr_darwin_aarch64_aapcs, implicit-def $lr, implicit $sp, implicit $x8
   ; CHECK-NEXT:   ADJCALLSTACKUP 0, 0, implicit-def $sp, implicit $sp
   ; CHECK-NEXT:   RET_ReallyLR
-  call void @test_explicit_sret(ptr %arg)
+  call void @test_explicit_sret(ptr sret(i64) %arg)
   ret void
 }
 
@@ -43,7 +43,7 @@ define void @dont_tail_call_explicit_sret_alloca_unused() {
   ; CHECK-NEXT:   ADJCALLSTACKUP 0, 0, implicit-def $sp, implicit $sp
   ; CHECK-NEXT:   RET_ReallyLR
   %l = alloca i64, align 8
-  tail call void @test_explicit_sret(ptr %l)
+  tail call void @test_explicit_sret(ptr sret(i64) %l)
   ret void
 }
 
@@ -64,7 +64,7 @@ define void @dont_tail_call_explicit_sret_alloca_dummyusers(ptr %ptr) {
   %l = alloca i64, align 8
   %r = load i64, ptr %ptr, align 8
   store i64 %r, ptr %l, align 8
-  tail call void @test_explicit_sret(ptr %l)
+  tail call void @test_explicit_sret(ptr sret(i64) %l)
   ret void
 }
 
@@ -82,7 +82,7 @@ define void @dont_tail_call_tailcall_explicit_sret_gep(ptr %ptr) {
   ; CHECK-NEXT:   ADJCALLSTACKUP 0, 0, implicit-def $sp, implicit $sp
   ; CHECK-NEXT:   RET_ReallyLR
   %ptr2 = getelementptr i64, ptr %ptr, i32 1
-  tail call void @test_explicit_sret(ptr %ptr2)
+  tail call void @test_explicit_sret(ptr sret(i64) %ptr2)
   ret void
 }
 
@@ -98,7 +98,7 @@ define i64 @dont_tail_call_sret_alloca_returned() {
   ; CHECK-NEXT:   $x0 = COPY [[LOAD]](i64)
   ; CHECK-NEXT:   RET_ReallyLR implicit $x0
   %l = alloca i64, align 8
-  tail call void @test_explicit_sret(ptr %l)
+  tail call void @test_explicit_sret(ptr sret(i64) %l)
   %r = load i64, ptr %l, align 8
   ret i64 %r
 }
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/call-translator.ll b/llvm/test/CodeGen/AArch64/GlobalISel/call-translator.ll
index 25baf6a295b14..2071f8eed9fa4 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/call-translator.ll
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/call-translator.ll
@@ -151,13 +151,14 @@ define void @test_abi_exts_call(ptr %addr) {
   ret void
 }
 
+; zeroext on callee is not inherited.
 ; CHECK-LABEL: name: test_zext_in_callee
 ; CHECK: bb.1 (%ir-block.0):
 ; CHECK:   liveins: $x0
 ; CHECK:   [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 ; CHECK:   [[LOAD:%[0-9]+]]:_(i8) = G_LOAD [[COPY]](p0) :: (load (i8) from %ir.addr)
 ; CHECK:   ADJCALLSTACKDOWN 0, 0, implicit-def $sp, implicit $sp
-; CHECK:   [[ZEXT:%[0-9]+]]:_(i32) = G_ZEXT [[LOAD]](i8)
+; CHECK:   [[ZEXT:%[0-9]+]]:_(i32) = G_ANYEXT [[LOAD]](i8)
 ; CHECK:   $w0 = COPY [[ZEXT]](i32)
 ; CHECK:   BL @has_zext_param, csr_aarch64_aapcs, implicit-def $lr, implicit $sp, implicit $w0
 ; CHECK:   ADJCALLSTACKUP 0, 0, implicit-def $sp, implicit $sp
@@ -169,13 +170,14 @@ define void @test_zext_in_callee(ptr %addr) {
   ret void
 }
 
+; signext on callee is not inherited.
 ; CHECK-LABEL: name: test_sext_in_callee
 ; CHECK: bb.1 (%ir-block.0):
 ; CHECK:   liveins: $x0
 ; CHECK:   [[COPY:%[0-9]+]]:_(p0) = COPY $x0
 ; CHECK:   [[LOAD:%[0-9]+]]:_(i8) = G_LOAD [[COPY]](p0) :: (load (i8) from %ir.addr)
 ; CHECK:   ADJCALLSTACKDOWN 0, 0, implicit-def $sp, implicit $sp
-; CHECK:   [[SEXT:%[0-9]+]]:_(i32) = G_SEXT [[LOAD]](i8)
+; CHECK:   [[SEXT:%[0-9]+]]:_(i32) = G_ANYEXT [[LOAD]](i8)
 ; CHECK:   $w0 = COPY [[SEXT]](i32)
 ; CHECK:   BL @has_sext_param, csr_aarch64_aapcs, implicit-def $lr, implicit $sp, implicit $w0
 ; CHECK:   ADJCALLSTACKUP 0, 0, implicit-def $sp, implicit $sp
@@ -364,7 +366,7 @@ define void @call_returns_array_size0_struct() {
 
 ; Test extends on return values.
 
-; This should notice that the return value from has_zext_return is zero
+; This should *not* assume that the return value from has_zext_return is zero
 ; extended.
 declare zeroext i16 @has_zext_return()
 define i32 @test_zext_return_from_callee() {
@@ -374,8 +376,7 @@ define i32 @test_zext_return_from_callee() {
   ; CHECK-NEXT:   BL @has_zext_return, csr_aarch64_aapcs, implicit-def $lr, implicit $sp, implicit-def $w0
   ; CHECK-NEXT:   ADJCALLSTACKUP 0, 0, implicit-def $sp, implicit $sp
   ; CHECK-NEXT:   [[COPY:%[0-9]+]]:_(i32) = COPY $w0
-  ; CHECK-NEXT:   [[ASSERT_ZEXT:%[0-9]+]]:_(i32) = G_ASSERT_ZEXT [[COPY]], 16
-  ; CHECK-NEXT:   [[TRUNC:%[0-9]+]]:_(i16) = G_TRUNC [[ASSERT_ZEXT]](i32)
+  ; CHECK-NEXT:   [[TRUNC:%[0-9]+]]:_(i16) = G_TRUNC [[COPY]](i32)
   ; CHECK-NEXT:   [[ZEXT:%[0-9]+]]:_(i32) = G_ZEXT [[TRUNC]](i16)
   ; CHECK-NEXT:   $w0 = COPY [[ZEXT]](i32)
   ; CHECK-NEXT:   RET_ReallyLR implicit $w0
@@ -403,7 +404,7 @@ define i32 @test_zext_return_from_callee2() {
   ret i32 %ext
 }
 
-; This should notice that the return value from has_sext_return is sign
+; This should *not* assume that the return value from has_sext_return is sign
 ; extended.
 declare signext i16 @has_sext_return()
 define i32 @test_sext_return_from_callee() {
@@ -413,8 +414,7 @@ define i32 @test_sext_return_from_callee() {
   ; CHECK-NEXT:   BL @has_sext_return, csr_aarch64_aapcs, implicit-def $lr, implicit $sp, implicit-def $w0
   ; CHECK-NEXT:   ADJCALLSTACKUP 0, 0, implicit-def $sp, implicit $sp
   ; CHECK-NEXT:   [[COPY:%[0-9]+]]:_(i32) = COPY $w0
-  ; CHECK-NEXT:   [[ASSERT_SEXT:%[0-9]+]]:_(i32) = G_ASSERT_SEXT [[COPY]], 16
-  ; CHECK-NEXT:   [[TRUNC:%[0-9]+]]:_(i16) = G_TRUNC [[ASSERT_SEXT]](i32)
+  ; CHECK-NEXT:   [[TRUNC:%[0-9]+]]:_(i16) = G_TRUNC [[COPY]](i32)
   ; CHECK-NEXT:   [[SEXT:%[0-9]+]]:_(i32) = G_SEXT [[TRUNC]](i16)
   ; CHECK-NEXT:   $w0 = COPY [[SEXT]](i32)
   ; CHECK-NEXT:   RET_ReallyLR implicit $w0
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/swifterror.ll b/llvm/test/CodeGen/AArch64/GlobalISel/swifterror.ll
index 78fc6ccc50663..26b042213972c 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/swifterror.ll
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/swifterror.ll
@@ -518,7 +518,7 @@ define float @swifterror_param_not_on_call(ptr %error_ref) {
 entry:
   %error_ptr_ref = alloca swifterror ptr
   store ptr null, ptr %error_ptr_ref
-  %call = call float @foo(ptr %error_ptr_ref)
+  %call = call float @foo(ptr swifterror %error_ptr_ref)
   %error_from_foo = load ptr, ptr %error_ptr_ref
   %had_error_from_foo = icmp ne ptr %error_from_foo, null
   br i1 %had_error_from_foo, label %handler, label %cont
@@ -550,7 +550,7 @@ entry:
   %s = alloca %struct.S, align 8
   %error_ptr_ref = alloca swifterror ptr
   store ptr null, ptr %error_ptr_ref
-  call void @foo_sret(ptr %s, i32 1, ptr %error_ptr_ref)
+  call void @foo_sret(ptr %s, i32 1, ptr swifterror %error_ptr_ref)
   %error_from_foo = load ptr, ptr %error_ptr_ref
   %had_error_from_foo = icmp ne ptr %error_from_foo, null
   br i1 %had_error_from_foo, label %handler, label %cont
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/swiftself.ll b/llvm/test/CodeGen/AArch64/GlobalISel/swiftself.ll
index b8c9102af3bb1..68872b18b76c0 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/swiftself.ll
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/swiftself.ll
@@ -61,10 +61,10 @@ entry:
   ret void
 }
 
-; Check that x20 is used to pass a swiftself argument when the parameter is
+; Check that x20 is NOT used to pass a swiftself argument when the attribute is
 ; only in the declaration's arguments.
 ; CHECK-LABEL: _swiftself_not_on_call_params:
-; CHECK: mov x20, x0
+; CHECK-NOT: mov{{.*}}x20
 ; CHECK: bl {{_?}}swiftself_param
 ; CHECK: ret
 define ptr @swiftself_not_on_call_params(ptr %arg) {
diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-call-return-values.ll b/llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-call-return-values.ll
index 6573088a41fc2..713ca4bb844af 100644
--- a/llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-call-return-values.ll
+++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-call-return-values.ll
@@ -286,7 +286,7 @@ define amdgpu_kernel void @test_call_external_i1_zeroext_func_void() #0 {
   ; GCN-NEXT:   [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[TRUNC]](s1)
   ; GCN-NEXT:   G_STORE [[ZEXT]](s32), [[DEF]](p1) :: (volatile store (s32) into `ptr addrspace(1) poison`, addrspace 1)
   ; GCN-NEXT:   S_ENDPGM 0
-  %val = call i1 @external_i1_zeroext_func_void()
+  %val = call zeroext i1 @external_i1_zeroext_func_void()
   %val.ext = zext i1 %val to i32
   store volatile i32 %val.ext, ptr addrspace(1) poison
   ret void
@@ -348,7 +348,7 @@ define amdgpu_kernel void @test_call_external_i1_signext_func_void() #0 {
   ; GCN-NEXT:   [[SEXT:%[0-9]+]]:_(s32) = G_SEXT [[TRUNC]](s1)
   ; GCN-NEXT:   G_STORE [[SEXT]](s32), [[DEF]](p1) :: (volatile store (s32) into `ptr addrspace(1) poison`, addrspace 1)
   ; GCN-NEXT:   S_ENDPGM 0
-  %val = call i1 @external_i1_signext_func_void()
+  %val = call signext i1 @external_i1_signext_func_void()
   %val.ext = sext i1 %val to i32
   store volatile i32 %val.ext, ptr addrspace(1) poison
   ret void
@@ -490,7 +490,7 @@ define amdgpu_kernel void @test_call_external_i8_zeroext_func_void() #0 {
   ; GCN-NEXT:   [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[TRUNC]](s8)
   ; GCN-NEXT:   G_STORE [[ZEXT]](s32), [[DEF]](p1) :: (volatile store (s32) into `ptr addrspace(1) poison`, addrspace 1)
   ; GCN-NEXT:   S_ENDPGM 0
-  %val = call i8 @external_i8_zeroext_func_void()
+  %val = call zeroext i8 @external_i8_zeroext_func_void()
   %val.ext = zext i8 %val to i32
   store volatile i32 %val.ext, ptr addrspace(1) poison
   ret void
@@ -552,7 +552,7 @@ define amdgpu_kernel void @test_call_external_i8_signext_func_void() #0 {
   ; GCN-NEXT:   [[SEXT:%[0-9]+]]:_(s32) = G_SEXT [[TRUNC]](s8)
   ; GCN-NEXT:   G_STORE [[SEXT]](s32), [[DEF]](p1) :: (volatile store (s32) into `ptr addrspace(1) poison`, addrspace 1)
   ; GCN-NEXT:   S_ENDPGM 0
-  %val = call i8 @external_i8_signext_func_void()
+  %val = call signext i8 @external_i8_signext_func_void()
   %val.ext = sext i8 %val to i32
   store volatile i32 %val.ext, ptr addrspace(1) poison
   ret void
@@ -673,7 +673,7 @@ define amdgpu_kernel void @test_call_external_i16_zeroext_func_void() #0 {
   ; GCN-NEXT:   [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[TRUNC]](s16)
   ; GCN-NEXT:   G_STORE [[ZEXT]](s32), [[DEF]](p1) :: (volatile store (s32) into `ptr addrspace(1) poison`, addrspace 1)
   ; GCN-NEXT:   S_ENDPGM 0
-  %val = call i16 @external_i16_zeroext_func_void()
+  %val = call zeroext i16 @external_i16_zeroext_func_void()
   %val.ext = zext i16 %val to i32
   store volatile i32 %val.ext, ptr addrspace(1) poison
   ret void
@@ -735,7 +735,7 @@ define amdgpu_kernel void @test_call_external_i16_signext_func_void() #0 {
   ; GCN-NEXT:   [[SEXT:%[0-9]+]]:_(s32) = G_SEXT [[TRUNC]](s16)
   ; GCN-NEXT:   G_STORE [[SEXT]](s32), [[DEF]](p1) :: (volatile store (s32) into `ptr addrspace(1) poison`, addrspace 1)
   ; GCN-NEXT:   S_ENDPGM 0
-  %val = call i16 @external_i16_signext_func_void()
+  %val = call signext i16 @external_i16_signext_func_void()
   %val.ext = sext i16 %val to i32
   store volatile i32 %val.ext, ptr addrspace(1) poison
   ret void
diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-call-sret.ll b/llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-call-sret.ll
index 070d35a99d62a..97e7e5e7e012c 100644
--- a/llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-call-sret.ll
+++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-call-sret.ll
@@ -80,7 +80,7 @@ define amdgpu_kernel void @test_call_external_void_func_sret_struct_i8_i32_byval
   %in.gep1 = getelementptr inbounds { i8, i32 }, ptr addrspace(5) %in.val, i32 0, i32 1
   store i8 3, ptr addrspace(5) %in.gep0
   store i32 8, ptr addrspace(5) %in.gep1
-  call void @external_void_func_sret_struct_i8_i32_byval_struct_i8_i32(ptr addrspace(5) %out.val, ptr addrspace(5) %in.val)
+  call void @external_void_func_sret_struct_i8_i32_byval_struct_i8_i32(ptr addrspace(5) sret({ i8, i32 }) %out.val, ptr addrspace(5) byval({ i8, i32 }) %in.val)
   %out.gep0 = getelementptr inbounds { i8, i32 }, ptr addrspace(5) %out.val, i32 0, i32 0
   %out.gep1 = getelementptr inbounds { i8, i32 }, ptr addrspace(5) %out.val, i32 0, i32 1
   %out.val0 = load i8, ptr addrspace(5) %out.gep0
diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-call.ll b/llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-call.ll
index 6d4b1606452c2..c32c8124caa3a 100644
--- a/llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-call.ll
+++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-call.ll
@@ -4183,7 +4183,7 @@ define void @call_byval_3ai32_byval_i8_align32(ptr addrspace(5) %incoming0, ptr
   ; CHECK-NEXT:   $sgpr30_sgpr31 = noconvergent G_SI_CALL [[GV]](p0), @void_func_byval_a3i32_byval_i8_align32, csr_amdgpu, implicit $vgpr0, implicit $sgpr0_sgpr1_sgpr2_sgpr3, implicit $sgpr4_sgpr5, implicit $sgpr6_sgpr7, implicit $sgpr8_sgpr9, implicit $sgpr10_sgpr11, implicit $sgpr12, implicit $sgpr13, implicit $sgpr14, implicit $sgpr15, implicit $vgpr31
   ; CHECK-NEXT:   ADJCALLSTACKDOWN 0, 36, implicit-def $scc
   ; CHECK-NEXT:   SI_RETURN
-  call void @void_func_byval_a3i32_byval_i8_align32(ptr addrspace(5) byval([3 x i32]) %incoming0, ptr addrspace(5) align 32 %incoming1, i32 999)
+  call void @void_func_byval_a3i32_byval_i8_align32(ptr addrspace(5) byval([3 x i32]) %incoming0, ptr addrspace(5) byval(i8) align 32 %incoming1, i32 999)
   ret void
 }
 
diff --git a/llvm/test/CodeGen/AMDGPU/fncall-implicitdef.ll b/llvm/test/CodeGen/AMDGPU/fncall-implicitdef.ll
index 66a8b424b5763..6c660ef8fee0d 100644
--- a/llvm/test/CodeGen/AMDGPU/fncall-implicitdef.ll
+++ b/llvm/test/CodeGen/AMDGPU/fncall-implicitdef.ll
@@ -18,7 +18,7 @@ define amdgpu_ps <4 x float> @caller(ptr %ptr) {
 ; CHECK-NEXT:    s_swappc_b64 s[30:31], s[4:5]
 ; CHECK-NEXT:    ; return to shader part epilog
   %L = load i32, ptr %ptr, align 4
-  %R = call <4 x float> @fn(<4 x i32> zeroinitializer, i32 0, i32 %L, i32 0)
+  %R = call <4 x float> @fn(<4 x i32> inreg zeroinitializer, i32 0, i32 %L, i32 0)
   ret <4 x float> %R
 }
 
diff --git a/llvm/test/CodeGen/AMDGPU/swdev504645-global-fold.ll b/llvm/test/CodeGen/AMDGPU/swdev504645-global-fold.ll
index 20443fd5574e7..f623ba2cc34fe 100644
--- a/llvm/test/CodeGen/AMDGPU/swdev504645-global-fold.ll
+++ b/llvm/test/CodeGen/AMDGPU/swdev504645-global-fold.ll
@@ -34,7 +34,7 @@ define void @test_load_zext() #0 {
 ; CHECK-NEXT:    s_setpc_b64 s[30:31]
 .entry:
   %reloc = call i32 @llvm.amdgcn.reloc.constant(metadata !0)
-  call void @has_spgr_args(i32 %reloc)
+  call void @has_spgr_args(i32 inreg %reloc)
   ret void
 }
 
diff --git a/llvm/test/CodeGen/AMDGPU/waterfall-call-inreg-agpr.ll b/llvm/test/CodeGen/AMDGPU/waterfall-call-inreg-agpr.ll
index 4bfd1576cd3e7..0ff284e2fc692 100644
--- a/llvm/test/CodeGen/AMDGPU/waterfall-call-inreg-agpr.ll
+++ b/llvm/test/CodeGen/AMDGPU/waterfall-call-inreg-agpr.ll
@@ -60,6 +60,6 @@ define amdgpu_cs_chain_preserve void @caller() {
 ; CHECK-NEXT:  ; %bb.2:
 ; CHECK-NEXT:    s_endpgm
   %p = load ptr addrspace(3), ptr @G, align 4
-  call void @callee(ptr addrspace(3) %p, ptr addrspace(3) poison)
+  call void @callee(ptr addrspace(3) inreg %p, ptr addrspace(3) poison)
   ret void
 }
diff --git a/llvm/test/CodeGen/ARM/returned-ext.ll b/llvm/test/CodeGen/ARM/returned-ext.ll
index b59974f6a3cfa..e3550650058e9 100644
--- a/llvm/test/CodeGen/ARM/returned-ext.ll
+++ b/llvm/test/CodeGen/ARM/returned-ext.ll
@@ -56,7 +56,7 @@ entry:
 ; This shouldn't be required
 ; CHECKT2D: mov r0, [[SAVEX]]
 
-  %call = tail call i16 @retzext16(i16 returned %x)
+  %call = tail call zeroext i16 @retzext16(i16 returned %x)
   %b = zext i16 %call to i32
   %call2 = tail call i32 @identity32(i32 returned %b)
   ret i16 %x
@@ -149,7 +149,7 @@ entry:
 ; FIXME: Tail call should be OK here
 ; CHECKT2D: bl _identity32
 
-  %call = tail call i16 @bothzext16(i16 zeroext returned %x)
+  %call = tail call zeroext i16 @bothzext16(i16 zeroext returned %x)
   %b = zext i16 %x to i32
   %call2 = tail call i32 @identity32(i32 returned %b)
   ret i16 %call
diff --git a/llvm/test/CodeGen/ARM/struct-byval-loop.ll b/llvm/test/CodeGen/ARM/struct-byval-loop.ll
index 7a38dec2434f7..dd25df3901240 100644
--- a/llvm/test/CodeGen/ARM/struct-byval-loop.ll
+++ b/llvm/test/CodeGen/ARM/struct-byval-loop.ll
@@ -34,7 +34,7 @@ define void @test_80() {
 ; CHECK-NEXT:  .LCPI0_0:
 ; CHECK-NEXT:    .long 68 @ 0x44
   %a = alloca %type_80
-  call void @func_80(ptr null, ptr %a)
+  call void @func_80(ptr null, ptr byval(%type_80) %a)
   ret void
 }
 
@@ -77,6 +77,6 @@ define void @test_4000() {
 ; CHECK-NEXT:  .LCPI1_0:
 ; CHECK-NEXT:    .long 3988 @ 0xf94
   %a = alloca %type_4000
-  call void @func_4000(ptr null, ptr %a)
+  call void @func_4000(ptr null, ptr byval(%type_4000) %a)
   ret void
 }
diff --git a/llvm/test/CodeGen/NVPTX/forward-ld-param.ll b/llvm/test/CodeGen/NVPTX/forward-ld-param.ll
index 4f1454d3788a4..3de524de4745a 100644
--- a/llvm/test/CodeGen/NVPTX/forward-ld-param.ll
+++ b/llvm/test/CodeGen/NVPTX/forward-ld-param.ll
@@ -69,7 +69,7 @@ define void @test_ld_param_byval(ptr byval(i32) %a) {
 ; CHECK-NEXT:    call.uni byval_user, (param0);
 ; CHECK-NEXT:    } // callseq 1
 ; CHECK-NEXT:    ret;
-  call void @byval_user(ptr %a)
+  call void @byval_user(ptr byval(i32) %a)
   ret void
 }
 
diff --git a/llvm/test/CodeGen/RISCV/rvv/shrinkwrap.ll b/llvm/test/CodeGen/RISCV/rvv/shrinkwrap.ll
index d12f2c889650f..da0cce53f3ab4 100644
--- a/llvm/test/CodeGen/RISCV/rvv/shrinkwrap.ll
+++ b/llvm/test/CodeGen/RISCV/rvv/shrinkwrap.ll
@@ -71,7 +71,7 @@ define void @vecaddr_straightline(i32 zeroext %a, ptr %p) {
   %cmp0 = icmp eq i32 %a, 57
   br i1 %cmp0, label %exit, label %do_call
 do_call:
-  call i32 @foo()
+  call zeroext i32 @foo()
   br label %exit
 exit:
   %v3 = load <4 x i32>, ptr %gep
@@ -155,7 +155,7 @@ define void @vecaddr_loop(i32 zeroext %a, ptr %p) {
   %cmp0 = icmp eq i32 %a, 57
   br i1 %cmp0, label %exit, label %do_call
 do_call:
-  %b = call i32 @foo()
+  %b = call zeroext i32 @foo()
   %v3 = load <4 x i32>, ptr %gep
   %v4 = add <4 x i32> %v3, splat (i32 1)
   store <4 x i32> %v4, ptr %gep
diff --git a/llvm/test/CodeGen/RISCV/shrinkwrap.ll b/llvm/test/CodeGen/RISCV/shrinkwrap.ll
index e06673d44ea75..a9c359b6a378c 100644
--- a/llvm/test/CodeGen/RISCV/shrinkwrap.ll
+++ b/llvm/test/CodeGen/RISCV/shrinkwrap.ll
@@ -275,11 +275,11 @@ define void @li_straightline_a(i32 zeroext %a, i32 zeroext %b) {
   %cmp0 = icmp eq i32 %a, 57
   br i1 %cmp0, label %exit, label %do_call
 do_call:
-  call i32 @foo()
+  call zeroext i32 @foo()
   %cmp1 = icmp eq i32 %b, 57
   br i1 %cmp1, label %exit, label %do_call2
 do_call2:
-  call i32 @foo()
+  call zeroext i32 @foo()
   br label %exit
 exit:
   ret void
@@ -392,13 +392,13 @@ define void @li_straightline_b(i32 zeroext %a, i32 zeroext %b) {
   %cmp0 = icmp eq i32 %a, 57
   br i1 %cmp0, label %exit, label %do_call
 do_call:
-  call i32 @foo()
+  call zeroext i32 @foo()
   br label %next
 next:
   %cmp1 = icmp eq i32 %b, 57
   br i1 %cmp1, label %exit, label %do_call2
 do_call2:
-  call i32 @foo()
+  call zeroext i32 @foo()
   br label %exit
 exit:
   ret void
@@ -494,13 +494,13 @@ define void @li_straightline_c(i32 zeroext %a) {
   %cmp0 = icmp eq i32 %a, 57
   br i1 %cmp0, label %exit, label %do_call
 do_call:
-  %b = call i32 @foo()
+  %b = call zeroext i32 @foo()
   br label %next
 next:
   %cmp1 = icmp eq i32 %b, 57
   br i1 %cmp1, label %exit, label %do_call2
 do_call2:
-  call i32 @foo()
+  call zeroext i32 @foo()
   br label %exit
 exit:
   ret void
@@ -619,7 +619,7 @@ define void @li_loop(i32 zeroext %a, i32 zeroext %b) {
   %cmp0 = icmp eq i32 %a, 57
   br i1 %cmp0, label %exit, label %do_call
 do_call:
-  call i32 @foo()
+  call zeroext i32 @foo()
   %cmp1 = icmp eq i32 %b, 57
   br i1 %cmp1, label %exit, label %do_call
 exit:
diff --git a/llvm/test/CodeGen/SPARC/64abi.ll b/llvm/test/CodeGen/SPARC/64abi.ll
index dc8c9af4a5185..3152bf97e3202 100644
--- a/llvm/test/CodeGen/SPARC/64abi.ll
+++ b/llvm/test/CodeGen/SPARC/64abi.ll
@@ -342,8 +342,8 @@ define inreg { i32, float } @ret_i32_float_packed(i32 %a0, i32 %a1,
 ; HARD: st %f1, [%i1]
 ; SOFT: st %o0, [%i1]
 define void @call_ret_i32_float_packed(ptr %i0, ptr %i1) {
-  %rv = call { i32, float } @ret_i32_float_packed(i32 undef, i32 undef,
-                                                  ptr undef, ptr undef)
+  %rv = call inreg { i32, float } @ret_i32_float_packed(i32 undef, i32 undef,
+                                                        ptr undef, ptr undef)
   %e0 = extractvalue { i32, float } %rv, 0
   store i32 %e0, ptr %i0
   %e1 = extractvalue { i32, float } %rv, 1
@@ -374,8 +374,8 @@ define inreg { i32, i32 } @ret_i32_packed(i32 %a0, i32 %a1,
 ; CHECK: st [[R]], [%i0]
 ; CHECK: st %o0, [%i1]
 define void @call_ret_i32_packed(ptr %i0, ptr %i1) {
-  %rv = call { i32, i32 } @ret_i32_packed(i32 undef, i32 undef,
-                                          ptr undef, ptr undef)
+  %rv = call inreg { i32, i32 } @ret_i32_packed(i32 undef, i32 undef,
+                                                ptr undef, ptr undef)
   %e0 = extractvalue { i32, i32 } %rv, 0
   store i32 %e0, ptr %i0
   %e1 = extractvalue { i32, i32 } %rv, 1
diff --git a/llvm/test/CodeGen/SystemZ/args-14.ll b/llvm/test/CodeGen/SystemZ/args-14.ll
index 84e7523e788de..f2d836bef9cac 100644
--- a/llvm/test/CodeGen/SystemZ/args-14.ll
+++ b/llvm/test/CodeGen/SystemZ/args-14.ll
@@ -1,11 +1,10 @@
 ; RUN: llc < %s -mtriple=s390x-linux-gnu -argext-abi-check
 
 ; Test that it works to pass structs as outgoing call arguments when the
-; NoExt attribute is given, either in the call instruction or in the
-; prototype of the called function.
+; NoExt attribute is given on the call instruction.
 define void @caller() {
   call void @bar_Struct_32(i32 noext 123)
-  call void @bar_Struct_16(i16 123)
+  call void @bar_Struct_16(i16 noext 123)
   call void @bar_Struct_8(i8 noext 123)
   ret void
 }
diff --git a/llvm/test/CodeGen/SystemZ/call-zos-01.ll b/llvm/test/CodeGen/SystemZ/call-zos-01.ll
index 7a2fb3f2dfc49..49ce364c3eebd 100644
--- a/llvm/test/CodeGen/SystemZ/call-zos-01.ll
+++ b/llvm/test/CodeGen/SystemZ/call-zos-01.ll
@@ -5,7 +5,7 @@
 ; CHECK-LABEL: call_char DS 0H
 ; CHECK: lghi  1,8
 define i8 @call_char(){
-  %retval = call i8 (i8) @pass_char(i8 8)
+  %retval = call signext i8 (i8) @pass_char(i8 signext 8)
   ret i8 %retval
 }
 
@@ -13,7 +13,7 @@ define i8 @call_char(){
 ; CHECK: lghi  1,16
 define i16 @call_short() {
 entry:
-  %retval = call i16 (i16) @pass_short(i16 16)
+  %retval = call signext i16 (i16) @pass_short(i16 signext 16)
   ret i16 %retval
 }
 
@@ -22,7 +22,7 @@ entry:
 ; CHECK: lghi  2,33
 define i32 @call_int() {
 entry:
-  %retval = call i32 (i32, i32) @pass_int(i32 32, i32 33)
+  %retval = call signext i32 (i32, i32) @pass_int(i32 signext 32, i32 signext 33)
   ret i32 %retval
 }
 
@@ -50,7 +50,7 @@ entry:
 ; CHECK: lghi  3,16
 define i64 @call_integrals() {
 entry:
-  %retval = call i64 (i64, i32, i16, i64) @pass_integrals0(i64 64, i32 32, i16 16, i64 128)
+  %retval = call signext i64 (i64, i32, i16, i64) @pass_integrals0(i64 signext 64, i32 signext 32, i16 signext 16, i64 signext 128)
   ret i64 %retval
 }
 
diff --git a/llvm/test/CodeGen/VE/Scalar/call.ll b/llvm/test/CodeGen/VE/Scalar/call.ll
index 9d949919dc80a..15491310fb229 100644
--- a/llvm/test/CodeGen/VE/Scalar/call.ll
+++ b/llvm/test/CodeGen/VE/Scalar/call.ll
@@ -64,7 +64,7 @@ define i32 @stack_call_int_szext() {
 ; CHECK-NEXT:    st %s34, 240(, %s11)
 ; CHECK-NEXT:    bsic %s10, (, %s12)
 ; CHECK-NEXT:    or %s11, 0, %s9
-  %r = tail call i32 @stack_callee_int_szext(i1 -1, i8 -1, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i16 -1, i8 -1)
+  %r = tail call i32 @stack_callee_int_szext(i1 signext -1, i8 zeroext -1, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i16 zeroext -1, i8 signext -1)
   ret i32 %r
 }
 
diff --git a/llvm/test/CodeGen/VE/Scalar/va_callee.ll b/llvm/test/CodeGen/VE/Scalar/va_callee.ll
index 8ed707dac8a71..708d60fecbdbb 100644
--- a/llvm/test/CodeGen/VE/Scalar/va_callee.ll
+++ b/llvm/test/CodeGen/VE/Scalar/va_callee.ll
@@ -27,11 +27,11 @@ define i32 @va_func(i32, ...) {
   %p10 = va_arg ptr %va, double
   call void @llvm.va_end(ptr nonnull %va)
   call void @use_i32(i32 %p1)
-  call void @use_s16(i16 %p2)
-  call void @use_s8(i8 %p3)
+  call void @use_s16(i16 signext %p2)
+  call void @use_s8(i8 signext %p3)
   call void @use_i32(i32 %p4)
-  call void @use_u16(i16 %p5)
-  call void @use_u8(i8 %p6)
+  call void @use_u16(i16 zeroext %p5)
+  call void @use_u8(i8 zeroext %p6)
   call void @use_float(float %p7)
   call void @use_i8p(ptr %p8)
   call void @use_i64(i64 %p9)
@@ -73,11 +73,11 @@ define i32 @va_copy0(i32, ...) {
   call void @llvm.va_end(ptr nonnull %vb)
   call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %vb)
   call void @use_i32(i32 %p1)
-  call void @use_s16(i16 %p2)
-  call void @use_s8(i8 %p3)
+  call void @use_s16(i16 signext %p2)
+  call void @use_s8(i8 signext %p3)
   call void @use_i32(i32 %p4)
-  call void @use_u16(i16 %p5)
-  call void @use_u8(i8 %p6)
+  call void @use_u16(i16 zeroext %p5)
+  call void @use_u8(i8 zeroext %p6)
   call void @use_float(float %p7)
   call void @use_i8p(ptr %p8)
   call void @use_i64(i64 %p9)
@@ -117,11 +117,11 @@ define i32 @va_copy8(i32, ...) {
   %p10 = va_arg ptr %vc, double
   call void @llvm.va_end(ptr nonnull %vc)
   call void @use_i32(i32 %p1)
-  call void @use_s16(i16 %p2)
-  call void @use_s8(i8 %p3)
+  call void @use_s16(i16 signext %p2)
+  call void @use_s8(i8 signext %p3)
   call void @use_i32(i32 %p4)
-  call void @use_u16(i16 %p5)
-  call void @use_u8(i8 %p6)
+  call void @use_u16(i16 zeroext %p5)
+  call void @use_u8(i8 zeroext %p6)
   call void @use_float(float %p7)
   call void @use_i8p(ptr %p8)
   call void @use_i64(i64 %p9)
diff --git a/llvm/test/CodeGen/VE/Vector/fastcc_caller.ll b/llvm/test/CodeGen/VE/Vector/fastcc_caller.ll
index 72e95091f8534..35cbba2b8e13a 100644
--- a/llvm/test/CodeGen/VE/Vector/fastcc_caller.ll
+++ b/llvm/test/CodeGen/VE/Vector/fastcc_caller.ll
@@ -67,7 +67,7 @@ define fastcc i32 @stack_call_int_szext() {
 ; CHECK-NEXT:    st %s34, 240(, %s11)
 ; CHECK-NEXT:    bsic %s10, (, %s12)
 ; CHECK-NEXT:    or %s11, 0, %s9
-  %r = tail call fastcc i32 @stack_callee_int_szext(i1 -1, i8 -1, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i16 -1, i8 -1)
+  %r = tail call fastcc i32 @stack_callee_int_szext(i1 signext -1, i8 zeroext -1, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i16 zeroext -1, i8 signext -1)
   ret i32 %r
 }
 
diff --git a/llvm/test/CodeGen/WebAssembly/signext-zeroext-callsite.ll b/llvm/test/CodeGen/WebAssembly/signext-zeroext-callsite.ll
index f7f0b68c1b665..1d7adfb712b68 100644
--- a/llvm/test/CodeGen/WebAssembly/signext-zeroext-callsite.ll
+++ b/llvm/test/CodeGen/WebAssembly/signext-zeroext-callsite.ll
@@ -7,25 +7,15 @@ target triple = "wasm32-unknown-unknown"
 
 declare i32 @foo(i1 signext noundef, i32 noundef)
 
-; callsite_signext and callsite_nosignext must emit equivalent codes
+; callsite_signext and callsite_nosignext should emit different code,
+; as the signext is not inherited from the callee.
 
 define i32 @callsite_nosignext() {
 ; CHECK-LABEL: callsite_nosignext:
 ; CHECK:         .functype callsite_nosignext () -> (i32)
-; CHECK-NEXT:    .local i32, i32, i32
 ; CHECK-NEXT:  # %bb.0: # %start
 ; CHECK-NEXT:    i32.const 1
-; CHECK-NEXT:    local.set 0
 ; CHECK-NEXT:    i32.const 0
-; CHECK-NEXT:    local.set 1
-; CHECK-NEXT:    i32.const 31
-; CHECK-NEXT:    local.set 2
-; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i32.shl
-; CHECK-NEXT:    local.get 2
-; CHECK-NEXT:    i32.shr_s
-; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    call foo
 ; CHECK-NEXT:    return
 ;
@@ -35,7 +25,7 @@ define i32 @callsite_nosignext() {
 ; NO-FAST-ISEL-NEXT:  # %bb.0: # %start
 ; NO-FAST-ISEL-NEXT:    i32.const 0
 ; NO-FAST-ISEL-NEXT:    local.set 0
-; NO-FAST-ISEL-NEXT:    i32.const -1
+; NO-FAST-ISEL-NEXT:    i32.const 1
 ; NO-FAST-ISEL-NEXT:    local.get 0
 ; NO-FAST-ISEL-NEXT:    call foo
 ; NO-FAST-ISEL-NEXT:    return
@@ -81,21 +71,15 @@ start:
 
 declare i32 @foo2(i1 zeroext noundef, i32 noundef)
 
-; callsite_zeroext and callsite_nozeroext must emit equivalent codes
+; callsite_zeroext and callsite_nozeroext should emit different code,
+; as the zeroext is not inherited from the callee.
 
 define i32 @callsite_nozeroext() {
 ; CHECK-LABEL: callsite_nozeroext:
 ; CHECK:         .functype callsite_nozeroext () -> (i32)
-; CHECK-NEXT:    .local i32, i32
 ; CHECK-NEXT:  # %bb.0: # %start
 ; CHECK-NEXT:    i32.const 1
-; CHECK-NEXT:    local.set 0
 ; CHECK-NEXT:    i32.const 0
-; CHECK-NEXT:    local.set 1
-; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    i32.const 1
-; CHECK-NEXT:    i32.and
-; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    call foo2
 ; CHECK-NEXT:    return
 ;
diff --git a/llvm/test/CodeGen/X86/bool-zext.ll b/llvm/test/CodeGen/X86/bool-zext.ll
index 539be245eb1d0..2df0a63f151e0 100644
--- a/llvm/test/CodeGen/X86/bool-zext.ll
+++ b/llvm/test/CodeGen/X86/bool-zext.ll
@@ -53,7 +53,7 @@ define zeroext i1 @bar3() nounwind ssp {
 ; X64-NEXT:    callq foo2 at PLT
 ; X64-NEXT:    popq %rcx
 ; X64-NEXT:    retq
-  %call = call i1 @foo2() nounwind
+  %call = call zeroext i1 @foo2() nounwind
   ret i1 %call
 }
 
diff --git a/llvm/test/CodeGen/X86/return-ext.ll b/llvm/test/CodeGen/X86/return-ext.ll
index d38284df1f530..69bc67489cb1c 100644
--- a/llvm/test/CodeGen/X86/return-ext.ll
+++ b/llvm/test/CodeGen/X86/return-ext.ll
@@ -97,7 +97,7 @@ entry:
 
 define i32 @use_i1() {
 entry:
-  %0 = call i1 @unsigned_i1();
+  %0 = call zeroext i1 @unsigned_i1();
   %1 = zext i1 %0 to i32
   ret i32 %1
 
@@ -112,7 +112,7 @@ entry:
 
 define i32 @use_i8() {
 entry:
-  %0 = call i8 @unsigned_i8();
+  %0 = call zeroext i8 @unsigned_i8();
   %1 = zext i8 %0 to i32
   ret i32 %1
 
@@ -127,7 +127,7 @@ entry:
 
 define i32 @use_i16() {
 entry:
-  %0 = call i16 @unsigned_i16();
+  %0 = call zeroext i16 @unsigned_i16();
   %1 = zext i16 %0 to i32
   ret i32 %1
 
diff --git a/llvm/test/Instrumentation/ThreadSanitizer/tsan_basic.ll b/llvm/test/Instrumentation/ThreadSanitizer/tsan_basic.ll
index 5a15cfa6864c4..14020d0a76d97 100644
--- a/llvm/test/Instrumentation/ThreadSanitizer/tsan_basic.ll
+++ b/llvm/test/Instrumentation/ThreadSanitizer/tsan_basic.ll
@@ -94,7 +94,7 @@ define void @SwiftError(ptr swifterror) sanitize_thread {
 define void @SwiftErrorCall(ptr swifterror) sanitize_thread {
   %swifterror_addr = alloca swifterror ptr
   store ptr null, ptr %0
-  call void @SwiftError(ptr %0)
+  call void @SwiftError(ptr swifterror %0)
   ret void
 }
 
diff --git a/llvm/test/Transforms/DeadArgElim/deadexternal.ll b/llvm/test/Transforms/DeadArgElim/deadexternal.ll
index 5120d1a5f98ee..6839e4ecf5736 100644
--- a/llvm/test/Transforms/DeadArgElim/deadexternal.ll
+++ b/llvm/test/Transforms/DeadArgElim/deadexternal.ll
@@ -62,6 +62,6 @@ define void @unused_swifterror_arg(ptr swifterror %dead_arg) {
 define void @dont_replace_by_poison() {
   %error_ptr_ref = alloca swifterror ptr
   store ptr null, ptr %error_ptr_ref
-  call void @unused_swifterror_arg(ptr %error_ptr_ref)
+  call void @unused_swifterror_arg(ptr swifterror %error_ptr_ref)
   ret void
 }
diff --git a/llvm/test/Transforms/Inline/access-attributes-prop.ll b/llvm/test/Transforms/Inline/access-attributes-prop.ll
index a5c52ecdfd8c2..efa3cb7d26413 100644
--- a/llvm/test/Transforms/Inline/access-attributes-prop.ll
+++ b/llvm/test/Transforms/Inline/access-attributes-prop.ll
@@ -591,17 +591,17 @@ define ptr @callee_bad_param_prop(ptr readonly %x) {
 define dso_local void @foo_byval_readonly2(ptr readonly %p) {
 ; CHECK-LABEL: define {{[^@]+}}@foo_byval_readonly2
 ; CHECK-SAME: (ptr readonly [[P:%.*]]) {
-; CHECK-NEXT:    call void @bar4(ptr [[P]])
+; CHECK-NEXT:    call void @bar4(ptr byval([4 x i32]) [[P]])
 ; CHECK-NEXT:    ret void
 ;
-  call void @bar4(ptr %p)
+  call void @bar4(ptr byval([4 x i32]) %p)
   ret void
 }
 
 define void @prop_byval_readonly2(ptr %p) {
 ; CHECK-LABEL: define {{[^@]+}}@prop_byval_readonly2
 ; CHECK-SAME: (ptr [[P:%.*]]) {
-; CHECK-NEXT:    call void @bar4(ptr [[P]])
+; CHECK-NEXT:    call void @bar4(ptr byval([4 x i32]) [[P]])
 ; CHECK-NEXT:    ret void
 ;
   call void @foo_byval_readonly2(ptr %p)
diff --git a/llvm/test/Transforms/PhaseOrdering/pr64289-tce.ll b/llvm/test/Transforms/PhaseOrdering/pr64289-tce.ll
index f56463a0b6107..d420511952539 100644
--- a/llvm/test/Transforms/PhaseOrdering/pr64289-tce.ll
+++ b/llvm/test/Transforms/PhaseOrdering/pr64289-tce.ll
@@ -19,7 +19,7 @@ start:
 
 recurse:
   store i64 0, ptr %new_x, align 8
-  call void @pr64289(ptr %new_x)
+  call void @pr64289(ptr byval(i64) %new_x)
   br label %end
 
 end:
diff --git a/llvm/test/Transforms/SROA/readonlynocapture.ll b/llvm/test/Transforms/SROA/readonlynocapture.ll
index b6f7b1fd1685e..488efc9930677 100644
--- a/llvm/test/Transforms/SROA/readonlynocapture.ll
+++ b/llvm/test/Transforms/SROA/readonlynocapture.ll
@@ -396,12 +396,12 @@ define i32 @simple_byval() {
 ; CHECK-LABEL: @simple_byval(
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    store i32 0, ptr [[A]], align 4
-; CHECK-NEXT:    call void @callee_byval(ptr [[A]])
+; CHECK-NEXT:    call void @callee_byval(ptr byval(i32) [[A]])
 ; CHECK-NEXT:    ret i32 0
 ;
   %a = alloca i32
   store i32 0, ptr %a
-  call void @callee_byval(ptr %a)
+  call void @callee_byval(ptr byval(i32) %a)
   %l1 = load i32, ptr %a
   ret i32 %l1
 }
diff --git a/llvm/test/Transforms/SimplifyCFG/hoist-sink-swifterror-store.ll b/llvm/test/Transforms/SimplifyCFG/hoist-sink-swifterror-store.ll
index 5dff39c1f9a52..b002fac9aec30 100644
--- a/llvm/test/Transforms/SimplifyCFG/hoist-sink-swifterror-store.ll
+++ b/llvm/test/Transforms/SimplifyCFG/hoist-sink-swifterror-store.ll
@@ -155,11 +155,11 @@ define swiftcc void @sink_call(i1 %c) {
 ; CHECK-NEXT:    br i1 [[C]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    call void @clobber1()
-; CHECK-NEXT:    call swiftcc void @foo(ptr [[TMP2]])
+; CHECK-NEXT:    call swiftcc void @foo(ptr swifterror [[TMP2]])
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       else:
 ; CHECK-NEXT:    call void @clobber2()
-; CHECK-NEXT:    call swiftcc void @foo(ptr [[TMP1]])
+; CHECK-NEXT:    call swiftcc void @foo(ptr swifterror [[TMP1]])
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
@@ -170,12 +170,12 @@ define swiftcc void @sink_call(i1 %c) {
 
 then:
   call void @clobber1()
-  call swiftcc void @foo(ptr %3)
+  call swiftcc void @foo(ptr swifterror %3)
   br label %exit
 
 else:
   call void @clobber2()
-  call swiftcc void @foo(ptr %2)
+  call swiftcc void @foo(ptr swifterror %2)
   br label %exit
 
 exit:
@@ -198,7 +198,7 @@ define swiftcc void @safe_sink_call(i1 %c) {
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    [[B_SINK:%.*]] = phi ptr [ [[B]], [[ELSE]] ], [ [[A]], [[THEN]] ]
-; CHECK-NEXT:    call swiftcc void @bar(ptr [[ERR]], ptr [[B_SINK]])
+; CHECK-NEXT:    call swiftcc void @bar(ptr swifterror [[ERR]], ptr [[B_SINK]])
 ; CHECK-NEXT:    ret void
 ;
   %err = alloca swifterror ptr, align 8
@@ -208,12 +208,12 @@ define swiftcc void @safe_sink_call(i1 %c) {
 
 then:
   call void @clobber1()
-  call swiftcc void @bar(ptr %err, ptr %a)
+  call swiftcc void @bar(ptr swifterror %err, ptr %a)
   br label %exit
 
 else:
   call void @clobber2()
-  call swiftcc void @bar(ptr %err, ptr %b)
+  call swiftcc void @bar(ptr swifterror %err, ptr %b)
   br label %exit
 
 exit:
diff --git a/llvm/unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp b/llvm/unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp
index f4b22e7ec4da5..626281d5c1a09 100644
--- a/llvm/unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp
@@ -42,8 +42,8 @@ TEST(IndirectionUtilsTest, MakeStub) {
   EXPECT_TRUE(Call->isTailCall()) << "Indirect call from stub should be tail call.";
   EXPECT_TRUE(Call->hasStructRetAttr())
     << "makeStub should propagate sret attr on 1st argument.";
-  EXPECT_TRUE(Call->paramHasAttr(1U, Attribute::ByVal))
-    << "makeStub should propagate byval attr on 2nd argument.";
+  EXPECT_TRUE(Call->isByValArgument(1U))
+      << "makeStub should propagate byval attr on 2nd argument.";
 }
 
 }
diff --git a/llvm/unittests/IR/AttributesTest.cpp b/llvm/unittests/IR/AttributesTest.cpp
index 5e795ef771713..1c6fc053f9779 100644
--- a/llvm/unittests/IR/AttributesTest.cpp
+++ b/llvm/unittests/IR/AttributesTest.cpp
@@ -287,17 +287,17 @@ TEST(Attributes, MismatchedABIAttrs) {
 
   {
     auto *I = cast<CallBase>(&M->getFunction("g")->getEntryBlock().front());
-    ASSERT_TRUE(I->isByValArgument(0));
-    ASSERT_TRUE(I->getParamByValType(0));
+    ASSERT_FALSE(I->isByValArgument(0));
+    ASSERT_FALSE(I->getParamByValType(0));
   }
   {
     auto *I = cast<CallBase>(&M->getFunction("h")->getEntryBlock().front());
-    ASSERT_TRUE(I->getParamPreallocatedType(0));
+    ASSERT_FALSE(I->getParamPreallocatedType(0));
   }
   {
     auto *I = cast<CallBase>(&M->getFunction("i")->getEntryBlock().front());
-    ASSERT_TRUE(I->isInAllocaArgument(0));
-    ASSERT_TRUE(I->getParamInAllocaType(0));
+    ASSERT_FALSE(I->isInAllocaArgument(0));
+    ASSERT_FALSE(I->getParamInAllocaType(0));
   }
 }
 



More information about the llvm-commits mailing list