[llvm-branch-commits] [llvm] RuntimeLibcalls: Add missing attributes to memory and allocator libcalls (PR #240735)
Matt Arsenault via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Mon Nov 9 23:15:47 PST 2026
https://github.com/arsenm created https://github.com/llvm/llvm-project/pull/240735
Add the attributes inferLibFuncAttributes would give these functions.
Co-authored-by: Claude Opus 5.5 <noreply at anthropic.com>
>From b6c931704143fa9390cfb7cdd5326904d5b88544 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Mon, 9 Nov 2026 23:10:59 -0800
Subject: [PATCH] RuntimeLibcalls: Add missing attributes to memory and
allocator libcalls
Add the attributes inferLibFuncAttributes would give these functions.
Co-authored-by: Claude Opus 5.5 <noreply at anthropic.com>
---
llvm/include/llvm/IR/RuntimeLibcalls.td | 91 ++++++++++++++-----
llvm/include/llvm/IR/RuntimeLibcallsImpl.td | 14 ++-
.../Util/DeclareRuntimeLibcalls/aarch64.ll | 82 +++++++++--------
.../Util/DeclareRuntimeLibcalls/aix.ll | 10 +-
.../Util/DeclareRuntimeLibcalls/amdlibm.ll | 4 +-
.../Util/DeclareRuntimeLibcalls/arm.ll | 32 ++++---
.../Util/DeclareRuntimeLibcalls/arm64ec.ll | 16 ++--
.../Util/DeclareRuntimeLibcalls/armpl.ll | 4 +-
.../Util/DeclareRuntimeLibcalls/avr.ll | 16 ++--
.../Util/DeclareRuntimeLibcalls/basic.ll | 14 ++-
.../Util/DeclareRuntimeLibcalls/bsd.ll | 48 +++++-----
.../Util/DeclareRuntimeLibcalls/divmod.ll | 20 ++--
.../Util/DeclareRuntimeLibcalls/hexagon.ll | 32 ++++---
.../Util/DeclareRuntimeLibcalls/mips.ll | 32 ++++---
.../Util/DeclareRuntimeLibcalls/msp430.ll | 16 ++--
.../Util/DeclareRuntimeLibcalls/ppc.ll | 84 ++++++++++-------
.../Util/DeclareRuntimeLibcalls/riscv.ll | 32 ++++---
.../Util/DeclareRuntimeLibcalls/sparc.ll | 32 ++++---
.../Util/DeclareRuntimeLibcalls/systemz.ll | 32 ++++---
.../Util/DeclareRuntimeLibcalls/windows.ll | 64 +++++++------
20 files changed, 404 insertions(+), 271 deletions(-)
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index 740958cb8b255e..41054cdd78a337 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.td
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -254,7 +254,12 @@ defvar OutPtrAttrs = [NoAlias, WriteOnly, NonNull];
foreach IntTy = [TypeSuffix<"I32", Int32>, TypeSuffix<"I64", Int64>,
TypeSuffix<"I128", Int128>] in {
def MULO_#IntTy.Suffix
- : RuntimeLibcall<IntTy.Type, [IntTy.Type, IntTy.Type, Ptr]>;
+ : RuntimeLibcall<IntTy.Type, [IntTy.Type, IntTy.Type, Ptr]> {
+ let FnAttrs = CommonFnAttrs;
+ let Memory = ArgMemWriteOnly;
+ let ParamAttrs = [[], [], OutPtrAttrs];
+ let ParamPointeeTypes = [NoneType, NoneType, Int];
+ }
}
foreach IntTy = [TypeSuffix<"I8", Int8>, TypeSuffix<"I16", Int16>,
@@ -262,7 +267,7 @@ foreach IntTy = [TypeSuffix<"I8", Int8>, TypeSuffix<"I16", Int16>,
TypeSuffix<"I128", Int128>] in {
def SDIVREM_#IntTy.Suffix
: RuntimeLibcall<IntTy.Type, [IntTy.Type, IntTy.Type, Ptr]> {
- let FnAttrs = MathFnAttrs;
+ let FnAttrs = CommonFnAttrs;
let Memory = ArgMemWriteOnly;
let ParamAttrs = [[], [], OutPtrAttrs];
let ParamPointeeTypes = [NoneType, NoneType, IntTy.Type];
@@ -274,7 +279,7 @@ foreach IntTy = [TypeSuffix<"I8", UInt8>, TypeSuffix<"I16", UInt16>,
TypeSuffix<"I128", UInt128>] in {
def UDIVREM_#IntTy.Suffix
: RuntimeLibcall<IntTy.Type, [IntTy.Type, IntTy.Type, Ptr]> {
- let FnAttrs = MathFnAttrs;
+ let FnAttrs = CommonFnAttrs;
let Memory = ArgMemWriteOnly;
let ParamAttrs = [[], [], OutPtrAttrs];
let ParamPointeeTypes = [NoneType, NoneType, IntTy.Type];
@@ -317,7 +322,7 @@ def PPCF128 : TypeSuffix<"PPCF128", PPCFP128>;
foreach FPTy = [F32, F64] in {
def SQRT_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type]> {
- let FnAttrs = MathFnAttrs;
+ let FnAttrs = CommonFnAttrs;
let Memory = ErrnoMemWriteOnly;
let RetAttrs = [NoFPClassAttr<"fcNegInf | fcNegSubnormal | fcNegNormal">];
}
@@ -706,39 +711,73 @@ foreach FPTy = [F32, F64, F128, PPCF128] in {
}
// Memory
-def MEMCMP : RuntimeLibcall<Int, [Ptr, Ptr, SizeT]>;
-def MEMCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT]>;
+defvar ReadPtrAttrs = [ReadOnly, CapturesNone];
+
+class MemCmpLibcall : RuntimeLibcall<Int, [Ptr, Ptr, SizeT]> {
+ let FnAttrs = CommonFnAttrs;
+ let Memory = ArgMemReadOnly;
+ let ParamAttrs = [ReadPtrAttrs, ReadPtrAttrs];
+}
+
+def MEMCMP : MemCmpLibcall;
+def MEMCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT]> {
+ let FnAttrs = CommonFnAttrs;
+ let Memory = ArgMemOnly;
+ let ParamAttrs = [[NoAlias, Returned, WriteOnly],
+ [NoAlias, ReadOnly, CapturesNone]];
+}
def MEMCPY_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT]>;
-def MEMMOVE : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT]>;
+def MEMMOVE : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT]> {
+ let FnAttrs = CommonFnAttrs;
+ let Memory = ArgMemOnly;
+ let ParamAttrs = [[Returned, WriteOnly], ReadPtrAttrs];
+}
def MEMMOVE_CHK : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT, SizeT]>;
-def MEMSET : RuntimeLibcall<Ptr, [Ptr, Int, SizeT]>;
+def MEMSET : RuntimeLibcall<Ptr, [Ptr, Int, SizeT]> {
+ let FnAttrs = CommonFnAttrs;
+ let Memory = ArgMemWriteOnly;
+ let ParamAttrs = [[Returned, WriteOnly]];
+}
def MEMSET_CHK : RuntimeLibcall<Ptr, [Ptr, Int, SizeT, SizeT]>;
-def MallocFamily : AllocFamilyAttr<"malloc">;
-
-def MALLOC : RuntimeLibcall<Ptr, [SizeT]> {
+class MallocLibcall<string family> : RuntimeLibcall<Ptr, [SizeT]> {
let FnAttrs = [NoFree, NoUnwind, WillReturn,
AllocKindAttr<"AllocFnKind::Alloc | AllocFnKind::Uninitialized">,
- AllocSizeAttr<0>, MallocFamily];
+ AllocSizeAttr<0>, AllocFamilyAttr<family>];
+ let Memory = InaccessibleOrErrnoMem;
let RetAttrs = [NoAlias, NoUndef];
let ParamAttrs = [[NoUndef]];
}
-def CALLOC : RuntimeLibcall<Ptr, [SizeT, SizeT]> {
+class CallocLibcall<string family> : RuntimeLibcall<Ptr, [SizeT, SizeT]> {
let FnAttrs = [NoFree, NoUnwind, WillReturn,
- AllocKindAttr<"AllocFnKind::Alloc">, AllocSizeAttr<0, "1">,
- MallocFamily];
+ AllocKindAttr<"AllocFnKind::Alloc | AllocFnKind::Zeroed">,
+ AllocSizeAttr<0, "1">, AllocFamilyAttr<family>];
+ let Memory = InaccessibleOrErrnoMem;
let RetAttrs = [NoAlias, NoUndef];
let ParamAttrs = [[NoUndef], [NoUndef]];
}
-def FREE : RuntimeLibcall<Void, [Ptr]> {
+class FreeLibcall<string family> : RuntimeLibcall<Void, [Ptr]> {
let FnAttrs = [NoUnwind, WillReturn, AllocKindAttr<"AllocFnKind::Free">,
- MallocFamily];
+ AllocFamilyAttr<family>];
+ let Memory = InaccessibleOrArgMem;
let ParamAttrs = [[AllocatedPointer, NoUndef, CapturesNone]];
}
-def BZERO : RuntimeLibcall<Void, [Ptr, SizeT]>;
-def STRLEN : RuntimeLibcall<SizeT, [Ptr]>;
+def MALLOC : MallocLibcall<"malloc">;
+def CALLOC : CallocLibcall<"malloc">;
+def FREE : FreeLibcall<"malloc">;
+
+def BZERO : RuntimeLibcall<Void, [Ptr, SizeT]> {
+ let FnAttrs = CommonFnAttrs;
+ let Memory = ArgMemWriteOnly;
+ let ParamAttrs = [[WriteOnly, CapturesNone]];
+}
+def STRLEN : RuntimeLibcall<SizeT, [Ptr]> {
+ let FnAttrs = CommonFnAttrs;
+ let Memory = ArgMemReadOnly;
+ let ParamAttrs = [ReadPtrAttrs];
+}
// Element-wise unordered-atomic memory of different sizes
foreach MemSize = [1, 2, 4, 8, 16] in {
@@ -1003,8 +1042,12 @@ def ATOF : RuntimeLibcall<Dbl, [Ptr]>;
def ATOI : RuntimeLibcall<Int, [Ptr]>;
def ATOL : RuntimeLibcall<Long, [Ptr]>;
def ATOLL : RuntimeLibcall<LLong, [Ptr]>;
-def BCMP : RuntimeLibcall<Int, [Ptr, Ptr, SizeT]>;
-def BCOPY : RuntimeLibcall<Void, [Ptr, Ptr, SizeT]>;
+def BCMP : MemCmpLibcall;
+def BCOPY : RuntimeLibcall<Void, [Ptr, Ptr, SizeT]> {
+ let FnAttrs = CommonFnAttrs;
+ let Memory = ArgMemOnly;
+ let ParamAttrs = [ReadPtrAttrs, [WriteOnly, CapturesNone]];
+}
def CHMOD : RuntimeLibcall<Int, [Ptr, IntX]>;
def CHOWN : RuntimeLibcall<Int, [Ptr, IntX, IntX]>;
def CLEARERR : RuntimeLibcall<Void, [Ptr]>;
@@ -1234,9 +1277,9 @@ def UNSETENV : RuntimeLibcall<Int, [Ptr]>;
def UTIME : RuntimeLibcall<Int, [Ptr, Ptr]>;
def UTIMES : RuntimeLibcall<Int, [Ptr, Ptr]>;
def VALLOC : RuntimeLibcall<Ptr, [SizeT]>;
-def VEC_CALLOC : RuntimeLibcall<Ptr, [SizeT, SizeT]>;
-def VEC_FREE : RuntimeLibcall<Void, [Ptr]>;
-def VEC_MALLOC : 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 VFPRINTF : RuntimeLibcall<Int, [Ptr, Ptr, Ptr]>;
def VFSCANF : RuntimeLibcall<Int, [Ptr, Ptr, Ptr]>;
diff --git a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
index 03346b17fece47..46e4cd24ea0d94 100644
--- a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
+++ b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
@@ -159,8 +159,18 @@ class MemoryEffects<ModRefInfo mr = ModRef> {
def UnknownMemory : MemoryEffects;
def NoMemory : MemoryEffects<NoModRef>;
+def ArgMemOnly : MemoryEffects<NoModRef> { let ArgMem = ModRef; }
+def ArgMemReadOnly : MemoryEffects<NoModRef> { let ArgMem = Ref; }
def ArgMemWriteOnly : MemoryEffects<NoModRef> { let ArgMem = Mod; }
def ErrnoMemWriteOnly : MemoryEffects<NoModRef> { let ErrnoMem = Mod; }
+def InaccessibleOrErrnoMem : MemoryEffects<NoModRef> {
+ let InaccessibleMem = ModRef;
+ let ErrnoMem = ModRef;
+}
+def InaccessibleOrArgMem : MemoryEffects<NoModRef> {
+ let ArgMem = ModRef;
+ let InaccessibleMem = ModRef;
+}
class ValueAttr<list<AttrProperty> props, string expr>
: Attr<"", IntersectPreserve, props> {
@@ -224,7 +234,7 @@ class MaskedRuntimeLibcall<RuntimeLibcall unmasked, FuncArgType mask>
}
// TODO: NoCallback probably unsafe in general
-defvar MathFnAttrs = [NoCallback, NoFree, NoSync, NoUnwind, WillReturn];
+defvar CommonFnAttrs = [NoCallback, NoFree, NoSync, NoUnwind, WillReturn];
multiclass VectorMathLibcall<string suffix, FuncArgType RetType = NoneType,
list<FuncArgType> ArgTypes = [],
@@ -233,7 +243,7 @@ multiclass VectorMathLibcall<string suffix, FuncArgType RetType = NoneType,
list<FuncArgType> paramPointeeTypes = []> {
defvar VT = !cast<VectorFuncArgType>(suffix);
def _#suffix : RuntimeLibcall<RetType, ArgTypes> {
- let FnAttrs = MathFnAttrs;
+ let FnAttrs = CommonFnAttrs;
let Memory = memory;
let ParamAttrs = paramAttrs;
let ParamPointeeTypes = paramPointeeTypes;
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aarch64.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aarch64.ll
index f2e209fc914aae..a2d07f5ff2d0ee 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aarch64.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aarch64.ll
@@ -323,7 +323,7 @@
; LINUX-NEXT: declare double @__muldf3(double, double)
; LINUX-NEXT: declare i64 @__muldi3(i64, i64)
; LINUX-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; LINUX-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; LINUX-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; LINUX-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; LINUX-NEXT: declare float @__mulsf3(float, float)
; LINUX-NEXT: declare i32 @__mulsi3(i32, i32)
@@ -532,9 +532,9 @@
; LINUX-NEXT: declare i64 @lroundf(float)
; LINUX-NEXT: declare i64 @lroundl(fp128)
; LINUX-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; LINUX-NEXT: declare ptr @memset(ptr returned writeonly, i32, i64) [[ARGMEM_WRITE_ATTRS]]
; LINUX-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; LINUX-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; LINUX-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16))
@@ -595,9 +595,11 @@
; LINUX-NEXT: declare double @trunc(double)
; LINUX-NEXT: declare float @truncf(float)
; LINUX-NEXT: declare fp128 @truncl(fp128)
-; LINUX-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; LINUX-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; LINUX-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; LINUX-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; LINUX-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
; DARWIN: @__safestack_unsafe_stack_ptr = external thread_local(initialexec) global ptr
@@ -910,7 +912,7 @@
; DARWIN-NEXT: declare double @__muldf3(double, double)
; DARWIN-NEXT: declare i64 @__muldi3(i64, i64)
; DARWIN-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; DARWIN-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; DARWIN-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; DARWIN-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; DARWIN-NEXT: declare float @__mulsf3(float, float)
; DARWIN-NEXT: declare i32 @__mulsi3(i32, i32)
@@ -1023,7 +1025,7 @@
; DARWIN-NEXT: declare double @atan2(double, double)
; DARWIN-NEXT: declare float @atan2f(float, float)
; DARWIN-NEXT: declare float @atanf(float)
-; DARWIN-NEXT: declare void @bzero(ptr, i64)
+; DARWIN-NEXT: declare void @bzero(ptr writeonly captures(none), i64) [[ARGMEM_WRITE_ATTRS]]
; DARWIN-NEXT: declare void @cabs(...)
; DARWIN-NEXT: declare void @cabsf(...)
; DARWIN-NEXT: declare noalias noundef ptr @calloc(i64 noundef, i64 noundef) [[CALLOC_ATTRS:#[0-9]+]]
@@ -1087,9 +1089,9 @@
; DARWIN-NEXT: declare i64 @lround(double)
; DARWIN-NEXT: declare i64 @lroundf(float)
; DARWIN-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-9]+]]
-; 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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; DARWIN-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; DARWIN-NEXT: declare ptr @memset(ptr returned writeonly, i32, i64) [[ARGMEM_WRITE_ATTRS]]
; DARWIN-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; DARWIN-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; DARWIN-NEXT: declare double @nan(ptr)
@@ -1130,9 +1132,11 @@
; DARWIN-NEXT: declare float @tgammaf(float)
; DARWIN-NEXT: declare double @trunc(double)
; DARWIN-NEXT: declare float @truncf(float)
-; DARWIN-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; DARWIN-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; DARWIN-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; DARWIN-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; DARWIN-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
; WINMSVC: @__safestack_unsafe_stack_ptr = external thread_local(initialexec) global ptr
@@ -1446,7 +1450,7 @@
; WINMSVC-NEXT: declare double @__muldf3(double, double)
; WINMSVC-NEXT: declare i64 @__muldi3(i64, i64)
; WINMSVC-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; WINMSVC-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; WINMSVC-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; WINMSVC-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; WINMSVC-NEXT: declare float @__mulsf3(float, float)
; WINMSVC-NEXT: declare i32 @__mulsi3(i32, i32)
@@ -1618,9 +1622,9 @@
; WINMSVC-NEXT: declare i32 @lround(double)
; WINMSVC-NEXT: declare i32 @lroundf(float)
; WINMSVC-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-9]+]]
-; 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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; WINMSVC-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; WINMSVC-NEXT: declare ptr @memset(ptr returned writeonly, i32, i64) [[ARGMEM_WRITE_ATTRS]]
; WINMSVC-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; WINMSVC-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; WINMSVC-NEXT: declare double @nan(ptr)
@@ -1659,9 +1663,11 @@
; WINMSVC-NEXT: declare float @tgammaf(float)
; WINMSVC-NEXT: declare double @trunc(double)
; WINMSVC-NEXT: declare float @truncf(float)
-; WINMSVC-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; WINMSVC-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; WINMSVC-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; WINMSVC-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
; MINGW: @__safestack_unsafe_stack_ptr = external thread_local(initialexec) global ptr
@@ -1975,7 +1981,7 @@
; MINGW-NEXT: declare double @__muldf3(double, double)
; MINGW-NEXT: declare i64 @__muldi3(i64, i64)
; MINGW-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; MINGW-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; MINGW-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; MINGW-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; MINGW-NEXT: declare float @__mulsf3(float, float)
; MINGW-NEXT: declare i32 @__mulsi3(i32, i32)
@@ -2149,9 +2155,9 @@
; MINGW-NEXT: declare i32 @lround(double)
; MINGW-NEXT: declare i32 @lroundf(float)
; MINGW-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-9]+]]
-; 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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; MINGW-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; MINGW-NEXT: declare ptr @memset(ptr returned writeonly, i32, i64) [[ARGMEM_WRITE_ATTRS]]
; MINGW-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; MINGW-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; MINGW-NEXT: declare double @nan(ptr)
@@ -2192,9 +2198,11 @@
; MINGW-NEXT: declare float @tgammaf(float)
; MINGW-NEXT: declare double @trunc(double)
; MINGW-NEXT: declare float @truncf(float)
-; MINGW-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; MINGW-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; MINGW-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; MINGW-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; MINGW-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
; ANDROID: @__safestack_unsafe_stack_ptr = external thread_local(initialexec) global ptr
@@ -2512,7 +2520,7 @@
; ANDROID-NEXT: declare double @__muldf3(double, double)
; ANDROID-NEXT: declare i64 @__muldi3(i64, i64)
; ANDROID-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; ANDROID-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; ANDROID-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; ANDROID-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; ANDROID-NEXT: declare float @__mulsf3(float, float)
; ANDROID-NEXT: declare i32 @__mulsi3(i32, i32)
@@ -2722,9 +2730,9 @@
; ANDROID-NEXT: declare i64 @lroundf(float)
; ANDROID-NEXT: declare i64 @lroundl(fp128)
; ANDROID-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; ANDROID-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; ANDROID-NEXT: declare ptr @memset(ptr returned writeonly, i32, i64) [[ARGMEM_WRITE_ATTRS]]
; ANDROID-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; ANDROID-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; ANDROID-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16))
@@ -2785,7 +2793,9 @@
; ANDROID-NEXT: declare double @trunc(double)
; ANDROID-NEXT: declare float @truncf(float)
; ANDROID-NEXT: declare fp128 @truncl(fp128)
-; ANDROID-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; ANDROID-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; ANDROID-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; ANDROID-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; ANDROID-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aix.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aix.ll
index 7bd763b829dda5..dcd0b3a29e35fe 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aix.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aix.ll
@@ -1,7 +1,11 @@
; REQUIRES: webassembly-registered-target
; RUN: opt -S -passes=declare-runtime-libcalls -mtriple=powerpc64-ibm-aix < %s | FileCheck %s
-; CHECK: declare ptr @vec_calloc(i64, i64)
-; CHECK: declare void @vec_free(ptr)
-; CHECK: declare ptr @vec_malloc(i64)
+; 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: 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_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" }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/amdlibm.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/amdlibm.ll
index be4727c4a54e28..91d9c0e1c156b6 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/amdlibm.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/amdlibm.ll
@@ -267,5 +267,5 @@
; CHECK: declare <8 x float> @amd_vrs8_tanhf(<8 x float>) [[ATTRS]]
-; CHECK: attributes [[ATTRS]] = { nocallback nofree nosync nounwind willreturn }
-; CHECK: attributes [[ATTRS_PTR_ARG]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; CHECK-DAG: attributes [[ATTRS]] = { nocallback nofree nosync nounwind willreturn }
+; CHECK-DAG: attributes [[ATTRS_PTR_ARG]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/arm.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/arm.ll
index 06ca7f75d54985..11d823fd4dfa62 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/arm.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/arm.ll
@@ -256,7 +256,7 @@
; SJLJ-NEXT: declare arm_aapcscc double @__muldf3(double, double)
; SJLJ-NEXT: declare arm_aapcscc i64 @__muldi3(i64, i64)
; SJLJ-NEXT: declare arm_aapcscc signext i16 @__mulhi3(i16 signext, i16 signext)
-; SJLJ-NEXT: declare arm_aapcscc i32 @__mulosi4(i32, i32, ptr)
+; 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 signext i8 @__mulqi3(i8 signext, i8 signext)
; SJLJ-NEXT: declare arm_aapcscc float @__mulsf3(float, float)
; SJLJ-NEXT: declare arm_aapcscc i32 @__mulsi3(i32, i32)
@@ -430,9 +430,9 @@
; SJLJ-NEXT: declare arm_aapcscc i32 @lround(double)
; SJLJ-NEXT: declare arm_aapcscc i32 @lroundf(float)
; SJLJ-NEXT: declare arm_aapcscc noalias noundef ptr @malloc(i32 noundef) [[MALLOC_ATTRS:#[0-9]+]]
-; 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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i32) [[ARGMEM_ATTRS:#[0-9]+]]
+; SJLJ-NEXT: declare arm_aapcscc ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i32) [[ARGMEM_ATTRS]]
+; SJLJ-NEXT: declare arm_aapcscc ptr @memset(ptr returned writeonly, i32, i32) [[ARGMEM_WRITE_ATTRS]]
; SJLJ-NEXT: declare arm_aapcscc double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; SJLJ-NEXT: declare arm_aapcscc float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; SJLJ-NEXT: declare arm_aapcscc double @nan(ptr)
@@ -474,9 +474,11 @@
; SJLJ-NEXT: declare arm_aapcscc double @trunc(double)
; SJLJ-NEXT: declare arm_aapcscc float @truncf(float)
; SJLJ-NEXT: attributes [[DIVMOD_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(none) }
-; SJLJ-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; SJLJ-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; SJLJ-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; SJLJ-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; SJLJ-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
; DWARF: @__safestack_unsafe_stack_ptr = external thread_local(initialexec) global ptr
@@ -728,7 +730,7 @@
; DWARF-NEXT: declare arm_aapcscc double @__muldf3(double, double)
; DWARF-NEXT: declare arm_aapcscc i64 @__muldi3(i64, i64)
; DWARF-NEXT: declare arm_aapcscc signext i16 @__mulhi3(i16 signext, i16 signext)
-; DWARF-NEXT: declare arm_aapcscc i32 @__mulosi4(i32, i32, ptr)
+; 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 signext i8 @__mulqi3(i8 signext, i8 signext)
; DWARF-NEXT: declare arm_aapcscc float @__mulsf3(float, float)
; DWARF-NEXT: declare arm_aapcscc i32 @__mulsi3(i32, i32)
@@ -902,9 +904,9 @@
; DWARF-NEXT: declare arm_aapcscc i32 @lround(double)
; DWARF-NEXT: declare arm_aapcscc i32 @lroundf(float)
; DWARF-NEXT: declare arm_aapcscc noalias noundef ptr @malloc(i32 noundef) [[MALLOC_ATTRS:#[0-9]+]]
-; 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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i32) [[ARGMEM_ATTRS:#[0-9]+]]
+; DWARF-NEXT: declare arm_aapcscc ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i32) [[ARGMEM_ATTRS]]
+; DWARF-NEXT: declare arm_aapcscc ptr @memset(ptr returned writeonly, i32, i32) [[ARGMEM_WRITE_ATTRS]]
; DWARF-NEXT: declare arm_aapcscc double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; DWARF-NEXT: declare arm_aapcscc float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; DWARF-NEXT: declare arm_aapcscc double @nan(ptr)
@@ -946,7 +948,9 @@
; DWARF-NEXT: declare arm_aapcscc double @trunc(double)
; DWARF-NEXT: declare arm_aapcscc float @truncf(float)
; DWARF-NEXT: attributes [[DIVMOD_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(none) }
-; DWARF-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; DWARF-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; DWARF-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; DWARF-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; DWARF-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/arm64ec.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/arm64ec.ll
index 23d5ca31a58095..4404e4690ee941 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/arm64ec.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/arm64ec.ll
@@ -303,7 +303,7 @@
; CHECK-NEXT: declare double @"#__muldf3"(double, double)
; CHECK-NEXT: declare i64 @"#__muldi3"(i64, i64)
; CHECK-NEXT: declare signext i16 @"#__mulhi3"(i16 signext, i16 signext)
-; CHECK-NEXT: declare i32 @"#__mulosi4"(i32, i32, ptr)
+; CHECK-NEXT: declare i32 @"#__mulosi4"(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; CHECK-NEXT: declare signext i8 @"#__mulqi3"(i8 signext, i8 signext)
; CHECK-NEXT: declare float @"#__mulsf3"(float, float)
; CHECK-NEXT: declare i32 @"#__mulsi3"(i32, i32)
@@ -474,9 +474,9 @@
; CHECK-NEXT: declare i32 @"#lround"(double)
; CHECK-NEXT: declare i32 @"#lroundf"(float)
; CHECK-NEXT: declare noalias noundef ptr @"#malloc"(i64 noundef) [[MALLOC_ATTRS:#[0-9]+]]
-; 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 ptr @"#memcpy"(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare ptr @"#memmove"(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; CHECK-NEXT: declare ptr @"#memset"(ptr returned writeonly, i32, i64) [[ARGMEM_WRITE_ATTRS]]
; CHECK-NEXT: declare double @"#modf"(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; CHECK-NEXT: declare float @"#modff"(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; CHECK-NEXT: declare double @"#nan"(ptr)
@@ -515,7 +515,9 @@
; CHECK-NEXT: declare float @"#tgammaf"(float)
; CHECK-NEXT: declare double @"#trunc"(double)
; CHECK-NEXT: declare float @"#truncf"(float)
-; CHECK-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; CHECK-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; CHECK-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; CHECK-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/armpl.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/armpl.ll
index 166788541dd646..00352d145c7bb5 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/armpl.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/armpl.ll
@@ -369,5 +369,5 @@
; CHECK: declare aarch64_vector_pcs <2 x double> @armpl_vtgammaq_f64(<2 x double>) [[ATTRS]]
-; CHECK: attributes [[ATTRS]] = { nocallback nofree nosync nounwind willreturn }
-; CHECK: attributes [[ATTRS_PTR_ARG]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; CHECK-DAG: attributes [[ATTRS]] = { nocallback nofree nosync nounwind willreturn }
+; CHECK-DAG: attributes [[ATTRS_PTR_ARG]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/avr.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/avr.ll
index 53f6392f46bd71..792c5d598a5831 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/avr.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/avr.ll
@@ -192,7 +192,7 @@
; CHECK-NEXT: declare double @__muldf3(double, double) addrspace(1)
; CHECK-NEXT: declare i64 @__muldi3(i64, i64) addrspace(1)
; CHECK-NEXT: declare i16 @__mulhi3(i16, i16) addrspace(1)
-; CHECK-NEXT: declare i32 @__mulosi4(i32, i32, ptr) addrspace(1)
+; 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 signext i8 @__mulqi3(i8 signext, i8 signext) addrspace(1)
; CHECK-NEXT: declare float @__mulsf3(float, float) addrspace(1)
; CHECK-NEXT: declare i32 @__mulsi3(i32, i32) addrspace(1)
@@ -363,9 +363,9 @@
; CHECK-NEXT: declare i32 @lround(double) addrspace(1)
; CHECK-NEXT: declare i32 @lroundf(float) addrspace(1)
; CHECK-NEXT: declare noalias noundef ptr @malloc(i16 noundef) addrspace(1) [[MALLOC_ATTRS:#[0-9]+]]
-; 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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i16) addrspace(1) [[ARGMEM_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i16) addrspace(1) [[ARGMEM_ATTRS]]
+; CHECK-NEXT: declare ptr @memset(ptr returned writeonly, i16, i16) addrspace(1) [[ARGMEM_WRITE_ATTRS]]
; CHECK-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 1 dereferenceable(8)) addrspace(1)
; CHECK-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 1 dereferenceable(4)) addrspace(1)
; CHECK-NEXT: declare double @nan(ptr) addrspace(1)
@@ -404,7 +404,9 @@
; CHECK-NEXT: declare double @trunc(double) addrspace(1)
; CHECK-NEXT: declare float @truncf(float) addrspace(1)
; CHECK-NEXT: attributes [[DIVMOD_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(none) }
-; CHECK-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; CHECK-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; CHECK-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; CHECK-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/basic.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/basic.ll
index 1dc4eaf940a352..c0502da25af930 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/basic.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/basic.ll
@@ -17,6 +17,8 @@ define float @sinf(float %x) {
; CHECK: declare ptr @__memmove_chk(ptr, ptr, i64, i64)
; CHECK: declare ptr @__memset_chk(ptr, i32, i64, i64)
+; CHECK: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
+
; CHECK: declare i128 @__umodti3(i128, i128)
; CHECK: declare float @acosf(float)
@@ -31,6 +33,10 @@ define float @sinf(float %x) {
; CHECK: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-9]+]]
+; CHECK: declare ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; CHECK: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; CHECK: declare ptr @memset(ptr returned writeonly, i32, i64) [[ARGMEM_WRITE_ATTRS]]
+
; CHECK: declare double @nan(ptr)
; CHECK: declare float @nanf(ptr)
; CHECK: declare x86_fp80 @nanl(ptr)
@@ -65,6 +71,8 @@ define float @sinf(float %x) {
; CHECK: declare x86_fp80 @truncl(x86_fp80)
-; CHECK: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; CHECK: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; CHECK: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/bsd.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/bsd.ll
index 27eaf1906b8501..6a83faafbe4a78 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/bsd.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/bsd.ll
@@ -228,7 +228,7 @@
; LINUX-NEXT: declare i128 @__modti3(i128, i128)
; LINUX-NEXT: declare double @__muldf3(double, double)
; LINUX-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; LINUX-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; LINUX-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; LINUX-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; LINUX-NEXT: declare float @__mulsf3(float, float)
; LINUX-NEXT: declare i32 @__mulsi3(i32, i32)
@@ -474,9 +474,9 @@
; LINUX-NEXT: declare i64 @lroundf128(fp128)
; LINUX-NEXT: declare i64 @lroundl(x86_fp80)
; LINUX-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; LINUX-NEXT: declare ptr @memset(ptr returned writeonly, i32, i64) [[ARGMEM_WRITE_ATTRS]]
; LINUX-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; LINUX-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; LINUX-NEXT: declare fp128 @modff128(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16))
@@ -550,9 +550,11 @@
; LINUX-NEXT: declare float @truncf(float)
; LINUX-NEXT: declare fp128 @truncf128(fp128)
; LINUX-NEXT: declare x86_fp80 @truncl(x86_fp80)
-; LINUX-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; LINUX-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; LINUX-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; LINUX-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; LINUX-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
; FREEBSD: @__safestack_unsafe_stack_ptr = external thread_local(initialexec) global ptr
@@ -771,7 +773,7 @@
; FREEBSD-NEXT: declare i128 @__modti3(i128, i128)
; FREEBSD-NEXT: declare double @__muldf3(double, double)
; FREEBSD-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; FREEBSD-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; FREEBSD-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; FREEBSD-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; FREEBSD-NEXT: declare float @__mulsf3(float, float)
; FREEBSD-NEXT: declare i32 @__mulsi3(i32, i32)
@@ -986,9 +988,9 @@
; FREEBSD-NEXT: declare i64 @lroundf(float)
; FREEBSD-NEXT: declare i64 @lroundl(x86_fp80)
; FREEBSD-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; FREEBSD-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; FREEBSD-NEXT: declare ptr @memset(ptr returned writeonly, i32, i64) [[ARGMEM_WRITE_ATTRS]]
; FREEBSD-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; FREEBSD-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; FREEBSD-NEXT: declare x86_fp80 @modfl(x86_fp80, ptr noalias nonnull writeonly align 16 dereferenceable(10))
@@ -1046,9 +1048,11 @@
; FREEBSD-NEXT: declare double @trunc(double)
; FREEBSD-NEXT: declare float @truncf(float)
; FREEBSD-NEXT: declare x86_fp80 @truncl(x86_fp80)
-; FREEBSD-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; FREEBSD-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; FREEBSD-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; FREEBSD-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; FREEBSD-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
; OPENBSD: @__guard_local = external global ptr
@@ -1267,7 +1271,7 @@
; OPENBSD-NEXT: declare i128 @__modti3(i128, i128)
; OPENBSD-NEXT: declare double @__muldf3(double, double)
; OPENBSD-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; OPENBSD-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; OPENBSD-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; OPENBSD-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; OPENBSD-NEXT: declare float @__mulsf3(float, float)
; OPENBSD-NEXT: declare i32 @__mulsi3(i32, i32)
@@ -1482,9 +1486,9 @@
; OPENBSD-NEXT: declare i64 @lroundf(float)
; OPENBSD-NEXT: declare i64 @lroundl(x86_fp80)
; OPENBSD-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; OPENBSD-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; OPENBSD-NEXT: declare ptr @memset(ptr returned writeonly, i32, i64) [[ARGMEM_WRITE_ATTRS]]
; OPENBSD-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; OPENBSD-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; OPENBSD-NEXT: declare x86_fp80 @modfl(x86_fp80, ptr noalias nonnull writeonly align 16 dereferenceable(10))
@@ -1542,7 +1546,9 @@
; OPENBSD-NEXT: declare double @trunc(double)
; OPENBSD-NEXT: declare float @truncf(float)
; OPENBSD-NEXT: declare x86_fp80 @truncl(x86_fp80)
-; OPENBSD-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; OPENBSD-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; OPENBSD-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; OPENBSD-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; OPENBSD-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/divmod.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/divmod.ll
index 08012cf5dd1c97..f77f15238ec20e 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/divmod.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/divmod.ll
@@ -5,17 +5,17 @@
; RUN: opt -S -passes=declare-runtime-libcalls -mtriple=armv7-apple-ios5.0 < %s | FileCheck -check-prefix=DARWIN %s
-; AEABI: declare arm_aapcscc inreg { i32, i32 } @__aeabi_idivmod(i32, i32) #0
-; AEABI: declare arm_aapcscc inreg { i64, i64 } @__aeabi_ldivmod(i64, i64) #0
-; AEABI: declare arm_aapcscc inreg { i32, i32 } @__aeabi_uidivmod(i32, i32) #0
-; AEABI: declare arm_aapcscc inreg { i64, i64 } @__aeabi_uldivmod(i64, i64) #0
-; AEABI: attributes #0 = { nocallback nofree nosync nounwind willreturn memory(none) }
+; AEABI: declare arm_aapcscc inreg { i32, i32 } @__aeabi_idivmod(i32, i32) [[DIVMOD_ATTRS:#[0-9]+]]
+; AEABI: declare arm_aapcscc inreg { i64, i64 } @__aeabi_ldivmod(i64, i64) [[DIVMOD_ATTRS]]
+; AEABI: declare arm_aapcscc inreg { i32, i32 } @__aeabi_uidivmod(i32, i32) [[DIVMOD_ATTRS]]
+; AEABI: declare arm_aapcscc inreg { i64, i64 } @__aeabi_uldivmod(i64, i64) [[DIVMOD_ATTRS]]
+; AEABI: attributes [[DIVMOD_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(none) }
-; WINDOWS: declare arm_aapcscc inreg { i32, i32 } @__rt_sdiv(i32, i32) #0
-; WINDOWS: declare arm_aapcscc inreg { i64, i64 } @__rt_sdiv64(i64, i64) #0
-; WINDOWS: declare arm_aapcscc inreg { i32, i32 } @__rt_udiv(i32, i32) #0
-; WINDOWS: declare arm_aapcscc inreg { i64, i64 } @__rt_udiv64(i64, i64) #0
-; WINDOWS: attributes #0 = { nocallback nofree nosync nounwind willreturn memory(none) }
+; WINDOWS: declare arm_aapcscc inreg { i32, i32 } @__rt_sdiv(i32, i32) [[DIVMOD_ATTRS:#[0-9]+]]
+; WINDOWS: declare arm_aapcscc inreg { i64, i64 } @__rt_sdiv64(i64, i64) [[DIVMOD_ATTRS]]
+; WINDOWS: declare arm_aapcscc inreg { i32, i32 } @__rt_udiv(i32, i32) [[DIVMOD_ATTRS]]
+; 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]]
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/hexagon.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/hexagon.ll
index 73ea2866069d1b..fb73e9a62f3070 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/hexagon.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/hexagon.ll
@@ -222,7 +222,7 @@
; CHECK-NEXT: declare double @__muldf3(double, double)
; CHECK-NEXT: declare i64 @__muldi3(i64, i64)
; CHECK-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; CHECK-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; CHECK-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; CHECK-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; CHECK-NEXT: declare float @__mulsf3(float, float)
; CHECK-NEXT: declare i32 @__mulsi3(i32, i32)
@@ -398,9 +398,9 @@
; CHECK-NEXT: declare i32 @lround(double)
; CHECK-NEXT: declare i32 @lroundf(float)
; CHECK-NEXT: declare noalias noundef ptr @malloc(i32 noundef) [[MALLOC_ATTRS:#[0-9]+]]
-; 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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i32) [[ARGMEM_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i32) [[ARGMEM_ATTRS]]
+; CHECK-NEXT: declare ptr @memset(ptr returned writeonly, i32, i32) [[ARGMEM_WRITE_ATTRS]]
; CHECK-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; CHECK-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; CHECK-NEXT: declare double @nan(ptr)
@@ -440,9 +440,11 @@
; CHECK-NEXT: declare double @trunc(double)
; CHECK-NEXT: declare float @truncf(float)
; CHECK-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
-; CHECK-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; CHECK-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; CHECK-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; LINUX: @__safestack_unsafe_stack_ptr = external thread_local(initialexec) global ptr
; LINUX-NEXT: @__stack_chk_guard = external global ptr
@@ -661,7 +663,7 @@
; LINUX-NEXT: declare double @__muldf3(double, double)
; LINUX-NEXT: declare i64 @__muldi3(i64, i64)
; LINUX-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; LINUX-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; LINUX-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; LINUX-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; LINUX-NEXT: declare float @__mulsf3(float, float)
; LINUX-NEXT: declare i32 @__mulsi3(i32, i32)
@@ -837,9 +839,9 @@
; LINUX-NEXT: declare i32 @lround(double)
; LINUX-NEXT: declare i32 @lroundf(float)
; LINUX-NEXT: declare noalias noundef ptr @malloc(i32 noundef) [[MALLOC_ATTRS:#[0-9]+]]
-; 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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i32) [[ARGMEM_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i32) [[ARGMEM_ATTRS]]
+; LINUX-NEXT: declare ptr @memset(ptr returned writeonly, i32, i32) [[ARGMEM_WRITE_ATTRS]]
; LINUX-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; LINUX-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; LINUX-NEXT: declare double @nan(ptr)
@@ -881,6 +883,8 @@
; LINUX-NEXT: declare double @trunc(double)
; LINUX-NEXT: declare float @truncf(float)
; LINUX-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
-; LINUX-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; LINUX-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; LINUX-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; LINUX-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/mips.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/mips.ll
index 514f513b890f0b..5cb8ce11a7a2b3 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/mips.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/mips.ll
@@ -234,7 +234,7 @@
; MIPS32-NEXT: declare double @__muldf3(double, double)
; MIPS32-NEXT: declare i64 @__muldi3(i64, i64)
; MIPS32-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; MIPS32-NEXT: declare i32 @__mulosi4(i32 signext, i32 signext, ptr)
+; 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 signext i8 @__mulqi3(i8 signext, i8 signext)
; MIPS32-NEXT: declare float @__mulsf3(float, float)
; MIPS32-NEXT: declare i32 @__mulsi3(i32 signext, i32 signext)
@@ -409,9 +409,9 @@
; MIPS32-NEXT: declare i32 @lround(double)
; MIPS32-NEXT: declare i32 @lroundf(float)
; MIPS32-NEXT: declare noalias noundef ptr @malloc(i32 noundef signext) [[MALLOC_ATTRS:#[0-9]+]]
-; 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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i32 signext) [[ARGMEM_ATTRS:#[0-9]+]]
+; MIPS32-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i32 signext) [[ARGMEM_ATTRS]]
+; MIPS32-NEXT: declare ptr @memset(ptr returned writeonly, i32 signext, i32 signext) [[ARGMEM_WRITE_ATTRS]]
; MIPS32-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; MIPS32-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; MIPS32-NEXT: declare double @nan(ptr)
@@ -452,9 +452,11 @@
; MIPS32-NEXT: declare float @tgammaf(float)
; MIPS32-NEXT: declare double @trunc(double)
; MIPS32-NEXT: declare float @truncf(float)
-; MIPS32-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; MIPS32-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; MIPS32-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; MIPS32-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; MIPS32-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
; MIPS64: @__safestack_unsafe_stack_ptr = external thread_local(initialexec) global ptr
@@ -660,7 +662,7 @@
; MIPS64-NEXT: declare double @__muldf3(double, double)
; MIPS64-NEXT: declare i64 @__muldi3(i64, i64)
; MIPS64-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; MIPS64-NEXT: declare i32 @__mulosi4(i32 signext, i32 signext, ptr)
+; 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 signext i8 @__mulqi3(i8 signext, i8 signext)
; MIPS64-NEXT: declare float @__mulsf3(float, float)
; MIPS64-NEXT: declare i32 @__mulsi3(i32 signext, i32 signext)
@@ -869,9 +871,9 @@
; MIPS64-NEXT: declare i64 @lroundf(float)
; MIPS64-NEXT: declare i64 @lroundl(fp128)
; MIPS64-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; MIPS64-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; MIPS64-NEXT: declare ptr @memset(ptr returned writeonly, i32 signext, i64) [[ARGMEM_WRITE_ATTRS]]
; MIPS64-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; MIPS64-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; MIPS64-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16))
@@ -932,7 +934,9 @@
; MIPS64-NEXT: declare double @trunc(double)
; MIPS64-NEXT: declare float @truncf(float)
; MIPS64-NEXT: declare fp128 @truncl(fp128)
-; MIPS64-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; MIPS64-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; MIPS64-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; MIPS64-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; MIPS64-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/msp430.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/msp430.ll
index dc60456a152dae..428e5162e3c1c0 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/msp430.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/msp430.ll
@@ -241,7 +241,7 @@
; CHECK-NEXT: declare double @__muldf3(double, double)
; CHECK-NEXT: declare i64 @__muldi3(i64, i64)
; CHECK-NEXT: declare i16 @__mulhi3(i16, i16)
-; CHECK-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; CHECK-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 2 dereferenceable(2)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; CHECK-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; CHECK-NEXT: declare float @__mulsf3(float, float)
; CHECK-NEXT: declare i32 @__mulsi3(i32, i32)
@@ -416,9 +416,9 @@
; CHECK-NEXT: declare i32 @lround(double)
; CHECK-NEXT: declare i32 @lroundf(float)
; CHECK-NEXT: declare noalias noundef ptr @malloc(i16 noundef) [[MALLOC_ATTRS:#[0-9]+]]
-; 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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i16) [[ARGMEM_ATTRS:#[0-9]+]]
+; CHECK-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i16) [[ARGMEM_ATTRS]]
+; CHECK-NEXT: declare ptr @memset(ptr returned writeonly, i16, i16) [[ARGMEM_WRITE_ATTRS]]
; CHECK-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 2 dereferenceable(8))
; CHECK-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 2 dereferenceable(4))
; CHECK-NEXT: declare double @nan(ptr)
@@ -457,7 +457,9 @@
; CHECK-NEXT: declare float @tgammaf(float)
; CHECK-NEXT: declare double @trunc(double)
; CHECK-NEXT: declare float @truncf(float)
-; CHECK-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; CHECK-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; CHECK-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; CHECK-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ppc.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ppc.ll
index 4ded6ba96c8107..5d4e7d3093b97e 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ppc.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ppc.ll
@@ -9,14 +9,14 @@
; AIX32: @__ssp_canary_word = external global ptr
; AIX32-NEXT: declare i32 @_Unwind_RaiseException(ptr)
; AIX32-NEXT: declare void @_Unwind_Resume(ptr)
-; AIX32-NEXT: declare void @___bzero(ptr, i32)
+; AIX32-NEXT: declare void @___bzero(ptr writeonly captures(none), i32) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; AIX32-NEXT: declare ptr @___memccpy(ptr, ptr, i32, i32)
-; AIX32-NEXT: declare i32 @___memcmp(ptr, ptr, i32)
-; AIX32-NEXT: declare ptr @___memmove(ptr, ptr, i32)
-; AIX32-NEXT: declare ptr @___memset(ptr, i32, i32)
+; AIX32-NEXT: declare i32 @___memcmp(ptr readonly captures(none), ptr readonly captures(none), i32) [[ARGMEM_READ_ATTRS:#[0-9]+]]
+; AIX32-NEXT: declare ptr @___memmove(ptr returned writeonly, ptr readonly captures(none), i32) [[ARGMEM_ATTRS:#[0-9]+]]
+; AIX32-NEXT: declare ptr @___memset(ptr returned writeonly, i32, i32) [[ARGMEM_WRITE_ATTRS]]
; AIX32-NEXT: declare i32 @___strcmp(ptr, ptr)
; AIX32-NEXT: declare ptr @___strcpy(ptr, ptr)
-; AIX32-NEXT: declare i32 @___strlen(ptr)
+; AIX32-NEXT: declare i32 @___strlen(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
; AIX32-NEXT: declare ptr @___strstr(ptr, ptr)
; AIX32-NEXT: declare double @__adddf3(double, double)
; AIX32-NEXT: declare fp128 @__addkf3(fp128, fp128)
@@ -242,7 +242,7 @@
; AIX32-NEXT: declare i64 @__muldi3(i64, i64)
; AIX32-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
; AIX32-NEXT: declare fp128 @__mulkf3(fp128, fp128)
-; AIX32-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; AIX32-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS]]
; AIX32-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; AIX32-NEXT: declare float @__mulsf3(float, float)
; AIX32-NEXT: declare i32 @__mulsi3(i32, i32)
@@ -481,8 +481,8 @@
; AIX32-NEXT: declare i32 @lroundf128(fp128)
; AIX32-NEXT: declare i32 @lroundl(double)
; 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 ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i32) [[ARGMEM_ATTRS]]
+; AIX32-NEXT: declare ptr @memset(ptr returned writeonly, i32, i32) [[ARGMEM_WRITE_ATTRS]]
; AIX32-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 4 dereferenceable(8))
; AIX32-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; AIX32-NEXT: declare fp128 @modff128(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16))
@@ -553,26 +553,32 @@
; AIX32-NEXT: declare float @truncf(float)
; AIX32-NEXT: declare fp128 @truncf128(fp128)
; AIX32-NEXT: declare double @truncl(double)
-; AIX32-NEXT: declare ptr @vec_calloc(i32, i32)
-; AIX32-NEXT: declare void @vec_free(ptr)
-; AIX32-NEXT: declare ptr @vec_malloc(i32)
+; 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: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; AIX32-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; AIX32-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; 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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
+; 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 [[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 [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(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_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" }
; AIX64: @__ssp_canary_word = external global ptr
; AIX64-NEXT: declare signext i32 @_Unwind_RaiseException(ptr)
; AIX64-NEXT: declare void @_Unwind_Resume(ptr)
-; AIX64-NEXT: declare void @___bzero64(ptr, i64)
+; AIX64-NEXT: declare void @___bzero64(ptr writeonly captures(none), i64) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; AIX64-NEXT: declare ptr @___memccpy64(ptr, ptr, i32 signext, i64)
-; AIX64-NEXT: declare signext i32 @___memcmp64(ptr, ptr, i64)
-; AIX64-NEXT: declare ptr @___memmove64(ptr, ptr, i64)
-; AIX64-NEXT: declare ptr @___memset64(ptr, i32 signext, i64)
+; AIX64-NEXT: declare signext i32 @___memcmp64(ptr readonly captures(none), ptr readonly captures(none), i64) [[ARGMEM_READ_ATTRS:#[0-9]+]]
+; AIX64-NEXT: declare ptr @___memmove64(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; AIX64-NEXT: declare ptr @___memset64(ptr returned writeonly, i32 signext, i64) [[ARGMEM_WRITE_ATTRS]]
; AIX64-NEXT: declare signext i32 @___strcmp64(ptr, ptr)
; AIX64-NEXT: declare ptr @___strcpy64(ptr, ptr)
-; AIX64-NEXT: declare i64 @___strlen64(ptr)
+; AIX64-NEXT: declare i64 @___strlen64(ptr readonly captures(none)) [[ARGMEM_READ_ATTRS]]
; AIX64-NEXT: declare ptr @___strstr64(ptr, ptr)
; AIX64-NEXT: declare double @__adddf3(double, double)
; AIX64-NEXT: declare fp128 @__addkf3(fp128, fp128)
@@ -801,7 +807,7 @@
; AIX64-NEXT: declare i64 @__muldi3(i64, i64)
; AIX64-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
; AIX64-NEXT: declare fp128 @__mulkf3(fp128, fp128)
-; AIX64-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr)
+; 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 i8 @__mulqi3(i8 signext, i8 signext)
; AIX64-NEXT: declare float @__mulsf3(float, float)
; AIX64-NEXT: declare signext i32 @__mulsi3(i32 signext, i32 signext)
@@ -1041,8 +1047,8 @@
; AIX64-NEXT: declare i64 @lroundf128(fp128)
; AIX64-NEXT: declare i64 @lroundl(double)
; 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 ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; AIX64-NEXT: declare ptr @memset(ptr returned writeonly, i32 signext, i64) [[ARGMEM_WRITE_ATTRS]]
; AIX64-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 4 dereferenceable(8))
; AIX64-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; AIX64-NEXT: declare fp128 @modff128(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16))
@@ -1113,14 +1119,20 @@
; AIX64-NEXT: declare float @truncf(float)
; AIX64-NEXT: declare fp128 @truncf128(fp128)
; AIX64-NEXT: declare double @truncl(double)
-; AIX64-NEXT: declare ptr @vec_calloc(i64, i64)
-; AIX64-NEXT: declare void @vec_free(ptr)
-; AIX64-NEXT: declare ptr @vec_malloc(i64)
+; 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: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; AIX64-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; AIX64-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; 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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
+; 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 [[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 [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(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_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" }
; LINUX: @__stack_chk_guard = external global ptr
; LINUX-NEXT: declare signext i32 @_Unwind_RaiseException(ptr)
@@ -1352,7 +1364,7 @@
; LINUX-NEXT: declare i64 @__muldi3(i64, i64)
; LINUX-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
; LINUX-NEXT: declare fp128 @__mulkf3(fp128, fp128)
-; LINUX-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr)
+; 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 i8 @__mulqi3(i8 signext, i8 signext)
; LINUX-NEXT: declare float @__mulsf3(float, float)
; LINUX-NEXT: declare signext i32 @__mulsi3(i32 signext, i32 signext)
@@ -1592,9 +1604,9 @@
; LINUX-NEXT: declare i64 @lroundf128(fp128)
; LINUX-NEXT: declare i64 @lroundl(ppc_fp128)
; LINUX-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; LINUX-NEXT: declare ptr @memset(ptr returned writeonly, i32 signext, i64) [[ARGMEM_WRITE_ATTRS]]
; LINUX-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; LINUX-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; LINUX-NEXT: declare fp128 @modff128(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16))
@@ -1668,7 +1680,9 @@
; LINUX-NEXT: declare float @truncf(float)
; LINUX-NEXT: declare fp128 @truncf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @truncl(ppc_fp128)
-; LINUX-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; LINUX-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; LINUX-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; LINUX-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; LINUX-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/riscv.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/riscv.ll
index 23c30d86be8dea..c658c69e3d3a3c 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/riscv.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/riscv.ll
@@ -205,7 +205,7 @@
; RV32-NEXT: declare double @__muldf3(double, double)
; RV32-NEXT: declare i64 @__muldi3(i64, i64)
; RV32-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; RV32-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; RV32-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; RV32-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; RV32-NEXT: declare float @__mulsf3(float, float)
; RV32-NEXT: declare i32 @__mulsi3(i32, i32)
@@ -414,9 +414,9 @@
; RV32-NEXT: declare i32 @lroundf(float)
; RV32-NEXT: declare i32 @lroundl(fp128)
; RV32-NEXT: declare noalias noundef ptr @malloc(i32 noundef) [[MALLOC_ATTRS:#[0-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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i32) [[ARGMEM_ATTRS:#[0-9]+]]
+; RV32-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i32) [[ARGMEM_ATTRS]]
+; RV32-NEXT: declare ptr @memset(ptr returned writeonly, i32, i32) [[ARGMEM_WRITE_ATTRS]]
; RV32-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; RV32-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; RV32-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16))
@@ -474,9 +474,11 @@
; RV32-NEXT: declare double @trunc(double)
; RV32-NEXT: declare float @truncf(float)
; RV32-NEXT: declare fp128 @truncl(fp128)
-; RV32-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; RV32-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; RV32-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; RV32-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; RV32-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
; RV64: @__safestack_unsafe_stack_ptr = external thread_local(initialexec) global ptr
@@ -682,7 +684,7 @@
; RV64-NEXT: declare double @__muldf3(double, double)
; RV64-NEXT: declare i64 @__muldi3(i64, i64)
; RV64-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; RV64-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr)
+; 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 i8 @__mulqi3(i8 signext, i8 signext)
; RV64-NEXT: declare float @__mulsf3(float, float)
; RV64-NEXT: declare signext i32 @__mulsi3(i32 signext, i32 signext)
@@ -892,9 +894,9 @@
; RV64-NEXT: declare i64 @lroundf(float)
; RV64-NEXT: declare i64 @lroundl(fp128)
; RV64-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; RV64-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; RV64-NEXT: declare ptr @memset(ptr returned writeonly, i32 signext, i64) [[ARGMEM_WRITE_ATTRS]]
; RV64-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; RV64-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; RV64-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16))
@@ -952,7 +954,9 @@
; RV64-NEXT: declare double @trunc(double)
; RV64-NEXT: declare float @truncf(float)
; RV64-NEXT: declare fp128 @truncl(fp128)
-; RV64-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; RV64-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; RV64-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; RV64-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; RV64-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/sparc.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/sparc.ll
index b645a522cbd2d5..bb1ac3fd6187af 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/sparc.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/sparc.ll
@@ -211,7 +211,7 @@
; SPARC32-NEXT: declare double @__muldf3(double, double)
; SPARC32-NEXT: declare i64 @__muldi3(i64, i64)
; SPARC32-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; SPARC32-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; SPARC32-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; SPARC32-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; SPARC32-NEXT: declare float @__mulsf3(float, float)
; SPARC32-NEXT: declare fp128 @__multf3(fp128, fp128)
@@ -416,9 +416,9 @@
; SPARC32-NEXT: declare i32 @lroundf(float)
; SPARC32-NEXT: declare i32 @lroundl(fp128)
; SPARC32-NEXT: declare noalias noundef ptr @malloc(i32 noundef) [[MALLOC_ATTRS:#[0-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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i32) [[ARGMEM_ATTRS:#[0-9]+]]
+; SPARC32-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i32) [[ARGMEM_ATTRS]]
+; SPARC32-NEXT: declare ptr @memset(ptr returned writeonly, i32, i32) [[ARGMEM_WRITE_ATTRS]]
; SPARC32-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; SPARC32-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; SPARC32-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 8 dereferenceable(16))
@@ -479,9 +479,11 @@
; SPARC32-NEXT: declare double @trunc(double)
; SPARC32-NEXT: declare float @truncf(float)
; SPARC32-NEXT: declare fp128 @truncl(fp128)
-; SPARC32-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; SPARC32-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; SPARC32-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; SPARC32-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; SPARC32-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
; SPARC64: @__safestack_unsafe_stack_ptr = external thread_local(initialexec) global ptr
@@ -691,7 +693,7 @@
; SPARC64-NEXT: declare double @__muldf3(double, double)
; SPARC64-NEXT: declare i64 @__muldi3(i64, i64)
; SPARC64-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; SPARC64-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr)
+; 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 i8 @__mulqi3(i8 signext, i8 signext)
; SPARC64-NEXT: declare float @__mulsf3(float, float)
; SPARC64-NEXT: declare signext i32 @__mulsi3(i32 signext, i32 signext)
@@ -900,9 +902,9 @@
; SPARC64-NEXT: declare i64 @lroundf(float)
; SPARC64-NEXT: declare i64 @lroundl(fp128)
; SPARC64-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; SPARC64-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; SPARC64-NEXT: declare ptr @memset(ptr returned writeonly, i32 signext, i64) [[ARGMEM_WRITE_ATTRS]]
; SPARC64-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; SPARC64-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; SPARC64-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16))
@@ -963,7 +965,9 @@
; SPARC64-NEXT: declare double @trunc(double)
; SPARC64-NEXT: declare float @truncf(float)
; SPARC64-NEXT: declare fp128 @truncl(fp128)
-; SPARC64-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; SPARC64-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; SPARC64-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; SPARC64-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; SPARC64-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/systemz.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/systemz.ll
index b1bade94eb998e..4bfc0326d11bc1 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/systemz.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/systemz.ll
@@ -207,7 +207,7 @@
; LINUX-NEXT: declare double @__muldf3(double, double)
; LINUX-NEXT: declare i64 @__muldi3(i64, i64)
; LINUX-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; LINUX-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr)
+; 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 i8 @__mulqi3(i8 signext, i8 signext)
; LINUX-NEXT: declare float @__mulsf3(float, float)
; LINUX-NEXT: declare signext i32 @__mulsi3(i32 signext, i32 signext)
@@ -416,9 +416,9 @@
; LINUX-NEXT: declare i64 @lroundf(float)
; LINUX-NEXT: declare i64 @lroundl(fp128)
; LINUX-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; LINUX-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; LINUX-NEXT: declare ptr @memset(ptr returned writeonly, i32 signext, i64) [[ARGMEM_WRITE_ATTRS]]
; LINUX-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; LINUX-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; LINUX-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 8 dereferenceable(16))
@@ -479,9 +479,11 @@
; LINUX-NEXT: declare double @trunc(double)
; LINUX-NEXT: declare float @truncf(float)
; LINUX-NEXT: declare fp128 @truncl(fp128)
-; LINUX-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; LINUX-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; LINUX-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; LINUX-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; LINUX-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
; ZOS: @__stack_chk_guard = external global ptr
@@ -791,7 +793,7 @@
; ZOS-NEXT: declare double @__muldf3(double, double)
; ZOS-NEXT: declare i64 @__muldi3(i64, i64)
; ZOS-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; ZOS-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr)
+; 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 i8 @__mulqi3(i8 signext, i8 signext)
; ZOS-NEXT: declare float @__mulsf3(float, float)
; ZOS-NEXT: declare signext i32 @__mulsi3(i32 signext, i32 signext)
@@ -1000,9 +1002,9 @@
; ZOS-NEXT: declare i64 @lroundf(float)
; ZOS-NEXT: declare i64 @lroundl(fp128)
; ZOS-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; ZOS-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; ZOS-NEXT: declare ptr @memset(ptr returned writeonly, i32 signext, i64) [[ARGMEM_WRITE_ATTRS]]
; ZOS-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; ZOS-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; ZOS-NEXT: declare fp128 @modfl(fp128, ptr noalias nonnull writeonly align 8 dereferenceable(16))
@@ -1061,6 +1063,8 @@
; ZOS-NEXT: declare float @truncf(float)
; ZOS-NEXT: declare fp128 @truncl(fp128)
; ZOS-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
-; ZOS-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; ZOS-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; ZOS-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; ZOS-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/windows.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/windows.ll
index 8dfda76865ed7b..ae388d69c9532c 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/windows.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/windows.ll
@@ -219,7 +219,7 @@
; MSVC-NEXT: declare <2 x i64> @__modti3(<2 x i64>, <2 x i64>)
; MSVC-NEXT: declare double @__muldf3(double, double)
; MSVC-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; MSVC-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; MSVC-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; MSVC-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; MSVC-NEXT: declare float @__mulsf3(float, float)
; MSVC-NEXT: declare i32 @__mulsi3(i32, i32)
@@ -396,9 +396,9 @@
; MSVC-NEXT: declare i32 @lround(double)
; MSVC-NEXT: declare i32 @lroundf(float)
; MSVC-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-9]+]]
-; 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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; MSVC-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; MSVC-NEXT: declare ptr @memset(ptr returned writeonly, i32, i64) [[ARGMEM_WRITE_ATTRS]]
; MSVC-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; MSVC-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; MSVC-NEXT: declare double @nan(ptr)
@@ -437,9 +437,11 @@
; MSVC-NEXT: declare float @tgammaf(float)
; MSVC-NEXT: declare double @trunc(double)
; MSVC-NEXT: declare float @truncf(float)
-; MSVC-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; MSVC-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; MSVC-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; MSVC-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
; MINGW: @__safestack_unsafe_stack_ptr = external thread_local(initialexec) global ptr
@@ -665,7 +667,7 @@
; MINGW-NEXT: declare <2 x i64> @__modti3(<2 x i64>, <2 x i64>)
; MINGW-NEXT: declare double @__muldf3(double, double)
; MINGW-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; MINGW-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; MINGW-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; MINGW-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; MINGW-NEXT: declare float @__mulsf3(float, float)
; MINGW-NEXT: declare i32 @__mulsi3(i32, i32)
@@ -908,9 +910,9 @@
; MINGW-NEXT: declare i32 @lroundf128(fp128)
; MINGW-NEXT: declare i32 @lroundl(x86_fp80)
; MINGW-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-9]+]]
-; 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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; MINGW-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; MINGW-NEXT: declare ptr @memset(ptr returned writeonly, i32, i64) [[ARGMEM_WRITE_ATTRS]]
; MINGW-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; MINGW-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; MINGW-NEXT: declare fp128 @modff128(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16))
@@ -984,9 +986,11 @@
; MINGW-NEXT: declare float @truncf(float)
; MINGW-NEXT: declare fp128 @truncf128(fp128)
; MINGW-NEXT: declare x86_fp80 @truncl(x86_fp80)
-; MINGW-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; MINGW-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; MINGW-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; MINGW-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; MINGW-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
; CYGWIN: @__safestack_unsafe_stack_ptr = external thread_local(initialexec) global ptr
@@ -1206,7 +1210,7 @@
; CYGWIN-NEXT: declare <2 x i64> @__modti3(<2 x i64>, <2 x i64>)
; CYGWIN-NEXT: declare double @__muldf3(double, double)
; CYGWIN-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; CYGWIN-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; CYGWIN-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; CYGWIN-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; CYGWIN-NEXT: declare float @__mulsf3(float, float)
; CYGWIN-NEXT: declare i32 @__mulsi3(i32, i32)
@@ -1421,9 +1425,9 @@
; CYGWIN-NEXT: declare i64 @lroundf(float)
; CYGWIN-NEXT: declare i64 @lroundl(x86_fp80)
; CYGWIN-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; CYGWIN-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; CYGWIN-NEXT: declare ptr @memset(ptr returned writeonly, i32, i64) [[ARGMEM_WRITE_ATTRS]]
; CYGWIN-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; CYGWIN-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; CYGWIN-NEXT: declare x86_fp80 @modfl(x86_fp80, ptr noalias nonnull writeonly align 16 dereferenceable(10))
@@ -1481,9 +1485,11 @@
; CYGWIN-NEXT: declare double @trunc(double)
; CYGWIN-NEXT: declare float @truncf(float)
; CYGWIN-NEXT: declare x86_fp80 @truncl(x86_fp80)
-; CYGWIN-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; CYGWIN-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; CYGWIN-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; CYGWIN-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; CYGWIN-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
; UEFI: @__safestack_unsafe_stack_ptr = external thread_local(initialexec) global ptr
@@ -1698,7 +1704,7 @@
; UEFI-NEXT: declare <2 x i64> @__modti3(<2 x i64>, <2 x i64>)
; UEFI-NEXT: declare double @__muldf3(double, double)
; UEFI-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; UEFI-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; UEFI-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; UEFI-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; UEFI-NEXT: declare float @__mulsf3(float, float)
; UEFI-NEXT: declare i32 @__mulsi3(i32, i32)
@@ -1880,9 +1886,9 @@
; UEFI-NEXT: declare i32 @lround(double)
; UEFI-NEXT: declare i32 @lroundf(float)
; UEFI-NEXT: declare noalias noundef ptr @malloc(i64 noundef) [[MALLOC_ATTRS:#[0-9]+]]
-; 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 ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i64) [[ARGMEM_ATTRS:#[0-9]+]]
+; UEFI-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i64) [[ARGMEM_ATTRS]]
+; UEFI-NEXT: declare ptr @memset(ptr returned writeonly, i32, i64) [[ARGMEM_WRITE_ATTRS]]
; UEFI-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; UEFI-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; UEFI-NEXT: declare double @nan(ptr)
@@ -1921,7 +1927,9 @@
; UEFI-NEXT: declare float @tgammaf(float)
; UEFI-NEXT: declare double @trunc(double)
; UEFI-NEXT: declare float @truncf(float)
-; UEFI-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; UEFI-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; UEFI-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; UEFI-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
+; 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 [[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 [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; UEFI-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
More information about the llvm-branch-commits
mailing list