[llvm-branch-commits] [llvm] RuntimeLibcalls: Add attributes inferLibFuncAttributes gives libcalls (PR #241618)

Matt Arsenault via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Wed Nov 18 11:46:03 PST 2026


https://github.com/arsenm updated https://github.com/llvm/llvm-project/pull/241618

>From 0986dcf9f9065784cf8c8e0ff3840fcfc2b61b5c Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Tue, 10 Nov 2026 10:45:37 -0800
Subject: [PATCH] RuntimeLibcalls: Add attributes inferLibFuncAttributes gives
 libcalls

Remove more differences with the attributes the InferFunctionAttrs
pass would add to the declared libcalls.

Co-authored-by: Claude Opus 5.5 <noreply at anthropic.com>
---
 llvm/include/llvm/IR/RuntimeLibcalls.td       |  77 ++++++--
 llvm/include/llvm/IR/RuntimeLibcallsImpl.td   |  10 +-
 .../Util/DeclareRuntimeLibcalls/aarch64.ll    | 165 ++++++++++--------
 .../Util/DeclareRuntimeLibcalls/aix.ll        |   7 +-
 .../Util/DeclareRuntimeLibcalls/amdlibm.ll    |  12 +-
 .../Util/DeclareRuntimeLibcalls/arm.ll        |  60 ++++---
 .../Util/DeclareRuntimeLibcalls/arm64ec.ll    |  24 +--
 .../Util/DeclareRuntimeLibcalls/armpl.ll      |  24 +--
 .../Util/DeclareRuntimeLibcalls/avr.ll        |  26 +--
 .../Util/DeclareRuntimeLibcalls/basic.ll      |  20 ++-
 .../Util/DeclareRuntimeLibcalls/bsd.ll        | 108 ++++++------
 .../Util/DeclareRuntimeLibcalls/darwin.ll     |  10 +-
 .../Util/DeclareRuntimeLibcalls/divmod.ll     |   4 +-
 .../Util/DeclareRuntimeLibcalls/hexagon.ll    |  56 +++---
 .../Util/DeclareRuntimeLibcalls/m68k.ll       |  26 +--
 .../Util/DeclareRuntimeLibcalls/mips.ll       |  68 ++++----
 .../Util/DeclareRuntimeLibcalls/msp430.ll     |  26 +--
 .../Util/DeclareRuntimeLibcalls/ppc.ll        | 134 +++++++-------
 .../Util/DeclareRuntimeLibcalls/riscv.ll      |  64 +++----
 .../DeclareRuntimeLibcalls/sleef-riscv.ll     |  12 +-
 .../Util/DeclareRuntimeLibcalls/sleef.ll      |  24 +--
 .../Util/DeclareRuntimeLibcalls/sparc.ll      |  76 ++++----
 .../Util/DeclareRuntimeLibcalls/systemz.ll    |  76 ++++----
 .../Util/DeclareRuntimeLibcalls/ve.ll         |  32 ++--
 .../Util/DeclareRuntimeLibcalls/windows.ll    | 126 ++++++-------
 25 files changed, 697 insertions(+), 570 deletions(-)

diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index fa8f85444c3488..e08fc4efaf651e 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.td
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -258,7 +258,7 @@ foreach IntTy = [TypeSuffix<"I8", UInt8>, TypeSuffix<"I16", UInt16>,
   def UREM_#IntTy.Suffix : PureLibcall<IntTy.Type, [IntTy.Type, IntTy.Type]>;
 }
 
-defvar OutPtrAttrs = [NoAlias, WriteOnly, NonNull];
+defvar OutPtrAttrs = [NoAlias, WriteOnly, NonNull, CapturesNone];
 defvar ReadPtrAttrs = [ReadOnly, CapturesNone];
 
 foreach IntTy = [TypeSuffix<"I32", Int32>, TypeSuffix<"I64", Int64>,
@@ -727,6 +727,9 @@ foreach FPTy = [F32, F64, F128, PPCF128] in {
 }
 
 // Memory
+
+defvar ChkFnAttrs = [NoCallback, NoFree, NoSync, NoUnwind];
+
 class MemCmpLibcall : RuntimeLibcall<Int, [Ptr, Ptr, SizeT]> {
   let FnAttrs = CommonFnAttrs;
   let Memory = ArgMemReadOnly;
@@ -735,16 +738,31 @@ class MemCmpLibcall : RuntimeLibcall<Int, [Ptr, Ptr, SizeT]> {
 
 def MEMCMP : MemCmpLibcall;
 def MEMCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT]>;
-def MEMCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT]>;
+def MEMCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT]> {
+  let FnAttrs = ChkFnAttrs;
+  let Memory = ArgMemOnly;
+  let ParamAttrs = [[NoAlias, WriteOnly], [NoAlias, ReadOnly, CapturesNone]];
+}
+
 def MEMMOVE : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT]>;
-def MEMMOVE_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT]>;
+def MEMMOVE_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT]> {
+  let FnAttrs = ChkFnAttrs;
+  let Memory = ArgMemOnly;
+  let ParamAttrs = [[WriteOnly], ReadPtrAttrs];
+}
+
 def MEMSET : RuntimeLibcall<Ptr, [Ptr, Int, SizeT]>;
-def MEMSET_CHK : RuntimeLibcall<Ptr, [Ptr, Int, SizeT, SizeT]>;
+def MEMSET_CHK : RuntimeLibcall<Ptr, [Ptr, Int, SizeT, SizeT]> {
+  let FnAttrs = ChkFnAttrs;
+  let Memory = ArgMemWriteOnly;
+  let ParamAttrs = [[WriteOnly]];
+}
+
 class MallocLibcall<string family> : RuntimeLibcall<Ptr, [SizeT]> {
   let FnAttrs = [NoFree, NoUnwind, WillReturn,
                  AllocKindAttr<"AllocFnKind::Alloc | AllocFnKind::Uninitialized">,
                  AllocSizeAttr<0>, AllocFamilyAttr<family>];
-  let Memory = InaccessibleOrErrnoMem;
+  let Memory = InaccessibleMemOrErrnoWrite;
   let RetAttrs = [NoAlias, NoUndef];
   let ParamAttrs = [[NoUndef]];
 }
@@ -753,7 +771,7 @@ class CallocLibcall<string family> : RuntimeLibcall<Ptr, [SizeT, SizeT]> {
   let FnAttrs = [NoFree, NoUnwind, WillReturn,
                  AllocKindAttr<"AllocFnKind::Alloc | AllocFnKind::Zeroed">,
                  AllocSizeAttr<0, "1">, AllocFamilyAttr<family>];
-  let Memory = InaccessibleOrErrnoMem;
+  let Memory = InaccessibleMemOrErrnoWrite;
   let RetAttrs = [NoAlias, NoUndef];
   let ParamAttrs = [[NoUndef], [NoUndef]];
 }
@@ -765,6 +783,17 @@ class FreeLibcall<string family> : RuntimeLibcall<Void, [Ptr]> {
   let ParamAttrs = [[AllocatedPointer, NoUndef, CapturesNone]];
 }
 
+class ReallocLibcall<string family, list<FuncArgType> SizeTypes,
+                     AllocSizeAttr allocSize>
+    : RuntimeLibcall<Ptr, !listconcat([Ptr], SizeTypes)> {
+  let FnAttrs = [NoUnwind, WillReturn, AllocKindAttr<"AllocFnKind::Realloc">,
+                 allocSize, AllocFamilyAttr<family>];
+  let Memory = InaccessibleOrArgMemOrErrnoWrite;
+  let RetAttrs = [NoAlias, NoUndef];
+  let ParamAttrs = !listconcat([[AllocatedPointer, CapturesNone]],
+                               !listsplat([NoUndef], !size(SizeTypes)));
+}
+
 def MALLOC : MallocLibcall<"malloc">;
 def CALLOC : CallocLibcall<"malloc">;
 def FREE : FreeLibcall<"malloc">;
@@ -1158,8 +1187,17 @@ def FWRITE : RuntimeLibcall<SizeT, [Ptr, SizeT, SizeT, Ptr]>;
 def FWRITE_UNLOCKED : RuntimeLibcall<SizeT, [Ptr, SizeT, SizeT, Ptr]>;
 def GETC : RuntimeLibcall<Int, [Ptr]>;
 def GETCHAR : RuntimeLibcall<Int, []>;
-def GETCHAR_UNLOCKED : RuntimeLibcall<Int, []>;
-def GETC_UNLOCKED : RuntimeLibcall<Int, [Ptr]>;
+def GETCHAR_UNLOCKED : RuntimeLibcall<Int, []> {
+  let FnAttrs = [NoFree, NoUnwind];
+  let RetAttrs = [NoUndef];
+}
+
+def GETC_UNLOCKED : RuntimeLibcall<Int, [Ptr]> {
+  let FnAttrs = [NoFree, NoUnwind];
+  let RetAttrs = [NoUndef];
+  let ParamAttrs = [[NoUndef, CapturesNone]];
+}
+
 def GETENV : RuntimeLibcall<Ptr, [Ptr]>;
 def GETITIMER : RuntimeLibcall<Int, [Int, Ptr]>;
 def GETLOGIN_R : RuntimeLibcall<Int, [Ptr, SizeT]>;
@@ -1225,17 +1263,28 @@ def PREAD : RuntimeLibcall<SSizeT, [Int, Ptr, SizeT, IntPlus]>;
 def PRINTF : RuntimeLibcall<Int, [Ptr, Ellip]>;
 def PUTC : RuntimeLibcall<Int, [Int, Ptr]>;
 def PUTCHAR : RuntimeLibcall<Int, [Int]>;
-def PUTCHAR_UNLOCKED : RuntimeLibcall<Int, [Int]>;
-def PUTC_UNLOCKED : RuntimeLibcall<Int, [Int, Ptr]>;
+def PUTCHAR_UNLOCKED : RuntimeLibcall<Int, [Int]> {
+  let FnAttrs = [NoFree, NoUnwind];
+  let RetAttrs = [NoUndef];
+  let ParamAttrs = [[NoUndef]];
+}
+
+def PUTC_UNLOCKED : RuntimeLibcall<Int, [Int, Ptr]> {
+  let FnAttrs = [NoFree, NoUnwind];
+  let RetAttrs = [NoUndef];
+  let ParamAttrs = [[NoUndef], [NoUndef, CapturesNone]];
+}
+
 def PUTS : RuntimeLibcall<Int, [Ptr]>;
 def PVALLOC : RuntimeLibcall<Ptr, [SizeT]>;
 def PWRITE : RuntimeLibcall<SSizeT, [Int, Ptr, SizeT, IntPlus]>;
 def QSORT : RuntimeLibcall<Void, [Ptr, SizeT, SizeT, Ptr]>;
 def READ : RuntimeLibcall<SSizeT, [Int, Ptr, SizeT]>;
 def READLINK : RuntimeLibcall<SSizeT, [Ptr, Ptr, SizeT]>;
-def REALLOC : RuntimeLibcall<Ptr, [Ptr, SizeT]>;
-def REALLOCARRAY : RuntimeLibcall<Ptr, [Ptr, SizeT, SizeT]>;
-def REALLOCF : RuntimeLibcall<Ptr, [Ptr, SizeT]>;
+def REALLOC : ReallocLibcall<"malloc", [SizeT], AllocSizeAttr<1>>;
+def REALLOCARRAY
+    : ReallocLibcall<"malloc", [SizeT, SizeT], AllocSizeAttr<1, "2">>;
+def REALLOCF : ReallocLibcall<"malloc", [SizeT], AllocSizeAttr<1>>;
 def REALPATH : RuntimeLibcall<Ptr, [Ptr, Ptr]>;
 def REMOVE : RuntimeLibcall<Int, [Ptr]>;
 def RENAME : RuntimeLibcall<Int, [Ptr, Ptr]>;
@@ -1323,7 +1372,7 @@ def VALLOC : RuntimeLibcall<Ptr, [SizeT]>;
 def VEC_CALLOC : CallocLibcall<"vec_malloc">;
 def VEC_FREE : FreeLibcall<"vec_malloc">;
 def VEC_MALLOC : MallocLibcall<"vec_malloc">;
-def VEC_REALLOC : RuntimeLibcall<Ptr, [Ptr, SizeT]>;
+def VEC_REALLOC : ReallocLibcall<"vec_malloc", [SizeT], AllocSizeAttr<1>>;
 def VFPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ptr]>;
 def VFSCANF : RuntimeLibcall<Int, [Ptr, Ptr, Ptr]>;
 def VPRINTF : RuntimeLibcall<Int, [Ptr, Ptr]>;
diff --git a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
index 9b1d7cfebec8ca..c8b321aa31409e 100644
--- a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
+++ b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
@@ -171,9 +171,9 @@ def ArgOrErrnoMemWriteOnly : MemoryEffects<NoModRef> {
 }
 
 def ErrnoMemWriteOnly : MemoryEffects<NoModRef> { let ErrnoMem = Mod; }
-def InaccessibleOrErrnoMem : MemoryEffects<NoModRef> {
+def InaccessibleMemOrErrnoWrite : MemoryEffects<NoModRef> {
   let InaccessibleMem = ModRef;
-  let ErrnoMem = ModRef;
+  let ErrnoMem = Mod;
 }
 
 def InaccessibleOrArgMem : MemoryEffects<NoModRef> {
@@ -181,6 +181,12 @@ def InaccessibleOrArgMem : MemoryEffects<NoModRef> {
   let InaccessibleMem = ModRef;
 }
 
+def InaccessibleOrArgMemOrErrnoWrite : MemoryEffects<NoModRef> {
+  let ArgMem = ModRef;
+  let InaccessibleMem = ModRef;
+  let ErrnoMem = Mod;
+}
+
 class ValueAttr<list<AttrProperty> props, string expr>
     : Attr<"", IntersectPreserve, props> {
   string Expr = expr;
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aarch64.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aarch64.ll
index 1295c9c1cec8d0..98219b3b86dec1 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aarch64.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aarch64.ll
@@ -312,9 +312,9 @@
 ; LINUX-NEXT: declare i32 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare i32 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare i32 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; LINUX-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; LINUX-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; LINUX-NEXT: declare ptr @__memset_chk(ptr, i32, i64, i64)
+; LINUX-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; LINUX-NEXT: declare ptr @__memset_chk(ptr writeonly, i32, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; LINUX-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -323,7 +323,7 @@
 ; LINUX-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; LINUX-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; LINUX-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare i32 @__mulsi3(i32, i32) [[NOMEM_ATTRS]]
@@ -504,9 +504,9 @@
 ; LINUX-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare fp128 @fmodl(fp128, fp128) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; LINUX-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; LINUX-NEXT: declare double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @ldexpf(float, i32) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare fp128 @ldexpl(fp128, i32) [[SQRT_ATTRS]]
@@ -535,9 +535,9 @@
 ; LINUX-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; LINUX-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; LINUX-NEXT: declare ptr @memset(ptr, i32, i64)
-; LINUX-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
 ; LINUX-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; LINUX-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; LINUX-NEXT: declare nofpclass(snan inf zero sub norm) fp128 @nanl(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
@@ -553,9 +553,9 @@
 ; LINUX-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare fp128 @remainderl(fp128, fp128) [[SQRT_ATTRS]]
-; LINUX-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; LINUX-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; LINUX-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; LINUX-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare fp128 @rintl(fp128) [[SQRT_ATTRS]]
@@ -572,9 +572,9 @@
 ; LINUX-NEXT: declare float @scalbnf(float, i32) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare fp128 @scalbnl(fp128, i32) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare double @sin(double) [[SQRT_ATTRS]]
-; LINUX-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 dereferenceable(8), ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; LINUX-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4), ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; LINUX-NEXT: declare void @sincosl(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16), ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4), ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare void @sincosl(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; LINUX-NEXT: declare float @sinf(float) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare double @sinh(double) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @sinhf(float) [[SQRT_ATTRS]]
@@ -600,10 +600,12 @@
 ; LINUX-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; LINUX-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; LINUX-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; LINUX-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; LINUX-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; LINUX-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; LINUX-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; LINUX-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; LINUX-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; LINUX-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; LINUX-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; LINUX-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; LINUX-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
 
@@ -906,9 +908,9 @@
 ; DARWIN-NEXT: declare i32 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; DARWIN-NEXT: declare i32 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; DARWIN-NEXT: declare i32 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; DARWIN-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; DARWIN-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; DARWIN-NEXT: declare ptr @__memset_chk(ptr, i32, i64, i64)
+; DARWIN-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; DARWIN-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; DARWIN-NEXT: declare ptr @__memset_chk(ptr writeonly, i32, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; DARWIN-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; DARWIN-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; DARWIN-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -917,7 +919,7 @@
 ; DARWIN-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; DARWIN-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; DARWIN-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; DARWIN-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; DARWIN-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; DARWIN-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; DARWIN-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; DARWIN-NEXT: declare i32 @__mulsi3(i32, i32) [[NOMEM_ATTRS]]
@@ -1073,10 +1075,10 @@
 ; DARWIN-NEXT: declare double @fmod(double, double) [[SQRT_ATTRS]]
 ; DARWIN-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; DARWIN-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; DARWIN-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; DARWIN-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; DARWIN-NEXT: declare i32 @getc_unlocked(ptr)
-; DARWIN-NEXT: declare i32 @getchar_unlocked()
+; DARWIN-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; DARWIN-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; DARWIN-NEXT: declare noundef i32 @getc_unlocked(ptr noundef captures(none)) [[GETC_UNLOCKED_ATTRS:#[0-9]+]]
+; DARWIN-NEXT: declare noundef i32 @getchar_unlocked() [[GETC_UNLOCKED_ATTRS]]
 ; DARWIN-NEXT: declare double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; DARWIN-NEXT: declare float @ldexpf(float, i32) [[SQRT_ATTRS]]
 ; DARWIN-NEXT: declare i64 @llrint(double) [[SQRT_ATTRS]]
@@ -1097,8 +1099,8 @@
 ; DARWIN-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; DARWIN-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; DARWIN-NEXT: declare ptr @memset(ptr, i32, i64)
-; DARWIN-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; DARWIN-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; DARWIN-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; DARWIN-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; DARWIN-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; DARWIN-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; DARWIN-NEXT: declare double @nearbyint(double) [[NOMEM_ATTRS]]
@@ -1107,12 +1109,12 @@
 ; DARWIN-NEXT: declare float @nexttowardf(float, double) [[SQRT_ATTRS]]
 ; DARWIN-NEXT: declare double @pow(double, double) [[SQRT_ATTRS]]
 ; DARWIN-NEXT: declare float @powf(float, float) [[SQRT_ATTRS]]
-; DARWIN-NEXT: declare i32 @putc_unlocked(i32, ptr)
-; DARWIN-NEXT: declare i32 @putchar_unlocked(i32)
+; DARWIN-NEXT: declare noundef i32 @putc_unlocked(i32 noundef, ptr noundef captures(none)) [[GETC_UNLOCKED_ATTRS]]
+; DARWIN-NEXT: declare noundef i32 @putchar_unlocked(i32 noundef) [[GETC_UNLOCKED_ATTRS]]
 ; DARWIN-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; DARWIN-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
-; DARWIN-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; DARWIN-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; DARWIN-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; DARWIN-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; DARWIN-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; DARWIN-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; DARWIN-NEXT: declare double @round(double) [[NOMEM_ATTRS]]
@@ -1142,10 +1144,13 @@
 ; DARWIN-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; DARWIN-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; DARWIN-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; DARWIN-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; DARWIN-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; DARWIN-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; DARWIN-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; DARWIN-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; DARWIN-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; DARWIN-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; DARWIN-NEXT: attributes [[GETC_UNLOCKED_ATTRS]] = { nofree nounwind }
+; DARWIN-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; DARWIN-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; DARWIN-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
 
@@ -1449,9 +1454,9 @@
 ; WINMSVC-NEXT: declare i32 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; WINMSVC-NEXT: declare i32 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; WINMSVC-NEXT: declare i32 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; WINMSVC-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; WINMSVC-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; WINMSVC-NEXT: declare ptr @__memset_chk(ptr, i32, i64, i64)
+; WINMSVC-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; WINMSVC-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; WINMSVC-NEXT: declare ptr @__memset_chk(ptr writeonly, i32, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; WINMSVC-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; WINMSVC-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; WINMSVC-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -1460,7 +1465,7 @@
 ; WINMSVC-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; WINMSVC-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; WINMSVC-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; WINMSVC-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; WINMSVC-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; WINMSVC-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; WINMSVC-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; WINMSVC-NEXT: declare i32 @__mulsi3(i32, i32) [[NOMEM_ATTRS]]
@@ -1615,7 +1620,7 @@
 ; WINMSVC-NEXT: declare double @fmod(double, double) [[SQRT_ATTRS]]
 ; WINMSVC-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; WINMSVC-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; WINMSVC-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; WINMSVC-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; WINMSVC-NEXT: declare double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; WINMSVC-NEXT: declare i64 @llrint(double) [[SQRT_ATTRS]]
 ; WINMSVC-NEXT: declare i64 @llrintf(float) [[SQRT_ATTRS]]
@@ -1635,8 +1640,8 @@
 ; WINMSVC-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; WINMSVC-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; WINMSVC-NEXT: declare ptr @memset(ptr, i32, i64)
-; WINMSVC-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; WINMSVC-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; WINMSVC-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; WINMSVC-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; WINMSVC-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; WINMSVC-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; WINMSVC-NEXT: declare double @nearbyint(double) [[NOMEM_ATTRS]]
@@ -1647,8 +1652,8 @@
 ; WINMSVC-NEXT: declare float @powf(float, float) [[SQRT_ATTRS]]
 ; WINMSVC-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; WINMSVC-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
-; WINMSVC-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; WINMSVC-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; WINMSVC-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; WINMSVC-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; WINMSVC-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; WINMSVC-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; WINMSVC-NEXT: declare double @round(double) [[NOMEM_ATTRS]]
@@ -1678,9 +1683,11 @@
 ; WINMSVC-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; WINMSVC-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; WINMSVC-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
-; WINMSVC-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; WINMSVC-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; WINMSVC-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
+; WINMSVC-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; WINMSVC-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; WINMSVC-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; WINMSVC-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; WINMSVC-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; WINMSVC-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
 
@@ -1984,9 +1991,9 @@
 ; MINGW-NEXT: declare i32 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; MINGW-NEXT: declare i32 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; MINGW-NEXT: declare i32 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; MINGW-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; MINGW-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; MINGW-NEXT: declare ptr @__memset_chk(ptr, i32, i64, i64)
+; MINGW-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; MINGW-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; MINGW-NEXT: declare ptr @__memset_chk(ptr writeonly, i32, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; MINGW-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; MINGW-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; MINGW-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -1995,7 +2002,7 @@
 ; MINGW-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; MINGW-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; MINGW-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; MINGW-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; MINGW-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; MINGW-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; MINGW-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; MINGW-NEXT: declare i32 @__mulsi3(i32, i32) [[NOMEM_ATTRS]]
@@ -2150,8 +2157,8 @@
 ; MINGW-NEXT: declare double @fmod(double, double) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; MINGW-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; MINGW-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; MINGW-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; MINGW-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; MINGW-NEXT: declare double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare float @ldexpf(float, i32) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare i64 @llrint(double) [[SQRT_ATTRS]]
@@ -2172,8 +2179,8 @@
 ; MINGW-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; MINGW-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; MINGW-NEXT: declare ptr @memset(ptr, i32, i64)
-; MINGW-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; MINGW-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; MINGW-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; MINGW-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; MINGW-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; MINGW-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; MINGW-NEXT: declare double @nearbyint(double) [[NOMEM_ATTRS]]
@@ -2184,8 +2191,8 @@
 ; MINGW-NEXT: declare float @powf(float, float) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
-; MINGW-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; MINGW-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; MINGW-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; MINGW-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; MINGW-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare double @round(double) [[NOMEM_ATTRS]]
@@ -2197,8 +2204,8 @@
 ; MINGW-NEXT: declare double @scalbn(double, i32) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare float @scalbnf(float, i32) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare double @sin(double) [[SQRT_ATTRS]]
-; MINGW-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 dereferenceable(8), ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; MINGW-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4), ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; MINGW-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; MINGW-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4), ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; MINGW-NEXT: declare float @sinf(float) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare double @sinh(double) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare float @sinhf(float) [[SQRT_ATTRS]]
@@ -2217,10 +2224,12 @@
 ; MINGW-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; MINGW-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; MINGW-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; MINGW-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; MINGW-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; MINGW-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; MINGW-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; MINGW-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; MINGW-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; MINGW-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; MINGW-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; MINGW-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; MINGW-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
 
@@ -2528,9 +2537,9 @@
 ; ANDROID-NEXT: declare i32 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; ANDROID-NEXT: declare i32 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; ANDROID-NEXT: declare i32 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; ANDROID-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; ANDROID-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; ANDROID-NEXT: declare ptr @__memset_chk(ptr, i32, i64, i64)
+; ANDROID-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; ANDROID-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; ANDROID-NEXT: declare ptr @__memset_chk(ptr writeonly, i32, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; ANDROID-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; ANDROID-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; ANDROID-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -2539,7 +2548,7 @@
 ; ANDROID-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; ANDROID-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; ANDROID-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; ANDROID-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; ANDROID-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; ANDROID-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; ANDROID-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; ANDROID-NEXT: declare i32 @__mulsi3(i32, i32) [[NOMEM_ATTRS]]
@@ -2721,9 +2730,9 @@
 ; ANDROID-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; ANDROID-NEXT: declare fp128 @fmodl(fp128, fp128) [[SQRT_ATTRS]]
 ; ANDROID-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; ANDROID-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; ANDROID-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; ANDROID-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; ANDROID-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; ANDROID-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; ANDROID-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; ANDROID-NEXT: declare double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; ANDROID-NEXT: declare float @ldexpf(float, i32) [[SQRT_ATTRS]]
 ; ANDROID-NEXT: declare fp128 @ldexpl(fp128, i32) [[SQRT_ATTRS]]
@@ -2752,9 +2761,9 @@
 ; ANDROID-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; ANDROID-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; ANDROID-NEXT: declare ptr @memset(ptr, i32, i64)
-; ANDROID-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; ANDROID-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; ANDROID-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
+; ANDROID-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; ANDROID-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; ANDROID-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
 ; ANDROID-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; ANDROID-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; ANDROID-NEXT: declare nofpclass(snan inf zero sub norm) fp128 @nanl(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
@@ -2770,9 +2779,9 @@
 ; ANDROID-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; ANDROID-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
 ; ANDROID-NEXT: declare fp128 @remainderl(fp128, fp128) [[SQRT_ATTRS]]
-; ANDROID-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; ANDROID-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; ANDROID-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; ANDROID-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; ANDROID-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; ANDROID-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; ANDROID-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; ANDROID-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; ANDROID-NEXT: declare fp128 @rintl(fp128) [[SQRT_ATTRS]]
@@ -2789,9 +2798,9 @@
 ; ANDROID-NEXT: declare float @scalbnf(float, i32) [[SQRT_ATTRS]]
 ; ANDROID-NEXT: declare fp128 @scalbnl(fp128, i32) [[SQRT_ATTRS]]
 ; ANDROID-NEXT: declare double @sin(double) [[SQRT_ATTRS]]
-; ANDROID-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 dereferenceable(8), ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; ANDROID-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4), ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; ANDROID-NEXT: declare void @sincosl(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16), ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; ANDROID-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; ANDROID-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4), ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; ANDROID-NEXT: declare void @sincosl(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; ANDROID-NEXT: declare float @sinf(float) [[SQRT_ATTRS]]
 ; ANDROID-NEXT: declare double @sinh(double) [[SQRT_ATTRS]]
 ; ANDROID-NEXT: declare float @sinhf(float) [[SQRT_ATTRS]]
@@ -2817,9 +2826,11 @@
 ; ANDROID-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; ANDROID-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; ANDROID-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; ANDROID-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; ANDROID-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; ANDROID-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; ANDROID-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; ANDROID-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; ANDROID-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; ANDROID-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; ANDROID-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; ANDROID-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; ANDROID-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aix.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aix.ll
index dcd0b3a29e35fe..742565da9a3724 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aix.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aix.ll
@@ -4,8 +4,9 @@
 ; CHECK: declare noalias noundef ptr @vec_calloc(i64 noundef, i64 noundef) [[VEC_CALLOC_ATTRS:#[0-9]+]]
 ; CHECK: declare void @vec_free(ptr allocptr noundef captures(none)) [[VEC_FREE_ATTRS:#[0-9]+]]
 ; CHECK: declare noalias noundef ptr @vec_malloc(i64 noundef) [[VEC_MALLOC_ATTRS:#[0-9]+]]
-; CHECK: declare ptr @vec_realloc(ptr, i64)
+; CHECK: declare noalias noundef ptr @vec_realloc(ptr allocptr captures(none), i64 noundef) [[VEC_REALLOC_ATTRS:#[0-9]+]]
 
-; CHECK: attributes [[VEC_CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="vec_malloc" }
+; CHECK: attributes [[VEC_CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="vec_malloc" }
 ; CHECK: attributes [[VEC_FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="vec_malloc" }
-; CHECK: attributes [[VEC_MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="vec_malloc" }
+; CHECK: attributes [[VEC_MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="vec_malloc" }
+; CHECK: attributes [[VEC_REALLOC_ATTRS]] = { nounwind willreturn allockind("realloc") allocsize(1) memory(argmem: readwrite, inaccessiblemem: readwrite, errnomem: write) "alloc-family"="vec_malloc" }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/amdlibm.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/amdlibm.ll
index 91d9c0e1c156b6..4a500154214960 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/amdlibm.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/amdlibm.ll
@@ -47,7 +47,7 @@
 
 ; CHECK: declare <2 x double> @amd_vrd2_sin(<2 x double>) [[ATTRS]]
 
-; CHECK: declare void @amd_vrd2_sincos(<2 x double>, ptr noalias nonnull writeonly align 16 dereferenceable(16), ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ATTRS_PTR_ARG:#[0-9]+]]
+; CHECK: declare void @amd_vrd2_sincos(<2 x double>, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ATTRS_PTR_ARG:#[0-9]+]]
 
 ; CHECK: declare <2 x double> @amd_vrd2_tan(<2 x double>) [[ATTRS]]
 
@@ -93,7 +93,7 @@
 
 ; CHECK: declare <4 x double> @amd_vrd4_sin(<4 x double>) [[ATTRS]]
 
-; CHECK: declare void @amd_vrd4_sincos(<4 x double>, ptr noalias nonnull writeonly align 32 dereferenceable(32), ptr noalias nonnull writeonly align 32 dereferenceable(32)) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @amd_vrd4_sincos(<4 x double>, ptr noalias nonnull writeonly align 32 captures(none) dereferenceable(32), ptr noalias nonnull writeonly align 32 captures(none) dereferenceable(32)) [[ATTRS_PTR_ARG]]
 
 ; CHECK: declare <4 x double> @amd_vrd4_tan(<4 x double>) [[ATTRS]]
 
@@ -139,7 +139,7 @@
 
 ; CHECK: declare <8 x double> @amd_vrd8_sin(<8 x double>) [[ATTRS]]
 
-; CHECK: declare void @amd_vrd8_sincos(<8 x double>, ptr noalias nonnull writeonly align 64 dereferenceable(64), ptr noalias nonnull writeonly align 64 dereferenceable(64)) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @amd_vrd8_sincos(<8 x double>, ptr noalias nonnull writeonly align 64 captures(none) dereferenceable(64), ptr noalias nonnull writeonly align 64 captures(none) dereferenceable(64)) [[ATTRS_PTR_ARG]]
 
 ; CHECK: declare <8 x double> @amd_vrd8_tan(<8 x double>) [[ATTRS]]
 
@@ -175,7 +175,7 @@
 
 ; CHECK: declare <16 x float> @amd_vrs16_roundf(<16 x float>) [[ATTRS]]
 
-; CHECK: declare void @amd_vrs16_sincosf(<16 x float>, ptr noalias nonnull writeonly align 64 dereferenceable(64), ptr noalias nonnull writeonly align 64 dereferenceable(64)) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @amd_vrs16_sincosf(<16 x float>, ptr noalias nonnull writeonly align 64 captures(none) dereferenceable(64), ptr noalias nonnull writeonly align 64 captures(none) dereferenceable(64)) [[ATTRS_PTR_ARG]]
 
 ; CHECK: declare <16 x float> @amd_vrs16_sinf(<16 x float>) [[ATTRS]]
 
@@ -219,7 +219,7 @@
 
 ; CHECK: declare <4 x float> @amd_vrs4_roundf(<4 x float>) [[ATTRS]]
 
-; CHECK: declare void @amd_vrs4_sincosf(<4 x float>, ptr noalias nonnull writeonly align 16 dereferenceable(16), ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @amd_vrs4_sincosf(<4 x float>, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ATTRS_PTR_ARG]]
 
 ; CHECK: declare <4 x float> @amd_vrs4_sinf(<4 x float>) [[ATTRS]]
 
@@ -259,7 +259,7 @@
 
 ; CHECK: declare <8 x float> @amd_vrs8_roundf(<8 x float>) [[ATTRS]]
 
-; CHECK: declare void @amd_vrs8_sincosf(<8 x float>, ptr noalias nonnull writeonly align 32 dereferenceable(32), ptr noalias nonnull writeonly align 32 dereferenceable(32)) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @amd_vrs8_sincosf(<8 x float>, ptr noalias nonnull writeonly align 32 captures(none) dereferenceable(32), ptr noalias nonnull writeonly align 32 captures(none) dereferenceable(32)) [[ATTRS_PTR_ARG]]
 
 ; CHECK: declare <8 x float> @amd_vrs8_sinf(<8 x float>) [[ATTRS]]
 
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/arm.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/arm.ll
index 5945d70c7ae6ca..7aae9e2f3ba528 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/arm.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/arm.ll
@@ -245,9 +245,9 @@
 ; SJLJ-NEXT: declare arm_aapcscc i32 @__ltdf2(double, double) [[DIVMOD_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc i32 @__ltsf2(float, float) [[DIVMOD_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc i32 @__lttf2(fp128, fp128) [[DIVMOD_ATTRS]]
-; SJLJ-NEXT: declare arm_aapcscc ptr @__memcpy_chk(ptr, ptr, i32, i32)
-; SJLJ-NEXT: declare arm_aapcscc ptr @__memmove_chk(ptr, ptr, i32, i32)
-; SJLJ-NEXT: declare arm_aapcscc ptr @__memset_chk(ptr, i32, i32, i32)
+; SJLJ-NEXT: declare arm_aapcscc ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i32, i32) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; SJLJ-NEXT: declare arm_aapcscc ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i32, i32) [[CHK_ARGMEM_ATTRS]]
+; SJLJ-NEXT: declare arm_aapcscc ptr @__memset_chk(ptr writeonly, i32, i32, i32) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; SJLJ-NEXT: declare arm_aapcscc i64 @__moddi3(i64, i64) [[DIVMOD_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc signext i16 @__modhi3(i16 signext, i16 signext) [[DIVMOD_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc signext i8 @__modqi3(i8 signext, i8 signext) [[DIVMOD_ATTRS]]
@@ -256,7 +256,7 @@
 ; SJLJ-NEXT: declare arm_aapcscc double @__muldf3(double, double) [[DIVMOD_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc i64 @__muldi3(i64, i64) [[DIVMOD_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc signext i16 @__mulhi3(i16 signext, i16 signext) [[DIVMOD_ATTRS]]
-; SJLJ-NEXT: declare arm_aapcscc i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; SJLJ-NEXT: declare arm_aapcscc i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc signext i8 @__mulqi3(i8 signext, i8 signext) [[DIVMOD_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc float @__mulsf3(float, float) [[DIVMOD_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc i32 @__mulsi3(i32, i32) [[DIVMOD_ATTRS]]
@@ -411,8 +411,8 @@
 ; SJLJ-NEXT: declare arm_aapcscc double @fmod(double, double) [[SQRT_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc float @fmodf(float, float) [[SQRT_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; SJLJ-NEXT: declare arm_aapcscc double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; SJLJ-NEXT: declare arm_aapcscc float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; SJLJ-NEXT: declare arm_aapcscc double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; SJLJ-NEXT: declare arm_aapcscc float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc float @ldexpf(float, i32) [[SQRT_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc i64 @llrint(double) [[SQRT_ATTRS]]
@@ -433,8 +433,8 @@
 ; SJLJ-NEXT: declare arm_aapcscc ptr @memcpy(ptr, ptr, i32)
 ; SJLJ-NEXT: declare arm_aapcscc ptr @memmove(ptr, ptr, i32)
 ; SJLJ-NEXT: declare arm_aapcscc ptr @memset(ptr, i32, i32)
-; SJLJ-NEXT: declare arm_aapcscc double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; SJLJ-NEXT: declare arm_aapcscc float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; SJLJ-NEXT: declare arm_aapcscc double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; SJLJ-NEXT: declare arm_aapcscc float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; SJLJ-NEXT: declare arm_aapcscc nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc double @nearbyint(double) [[DIVMOD_ATTRS]]
@@ -445,8 +445,8 @@
 ; SJLJ-NEXT: declare arm_aapcscc float @powf(float, float) [[SQRT_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc double @remainder(double, double) [[SQRT_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc float @remainderf(float, float) [[SQRT_ATTRS]]
-; SJLJ-NEXT: declare arm_aapcscc double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; SJLJ-NEXT: declare arm_aapcscc float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; SJLJ-NEXT: declare arm_aapcscc double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; SJLJ-NEXT: declare arm_aapcscc float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc double @rint(double) [[SQRT_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc float @rintf(float) [[SQRT_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc double @round(double) [[DIVMOD_ATTRS]]
@@ -458,8 +458,8 @@
 ; SJLJ-NEXT: declare arm_aapcscc double @scalbn(double, i32) [[SQRT_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc float @scalbnf(float, i32) [[SQRT_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc double @sin(double) [[SQRT_ATTRS]]
-; SJLJ-NEXT: declare arm_aapcscc void @sincos(double, ptr noalias nonnull writeonly align 8 dereferenceable(8), ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; SJLJ-NEXT: declare arm_aapcscc void @sincosf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4), ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; SJLJ-NEXT: declare arm_aapcscc void @sincos(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; SJLJ-NEXT: declare arm_aapcscc void @sincosf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4), ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc float @sinf(float) [[SQRT_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc double @sinh(double) [[SQRT_ATTRS]]
 ; SJLJ-NEXT: declare arm_aapcscc float @sinhf(float) [[SQRT_ATTRS]]
@@ -478,10 +478,12 @@
 ; SJLJ-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; SJLJ-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; SJLJ-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; SJLJ-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; SJLJ-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; SJLJ-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; SJLJ-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; SJLJ-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; SJLJ-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; SJLJ-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; SJLJ-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; SJLJ-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; SJLJ-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
 
@@ -723,9 +725,9 @@
 ; DWARF-NEXT: declare arm_aapcscc i32 @__ltdf2(double, double) [[DIVMOD_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc i32 @__ltsf2(float, float) [[DIVMOD_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc i32 @__lttf2(fp128, fp128) [[DIVMOD_ATTRS]]
-; DWARF-NEXT: declare arm_aapcscc ptr @__memcpy_chk(ptr, ptr, i32, i32)
-; DWARF-NEXT: declare arm_aapcscc ptr @__memmove_chk(ptr, ptr, i32, i32)
-; DWARF-NEXT: declare arm_aapcscc ptr @__memset_chk(ptr, i32, i32, i32)
+; DWARF-NEXT: declare arm_aapcscc ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i32, i32) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; DWARF-NEXT: declare arm_aapcscc ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i32, i32) [[CHK_ARGMEM_ATTRS]]
+; DWARF-NEXT: declare arm_aapcscc ptr @__memset_chk(ptr writeonly, i32, i32, i32) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; DWARF-NEXT: declare arm_aapcscc i64 @__moddi3(i64, i64) [[DIVMOD_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc signext i16 @__modhi3(i16 signext, i16 signext) [[DIVMOD_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc signext i8 @__modqi3(i8 signext, i8 signext) [[DIVMOD_ATTRS]]
@@ -734,7 +736,7 @@
 ; DWARF-NEXT: declare arm_aapcscc double @__muldf3(double, double) [[DIVMOD_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc i64 @__muldi3(i64, i64) [[DIVMOD_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc signext i16 @__mulhi3(i16 signext, i16 signext) [[DIVMOD_ATTRS]]
-; DWARF-NEXT: declare arm_aapcscc i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; DWARF-NEXT: declare arm_aapcscc i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc signext i8 @__mulqi3(i8 signext, i8 signext) [[DIVMOD_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc float @__mulsf3(float, float) [[DIVMOD_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc i32 @__mulsi3(i32, i32) [[DIVMOD_ATTRS]]
@@ -889,8 +891,8 @@
 ; DWARF-NEXT: declare arm_aapcscc double @fmod(double, double) [[SQRT_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc float @fmodf(float, float) [[SQRT_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; DWARF-NEXT: declare arm_aapcscc double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; DWARF-NEXT: declare arm_aapcscc float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; DWARF-NEXT: declare arm_aapcscc double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; DWARF-NEXT: declare arm_aapcscc float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc float @ldexpf(float, i32) [[SQRT_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc i64 @llrint(double) [[SQRT_ATTRS]]
@@ -911,8 +913,8 @@
 ; DWARF-NEXT: declare arm_aapcscc ptr @memcpy(ptr, ptr, i32)
 ; DWARF-NEXT: declare arm_aapcscc ptr @memmove(ptr, ptr, i32)
 ; DWARF-NEXT: declare arm_aapcscc ptr @memset(ptr, i32, i32)
-; DWARF-NEXT: declare arm_aapcscc double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; DWARF-NEXT: declare arm_aapcscc float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; DWARF-NEXT: declare arm_aapcscc double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; DWARF-NEXT: declare arm_aapcscc float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; DWARF-NEXT: declare arm_aapcscc nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc double @nearbyint(double) [[DIVMOD_ATTRS]]
@@ -923,8 +925,8 @@
 ; DWARF-NEXT: declare arm_aapcscc float @powf(float, float) [[SQRT_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc double @remainder(double, double) [[SQRT_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc float @remainderf(float, float) [[SQRT_ATTRS]]
-; DWARF-NEXT: declare arm_aapcscc double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; DWARF-NEXT: declare arm_aapcscc float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; DWARF-NEXT: declare arm_aapcscc double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; DWARF-NEXT: declare arm_aapcscc float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc double @rint(double) [[SQRT_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc float @rintf(float) [[SQRT_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc double @round(double) [[DIVMOD_ATTRS]]
@@ -936,8 +938,8 @@
 ; DWARF-NEXT: declare arm_aapcscc double @scalbn(double, i32) [[SQRT_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc float @scalbnf(float, i32) [[SQRT_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc double @sin(double) [[SQRT_ATTRS]]
-; DWARF-NEXT: declare arm_aapcscc void @sincos(double, ptr noalias nonnull writeonly align 8 dereferenceable(8), ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; DWARF-NEXT: declare arm_aapcscc void @sincosf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4), ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; DWARF-NEXT: declare arm_aapcscc void @sincos(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; DWARF-NEXT: declare arm_aapcscc void @sincosf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4), ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc float @sinf(float) [[SQRT_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc double @sinh(double) [[SQRT_ATTRS]]
 ; DWARF-NEXT: declare arm_aapcscc float @sinhf(float) [[SQRT_ATTRS]]
@@ -956,9 +958,11 @@
 ; DWARF-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; DWARF-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; DWARF-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; DWARF-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; DWARF-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; DWARF-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; DWARF-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; DWARF-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; DWARF-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; DWARF-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; DWARF-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; DWARF-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; DWARF-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/arm64ec.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/arm64ec.ll
index 9f1670914ce1e9..261e01fe058242 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/arm64ec.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/arm64ec.ll
@@ -292,9 +292,9 @@
 ; CHECK-NEXT: declare i32 @"#__ltdf2"(double, double) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare i32 @"#__ltsf2"(float, float) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare i32 @"#__lttf2"(fp128, fp128) [[NOMEM_ATTRS]]
-; CHECK-NEXT: declare ptr @"#__memcpy_chk"(ptr, ptr, i64, i64)
-; CHECK-NEXT: declare ptr @"#__memmove_chk"(ptr, ptr, i64, i64)
-; CHECK-NEXT: declare ptr @"#__memset_chk"(ptr, i32, i64, i64)
+; CHECK-NEXT: declare ptr @"#__memcpy_chk"(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare ptr @"#__memmove_chk"(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; CHECK-NEXT: declare ptr @"#__memset_chk"(ptr writeonly, i32, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; CHECK-NEXT: declare i64 @"#__moddi3"(i64, i64) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare signext i16 @"#__modhi3"(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare signext i8 @"#__modqi3"(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -303,7 +303,7 @@
 ; CHECK-NEXT: declare double @"#__muldf3"(double, double) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare i64 @"#__muldi3"(i64, i64) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare signext i16 @"#__mulhi3"(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; CHECK-NEXT: declare i32 @"#__mulosi4"(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare i32 @"#__mulosi4"(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; CHECK-NEXT: declare signext i8 @"#__mulqi3"(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare float @"#__mulsf3"(float, float) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare i32 @"#__mulsi3"(i32, i32) [[NOMEM_ATTRS]]
@@ -457,7 +457,7 @@
 ; CHECK-NEXT: declare double @"#fmod"(double, double) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare float @"#fmodf"(float, float) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare void @"#free"(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; CHECK-NEXT: declare double @"#frexp"(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare double @"#frexp"(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; CHECK-NEXT: declare double @"#ldexp"(double, i32) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare i64 @"#llrint"(double) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare i64 @"#llrintf"(float) [[SQRT_ATTRS]]
@@ -477,8 +477,8 @@
 ; CHECK-NEXT: declare ptr @"#memcpy"(ptr, ptr, i64)
 ; CHECK-NEXT: declare ptr @"#memmove"(ptr, ptr, i64)
 ; CHECK-NEXT: declare ptr @"#memset"(ptr, i32, i64)
-; CHECK-NEXT: declare double @"#modf"(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; CHECK-NEXT: declare float @"#modff"(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare double @"#modf"(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare float @"#modff"(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; CHECK-NEXT: declare nofpclass(snan inf zero sub norm) double @"#nan"(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; CHECK-NEXT: declare nofpclass(snan inf zero sub norm) float @"#nanf"(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; CHECK-NEXT: declare double @"#nearbyint"(double) [[NOMEM_ATTRS]]
@@ -489,8 +489,8 @@
 ; CHECK-NEXT: declare float @"#powf"(float, float) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare double @"#remainder"(double, double) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare float @"#remainderf"(float, float) [[SQRT_ATTRS]]
-; CHECK-NEXT: declare double @"#remquo"(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; CHECK-NEXT: declare float @"#remquof"(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; CHECK-NEXT: declare double @"#remquo"(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare float @"#remquof"(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; CHECK-NEXT: declare double @"#rint"(double) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare float @"#rintf"(float) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare double @"#round"(double) [[NOMEM_ATTRS]]
@@ -520,8 +520,10 @@
 ; CHECK-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; CHECK-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; CHECK-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
-; CHECK-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; CHECK-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; CHECK-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
+; CHECK-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; CHECK-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; CHECK-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; CHECK-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; CHECK-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; CHECK-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/armpl.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/armpl.ll
index 00352d145c7bb5..f15c96149b8c33 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/armpl.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/armpl.ll
@@ -135,11 +135,11 @@
 
 ; CHECK: declare { <vscale x 4 x float>, <vscale x 4 x float> } @armpl_svmodf_f32_stret_x(<vscale x 4 x float>, <vscale x 4 x i1>)
 
-; CHECK: declare <vscale x 4 x float> @armpl_svmodf_f32_x(<vscale x 4 x float>, ptr noalias nonnull writeonly align 4, <vscale x 4 x i1>) [[ATTRS_PTR_ARG:#[0-9]+]]
+; CHECK: declare <vscale x 4 x float> @armpl_svmodf_f32_x(<vscale x 4 x float>, ptr noalias nonnull writeonly align 4 captures(none), <vscale x 4 x i1>) [[ATTRS_PTR_ARG:#[0-9]+]]
 
 ; CHECK: declare { <vscale x 2 x double>, <vscale x 2 x double> } @armpl_svmodf_f64_stret_x(<vscale x 2 x double>, <vscale x 2 x i1>)
 
-; CHECK: declare <vscale x 2 x double> @armpl_svmodf_f64_x(<vscale x 2 x double>, ptr noalias nonnull writeonly align 8, <vscale x 2 x i1>) [[ATTRS_PTR_ARG]]
+; CHECK: declare <vscale x 2 x double> @armpl_svmodf_f64_x(<vscale x 2 x double>, ptr noalias nonnull writeonly align 8 captures(none), <vscale x 2 x i1>) [[ATTRS_PTR_ARG]]
 
 ; CHECK: declare <vscale x 4 x float> @armpl_svnextafter_f32_x(<vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x i1>) [[ATTRS]]
 
@@ -153,13 +153,13 @@
 
 ; CHECK: declare <vscale x 2 x double> @armpl_svsin_f64_x(<vscale x 2 x double>, <vscale x 2 x i1>) [[ATTRS]]
 
-; CHECK: declare void @armpl_svsincos_f32_x(<vscale x 4 x float>, ptr noalias nonnull writeonly align 4, ptr noalias nonnull writeonly align 4, <vscale x 4 x i1>) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @armpl_svsincos_f32_x(<vscale x 4 x float>, ptr noalias nonnull writeonly align 4 captures(none), ptr noalias nonnull writeonly align 4 captures(none), <vscale x 4 x i1>) [[ATTRS_PTR_ARG]]
 
-; CHECK: declare void @armpl_svsincos_f64_x(<vscale x 2 x double>, ptr noalias nonnull writeonly align 8, ptr noalias nonnull writeonly align 8, <vscale x 2 x i1>) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @armpl_svsincos_f64_x(<vscale x 2 x double>, ptr noalias nonnull writeonly align 8 captures(none), ptr noalias nonnull writeonly align 8 captures(none), <vscale x 2 x i1>) [[ATTRS_PTR_ARG]]
 
-; CHECK: declare void @armpl_svsincospi_f32_x(<vscale x 4 x float>, ptr noalias nonnull writeonly align 4, ptr noalias nonnull writeonly align 4, <vscale x 4 x i1>) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @armpl_svsincospi_f32_x(<vscale x 4 x float>, ptr noalias nonnull writeonly align 4 captures(none), ptr noalias nonnull writeonly align 4 captures(none), <vscale x 4 x i1>) [[ATTRS_PTR_ARG]]
 
-; CHECK: declare void @armpl_svsincospi_f64_x(<vscale x 2 x double>, ptr noalias nonnull writeonly align 8, ptr noalias nonnull writeonly align 8, <vscale x 2 x i1>) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @armpl_svsincospi_f64_x(<vscale x 2 x double>, ptr noalias nonnull writeonly align 8 captures(none), ptr noalias nonnull writeonly align 8 captures(none), <vscale x 2 x i1>) [[ATTRS_PTR_ARG]]
 
 ; CHECK: declare <vscale x 4 x float> @armpl_svsinh_f32_x(<vscale x 4 x float>, <vscale x 4 x i1>) [[ATTRS]]
 
@@ -317,11 +317,11 @@
 
 ; CHECK: declare aarch64_vector_pcs <2 x double> @armpl_vlogq_f64(<2 x double>) [[ATTRS]]
 
-; CHECK: declare aarch64_vector_pcs <4 x float> @armpl_vmodfq_f32(<4 x float>, ptr noalias nonnull writeonly align 4 dereferenceable(16)) [[ATTRS_PTR_ARG]]
+; CHECK: declare aarch64_vector_pcs <4 x float> @armpl_vmodfq_f32(<4 x float>, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(16)) [[ATTRS_PTR_ARG]]
 
 ; CHECK: declare aarch64_vector_pcs { <4 x float>, <4 x float> } @armpl_vmodfq_f32_stret(<4 x float>)
 
-; CHECK: declare aarch64_vector_pcs <2 x double> @armpl_vmodfq_f64(<2 x double>, ptr noalias nonnull writeonly align 8 dereferenceable(16)) [[ATTRS_PTR_ARG]]
+; CHECK: declare aarch64_vector_pcs <2 x double> @armpl_vmodfq_f64(<2 x double>, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(16)) [[ATTRS_PTR_ARG]]
 
 ; CHECK: declare aarch64_vector_pcs { <2 x double>, <2 x double> } @armpl_vmodfq_f64_stret(<2 x double>)
 
@@ -333,13 +333,13 @@
 
 ; CHECK: declare aarch64_vector_pcs <2 x double> @armpl_vpowq_f64(<2 x double>, <2 x double>) [[ATTRS]]
 
-; CHECK: declare aarch64_vector_pcs void @armpl_vsincospiq_f32(<4 x float>, ptr noalias nonnull writeonly align 4 dereferenceable(16), ptr noalias nonnull writeonly align 4 dereferenceable(16)) [[ATTRS_PTR_ARG]]
+; CHECK: declare aarch64_vector_pcs void @armpl_vsincospiq_f32(<4 x float>, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(16)) [[ATTRS_PTR_ARG]]
 
-; CHECK: declare aarch64_vector_pcs void @armpl_vsincospiq_f64(<2 x double>, ptr noalias nonnull writeonly align 8 dereferenceable(16), ptr noalias nonnull writeonly align 8 dereferenceable(16)) [[ATTRS_PTR_ARG]]
+; CHECK: declare aarch64_vector_pcs void @armpl_vsincospiq_f64(<2 x double>, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(16)) [[ATTRS_PTR_ARG]]
 
-; CHECK: declare aarch64_vector_pcs void @armpl_vsincosq_f32(<4 x float>, ptr noalias nonnull writeonly align 4 dereferenceable(16), ptr noalias nonnull writeonly align 4 dereferenceable(16)) [[ATTRS_PTR_ARG]]
+; CHECK: declare aarch64_vector_pcs void @armpl_vsincosq_f32(<4 x float>, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(16)) [[ATTRS_PTR_ARG]]
 
-; CHECK: declare aarch64_vector_pcs void @armpl_vsincosq_f64(<2 x double>, ptr noalias nonnull writeonly align 8 dereferenceable(16), ptr noalias nonnull writeonly align 8 dereferenceable(16)) [[ATTRS_PTR_ARG]]
+; CHECK: declare aarch64_vector_pcs void @armpl_vsincosq_f64(<2 x double>, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(16)) [[ATTRS_PTR_ARG]]
 
 ; CHECK: declare aarch64_vector_pcs <4 x float> @armpl_vsinhq_f32(<4 x float>) [[ATTRS]]
 
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/avr.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/avr.ll
index 0490deafb796ab..bec2dd27cf2b23 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/avr.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/avr.ll
@@ -184,15 +184,15 @@
 ; CHECK-NEXT: declare i8 @__ltdf2(double, double) addrspace(1) [[DIVMOD_ATTRS]]
 ; CHECK-NEXT: declare i8 @__ltsf2(float, float) addrspace(1) [[DIVMOD_ATTRS]]
 ; CHECK-NEXT: declare i8 @__lttf2(fp128, fp128) addrspace(1) [[DIVMOD_ATTRS]]
-; CHECK-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i16, i16) addrspace(1)
-; CHECK-NEXT: declare ptr @__memmove_chk(ptr, ptr, i16, i16) addrspace(1)
-; CHECK-NEXT: declare ptr @__memset_chk(ptr, i16, i16, i16) addrspace(1)
+; CHECK-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i16, i16) addrspace(1) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i16, i16) addrspace(1) [[CHK_ARGMEM_ATTRS]]
+; CHECK-NEXT: declare ptr @__memset_chk(ptr writeonly, i16, i16, i16) addrspace(1) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; CHECK-NEXT: declare i64 @__moddi3(i64, i64) addrspace(1) [[DIVMOD_ATTRS]]
 ; CHECK-NEXT: declare i128 @__modti3(i128, i128) addrspace(1) [[DIVMOD_ATTRS]]
 ; CHECK-NEXT: declare double @__muldf3(double, double) addrspace(1) [[DIVMOD_ATTRS]]
 ; CHECK-NEXT: declare i64 @__muldi3(i64, i64) addrspace(1) [[DIVMOD_ATTRS]]
 ; CHECK-NEXT: declare i16 @__mulhi3(i16, i16) addrspace(1) [[DIVMOD_ATTRS]]
-; CHECK-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 1 dereferenceable(2)) addrspace(1) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 1 captures(none) dereferenceable(2)) addrspace(1) [[ARGMEM_WRITE_ATTRS]]
 ; CHECK-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) addrspace(1) [[DIVMOD_ATTRS]]
 ; CHECK-NEXT: declare float @__mulsf3(float, float) addrspace(1) [[DIVMOD_ATTRS]]
 ; CHECK-NEXT: declare i32 @__mulsi3(i32, i32) addrspace(1) [[DIVMOD_ATTRS]]
@@ -344,8 +344,8 @@
 ; CHECK-NEXT: declare double @fmod(double, double) addrspace(1) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare float @fmodf(float, float) addrspace(1) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare void @free(ptr allocptr noundef captures(none)) addrspace(1) [[FREE_ATTRS:#[0-9]+]]
-; CHECK-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 1 dereferenceable(2)) addrspace(1) [[ARGMEM_WRITE_ATTRS]]
-; CHECK-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 1 dereferenceable(2)) addrspace(1) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 1 captures(none) dereferenceable(2)) addrspace(1) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 1 captures(none) dereferenceable(2)) addrspace(1) [[ARGMEM_WRITE_ATTRS]]
 ; CHECK-NEXT: declare double @ldexp(double, i16) addrspace(1) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare float @ldexpf(float, i16) addrspace(1) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare i64 @llrint(double) addrspace(1) [[SQRT_ATTRS]]
@@ -366,8 +366,8 @@
 ; CHECK-NEXT: declare ptr @memcpy(ptr, ptr, i16) addrspace(1)
 ; CHECK-NEXT: declare ptr @memmove(ptr, ptr, i16) addrspace(1)
 ; CHECK-NEXT: declare ptr @memset(ptr, i16, i16) addrspace(1)
-; CHECK-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 1 dereferenceable(8)) addrspace(1) [[ARGMEM_WRITE_ATTRS]]
-; CHECK-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 1 dereferenceable(4)) addrspace(1) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 1 captures(none) dereferenceable(8)) addrspace(1) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 1 captures(none) dereferenceable(4)) addrspace(1) [[ARGMEM_WRITE_ATTRS]]
 ; CHECK-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) addrspace(1) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; CHECK-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) addrspace(1) [[ARGMEM_READ_ATTRS]]
 ; CHECK-NEXT: declare double @nearbyint(double) addrspace(1) [[DIVMOD_ATTRS]]
@@ -378,8 +378,8 @@
 ; CHECK-NEXT: declare float @powf(float, float) addrspace(1) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare double @remainder(double, double) addrspace(1) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare float @remainderf(float, float) addrspace(1) [[SQRT_ATTRS]]
-; CHECK-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 1 dereferenceable(2)) addrspace(1) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; CHECK-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 1 dereferenceable(2)) addrspace(1) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; CHECK-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 1 captures(none) dereferenceable(2)) addrspace(1) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 1 captures(none) dereferenceable(2)) addrspace(1) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; CHECK-NEXT: declare double @rint(double) addrspace(1) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare float @rintf(float) addrspace(1) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare double @round(double) addrspace(1) [[DIVMOD_ATTRS]]
@@ -408,9 +408,11 @@
 ; CHECK-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; CHECK-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; CHECK-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; CHECK-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; CHECK-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; CHECK-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; CHECK-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; CHECK-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; CHECK-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; CHECK-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; CHECK-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; CHECK-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; CHECK-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/basic.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/basic.ll
index 460c9f62723ecc..3375a8af43ee16 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/basic.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/basic.ll
@@ -18,11 +18,11 @@ define float @sinf(float %x) {
 
 ; CHECK: declare void @__llvm_memcpy_element_unordered_atomic_1(ptr noalias writeonly, ptr noalias readonly, i64) [[ARGMEM_ATTRS:#[0-9]+]]
 
-; CHECK: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; CHECK: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; CHECK: declare ptr @__memset_chk(ptr, i32, i64, i64)
+; CHECK: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; CHECK: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; CHECK: declare ptr @__memset_chk(ptr writeonly, i32, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 
-; CHECK: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; CHECK: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
 
 ; CHECK: declare i128 @__umodti3(i128, i128) [[NOMEM_ATTRS:#[0-9]+]]
 
@@ -51,9 +51,9 @@ define float @sinf(float %x) {
 ; CHECK: declare float @remainderf(float, float) [[ERRNO_ATTRS]]
 ; CHECK: declare x86_fp80 @remainderl(x86_fp80, x86_fp80) [[ERRNO_ATTRS]]
 
-; CHECK: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; CHECK: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; CHECK: declare x86_fp80 @remquol(x86_fp80, x86_fp80, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; CHECK: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; CHECK: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; CHECK: declare x86_fp80 @remquol(x86_fp80, x86_fp80, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 
 ; CHECK: declare double @scalbln(double, i64) [[ERRNO_ATTRS]]
 ; CHECK: declare float @scalblnf(float, i64) [[ERRNO_ATTRS]]
@@ -78,8 +78,10 @@ define float @sinf(float %x) {
 ; CHECK: attributes [[ERRNO_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; CHECK: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; CHECK: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
-; CHECK: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; CHECK: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; CHECK: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
+; CHECK: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; CHECK: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; CHECK: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; CHECK: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; CHECK: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; CHECK: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/bsd.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/bsd.ll
index 0d595cf9b3d82a..b9b83798c6d21c 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/bsd.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/bsd.ll
@@ -219,16 +219,16 @@
 ; LINUX-NEXT: declare i64 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare i64 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare i64 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; LINUX-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; LINUX-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; LINUX-NEXT: declare ptr @__memset_chk(ptr, i32, i64, i64)
+; LINUX-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; LINUX-NEXT: declare ptr @__memset_chk(ptr writeonly, i32, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; LINUX-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare i32 @__modsi3(i32, i32) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare i128 @__modti3(i128, i128) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; LINUX-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; LINUX-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare i32 @__mulsi3(i32, i32) [[NOMEM_ATTRS]]
@@ -437,10 +437,10 @@
 ; LINUX-NEXT: declare fp128 @fmodf128(fp128, fp128) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare x86_fp80 @fmodl(x86_fp80, x86_fp80) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; LINUX-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare fp128 @frexpf128(fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare x86_fp80 @frexpl(x86_fp80, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare fp128 @frexpf128(fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare x86_fp80 @frexpl(x86_fp80, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; LINUX-NEXT: declare double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @ldexpf(float, i32) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare fp128 @ldexpf128(fp128, i32) [[SQRT_ATTRS]]
@@ -477,10 +477,10 @@
 ; LINUX-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; LINUX-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; LINUX-NEXT: declare ptr @memset(ptr, i32, i64)
-; LINUX-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare fp128 @modff128(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare x86_fp80 @modfl(x86_fp80, ptr noalias nonnull writeonly align 16 dereferenceable(10)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare fp128 @modff128(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare x86_fp80 @modfl(x86_fp80, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(10)) [[ARGMEM_WRITE_ATTRS]]
 ; LINUX-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; LINUX-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; LINUX-NEXT: declare nofpclass(snan inf zero sub norm) x86_fp80 @nanl(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
@@ -498,9 +498,9 @@
 ; LINUX-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare x86_fp80 @remainderl(x86_fp80, x86_fp80) [[SQRT_ATTRS]]
-; LINUX-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; LINUX-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; LINUX-NEXT: declare x86_fp80 @remquol(x86_fp80, x86_fp80, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare x86_fp80 @remquol(x86_fp80, x86_fp80, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; LINUX-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare fp128 @rintf128(fp128) [[SQRT_ATTRS]]
@@ -520,10 +520,10 @@
 ; LINUX-NEXT: declare float @scalbnf(float, i32) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare x86_fp80 @scalbnl(x86_fp80, i32) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare double @sin(double) [[SQRT_ATTRS]]
-; LINUX-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 dereferenceable(8), ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; LINUX-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4), ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; LINUX-NEXT: declare void @sincosf128(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16), ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; LINUX-NEXT: declare void @sincosl(x86_fp80, ptr noalias nonnull writeonly align 16 dereferenceable(10), ptr noalias nonnull writeonly align 16 dereferenceable(10)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4), ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare void @sincosf128(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare void @sincosl(x86_fp80, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(10), ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(10)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; LINUX-NEXT: declare float @sinf(float) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare fp128 @sinf128(fp128) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare double @sinh(double) [[SQRT_ATTRS]]
@@ -555,10 +555,12 @@
 ; LINUX-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; LINUX-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; LINUX-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; LINUX-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; LINUX-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; LINUX-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; LINUX-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; LINUX-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; LINUX-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; LINUX-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; LINUX-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; LINUX-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; LINUX-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
 
@@ -769,16 +771,16 @@
 ; FREEBSD-NEXT: declare i64 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; FREEBSD-NEXT: declare i64 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; FREEBSD-NEXT: declare i64 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; FREEBSD-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; FREEBSD-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; FREEBSD-NEXT: declare ptr @__memset_chk(ptr, i32, i64, i64)
+; FREEBSD-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; FREEBSD-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; FREEBSD-NEXT: declare ptr @__memset_chk(ptr writeonly, i32, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; FREEBSD-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; FREEBSD-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; FREEBSD-NEXT: declare i32 @__modsi3(i32, i32) [[NOMEM_ATTRS]]
 ; FREEBSD-NEXT: declare i128 @__modti3(i128, i128) [[NOMEM_ATTRS]]
 ; FREEBSD-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; FREEBSD-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; FREEBSD-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; FREEBSD-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; FREEBSD-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; FREEBSD-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; FREEBSD-NEXT: declare i32 @__mulsi3(i32, i32) [[NOMEM_ATTRS]]
@@ -965,9 +967,9 @@
 ; FREEBSD-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; FREEBSD-NEXT: declare x86_fp80 @fmodl(x86_fp80, x86_fp80) [[SQRT_ATTRS]]
 ; FREEBSD-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; FREEBSD-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; FREEBSD-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; FREEBSD-NEXT: declare x86_fp80 @frexpl(x86_fp80, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; FREEBSD-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; FREEBSD-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; FREEBSD-NEXT: declare x86_fp80 @frexpl(x86_fp80, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; FREEBSD-NEXT: declare double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; FREEBSD-NEXT: declare float @ldexpf(float, i32) [[SQRT_ATTRS]]
 ; FREEBSD-NEXT: declare x86_fp80 @ldexpl(x86_fp80, i32) [[SQRT_ATTRS]]
@@ -996,9 +998,9 @@
 ; FREEBSD-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; FREEBSD-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; FREEBSD-NEXT: declare ptr @memset(ptr, i32, i64)
-; FREEBSD-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; FREEBSD-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; FREEBSD-NEXT: declare x86_fp80 @modfl(x86_fp80, ptr noalias nonnull writeonly align 16 dereferenceable(10)) [[ARGMEM_WRITE_ATTRS]]
+; FREEBSD-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; FREEBSD-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; FREEBSD-NEXT: declare x86_fp80 @modfl(x86_fp80, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(10)) [[ARGMEM_WRITE_ATTRS]]
 ; FREEBSD-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; FREEBSD-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; FREEBSD-NEXT: declare nofpclass(snan inf zero sub norm) x86_fp80 @nanl(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
@@ -1014,9 +1016,9 @@
 ; FREEBSD-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; FREEBSD-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
 ; FREEBSD-NEXT: declare x86_fp80 @remainderl(x86_fp80, x86_fp80) [[SQRT_ATTRS]]
-; FREEBSD-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; FREEBSD-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; FREEBSD-NEXT: declare x86_fp80 @remquol(x86_fp80, x86_fp80, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; FREEBSD-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; FREEBSD-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; FREEBSD-NEXT: declare x86_fp80 @remquol(x86_fp80, x86_fp80, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; FREEBSD-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; FREEBSD-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; FREEBSD-NEXT: declare x86_fp80 @rintl(x86_fp80) [[SQRT_ATTRS]]
@@ -1058,10 +1060,12 @@
 ; FREEBSD-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; FREEBSD-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; FREEBSD-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; FREEBSD-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; FREEBSD-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; FREEBSD-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; FREEBSD-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; FREEBSD-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; FREEBSD-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; FREEBSD-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; FREEBSD-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; FREEBSD-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; FREEBSD-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
 
@@ -1272,16 +1276,16 @@
 ; OPENBSD-NEXT: declare i64 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; OPENBSD-NEXT: declare i64 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; OPENBSD-NEXT: declare i64 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; OPENBSD-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; OPENBSD-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; OPENBSD-NEXT: declare ptr @__memset_chk(ptr, i32, i64, i64)
+; OPENBSD-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; OPENBSD-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; OPENBSD-NEXT: declare ptr @__memset_chk(ptr writeonly, i32, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; OPENBSD-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; OPENBSD-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; OPENBSD-NEXT: declare i32 @__modsi3(i32, i32) [[NOMEM_ATTRS]]
 ; OPENBSD-NEXT: declare i128 @__modti3(i128, i128) [[NOMEM_ATTRS]]
 ; OPENBSD-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; OPENBSD-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; OPENBSD-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; OPENBSD-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; OPENBSD-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; OPENBSD-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; OPENBSD-NEXT: declare i32 @__mulsi3(i32, i32) [[NOMEM_ATTRS]]
@@ -1468,9 +1472,9 @@
 ; OPENBSD-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; OPENBSD-NEXT: declare x86_fp80 @fmodl(x86_fp80, x86_fp80) [[SQRT_ATTRS]]
 ; OPENBSD-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; OPENBSD-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; OPENBSD-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; OPENBSD-NEXT: declare x86_fp80 @frexpl(x86_fp80, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; OPENBSD-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; OPENBSD-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; OPENBSD-NEXT: declare x86_fp80 @frexpl(x86_fp80, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; OPENBSD-NEXT: declare double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; OPENBSD-NEXT: declare float @ldexpf(float, i32) [[SQRT_ATTRS]]
 ; OPENBSD-NEXT: declare x86_fp80 @ldexpl(x86_fp80, i32) [[SQRT_ATTRS]]
@@ -1499,9 +1503,9 @@
 ; OPENBSD-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; OPENBSD-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; OPENBSD-NEXT: declare ptr @memset(ptr, i32, i64)
-; OPENBSD-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; OPENBSD-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; OPENBSD-NEXT: declare x86_fp80 @modfl(x86_fp80, ptr noalias nonnull writeonly align 16 dereferenceable(10)) [[ARGMEM_WRITE_ATTRS]]
+; OPENBSD-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; OPENBSD-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; OPENBSD-NEXT: declare x86_fp80 @modfl(x86_fp80, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(10)) [[ARGMEM_WRITE_ATTRS]]
 ; OPENBSD-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; OPENBSD-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; OPENBSD-NEXT: declare nofpclass(snan inf zero sub norm) x86_fp80 @nanl(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
@@ -1517,9 +1521,9 @@
 ; OPENBSD-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; OPENBSD-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
 ; OPENBSD-NEXT: declare x86_fp80 @remainderl(x86_fp80, x86_fp80) [[SQRT_ATTRS]]
-; OPENBSD-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; OPENBSD-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; OPENBSD-NEXT: declare x86_fp80 @remquol(x86_fp80, x86_fp80, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; OPENBSD-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; OPENBSD-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; OPENBSD-NEXT: declare x86_fp80 @remquol(x86_fp80, x86_fp80, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; OPENBSD-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; OPENBSD-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; OPENBSD-NEXT: declare x86_fp80 @rintl(x86_fp80) [[SQRT_ATTRS]]
@@ -1561,9 +1565,11 @@
 ; OPENBSD-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; OPENBSD-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; OPENBSD-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; OPENBSD-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; OPENBSD-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; OPENBSD-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; OPENBSD-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; OPENBSD-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; OPENBSD-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; OPENBSD-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; OPENBSD-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; OPENBSD-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; OPENBSD-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/darwin.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/darwin.ll
index 700847c0b62c2e..4eee27b3ea91b1 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/darwin.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/darwin.ll
@@ -16,8 +16,8 @@
 ; RUN: opt -S -passes=declare-runtime-libcalls -mtriple=arm64_32-apple-watchos < %s | FileCheck -check-prefix=HAS-MEMSET-PATTERN-32 %s
 ; RUN: opt -S -passes=declare-runtime-libcalls -mtriple=armv7k-apple-watchos < %s | FileCheck -check-prefix=HAS-MEMSET-PATTERN-32 %s
 
-; MACOS: declare i32 @getc_unlocked(ptr)
-; MACOS: declare i32 @getchar_unlocked()
+; MACOS: declare noundef i32 @getc_unlocked(ptr noundef captures(none)) [[STDIO_ATTRS:#[0-9]+]]
+; MACOS: declare noundef i32 @getchar_unlocked() [[STDIO_ATTRS]]
 
 ; HAS-MEMSET-PATTERN-32: declare void @memset_pattern16(ptr writeonly captures(none), ptr readonly captures(none), i32) [[MEMSET_PATTERN_ATTRS:#[0-9]+]]
 ; HAS-MEMSET-PATTERN-32: declare void @memset_pattern4(ptr writeonly captures(none), ptr readonly captures(none), i32) [[MEMSET_PATTERN_ATTRS]]
@@ -26,10 +26,12 @@
 ; HAS-MEMSET-PATTERN-64: declare void @memset_pattern4(ptr writeonly captures(none), ptr readonly captures(none), i64) [[MEMSET_PATTERN_ATTRS]]
 ; HAS-MEMSET-PATTERN-64: declare void @memset_pattern8(ptr writeonly captures(none), ptr readonly captures(none), i64) [[MEMSET_PATTERN_ATTRS]]
 
-; MACOS: declare i32 @putc_unlocked(i32, ptr)
-; MACOS: declare i32 @putchar_unlocked(i32)
+; MACOS: declare noundef i32 @putc_unlocked(i32 noundef, ptr noundef captures(none)) [[STDIO_ATTRS]]
+; MACOS: declare noundef i32 @putchar_unlocked(i32 noundef) [[STDIO_ATTRS]]
 
 ; HAS-MEMSET-PATTERN-32: attributes [[MEMSET_PATTERN_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; HAS-MEMSET-PATTERN-64: attributes [[MEMSET_PATTERN_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 
 ; NO-MEMSET-PATTERN-NOT: memset_pattern
+
+; MACOS: attributes [[STDIO_ATTRS]] = { nofree nounwind }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/divmod.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/divmod.ll
index f77f15238ec20e..32efbb192ac76d 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/divmod.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/divmod.ll
@@ -17,8 +17,8 @@
 ; WINDOWS: declare arm_aapcscc inreg { i64, i64 } @__rt_udiv64(i64, i64) [[DIVMOD_ATTRS]]
 ; WINDOWS: attributes [[DIVMOD_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(none) }
 
-; DARWIN: declare i32 @__divmodsi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[DIVMOD_ATTRS:#[0-9]+]]
-; DARWIN: declare i32 @__udivmodsi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[DIVMOD_ATTRS]]
+; DARWIN: declare i32 @__divmodsi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[DIVMOD_ATTRS:#[0-9]+]]
+; DARWIN: declare i32 @__udivmodsi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[DIVMOD_ATTRS]]
 ; DARWIN-NOT: inreg { i32, i32 } @__divmodsi4
 ; DARWIN: attributes [[DIVMOD_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
 
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/hexagon.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/hexagon.ll
index cf885236e274dc..e9bdba8488b9e0 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/hexagon.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/hexagon.ll
@@ -211,9 +211,9 @@
 ; CHECK-NEXT: declare i32 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare i32 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare i32 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; CHECK-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i32, i32)
-; CHECK-NEXT: declare ptr @__memmove_chk(ptr, ptr, i32, i32)
-; CHECK-NEXT: declare ptr @__memset_chk(ptr, i32, i32, i32)
+; CHECK-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i32, i32) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i32, i32) [[CHK_ARGMEM_ATTRS]]
+; CHECK-NEXT: declare ptr @__memset_chk(ptr writeonly, i32, i32, i32) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; CHECK-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -222,7 +222,7 @@
 ; CHECK-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; CHECK-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; CHECK-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare i32 @__mulsi3(i32, i32) [[NOMEM_ATTRS]]
@@ -378,8 +378,8 @@
 ; CHECK-NEXT: declare double @fmod(double, double) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; CHECK-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; CHECK-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; CHECK-NEXT: declare void @hexagon_memcpy_forward_vp4cp4n2(ptr, ptr, i32)
 ; CHECK-NEXT: declare double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare float @ldexpf(float, i32) [[SQRT_ATTRS]]
@@ -401,8 +401,8 @@
 ; CHECK-NEXT: declare ptr @memcpy(ptr, ptr, i32)
 ; CHECK-NEXT: declare ptr @memmove(ptr, ptr, i32)
 ; CHECK-NEXT: declare ptr @memset(ptr, i32, i32)
-; CHECK-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; CHECK-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; CHECK-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; CHECK-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; CHECK-NEXT: declare double @nearbyint(double) [[NOMEM_ATTRS]]
@@ -413,8 +413,8 @@
 ; CHECK-NEXT: declare float @powf(float, float) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
-; CHECK-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; CHECK-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; CHECK-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; CHECK-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare double @round(double) [[NOMEM_ATTRS]]
@@ -444,10 +444,12 @@
 ; CHECK-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; CHECK-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; CHECK-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; CHECK-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; CHECK-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; CHECK-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; CHECK-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; CHECK-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; CHECK-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; CHECK-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; CHECK-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; CHECK-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; CHECK-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
 
@@ -657,9 +659,9 @@
 ; LINUX-NEXT: declare i32 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare i32 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare i32 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; LINUX-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i32, i32)
-; LINUX-NEXT: declare ptr @__memmove_chk(ptr, ptr, i32, i32)
-; LINUX-NEXT: declare ptr @__memset_chk(ptr, i32, i32, i32)
+; LINUX-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i32, i32) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i32, i32) [[CHK_ARGMEM_ATTRS]]
+; LINUX-NEXT: declare ptr @__memset_chk(ptr writeonly, i32, i32, i32) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; LINUX-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -668,7 +670,7 @@
 ; LINUX-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; LINUX-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; LINUX-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare i32 @__mulsi3(i32, i32) [[NOMEM_ATTRS]]
@@ -824,8 +826,8 @@
 ; LINUX-NEXT: declare double @fmod(double, double) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; LINUX-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; LINUX-NEXT: declare void @hexagon_memcpy_forward_vp4cp4n2(ptr, ptr, i32)
 ; LINUX-NEXT: declare double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @ldexpf(float, i32) [[SQRT_ATTRS]]
@@ -847,8 +849,8 @@
 ; LINUX-NEXT: declare ptr @memcpy(ptr, ptr, i32)
 ; LINUX-NEXT: declare ptr @memmove(ptr, ptr, i32)
 ; LINUX-NEXT: declare ptr @memset(ptr, i32, i32)
-; LINUX-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; LINUX-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; LINUX-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; LINUX-NEXT: declare double @nearbyint(double) [[NOMEM_ATTRS]]
@@ -859,8 +861,8 @@
 ; LINUX-NEXT: declare float @powf(float, float) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
-; LINUX-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; LINUX-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; LINUX-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare double @round(double) [[NOMEM_ATTRS]]
@@ -872,8 +874,8 @@
 ; LINUX-NEXT: declare double @scalbn(double, i32) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @scalbnf(float, i32) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare double @sin(double) [[SQRT_ATTRS]]
-; LINUX-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 dereferenceable(8), ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; LINUX-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4), ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4), ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; LINUX-NEXT: declare float @sinf(float) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare double @sinh(double) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @sinhf(float) [[SQRT_ATTRS]]
@@ -892,9 +894,11 @@
 ; LINUX-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; LINUX-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; LINUX-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; LINUX-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; LINUX-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; LINUX-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; LINUX-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; LINUX-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; LINUX-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; LINUX-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; LINUX-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; LINUX-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; LINUX-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/m68k.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/m68k.ll
index ddbc528f8433b7..34c6a9a906c6a8 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/m68k.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/m68k.ll
@@ -188,9 +188,9 @@
 ; M68K-NEXT: declare i32 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; M68K-NEXT: declare i32 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; M68K-NEXT: declare i32 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; M68K-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i32, i32)
-; M68K-NEXT: declare ptr @__memmove_chk(ptr, ptr, i32, i32)
-; M68K-NEXT: declare ptr @__memset_chk(ptr, i32, i32, i32)
+; M68K-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i32, i32) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; M68K-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i32, i32) [[CHK_ARGMEM_ATTRS]]
+; M68K-NEXT: declare ptr @__memset_chk(ptr writeonly, i32, i32, i32) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; M68K-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; M68K-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; M68K-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -199,7 +199,7 @@
 ; M68K-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; M68K-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; M68K-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; M68K-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 2 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; M68K-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 2 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; M68K-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; M68K-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; M68K-NEXT: declare i32 @__mulsi3(i32, i32) [[NOMEM_ATTRS]]
@@ -355,8 +355,8 @@
 ; M68K-NEXT: declare double @fmod(double, double) [[SQRT_ATTRS]]
 ; M68K-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; M68K-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; M68K-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 2 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; M68K-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 2 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; M68K-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 2 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; M68K-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 2 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; M68K-NEXT: declare double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; M68K-NEXT: declare float @ldexpf(float, i32) [[SQRT_ATTRS]]
 ; M68K-NEXT: declare i64 @llrint(double) [[SQRT_ATTRS]]
@@ -377,8 +377,8 @@
 ; M68K-NEXT: declare ptr @memcpy(ptr, ptr, i32)
 ; M68K-NEXT: declare ptr @memmove(ptr, ptr, i32)
 ; M68K-NEXT: declare ptr @memset(ptr, i32, i32)
-; M68K-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; M68K-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; M68K-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; M68K-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; M68K-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; M68K-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; M68K-NEXT: declare double @nearbyint(double) [[NOMEM_ATTRS]]
@@ -389,8 +389,8 @@
 ; M68K-NEXT: declare float @powf(float, float) [[SQRT_ATTRS]]
 ; M68K-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; M68K-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
-; M68K-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 2 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; M68K-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 2 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; M68K-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 2 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; M68K-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 2 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; M68K-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; M68K-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; M68K-NEXT: declare double @round(double) [[NOMEM_ATTRS]]
@@ -420,9 +420,11 @@
 ; M68K-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; M68K-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; M68K-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; M68K-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; M68K-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; M68K-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; M68K-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; M68K-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; M68K-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; M68K-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; M68K-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; M68K-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; M68K-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/mips.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/mips.ll
index 2ff52a23570f7c..eaeaef4786ab94 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/mips.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/mips.ll
@@ -189,9 +189,9 @@
 ; MIPS32-NEXT: declare i32 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; MIPS32-NEXT: declare i32 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; MIPS32-NEXT: declare i32 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; MIPS32-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i32 signext, i32 signext)
-; MIPS32-NEXT: declare ptr @__memmove_chk(ptr, ptr, i32 signext, i32 signext)
-; MIPS32-NEXT: declare ptr @__memset_chk(ptr, i32 signext, i32 signext, i32 signext)
+; MIPS32-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i32 signext, i32 signext) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; MIPS32-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i32 signext, i32 signext) [[CHK_ARGMEM_ATTRS]]
+; MIPS32-NEXT: declare ptr @__memset_chk(ptr writeonly, i32 signext, i32 signext, i32 signext) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; MIPS32-NEXT: declare double @__mips16_adddf3(double, double) [[NOMEM_ATTRS]]
 ; MIPS32-NEXT: declare float @__mips16_addsf3(float, float) [[NOMEM_ATTRS]]
 ; MIPS32-NEXT: declare double @__mips16_divdf3(double, double) [[NOMEM_ATTRS]]
@@ -234,7 +234,7 @@
 ; MIPS32-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; MIPS32-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; MIPS32-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; MIPS32-NEXT: declare i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; MIPS32-NEXT: declare i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; MIPS32-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; MIPS32-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; MIPS32-NEXT: declare i32 @__mulsi3(i32 signext, i32 signext) [[NOMEM_ATTRS]]
@@ -390,8 +390,8 @@
 ; MIPS32-NEXT: declare double @fmod(double, double) [[SQRT_ATTRS]]
 ; MIPS32-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; MIPS32-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; MIPS32-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; MIPS32-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; MIPS32-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; MIPS32-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; MIPS32-NEXT: declare double @ldexp(double, i32 signext) [[SQRT_ATTRS]]
 ; MIPS32-NEXT: declare float @ldexpf(float, i32 signext) [[SQRT_ATTRS]]
 ; MIPS32-NEXT: declare i64 @llrint(double) [[SQRT_ATTRS]]
@@ -412,8 +412,8 @@
 ; MIPS32-NEXT: declare ptr @memcpy(ptr, ptr, i32 signext)
 ; MIPS32-NEXT: declare ptr @memmove(ptr, ptr, i32 signext)
 ; MIPS32-NEXT: declare ptr @memset(ptr, i32 signext, i32 signext)
-; MIPS32-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; MIPS32-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; MIPS32-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; MIPS32-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; MIPS32-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; MIPS32-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; MIPS32-NEXT: declare double @nearbyint(double) [[NOMEM_ATTRS]]
@@ -424,8 +424,8 @@
 ; MIPS32-NEXT: declare float @powf(float, float) [[SQRT_ATTRS]]
 ; MIPS32-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; MIPS32-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
-; MIPS32-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; MIPS32-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; MIPS32-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; MIPS32-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; MIPS32-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; MIPS32-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; MIPS32-NEXT: declare double @round(double) [[NOMEM_ATTRS]]
@@ -437,8 +437,8 @@
 ; MIPS32-NEXT: declare double @scalbn(double, i32 signext) [[SQRT_ATTRS]]
 ; MIPS32-NEXT: declare float @scalbnf(float, i32 signext) [[SQRT_ATTRS]]
 ; MIPS32-NEXT: declare double @sin(double) [[SQRT_ATTRS]]
-; MIPS32-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 dereferenceable(8), ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; MIPS32-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4), ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; MIPS32-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; MIPS32-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4), ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; MIPS32-NEXT: declare float @sinf(float) [[SQRT_ATTRS]]
 ; MIPS32-NEXT: declare double @sinh(double) [[SQRT_ATTRS]]
 ; MIPS32-NEXT: declare float @sinhf(float) [[SQRT_ATTRS]]
@@ -457,10 +457,12 @@
 ; MIPS32-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; MIPS32-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; MIPS32-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; MIPS32-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; MIPS32-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; MIPS32-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; MIPS32-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; MIPS32-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; MIPS32-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; MIPS32-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; MIPS32-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; MIPS32-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; MIPS32-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
 
@@ -656,9 +658,9 @@
 ; MIPS64-NEXT: declare i64 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; MIPS64-NEXT: declare i64 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; MIPS64-NEXT: declare i64 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; MIPS64-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; MIPS64-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; MIPS64-NEXT: declare ptr @__memset_chk(ptr, i32 signext, i64, i64)
+; MIPS64-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; MIPS64-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; MIPS64-NEXT: declare ptr @__memset_chk(ptr writeonly, i32 signext, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; MIPS64-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; MIPS64-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; MIPS64-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -667,7 +669,7 @@
 ; MIPS64-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; MIPS64-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; MIPS64-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; MIPS64-NEXT: declare i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; MIPS64-NEXT: declare i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; MIPS64-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; MIPS64-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; MIPS64-NEXT: declare i32 @__mulsi3(i32 signext, i32 signext) [[NOMEM_ATTRS]]
@@ -848,9 +850,9 @@
 ; MIPS64-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; MIPS64-NEXT: declare fp128 @fmodl(fp128, fp128) [[SQRT_ATTRS]]
 ; MIPS64-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; MIPS64-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; MIPS64-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; MIPS64-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; MIPS64-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; MIPS64-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; MIPS64-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; MIPS64-NEXT: declare double @ldexp(double, i32 signext) [[SQRT_ATTRS]]
 ; MIPS64-NEXT: declare float @ldexpf(float, i32 signext) [[SQRT_ATTRS]]
 ; MIPS64-NEXT: declare fp128 @ldexpl(fp128, i32 signext) [[SQRT_ATTRS]]
@@ -879,9 +881,9 @@
 ; MIPS64-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; MIPS64-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; MIPS64-NEXT: declare ptr @memset(ptr, i32 signext, i64)
-; MIPS64-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; MIPS64-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; MIPS64-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
+; MIPS64-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; MIPS64-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; MIPS64-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
 ; MIPS64-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; MIPS64-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; MIPS64-NEXT: declare nofpclass(snan inf zero sub norm) fp128 @nanl(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
@@ -897,9 +899,9 @@
 ; MIPS64-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; MIPS64-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
 ; MIPS64-NEXT: declare fp128 @remainderl(fp128, fp128) [[SQRT_ATTRS]]
-; MIPS64-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; MIPS64-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; MIPS64-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; MIPS64-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; MIPS64-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; MIPS64-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; MIPS64-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; MIPS64-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; MIPS64-NEXT: declare fp128 @rintl(fp128) [[SQRT_ATTRS]]
@@ -916,9 +918,9 @@
 ; MIPS64-NEXT: declare float @scalbnf(float, i32 signext) [[SQRT_ATTRS]]
 ; MIPS64-NEXT: declare fp128 @scalbnl(fp128, i32 signext) [[SQRT_ATTRS]]
 ; MIPS64-NEXT: declare double @sin(double) [[SQRT_ATTRS]]
-; MIPS64-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 dereferenceable(8), ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; MIPS64-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4), ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; MIPS64-NEXT: declare void @sincosl(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16), ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; MIPS64-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; MIPS64-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4), ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; MIPS64-NEXT: declare void @sincosl(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; MIPS64-NEXT: declare float @sinf(float) [[SQRT_ATTRS]]
 ; MIPS64-NEXT: declare double @sinh(double) [[SQRT_ATTRS]]
 ; MIPS64-NEXT: declare float @sinhf(float) [[SQRT_ATTRS]]
@@ -944,9 +946,11 @@
 ; MIPS64-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; MIPS64-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; MIPS64-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; MIPS64-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; MIPS64-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; MIPS64-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; MIPS64-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; MIPS64-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; MIPS64-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; MIPS64-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; MIPS64-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; MIPS64-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; MIPS64-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/msp430.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/msp430.ll
index 9d9339b126cf08..c5958d17d6361b 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/msp430.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/msp430.ll
@@ -186,9 +186,9 @@
 ; CHECK-NEXT: declare i16 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare i16 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare i16 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; CHECK-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i16, i16)
-; CHECK-NEXT: declare ptr @__memmove_chk(ptr, ptr, i16, i16)
-; CHECK-NEXT: declare ptr @__memset_chk(ptr, i16, i16, i16)
+; CHECK-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i16, i16) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i16, i16) [[CHK_ARGMEM_ATTRS]]
+; CHECK-NEXT: declare ptr @__memset_chk(ptr writeonly, i16, i16, i16) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; CHECK-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare i16 @__modhi3(i16, i16) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -241,7 +241,7 @@
 ; CHECK-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare i16 @__mulhi3(i16, i16) [[NOMEM_ATTRS]]
-; CHECK-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 2 dereferenceable(2)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 2 captures(none) dereferenceable(2)) [[ARGMEM_WRITE_ATTRS]]
 ; CHECK-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare i32 @__mulsi3(i32, i32) [[NOMEM_ATTRS]]
@@ -397,8 +397,8 @@
 ; CHECK-NEXT: declare double @fmod(double, double) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; CHECK-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 2 dereferenceable(2)) [[ARGMEM_WRITE_ATTRS]]
-; CHECK-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 2 dereferenceable(2)) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 2 captures(none) dereferenceable(2)) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 2 captures(none) dereferenceable(2)) [[ARGMEM_WRITE_ATTRS]]
 ; CHECK-NEXT: declare double @ldexp(double, i16) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare float @ldexpf(float, i16) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare i64 @llrint(double) [[SQRT_ATTRS]]
@@ -419,8 +419,8 @@
 ; CHECK-NEXT: declare ptr @memcpy(ptr, ptr, i16)
 ; CHECK-NEXT: declare ptr @memmove(ptr, ptr, i16)
 ; CHECK-NEXT: declare ptr @memset(ptr, i16, i16)
-; CHECK-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 2 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; CHECK-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 2 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 2 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 2 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; CHECK-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; CHECK-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; CHECK-NEXT: declare double @nearbyint(double) [[NOMEM_ATTRS]]
@@ -431,8 +431,8 @@
 ; CHECK-NEXT: declare float @powf(float, float) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
-; CHECK-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 2 dereferenceable(2)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; CHECK-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 2 dereferenceable(2)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; CHECK-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 2 captures(none) dereferenceable(2)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 2 captures(none) dereferenceable(2)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; CHECK-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare double @round(double) [[NOMEM_ATTRS]]
@@ -462,9 +462,11 @@
 ; CHECK-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; CHECK-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; CHECK-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; CHECK-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; CHECK-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; CHECK-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; CHECK-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; CHECK-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; CHECK-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; CHECK-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; CHECK-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; CHECK-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; CHECK-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ppc.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ppc.ll
index 554d12479ff7c4..96ab279c637204 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ppc.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ppc.ll
@@ -230,9 +230,9 @@
 ; AIX32-NEXT: declare i32 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; AIX32-NEXT: declare i32 @__ltkf2(fp128, fp128) [[NOMEM_ATTRS]]
 ; AIX32-NEXT: declare i32 @__ltsf2(float, float) [[NOMEM_ATTRS]]
-; AIX32-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i32, i32)
-; AIX32-NEXT: declare ptr @__memmove_chk(ptr, ptr, i32, i32)
-; AIX32-NEXT: declare ptr @__memset_chk(ptr, i32, i32, i32)
+; AIX32-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i32, i32) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; AIX32-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i32, i32) [[CHK_ARGMEM_ATTRS]]
+; AIX32-NEXT: declare ptr @__memset_chk(ptr writeonly, i32, i32, i32) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; AIX32-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; AIX32-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; AIX32-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -242,7 +242,7 @@
 ; AIX32-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; AIX32-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; AIX32-NEXT: declare fp128 @__mulkf3(fp128, fp128) [[NOMEM_ATTRS]]
-; AIX32-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; AIX32-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; AIX32-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; AIX32-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; AIX32-NEXT: declare i32 @__mulsi3(i32, i32) [[NOMEM_ATTRS]]
@@ -444,10 +444,10 @@
 ; AIX32-NEXT: declare fp128 @fmodf128(fp128, fp128) [[SQRT_ATTRS]]
 ; AIX32-NEXT: declare double @fmodl(double, double) [[SQRT_ATTRS]]
 ; AIX32-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; AIX32-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; AIX32-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; AIX32-NEXT: declare fp128 @frexpf128(fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; AIX32-NEXT: declare double @frexpl(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; AIX32-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; AIX32-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; AIX32-NEXT: declare fp128 @frexpf128(fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; AIX32-NEXT: declare double @frexpl(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; AIX32-NEXT: declare double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; AIX32-NEXT: declare float @ldexpf(float, i32) [[SQRT_ATTRS]]
 ; AIX32-NEXT: declare fp128 @ldexpf128(fp128, i32) [[SQRT_ATTRS]]
@@ -483,10 +483,10 @@
 ; AIX32-NEXT: declare noalias noundef ptr @malloc(i32 noundef) [[MALLOC_ATTRS:#[0-9]+]]
 ; AIX32-NEXT: declare ptr @memmove(ptr, ptr, i32)
 ; AIX32-NEXT: declare ptr @memset(ptr, i32, i32)
-; AIX32-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 4 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; AIX32-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; AIX32-NEXT: declare fp128 @modff128(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
-; AIX32-NEXT: declare double @modfl(double, ptr noalias nonnull writeonly align 4 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; AIX32-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; AIX32-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; AIX32-NEXT: declare fp128 @modff128(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
+; AIX32-NEXT: declare double @modfl(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
 ; AIX32-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; AIX32-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; AIX32-NEXT: declare nofpclass(snan inf zero sub norm) double @nanl(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
@@ -504,9 +504,9 @@
 ; AIX32-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; AIX32-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
 ; AIX32-NEXT: declare double @remainderl(double, double) [[SQRT_ATTRS]]
-; AIX32-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; AIX32-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; AIX32-NEXT: declare double @remquol(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; AIX32-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; AIX32-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; AIX32-NEXT: declare double @remquol(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; AIX32-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; AIX32-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; AIX32-NEXT: declare fp128 @rintf128(fp128) [[SQRT_ATTRS]]
@@ -526,7 +526,7 @@
 ; AIX32-NEXT: declare float @scalbnf(float, i32) [[SQRT_ATTRS]]
 ; AIX32-NEXT: declare double @scalbnl(double, i32) [[SQRT_ATTRS]]
 ; AIX32-NEXT: declare double @sin(double) [[SQRT_ATTRS]]
-; AIX32-NEXT: declare void @sincosf128(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16), ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; AIX32-NEXT: declare void @sincosf128(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; AIX32-NEXT: declare float @sinf(float) [[SQRT_ATTRS]]
 ; AIX32-NEXT: declare fp128 @sinf128(fp128) [[SQRT_ATTRS]]
 ; AIX32-NEXT: declare double @sinh(double) [[SQRT_ATTRS]]
@@ -556,21 +556,24 @@
 ; AIX32-NEXT: declare noalias noundef ptr @vec_calloc(i32 noundef, i32 noundef) [[VEC_CALLOC_ATTRS:#[0-9]+]]
 ; AIX32-NEXT: declare void @vec_free(ptr allocptr noundef captures(none)) [[VEC_FREE_ATTRS:#[0-9]+]]
 ; AIX32-NEXT: declare noalias noundef ptr @vec_malloc(i32 noundef) [[VEC_MALLOC_ATTRS:#[0-9]+]]
-; AIX32-NEXT: declare ptr @vec_realloc(ptr, i32)
+; AIX32-NEXT: declare noalias noundef ptr @vec_realloc(ptr allocptr captures(none), i32 noundef) [[VEC_REALLOC_ATTRS:#[0-9]+]]
 ; AIX32-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
 ; AIX32-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; AIX32-NEXT: attributes [[NOMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(none) }
 ; AIX32-NEXT: attributes [[ATOMIC_ATTRS]] = { nocallback nofree nounwind willreturn }
 ; AIX32-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; AIX32-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
+; AIX32-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; AIX32-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; AIX32-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; AIX32-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; AIX32-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; AIX32-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; AIX32-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; AIX32-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; AIX32-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
-; AIX32-NEXT: attributes [[VEC_CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="vec_malloc" }
+; AIX32-NEXT: attributes [[VEC_CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="vec_malloc" }
 ; AIX32-NEXT: attributes [[VEC_FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="vec_malloc" }
-; AIX32-NEXT: attributes [[VEC_MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="vec_malloc" }
+; AIX32-NEXT: attributes [[VEC_MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="vec_malloc" }
+; AIX32-NEXT: attributes [[VEC_REALLOC_ATTRS]] = { nounwind willreturn allockind("realloc") allocsize(1) memory(argmem: readwrite, inaccessiblemem: readwrite, errnomem: write) "alloc-family"="vec_malloc" }
 
 ; AIX64: @__ssp_canary_word = external global ptr
 ; AIX64-NEXT: declare signext i32 @_Unwind_RaiseException(ptr)
@@ -799,9 +802,9 @@
 ; AIX64-NEXT: declare i64 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; AIX64-NEXT: declare i64 @__ltkf2(fp128, fp128) [[NOMEM_ATTRS]]
 ; AIX64-NEXT: declare i64 @__ltsf2(float, float) [[NOMEM_ATTRS]]
-; AIX64-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; AIX64-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; AIX64-NEXT: declare ptr @__memset_chk(ptr, i32 signext, i64, i64)
+; AIX64-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; AIX64-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; AIX64-NEXT: declare ptr @__memset_chk(ptr writeonly, i32 signext, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; AIX64-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; AIX64-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; AIX64-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -811,7 +814,7 @@
 ; AIX64-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; AIX64-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; AIX64-NEXT: declare fp128 @__mulkf3(fp128, fp128) [[NOMEM_ATTRS]]
-; AIX64-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; AIX64-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; AIX64-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; AIX64-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; AIX64-NEXT: declare signext i32 @__mulsi3(i32 signext, i32 signext) [[NOMEM_ATTRS]]
@@ -1014,10 +1017,10 @@
 ; AIX64-NEXT: declare fp128 @fmodf128(fp128, fp128) [[SQRT_ATTRS]]
 ; AIX64-NEXT: declare double @fmodl(double, double) [[SQRT_ATTRS]]
 ; AIX64-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; AIX64-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; AIX64-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; AIX64-NEXT: declare fp128 @frexpf128(fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; AIX64-NEXT: declare double @frexpl(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; AIX64-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; AIX64-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; AIX64-NEXT: declare fp128 @frexpf128(fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; AIX64-NEXT: declare double @frexpl(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; AIX64-NEXT: declare double @ldexp(double, i32 signext) [[SQRT_ATTRS]]
 ; AIX64-NEXT: declare float @ldexpf(float, i32 signext) [[SQRT_ATTRS]]
 ; AIX64-NEXT: declare fp128 @ldexpf128(fp128, i32 signext) [[SQRT_ATTRS]]
@@ -1053,10 +1056,10 @@
 ; AIX64-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-9]+]]
 ; AIX64-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; AIX64-NEXT: declare ptr @memset(ptr, i32 signext, i64)
-; AIX64-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 4 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; AIX64-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; AIX64-NEXT: declare fp128 @modff128(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
-; AIX64-NEXT: declare double @modfl(double, ptr noalias nonnull writeonly align 4 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; AIX64-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; AIX64-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; AIX64-NEXT: declare fp128 @modff128(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
+; AIX64-NEXT: declare double @modfl(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
 ; AIX64-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; AIX64-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; AIX64-NEXT: declare nofpclass(snan inf zero sub norm) double @nanl(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
@@ -1074,9 +1077,9 @@
 ; AIX64-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; AIX64-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
 ; AIX64-NEXT: declare double @remainderl(double, double) [[SQRT_ATTRS]]
-; AIX64-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; AIX64-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; AIX64-NEXT: declare double @remquol(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; AIX64-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; AIX64-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; AIX64-NEXT: declare double @remquol(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; AIX64-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; AIX64-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; AIX64-NEXT: declare fp128 @rintf128(fp128) [[SQRT_ATTRS]]
@@ -1096,7 +1099,7 @@
 ; AIX64-NEXT: declare float @scalbnf(float, i32 signext) [[SQRT_ATTRS]]
 ; AIX64-NEXT: declare double @scalbnl(double, i32 signext) [[SQRT_ATTRS]]
 ; AIX64-NEXT: declare double @sin(double) [[SQRT_ATTRS]]
-; AIX64-NEXT: declare void @sincosf128(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16), ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; AIX64-NEXT: declare void @sincosf128(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; AIX64-NEXT: declare float @sinf(float) [[SQRT_ATTRS]]
 ; AIX64-NEXT: declare fp128 @sinf128(fp128) [[SQRT_ATTRS]]
 ; AIX64-NEXT: declare double @sinh(double) [[SQRT_ATTRS]]
@@ -1126,21 +1129,24 @@
 ; AIX64-NEXT: declare noalias noundef ptr @vec_calloc(i64 noundef, i64 noundef) [[VEC_CALLOC_ATTRS:#[0-9]+]]
 ; AIX64-NEXT: declare void @vec_free(ptr allocptr noundef captures(none)) [[VEC_FREE_ATTRS:#[0-9]+]]
 ; AIX64-NEXT: declare noalias noundef ptr @vec_malloc(i64 noundef) [[VEC_MALLOC_ATTRS:#[0-9]+]]
-; AIX64-NEXT: declare ptr @vec_realloc(ptr, i64)
+; AIX64-NEXT: declare noalias noundef ptr @vec_realloc(ptr allocptr captures(none), i64 noundef) [[VEC_REALLOC_ATTRS:#[0-9]+]]
 ; AIX64-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
 ; AIX64-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; AIX64-NEXT: attributes [[NOMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(none) }
 ; AIX64-NEXT: attributes [[ATOMIC_ATTRS]] = { nocallback nofree nounwind willreturn }
 ; AIX64-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; AIX64-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
+; AIX64-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; AIX64-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; AIX64-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; AIX64-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; AIX64-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; AIX64-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; AIX64-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; AIX64-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; AIX64-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
-; AIX64-NEXT: attributes [[VEC_CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="vec_malloc" }
+; AIX64-NEXT: attributes [[VEC_CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="vec_malloc" }
 ; AIX64-NEXT: attributes [[VEC_FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="vec_malloc" }
-; AIX64-NEXT: attributes [[VEC_MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="vec_malloc" }
+; AIX64-NEXT: attributes [[VEC_MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="vec_malloc" }
+; AIX64-NEXT: attributes [[VEC_REALLOC_ATTRS]] = { nounwind willreturn allockind("realloc") allocsize(1) memory(argmem: readwrite, inaccessiblemem: readwrite, errnomem: write) "alloc-family"="vec_malloc" }
 
 ; LINUX: @__stack_chk_guard = external global ptr
 ; LINUX-NEXT: declare signext i32 @_Unwind_RaiseException(ptr)
@@ -1360,9 +1366,9 @@
 ; LINUX-NEXT: declare i64 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare i64 @__ltkf2(fp128, fp128) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare i64 @__ltsf2(float, float) [[NOMEM_ATTRS]]
-; LINUX-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; LINUX-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; LINUX-NEXT: declare ptr @__memset_chk(ptr, i32 signext, i64, i64)
+; LINUX-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; LINUX-NEXT: declare ptr @__memset_chk(ptr writeonly, i32 signext, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; LINUX-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -1372,7 +1378,7 @@
 ; LINUX-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare fp128 @__mulkf3(fp128, fp128) [[NOMEM_ATTRS]]
-; LINUX-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; LINUX-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare signext i32 @__mulsi3(i32 signext, i32 signext) [[NOMEM_ATTRS]]
@@ -1575,10 +1581,10 @@
 ; LINUX-NEXT: declare fp128 @fmodf128(fp128, fp128) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare ppc_fp128 @fmodl(ppc_fp128, ppc_fp128) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; LINUX-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare fp128 @frexpf128(fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare ppc_fp128 @frexpl(ppc_fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare fp128 @frexpf128(fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare ppc_fp128 @frexpl(ppc_fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; LINUX-NEXT: declare double @ldexp(double, i32 signext) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @ldexpf(float, i32 signext) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare fp128 @ldexpf128(fp128, i32 signext) [[SQRT_ATTRS]]
@@ -1615,10 +1621,10 @@
 ; LINUX-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; LINUX-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; LINUX-NEXT: declare ptr @memset(ptr, i32 signext, i64)
-; LINUX-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare fp128 @modff128(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare ppc_fp128 @modfl(ppc_fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare fp128 @modff128(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare ppc_fp128 @modfl(ppc_fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
 ; LINUX-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; LINUX-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; LINUX-NEXT: declare nofpclass(snan inf zero sub norm) ppc_fp128 @nanl(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
@@ -1636,9 +1642,9 @@
 ; LINUX-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare ppc_fp128 @remainderl(ppc_fp128, ppc_fp128) [[SQRT_ATTRS]]
-; LINUX-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; LINUX-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; LINUX-NEXT: declare ppc_fp128 @remquol(ppc_fp128, ppc_fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare ppc_fp128 @remquol(ppc_fp128, ppc_fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; LINUX-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare fp128 @rintf128(fp128) [[SQRT_ATTRS]]
@@ -1658,10 +1664,10 @@
 ; LINUX-NEXT: declare float @scalbnf(float, i32 signext) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare ppc_fp128 @scalbnl(ppc_fp128, i32 signext) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare double @sin(double) [[SQRT_ATTRS]]
-; LINUX-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 dereferenceable(8), ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; LINUX-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4), ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; LINUX-NEXT: declare void @sincosf128(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16), ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; LINUX-NEXT: declare void @sincosl(ppc_fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16), ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4), ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare void @sincosf128(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare void @sincosl(ppc_fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; LINUX-NEXT: declare float @sinf(float) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare fp128 @sinf128(fp128) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare double @sinh(double) [[SQRT_ATTRS]]
@@ -1693,9 +1699,11 @@
 ; LINUX-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; LINUX-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; LINUX-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; LINUX-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; LINUX-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; LINUX-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; LINUX-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; LINUX-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; LINUX-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; LINUX-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; LINUX-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; LINUX-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; LINUX-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/riscv.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/riscv.ll
index 671889fd65c433..dc7f978a1de8e7 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/riscv.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/riscv.ll
@@ -194,9 +194,9 @@
 ; RV32-NEXT: declare i32 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; RV32-NEXT: declare i32 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; RV32-NEXT: declare i32 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; RV32-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i32, i32)
-; RV32-NEXT: declare ptr @__memmove_chk(ptr, ptr, i32, i32)
-; RV32-NEXT: declare ptr @__memset_chk(ptr, i32, i32, i32)
+; RV32-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i32, i32) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; RV32-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i32, i32) [[CHK_ARGMEM_ATTRS]]
+; RV32-NEXT: declare ptr @__memset_chk(ptr writeonly, i32, i32, i32) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; RV32-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; RV32-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; RV32-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -205,7 +205,7 @@
 ; RV32-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; RV32-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; RV32-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; RV32-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; RV32-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; RV32-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; RV32-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; RV32-NEXT: declare i32 @__mulsi3(i32, i32) [[NOMEM_ATTRS]]
@@ -386,9 +386,9 @@
 ; RV32-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; RV32-NEXT: declare fp128 @fmodl(fp128, fp128) [[SQRT_ATTRS]]
 ; RV32-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; RV32-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; RV32-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; RV32-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; RV32-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; RV32-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; RV32-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; RV32-NEXT: declare double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; RV32-NEXT: declare float @ldexpf(float, i32) [[SQRT_ATTRS]]
 ; RV32-NEXT: declare fp128 @ldexpl(fp128, i32) [[SQRT_ATTRS]]
@@ -417,9 +417,9 @@
 ; RV32-NEXT: declare ptr @memcpy(ptr, ptr, i32)
 ; RV32-NEXT: declare ptr @memmove(ptr, ptr, i32)
 ; RV32-NEXT: declare ptr @memset(ptr, i32, i32)
-; RV32-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; RV32-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; RV32-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
+; RV32-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; RV32-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; RV32-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
 ; RV32-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; RV32-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; RV32-NEXT: declare nofpclass(snan inf zero sub norm) fp128 @nanl(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
@@ -435,9 +435,9 @@
 ; RV32-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; RV32-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
 ; RV32-NEXT: declare fp128 @remainderl(fp128, fp128) [[SQRT_ATTRS]]
-; RV32-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; RV32-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; RV32-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; RV32-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; RV32-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; RV32-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; RV32-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; RV32-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; RV32-NEXT: declare fp128 @rintl(fp128) [[SQRT_ATTRS]]
@@ -479,10 +479,12 @@
 ; RV32-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; RV32-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; RV32-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; RV32-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; RV32-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; RV32-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; RV32-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; RV32-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; RV32-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; RV32-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; RV32-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; RV32-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; RV32-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
 
@@ -678,9 +680,9 @@
 ; RV64-NEXT: declare i64 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; RV64-NEXT: declare i64 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; RV64-NEXT: declare i64 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; RV64-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; RV64-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; RV64-NEXT: declare ptr @__memset_chk(ptr, i32 signext, i64, i64)
+; RV64-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; RV64-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; RV64-NEXT: declare ptr @__memset_chk(ptr writeonly, i32 signext, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; RV64-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; RV64-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; RV64-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -689,7 +691,7 @@
 ; RV64-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; RV64-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; RV64-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; RV64-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; RV64-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; RV64-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; RV64-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; RV64-NEXT: declare signext i32 @__mulsi3(i32 signext, i32 signext) [[NOMEM_ATTRS]]
@@ -871,9 +873,9 @@
 ; RV64-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; RV64-NEXT: declare fp128 @fmodl(fp128, fp128) [[SQRT_ATTRS]]
 ; RV64-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; RV64-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; RV64-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; RV64-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; RV64-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; RV64-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; RV64-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; RV64-NEXT: declare double @ldexp(double, i32 signext) [[SQRT_ATTRS]]
 ; RV64-NEXT: declare float @ldexpf(float, i32 signext) [[SQRT_ATTRS]]
 ; RV64-NEXT: declare fp128 @ldexpl(fp128, i32 signext) [[SQRT_ATTRS]]
@@ -902,9 +904,9 @@
 ; RV64-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; RV64-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; RV64-NEXT: declare ptr @memset(ptr, i32 signext, i64)
-; RV64-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; RV64-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; RV64-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
+; RV64-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; RV64-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; RV64-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
 ; RV64-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; RV64-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; RV64-NEXT: declare nofpclass(snan inf zero sub norm) fp128 @nanl(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
@@ -920,9 +922,9 @@
 ; RV64-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; RV64-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
 ; RV64-NEXT: declare fp128 @remainderl(fp128, fp128) [[SQRT_ATTRS]]
-; RV64-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; RV64-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; RV64-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; RV64-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; RV64-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; RV64-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; RV64-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; RV64-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; RV64-NEXT: declare fp128 @rintl(fp128) [[SQRT_ATTRS]]
@@ -964,9 +966,11 @@
 ; RV64-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; RV64-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; RV64-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; RV64-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; RV64-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; RV64-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; RV64-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; RV64-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; RV64-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; RV64-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; RV64-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; RV64-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; RV64-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/sleef-riscv.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/sleef-riscv.ll
index 7f4d9930de734d..e9481f4451c9ec 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/sleef-riscv.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/sleef-riscv.ll
@@ -121,9 +121,9 @@
 
 ; CHECK: declare <vscale x 4 x float> @Sleef_logfx_u10rvvm2(<vscale x 4 x float>) [[ATTRS]]
 
-; CHECK: declare <vscale x 2 x double> @Sleef_modfdx_rvvm2(<vscale x 2 x double>, ptr noalias nonnull writeonly align 8) [[ATTRS_PTR_ARG:#[0-9]+]]
+; CHECK: declare <vscale x 2 x double> @Sleef_modfdx_rvvm2(<vscale x 2 x double>, ptr noalias nonnull writeonly align 8 captures(none)) [[ATTRS_PTR_ARG:#[0-9]+]]
 
-; CHECK: declare <vscale x 4 x float> @Sleef_modffx_rvvm2(<vscale x 4 x float>, ptr noalias nonnull writeonly align 4) [[ATTRS_PTR_ARG]]
+; CHECK: declare <vscale x 4 x float> @Sleef_modffx_rvvm2(<vscale x 4 x float>, ptr noalias nonnull writeonly align 4 captures(none)) [[ATTRS_PTR_ARG]]
 
 ; CHECK: declare <vscale x 2 x double> @Sleef_nextafterdx_rvvm2(<vscale x 2 x double>, <vscale x 2 x double>) [[ATTRS]]
 
@@ -133,13 +133,13 @@
 
 ; CHECK: declare <vscale x 4 x float> @Sleef_powfx_u10rvvm2(<vscale x 4 x float>, <vscale x 4 x float>) [[ATTRS]]
 
-; CHECK: declare void @Sleef_sincosdx_u10rvvm2(<vscale x 2 x double>, ptr noalias nonnull writeonly align 8, ptr noalias nonnull writeonly align 8) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @Sleef_sincosdx_u10rvvm2(<vscale x 2 x double>, ptr noalias nonnull writeonly align 8 captures(none), ptr noalias nonnull writeonly align 8 captures(none)) [[ATTRS_PTR_ARG]]
 
-; CHECK: declare void @Sleef_sincosfx_u10rvvm2(<vscale x 4 x float>, ptr noalias nonnull writeonly align 4, ptr noalias nonnull writeonly align 4) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @Sleef_sincosfx_u10rvvm2(<vscale x 4 x float>, ptr noalias nonnull writeonly align 4 captures(none), ptr noalias nonnull writeonly align 4 captures(none)) [[ATTRS_PTR_ARG]]
 
-; CHECK: declare void @Sleef_sincospidx_u10rvvm2(<vscale x 2 x double>, ptr noalias nonnull writeonly align 8, ptr noalias nonnull writeonly align 8) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @Sleef_sincospidx_u10rvvm2(<vscale x 2 x double>, ptr noalias nonnull writeonly align 8 captures(none), ptr noalias nonnull writeonly align 8 captures(none)) [[ATTRS_PTR_ARG]]
 
-; CHECK: declare void @Sleef_sincospifx_u10rvvm2(<vscale x 4 x float>, ptr noalias nonnull writeonly align 4, ptr noalias nonnull writeonly align 4) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @Sleef_sincospifx_u10rvvm2(<vscale x 4 x float>, ptr noalias nonnull writeonly align 4 captures(none), ptr noalias nonnull writeonly align 4 captures(none)) [[ATTRS_PTR_ARG]]
 
 ; CHECK: declare <vscale x 2 x double> @Sleef_sindx_u10rvvm2(<vscale x 2 x double>) [[ATTRS]]
 
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/sleef.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/sleef.ll
index 18b36947330415..b31900a2cc0efc 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/sleef.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/sleef.ll
@@ -59,11 +59,11 @@
 
 ; CHECK: declare <2 x double> @_ZGVnN2v_tgamma(<2 x double>) [[ATTRS]]
 
-; CHECK: declare <2 x double> @_ZGVnN2vl8_modf(<2 x double>, ptr noalias nonnull writeonly align 8 dereferenceable(16)) [[ATTRS_PTR_ARG:#[0-9]+]]
+; CHECK: declare <2 x double> @_ZGVnN2vl8_modf(<2 x double>, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(16)) [[ATTRS_PTR_ARG:#[0-9]+]]
 
-; CHECK: declare void @_ZGVnN2vl8l8_sincos(<2 x double>, ptr noalias nonnull writeonly align 8 dereferenceable(16), ptr noalias nonnull writeonly align 8 dereferenceable(16)) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @_ZGVnN2vl8l8_sincos(<2 x double>, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(16)) [[ATTRS_PTR_ARG]]
 
-; CHECK: declare void @_ZGVnN2vl8l8_sincospi(<2 x double>, ptr noalias nonnull writeonly align 8 dereferenceable(16), ptr noalias nonnull writeonly align 8 dereferenceable(16)) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @_ZGVnN2vl8l8_sincospi(<2 x double>, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(16)) [[ATTRS_PTR_ARG]]
 
 ; CHECK: declare <2 x double> @_ZGVnN2vv_atan2(<2 x double>, <2 x double>) [[ATTRS]]
 
@@ -145,11 +145,11 @@
 
 ; CHECK: declare <4 x float> @_ZGVnN4v_tgammaf(<4 x float>) [[ATTRS]]
 
-; CHECK: declare <4 x float> @_ZGVnN4vl4_modff(<4 x float>, ptr noalias nonnull writeonly align 4 dereferenceable(16)) [[ATTRS_PTR_ARG]]
+; CHECK: declare <4 x float> @_ZGVnN4vl4_modff(<4 x float>, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(16)) [[ATTRS_PTR_ARG]]
 
-; CHECK: declare void @_ZGVnN4vl4l4_sincosf(<4 x float>, ptr noalias nonnull writeonly align 4 dereferenceable(16), ptr noalias nonnull writeonly align 4 dereferenceable(16)) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @_ZGVnN4vl4l4_sincosf(<4 x float>, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(16)) [[ATTRS_PTR_ARG]]
 
-; CHECK: declare void @_ZGVnN4vl4l4_sincospif(<4 x float>, ptr noalias nonnull writeonly align 4 dereferenceable(16), ptr noalias nonnull writeonly align 4 dereferenceable(16)) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @_ZGVnN4vl4l4_sincospif(<4 x float>, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(16)) [[ATTRS_PTR_ARG]]
 
 ; CHECK: declare <4 x float> @_ZGVnN4vv_atan2f(<4 x float>, <4 x float>) [[ATTRS]]
 
@@ -333,17 +333,17 @@
 
 ; CHECK: declare <vscale x 4 x float> @_ZGVsMxvvv_fmaf(<vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x i1>) [[ATTRS]]
 
-; CHECK: declare <vscale x 4 x float> @_ZGVsNxvl4_modff(<vscale x 4 x float>, ptr noalias nonnull writeonly align 4) [[ATTRS_PTR_ARG]]
+; CHECK: declare <vscale x 4 x float> @_ZGVsNxvl4_modff(<vscale x 4 x float>, ptr noalias nonnull writeonly align 4 captures(none)) [[ATTRS_PTR_ARG]]
 
-; CHECK: declare void @_ZGVsNxvl4l4_sincosf(<vscale x 4 x float>, ptr noalias nonnull writeonly align 4, ptr noalias nonnull writeonly align 4) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @_ZGVsNxvl4l4_sincosf(<vscale x 4 x float>, ptr noalias nonnull writeonly align 4 captures(none), ptr noalias nonnull writeonly align 4 captures(none)) [[ATTRS_PTR_ARG]]
 
-; CHECK: declare void @_ZGVsNxvl4l4_sincospif(<vscale x 4 x float>, ptr noalias nonnull writeonly align 4, ptr noalias nonnull writeonly align 4) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @_ZGVsNxvl4l4_sincospif(<vscale x 4 x float>, ptr noalias nonnull writeonly align 4 captures(none), ptr noalias nonnull writeonly align 4 captures(none)) [[ATTRS_PTR_ARG]]
 
-; CHECK: declare <vscale x 2 x double> @_ZGVsNxvl8_modf(<vscale x 2 x double>, ptr noalias nonnull writeonly align 8) [[ATTRS_PTR_ARG]]
+; CHECK: declare <vscale x 2 x double> @_ZGVsNxvl8_modf(<vscale x 2 x double>, ptr noalias nonnull writeonly align 8 captures(none)) [[ATTRS_PTR_ARG]]
 
-; CHECK: declare void @_ZGVsNxvl8l8_sincos(<vscale x 2 x double>, ptr noalias nonnull writeonly align 8, ptr noalias nonnull writeonly align 8) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @_ZGVsNxvl8l8_sincos(<vscale x 2 x double>, ptr noalias nonnull writeonly align 8 captures(none), ptr noalias nonnull writeonly align 8 captures(none)) [[ATTRS_PTR_ARG]]
 
-; CHECK: declare void @_ZGVsNxvl8l8_sincospi(<vscale x 2 x double>, ptr noalias nonnull writeonly align 8, ptr noalias nonnull writeonly align 8) [[ATTRS_PTR_ARG]]
+; CHECK: declare void @_ZGVsNxvl8l8_sincospi(<vscale x 2 x double>, ptr noalias nonnull writeonly align 8 captures(none), ptr noalias nonnull writeonly align 8 captures(none)) [[ATTRS_PTR_ARG]]
 
 ; CHECK: attributes [[ATTRS]] = { nocallback nofree nosync nounwind willreturn }
 ; CHECK: attributes [[ATTRS_PTR_ARG]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/sparc.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/sparc.ll
index eff36e796a3ca1..602c6e413c3c18 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/sparc.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/sparc.ll
@@ -201,9 +201,9 @@
 ; SPARC32-NEXT: declare i32 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; SPARC32-NEXT: declare i32 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; SPARC32-NEXT: declare i32 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; SPARC32-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i32, i32)
-; SPARC32-NEXT: declare ptr @__memmove_chk(ptr, ptr, i32, i32)
-; SPARC32-NEXT: declare ptr @__memset_chk(ptr, i32, i32, i32)
+; SPARC32-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i32, i32) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; SPARC32-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i32, i32) [[CHK_ARGMEM_ATTRS]]
+; SPARC32-NEXT: declare ptr @__memset_chk(ptr writeonly, i32, i32, i32) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; SPARC32-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; SPARC32-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; SPARC32-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -211,7 +211,7 @@
 ; SPARC32-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; SPARC32-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; SPARC32-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; SPARC32-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; SPARC32-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; SPARC32-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; SPARC32-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; SPARC32-NEXT: declare fp128 @__multf3(fp128, fp128) [[NOMEM_ATTRS]]
@@ -388,9 +388,9 @@
 ; SPARC32-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; SPARC32-NEXT: declare fp128 @fmodl(fp128, fp128) [[SQRT_ATTRS]]
 ; SPARC32-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; SPARC32-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; SPARC32-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; SPARC32-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; SPARC32-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; SPARC32-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; SPARC32-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; SPARC32-NEXT: declare double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; SPARC32-NEXT: declare float @ldexpf(float, i32) [[SQRT_ATTRS]]
 ; SPARC32-NEXT: declare fp128 @ldexpl(fp128, i32) [[SQRT_ATTRS]]
@@ -419,9 +419,9 @@
 ; SPARC32-NEXT: declare ptr @memcpy(ptr, ptr, i32)
 ; SPARC32-NEXT: declare ptr @memmove(ptr, ptr, i32)
 ; SPARC32-NEXT: declare ptr @memset(ptr, i32, i32)
-; SPARC32-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; SPARC32-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; SPARC32-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 8 dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
+; SPARC32-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; SPARC32-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; SPARC32-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
 ; SPARC32-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; SPARC32-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; SPARC32-NEXT: declare nofpclass(snan inf zero sub norm) fp128 @nanl(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
@@ -437,9 +437,9 @@
 ; SPARC32-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; SPARC32-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
 ; SPARC32-NEXT: declare fp128 @remainderl(fp128, fp128) [[SQRT_ATTRS]]
-; SPARC32-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; SPARC32-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; SPARC32-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; SPARC32-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; SPARC32-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; SPARC32-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; SPARC32-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; SPARC32-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; SPARC32-NEXT: declare fp128 @rintl(fp128) [[SQRT_ATTRS]]
@@ -456,9 +456,9 @@
 ; SPARC32-NEXT: declare float @scalbnf(float, i32) [[SQRT_ATTRS]]
 ; SPARC32-NEXT: declare fp128 @scalbnl(fp128, i32) [[SQRT_ATTRS]]
 ; SPARC32-NEXT: declare double @sin(double) [[SQRT_ATTRS]]
-; SPARC32-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 dereferenceable(8), ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; SPARC32-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4), ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; SPARC32-NEXT: declare void @sincosl(fp128, ptr noalias nonnull writeonly align 8 dereferenceable(16), ptr noalias nonnull writeonly align 8 dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; SPARC32-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; SPARC32-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4), ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; SPARC32-NEXT: declare void @sincosl(fp128, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; SPARC32-NEXT: declare float @sinf(float) [[SQRT_ATTRS]]
 ; SPARC32-NEXT: declare double @sinh(double) [[SQRT_ATTRS]]
 ; SPARC32-NEXT: declare float @sinhf(float) [[SQRT_ATTRS]]
@@ -484,10 +484,12 @@
 ; SPARC32-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; SPARC32-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; SPARC32-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; SPARC32-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; SPARC32-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; SPARC32-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; SPARC32-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; SPARC32-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; SPARC32-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; SPARC32-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; SPARC32-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; SPARC32-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; SPARC32-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
 
@@ -687,9 +689,9 @@
 ; SPARC64-NEXT: declare i64 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; SPARC64-NEXT: declare i64 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; SPARC64-NEXT: declare i64 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; SPARC64-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; SPARC64-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; SPARC64-NEXT: declare ptr @__memset_chk(ptr, i32 signext, i64, i64)
+; SPARC64-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; SPARC64-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; SPARC64-NEXT: declare ptr @__memset_chk(ptr writeonly, i32 signext, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; SPARC64-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; SPARC64-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; SPARC64-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -698,7 +700,7 @@
 ; SPARC64-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; SPARC64-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; SPARC64-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; SPARC64-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; SPARC64-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; SPARC64-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; SPARC64-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; SPARC64-NEXT: declare signext i32 @__mulsi3(i32 signext, i32 signext) [[NOMEM_ATTRS]]
@@ -879,9 +881,9 @@
 ; SPARC64-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; SPARC64-NEXT: declare fp128 @fmodl(fp128, fp128) [[SQRT_ATTRS]]
 ; SPARC64-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; SPARC64-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; SPARC64-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; SPARC64-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; SPARC64-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; SPARC64-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; SPARC64-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; SPARC64-NEXT: declare double @ldexp(double, i32 signext) [[SQRT_ATTRS]]
 ; SPARC64-NEXT: declare float @ldexpf(float, i32 signext) [[SQRT_ATTRS]]
 ; SPARC64-NEXT: declare fp128 @ldexpl(fp128, i32 signext) [[SQRT_ATTRS]]
@@ -910,9 +912,9 @@
 ; SPARC64-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; SPARC64-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; SPARC64-NEXT: declare ptr @memset(ptr, i32 signext, i64)
-; SPARC64-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; SPARC64-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; SPARC64-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
+; SPARC64-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; SPARC64-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; SPARC64-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
 ; SPARC64-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; SPARC64-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; SPARC64-NEXT: declare nofpclass(snan inf zero sub norm) fp128 @nanl(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
@@ -928,9 +930,9 @@
 ; SPARC64-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; SPARC64-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
 ; SPARC64-NEXT: declare fp128 @remainderl(fp128, fp128) [[SQRT_ATTRS]]
-; SPARC64-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; SPARC64-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; SPARC64-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; SPARC64-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; SPARC64-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; SPARC64-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; SPARC64-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; SPARC64-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; SPARC64-NEXT: declare fp128 @rintl(fp128) [[SQRT_ATTRS]]
@@ -947,9 +949,9 @@
 ; SPARC64-NEXT: declare float @scalbnf(float, i32 signext) [[SQRT_ATTRS]]
 ; SPARC64-NEXT: declare fp128 @scalbnl(fp128, i32 signext) [[SQRT_ATTRS]]
 ; SPARC64-NEXT: declare double @sin(double) [[SQRT_ATTRS]]
-; SPARC64-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 dereferenceable(8), ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; SPARC64-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4), ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; SPARC64-NEXT: declare void @sincosl(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16), ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; SPARC64-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; SPARC64-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4), ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; SPARC64-NEXT: declare void @sincosl(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; SPARC64-NEXT: declare float @sinf(float) [[SQRT_ATTRS]]
 ; SPARC64-NEXT: declare double @sinh(double) [[SQRT_ATTRS]]
 ; SPARC64-NEXT: declare float @sinhf(float) [[SQRT_ATTRS]]
@@ -975,9 +977,11 @@
 ; SPARC64-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; SPARC64-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; SPARC64-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; SPARC64-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; SPARC64-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; SPARC64-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; SPARC64-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; SPARC64-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; SPARC64-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; SPARC64-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; SPARC64-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; SPARC64-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; SPARC64-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/systemz.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/systemz.ll
index e14c2784dc55cd..b336d4b84a2037 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/systemz.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/systemz.ll
@@ -196,9 +196,9 @@
 ; LINUX-NEXT: declare i64 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare i64 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare i64 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; LINUX-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; LINUX-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; LINUX-NEXT: declare ptr @__memset_chk(ptr, i32 signext, i64, i64)
+; LINUX-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; LINUX-NEXT: declare ptr @__memset_chk(ptr writeonly, i32 signext, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; LINUX-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -207,7 +207,7 @@
 ; LINUX-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; LINUX-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; LINUX-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; LINUX-NEXT: declare signext i32 @__mulsi3(i32 signext, i32 signext) [[NOMEM_ATTRS]]
@@ -388,9 +388,9 @@
 ; LINUX-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare fp128 @fmodl(fp128, fp128) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; LINUX-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; LINUX-NEXT: declare double @ldexp(double, i32 signext) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @ldexpf(float, i32 signext) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare fp128 @ldexpl(fp128, i32 signext) [[SQRT_ATTRS]]
@@ -419,9 +419,9 @@
 ; LINUX-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; LINUX-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; LINUX-NEXT: declare ptr @memset(ptr, i32 signext, i64)
-; LINUX-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; LINUX-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 8 dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; LINUX-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
 ; LINUX-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; LINUX-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; LINUX-NEXT: declare nofpclass(snan inf zero sub norm) fp128 @nanl(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
@@ -437,9 +437,9 @@
 ; LINUX-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare fp128 @remainderl(fp128, fp128) [[SQRT_ATTRS]]
-; LINUX-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; LINUX-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; LINUX-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; LINUX-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare fp128 @rintl(fp128) [[SQRT_ATTRS]]
@@ -456,9 +456,9 @@
 ; LINUX-NEXT: declare float @scalbnf(float, i32 signext) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare fp128 @scalbnl(fp128, i32 signext) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare double @sin(double) [[SQRT_ATTRS]]
-; LINUX-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 dereferenceable(8), ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; LINUX-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4), ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; LINUX-NEXT: declare void @sincosl(fp128, ptr noalias nonnull writeonly align 8 dereferenceable(16), ptr noalias nonnull writeonly align 8 dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4), ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; LINUX-NEXT: declare void @sincosl(fp128, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; LINUX-NEXT: declare float @sinf(float) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare double @sinh(double) [[SQRT_ATTRS]]
 ; LINUX-NEXT: declare float @sinhf(float) [[SQRT_ATTRS]]
@@ -484,10 +484,12 @@
 ; LINUX-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; LINUX-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; LINUX-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; LINUX-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; LINUX-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; LINUX-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; LINUX-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; LINUX-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; LINUX-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; LINUX-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; LINUX-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; LINUX-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; LINUX-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
 
@@ -506,7 +508,7 @@
 ; ZOS-NEXT: declare float @"@@FEXP at B"(float) [[SQRT_ATTRS]]
 ; ZOS-NEXT: declare float @"@@FFLR at B"(float) [[NOMEM_ATTRS]]
 ; ZOS-NEXT: declare float @"@@FFMD at B"(float, float) [[SQRT_ATTRS]]
-; ZOS-NEXT: declare float @"@@FFXP at B"(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; ZOS-NEXT: declare float @"@@FFXP at B"(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; ZOS-NEXT: declare float @"@@FLG1 at B"(float) [[SQRT_ATTRS]]
 ; ZOS-NEXT: declare float @"@@FLG2 at B"(float) [[SQRT_ATTRS]]
 ; ZOS-NEXT: declare float @"@@FLOG at B"(float) [[SQRT_ATTRS]]
@@ -541,7 +543,7 @@
 ; ZOS-NEXT: declare fp128 @"@@LEXP at B"(fp128) [[SQRT_ATTRS]]
 ; ZOS-NEXT: declare fp128 @"@@LFLR at B"(fp128) [[NOMEM_ATTRS]]
 ; ZOS-NEXT: declare fp128 @"@@LFMD at B"(fp128, fp128) [[SQRT_ATTRS]]
-; ZOS-NEXT: declare fp128 @"@@LFXP at B"(fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; ZOS-NEXT: declare fp128 @"@@LFXP at B"(fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; ZOS-NEXT: declare fp128 @"@@LLG1 at B"(fp128) [[SQRT_ATTRS]]
 ; ZOS-NEXT: declare fp128 @"@@LLG2 at B"(fp128) [[SQRT_ATTRS]]
 ; ZOS-NEXT: declare fp128 @"@@LLOG at B"(fp128) [[SQRT_ATTRS]]
@@ -579,7 +581,7 @@
 ; ZOS-NEXT: declare double @"@@SCOS at B"(double) [[SQRT_ATTRS]]
 ; ZOS-NEXT: declare double @"@@SCRT at B"(double) [[NOMEM_ATTRS]]
 ; ZOS-NEXT: declare double @"@@SFLR at B"(double) [[NOMEM_ATTRS]]
-; ZOS-NEXT: declare double @"@@SFXP at B"(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; ZOS-NEXT: declare double @"@@SFXP at B"(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; ZOS-NEXT: declare double @"@@SLXP at B"(double, i32 signext) [[SQRT_ATTRS]]
 ; ZOS-NEXT: declare double @"@@SRNT at B"(double) [[SQRT_ATTRS]]
 ; ZOS-NEXT: declare double @"@@SSIN at B"(double) [[SQRT_ATTRS]]
@@ -787,9 +789,9 @@
 ; ZOS-NEXT: declare i64 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; ZOS-NEXT: declare i64 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; ZOS-NEXT: declare i64 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; ZOS-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; ZOS-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; ZOS-NEXT: declare ptr @__memset_chk(ptr, i32 signext, i64, i64)
+; ZOS-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; ZOS-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; ZOS-NEXT: declare ptr @__memset_chk(ptr writeonly, i32 signext, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; ZOS-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; ZOS-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; ZOS-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -798,7 +800,7 @@
 ; ZOS-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; ZOS-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; ZOS-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; ZOS-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; ZOS-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; ZOS-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; ZOS-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; ZOS-NEXT: declare signext i32 @__mulsi3(i32 signext, i32 signext) [[NOMEM_ATTRS]]
@@ -979,9 +981,9 @@
 ; ZOS-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; ZOS-NEXT: declare fp128 @fmodl(fp128, fp128) [[SQRT_ATTRS]]
 ; ZOS-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; ZOS-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; ZOS-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; ZOS-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; ZOS-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; ZOS-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; ZOS-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; ZOS-NEXT: declare double @ldexp(double, i32 signext) [[SQRT_ATTRS]]
 ; ZOS-NEXT: declare float @ldexpf(float, i32 signext) [[SQRT_ATTRS]]
 ; ZOS-NEXT: declare fp128 @ldexpl(fp128, i32 signext) [[SQRT_ATTRS]]
@@ -1010,9 +1012,9 @@
 ; ZOS-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; ZOS-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; ZOS-NEXT: declare ptr @memset(ptr, i32 signext, i64)
-; ZOS-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; ZOS-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; ZOS-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 8 dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
+; ZOS-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; ZOS-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; ZOS-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
 ; ZOS-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; ZOS-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; ZOS-NEXT: declare nofpclass(snan inf zero sub norm) fp128 @nanl(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
@@ -1028,9 +1030,9 @@
 ; ZOS-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; ZOS-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
 ; ZOS-NEXT: declare fp128 @remainderl(fp128, fp128) [[SQRT_ATTRS]]
-; ZOS-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; ZOS-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; ZOS-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; ZOS-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; ZOS-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; ZOS-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; ZOS-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; ZOS-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; ZOS-NEXT: declare fp128 @rintl(fp128) [[SQRT_ATTRS]]
@@ -1072,9 +1074,11 @@
 ; ZOS-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
 ; ZOS-NEXT: attributes [[ATOMIC_ATTRS]] = { nocallback nofree nounwind willreturn }
 ; ZOS-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
+; ZOS-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; ZOS-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; ZOS-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; ZOS-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; ZOS-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; ZOS-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; ZOS-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; ZOS-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; ZOS-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; ZOS-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ve.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ve.ll
index 77ea9f82818a95..c8ee1755a48f82 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ve.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ve.ll
@@ -195,9 +195,9 @@
 ; CHECK-NEXT: declare i64 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare i64 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare i64 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; CHECK-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; CHECK-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; CHECK-NEXT: declare ptr @__memset_chk(ptr, i32 signext, i64, i64)
+; CHECK-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; CHECK-NEXT: declare ptr @__memset_chk(ptr writeonly, i32 signext, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; CHECK-NEXT: declare i64 @__moddi3(i64, i64) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
@@ -206,7 +206,7 @@
 ; CHECK-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare i64 @__muldi3(i64, i64) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; CHECK-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; CHECK-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; CHECK-NEXT: declare signext i32 @__mulsi3(i32 signext, i32 signext) [[NOMEM_ATTRS]]
@@ -387,9 +387,9 @@
 ; CHECK-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare fp128 @fmodl(fp128, fp128) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; CHECK-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; CHECK-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; CHECK-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare fp128 @frexpl(fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; CHECK-NEXT: declare double @ldexp(double, i32 signext) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare float @ldexpf(float, i32 signext) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare fp128 @ldexpl(fp128, i32 signext) [[SQRT_ATTRS]]
@@ -418,9 +418,9 @@
 ; CHECK-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; CHECK-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; CHECK-NEXT: declare ptr @memset(ptr, i32 signext, i64)
-; CHECK-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; CHECK-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; CHECK-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; CHECK-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
 ; CHECK-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; CHECK-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; CHECK-NEXT: declare nofpclass(snan inf zero sub norm) fp128 @nanl(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
@@ -436,9 +436,9 @@
 ; CHECK-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare fp128 @remainderl(fp128, fp128) [[SQRT_ATTRS]]
-; CHECK-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; CHECK-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; CHECK-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; CHECK-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; CHECK-NEXT: declare fp128 @remquol(fp128, fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; CHECK-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; CHECK-NEXT: declare fp128 @rintl(fp128) [[SQRT_ATTRS]]
@@ -480,9 +480,11 @@
 ; CHECK-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; CHECK-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; CHECK-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; CHECK-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; CHECK-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; CHECK-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; CHECK-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; CHECK-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; CHECK-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; CHECK-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; CHECK-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; CHECK-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; CHECK-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/windows.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/windows.ll
index 9f241980be2aff..e561156324df1f 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/windows.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/windows.ll
@@ -210,16 +210,16 @@
 ; MSVC-NEXT: declare i64 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; MSVC-NEXT: declare i64 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; MSVC-NEXT: declare i64 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; MSVC-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; MSVC-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; MSVC-NEXT: declare ptr @__memset_chk(ptr, i32, i64, i64)
+; MSVC-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; MSVC-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; MSVC-NEXT: declare ptr @__memset_chk(ptr writeonly, i32, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; MSVC-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; MSVC-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; MSVC-NEXT: declare i32 @__modsi3(i32, i32) [[NOMEM_ATTRS]]
 ; MSVC-NEXT: declare <2 x i64> @__modti3(<2 x i64>, <2 x i64>) [[NOMEM_ATTRS]]
 ; MSVC-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; MSVC-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; MSVC-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; MSVC-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; MSVC-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; MSVC-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; MSVC-NEXT: declare i32 @__mulsi3(i32, i32) [[NOMEM_ATTRS]]
@@ -379,7 +379,7 @@
 ; MSVC-NEXT: declare double @fmod(double, double) [[SQRT_ATTRS]]
 ; MSVC-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; MSVC-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; MSVC-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; MSVC-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; MSVC-NEXT: declare double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; MSVC-NEXT: declare i64 @llrint(double) [[SQRT_ATTRS]]
 ; MSVC-NEXT: declare i64 @llrintf(float) [[SQRT_ATTRS]]
@@ -399,8 +399,8 @@
 ; MSVC-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; MSVC-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; MSVC-NEXT: declare ptr @memset(ptr, i32, i64)
-; MSVC-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; MSVC-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; MSVC-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; MSVC-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; MSVC-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; MSVC-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; MSVC-NEXT: declare double @nearbyint(double) [[NOMEM_ATTRS]]
@@ -411,8 +411,8 @@
 ; MSVC-NEXT: declare float @powf(float, float) [[SQRT_ATTRS]]
 ; MSVC-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; MSVC-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
-; MSVC-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; MSVC-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; MSVC-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; MSVC-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; MSVC-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; MSVC-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; MSVC-NEXT: declare double @round(double) [[NOMEM_ATTRS]]
@@ -442,9 +442,11 @@
 ; MSVC-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; MSVC-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; MSVC-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
-; MSVC-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; MSVC-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; MSVC-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
+; MSVC-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; MSVC-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; MSVC-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; MSVC-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; MSVC-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; MSVC-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
 
@@ -662,16 +664,16 @@
 ; MINGW-NEXT: declare i64 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; MINGW-NEXT: declare i64 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; MINGW-NEXT: declare i64 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; MINGW-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; MINGW-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; MINGW-NEXT: declare ptr @__memset_chk(ptr, i32, i64, i64)
+; MINGW-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; MINGW-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; MINGW-NEXT: declare ptr @__memset_chk(ptr writeonly, i32, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; MINGW-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; MINGW-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; MINGW-NEXT: declare i32 @__modsi3(i32, i32) [[NOMEM_ATTRS]]
 ; MINGW-NEXT: declare <2 x i64> @__modti3(<2 x i64>, <2 x i64>) [[NOMEM_ATTRS]]
 ; MINGW-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; MINGW-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; MINGW-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; MINGW-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; MINGW-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; MINGW-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; MINGW-NEXT: declare i32 @__mulsi3(i32, i32) [[NOMEM_ATTRS]]
@@ -877,10 +879,10 @@
 ; MINGW-NEXT: declare fp128 @fmodf128(fp128, fp128) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare x86_fp80 @fmodl(x86_fp80, x86_fp80) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; MINGW-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; MINGW-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; MINGW-NEXT: declare fp128 @frexpf128(fp128, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; MINGW-NEXT: declare x86_fp80 @frexpl(x86_fp80, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; MINGW-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; MINGW-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; MINGW-NEXT: declare fp128 @frexpf128(fp128, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; MINGW-NEXT: declare x86_fp80 @frexpl(x86_fp80, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; MINGW-NEXT: declare double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare float @ldexpf(float, i32) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare fp128 @ldexpf128(fp128, i32) [[SQRT_ATTRS]]
@@ -917,10 +919,10 @@
 ; MINGW-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; MINGW-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; MINGW-NEXT: declare ptr @memset(ptr, i32, i64)
-; MINGW-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; MINGW-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; MINGW-NEXT: declare fp128 @modff128(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
-; MINGW-NEXT: declare x86_fp80 @modfl(x86_fp80, ptr noalias nonnull writeonly align 16 dereferenceable(10)) [[ARGMEM_WRITE_ATTRS]]
+; MINGW-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; MINGW-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; MINGW-NEXT: declare fp128 @modff128(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_WRITE_ATTRS]]
+; MINGW-NEXT: declare x86_fp80 @modfl(x86_fp80, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(10)) [[ARGMEM_WRITE_ATTRS]]
 ; MINGW-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; MINGW-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; MINGW-NEXT: declare nofpclass(snan inf zero sub norm) x86_fp80 @nanl(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
@@ -938,9 +940,9 @@
 ; MINGW-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare x86_fp80 @remainderl(x86_fp80, x86_fp80) [[SQRT_ATTRS]]
-; MINGW-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; MINGW-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; MINGW-NEXT: declare x86_fp80 @remquol(x86_fp80, x86_fp80, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; MINGW-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; MINGW-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; MINGW-NEXT: declare x86_fp80 @remquol(x86_fp80, x86_fp80, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; MINGW-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare fp128 @rintf128(fp128) [[SQRT_ATTRS]]
@@ -960,10 +962,10 @@
 ; MINGW-NEXT: declare float @scalbnf(float, i32) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare x86_fp80 @scalbnl(x86_fp80, i32) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare double @sin(double) [[SQRT_ATTRS]]
-; MINGW-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 dereferenceable(8), ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; MINGW-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4), ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; MINGW-NEXT: declare void @sincosf128(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16), ptr noalias nonnull writeonly align 16 dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; MINGW-NEXT: declare void @sincosl(x86_fp80, ptr noalias nonnull writeonly align 16 dereferenceable(10), ptr noalias nonnull writeonly align 16 dereferenceable(10)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; MINGW-NEXT: declare void @sincos(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8), ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; MINGW-NEXT: declare void @sincosf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4), ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; MINGW-NEXT: declare void @sincosf128(fp128, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16), ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(16)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; MINGW-NEXT: declare void @sincosl(x86_fp80, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(10), ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(10)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; MINGW-NEXT: declare float @sinf(float) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare fp128 @sinf128(fp128) [[SQRT_ATTRS]]
 ; MINGW-NEXT: declare double @sinh(double) [[SQRT_ATTRS]]
@@ -995,10 +997,12 @@
 ; MINGW-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; MINGW-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; MINGW-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; MINGW-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; MINGW-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; MINGW-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; MINGW-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; MINGW-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; MINGW-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; MINGW-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; MINGW-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; MINGW-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; MINGW-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
 
@@ -1210,16 +1214,16 @@
 ; CYGWIN-NEXT: declare i64 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; CYGWIN-NEXT: declare i64 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; CYGWIN-NEXT: declare i64 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; CYGWIN-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; CYGWIN-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; CYGWIN-NEXT: declare ptr @__memset_chk(ptr, i32, i64, i64)
+; CYGWIN-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; CYGWIN-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; CYGWIN-NEXT: declare ptr @__memset_chk(ptr writeonly, i32, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; CYGWIN-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; CYGWIN-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; CYGWIN-NEXT: declare i32 @__modsi3(i32, i32) [[NOMEM_ATTRS]]
 ; CYGWIN-NEXT: declare <2 x i64> @__modti3(<2 x i64>, <2 x i64>) [[NOMEM_ATTRS]]
 ; CYGWIN-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; CYGWIN-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; CYGWIN-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; CYGWIN-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; CYGWIN-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; CYGWIN-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; CYGWIN-NEXT: declare i32 @__mulsi3(i32, i32) [[NOMEM_ATTRS]]
@@ -1406,9 +1410,9 @@
 ; CYGWIN-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; CYGWIN-NEXT: declare x86_fp80 @fmodl(x86_fp80, x86_fp80) [[SQRT_ATTRS]]
 ; CYGWIN-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; CYGWIN-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; CYGWIN-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; CYGWIN-NEXT: declare x86_fp80 @frexpl(x86_fp80, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; CYGWIN-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; CYGWIN-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; CYGWIN-NEXT: declare x86_fp80 @frexpl(x86_fp80, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; CYGWIN-NEXT: declare double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; CYGWIN-NEXT: declare float @ldexpf(float, i32) [[SQRT_ATTRS]]
 ; CYGWIN-NEXT: declare x86_fp80 @ldexpl(x86_fp80, i32) [[SQRT_ATTRS]]
@@ -1437,9 +1441,9 @@
 ; CYGWIN-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; CYGWIN-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; CYGWIN-NEXT: declare ptr @memset(ptr, i32, i64)
-; CYGWIN-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; CYGWIN-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; CYGWIN-NEXT: declare x86_fp80 @modfl(x86_fp80, ptr noalias nonnull writeonly align 16 dereferenceable(10)) [[ARGMEM_WRITE_ATTRS]]
+; CYGWIN-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; CYGWIN-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; CYGWIN-NEXT: declare x86_fp80 @modfl(x86_fp80, ptr noalias nonnull writeonly align 16 captures(none) dereferenceable(10)) [[ARGMEM_WRITE_ATTRS]]
 ; CYGWIN-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; CYGWIN-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; CYGWIN-NEXT: declare nofpclass(snan inf zero sub norm) x86_fp80 @nanl(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
@@ -1455,9 +1459,9 @@
 ; CYGWIN-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; CYGWIN-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
 ; CYGWIN-NEXT: declare x86_fp80 @remainderl(x86_fp80, x86_fp80) [[SQRT_ATTRS]]
-; CYGWIN-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; CYGWIN-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
-; CYGWIN-NEXT: declare x86_fp80 @remquol(x86_fp80, x86_fp80, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; CYGWIN-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; CYGWIN-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; CYGWIN-NEXT: declare x86_fp80 @remquol(x86_fp80, x86_fp80, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; CYGWIN-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; CYGWIN-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; CYGWIN-NEXT: declare x86_fp80 @rintl(x86_fp80) [[SQRT_ATTRS]]
@@ -1499,10 +1503,12 @@
 ; CYGWIN-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; CYGWIN-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; CYGWIN-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; CYGWIN-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; CYGWIN-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; CYGWIN-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; CYGWIN-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; CYGWIN-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; CYGWIN-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; CYGWIN-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; CYGWIN-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; CYGWIN-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; CYGWIN-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }
 
@@ -1709,16 +1715,16 @@
 ; UEFI-NEXT: declare i64 @__ltdf2(double, double) [[NOMEM_ATTRS]]
 ; UEFI-NEXT: declare i64 @__ltsf2(float, float) [[NOMEM_ATTRS]]
 ; UEFI-NEXT: declare i64 @__lttf2(fp128, fp128) [[NOMEM_ATTRS]]
-; UEFI-NEXT: declare ptr @__memcpy_chk(ptr, ptr, i64, i64)
-; UEFI-NEXT: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
-; UEFI-NEXT: declare ptr @__memset_chk(ptr, i32, i64, i64)
+; UEFI-NEXT: declare ptr @__memcpy_chk(ptr noalias writeonly, ptr noalias readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS:#[0-9]+]]
+; UEFI-NEXT: declare ptr @__memmove_chk(ptr writeonly, ptr readonly captures(none), i64, i64) [[CHK_ARGMEM_ATTRS]]
+; UEFI-NEXT: declare ptr @__memset_chk(ptr writeonly, i32, i64, i64) [[CHK_ARGMEM_WRITE_ATTRS:#[0-9]+]]
 ; UEFI-NEXT: declare signext i16 @__modhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
 ; UEFI-NEXT: declare signext i8 @__modqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; UEFI-NEXT: declare i32 @__modsi3(i32, i32) [[NOMEM_ATTRS]]
 ; UEFI-NEXT: declare <2 x i64> @__modti3(<2 x i64>, <2 x i64>) [[NOMEM_ATTRS]]
 ; UEFI-NEXT: declare double @__muldf3(double, double) [[NOMEM_ATTRS]]
 ; UEFI-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext) [[NOMEM_ATTRS]]
-; UEFI-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+; UEFI-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; UEFI-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext) [[NOMEM_ATTRS]]
 ; UEFI-NEXT: declare float @__mulsf3(float, float) [[NOMEM_ATTRS]]
 ; UEFI-NEXT: declare i32 @__mulsi3(i32, i32) [[NOMEM_ATTRS]]
@@ -1881,8 +1887,8 @@
 ; UEFI-NEXT: declare double @fmod(double, double) [[SQRT_ATTRS]]
 ; UEFI-NEXT: declare float @fmodf(float, float) [[SQRT_ATTRS]]
 ; UEFI-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
-; UEFI-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
-; UEFI-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; UEFI-NEXT: declare double @frexp(double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; UEFI-NEXT: declare float @frexpf(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; UEFI-NEXT: declare double @ldexp(double, i32) [[SQRT_ATTRS]]
 ; UEFI-NEXT: declare float @ldexpf(float, i32) [[SQRT_ATTRS]]
 ; UEFI-NEXT: declare i64 @llrint(double) [[SQRT_ATTRS]]
@@ -1903,8 +1909,8 @@
 ; UEFI-NEXT: declare ptr @memcpy(ptr, ptr, i64)
 ; UEFI-NEXT: declare ptr @memmove(ptr, ptr, i64)
 ; UEFI-NEXT: declare ptr @memset(ptr, i32, i64)
-; UEFI-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
-; UEFI-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
+; UEFI-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 captures(none) dereferenceable(8)) [[ARGMEM_WRITE_ATTRS]]
+; UEFI-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
 ; UEFI-NEXT: declare nofpclass(snan inf zero sub norm) double @nan(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS:#[0-9]+]]
 ; UEFI-NEXT: declare nofpclass(snan inf zero sub norm) float @nanf(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
 ; UEFI-NEXT: declare double @nearbyint(double) [[NOMEM_ATTRS]]
@@ -1915,8 +1921,8 @@
 ; UEFI-NEXT: declare float @powf(float, float) [[SQRT_ATTRS]]
 ; UEFI-NEXT: declare double @remainder(double, double) [[SQRT_ATTRS]]
 ; UEFI-NEXT: declare float @remainderf(float, float) [[SQRT_ATTRS]]
-; UEFI-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
-; UEFI-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
+; UEFI-NEXT: declare double @remquo(double, double, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS:#[0-9]+]]
+; UEFI-NEXT: declare float @remquof(float, float, ptr noalias nonnull writeonly align 4 captures(none) dereferenceable(4)) [[ARGMEM_ERRNO_WRITE_ATTRS]]
 ; UEFI-NEXT: declare double @rint(double) [[SQRT_ATTRS]]
 ; UEFI-NEXT: declare float @rintf(float) [[SQRT_ATTRS]]
 ; UEFI-NEXT: declare double @round(double) [[NOMEM_ATTRS]]
@@ -1946,9 +1952,11 @@
 ; UEFI-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
 ; UEFI-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; UEFI-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; UEFI-NEXT: attributes [[CHK_ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: readwrite) }
+; UEFI-NEXT: attributes [[CHK_ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind memory(argmem: write) }
 ; UEFI-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; UEFI-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; UEFI-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; UEFI-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
-; UEFI-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; UEFI-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: write) "alloc-family"="malloc" }
 ; UEFI-NEXT: attributes [[ARGMEM_READ_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
 ; UEFI-NEXT: attributes [[ARGMEM_ERRNO_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) }



More information about the llvm-branch-commits mailing list