[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
Tue Nov 10 18:11:05 PST 2026
https://github.com/arsenm updated https://github.com/llvm/llvm-project/pull/240735
>From ed504d9e43e1eab11e1970bb0d9348db957794b9 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 | 96 ++++++++++++++-----
llvm/include/llvm/IR/RuntimeLibcallsImpl.td | 15 ++-
.../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/m68k.ll | 16 ++--
.../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/ve.ll | 16 ++--
.../Util/DeclareRuntimeLibcalls/windows.ll | 64 +++++++------
22 files changed, 428 insertions(+), 285 deletions(-)
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index 0123afd784cfa2..1576f4b25b05b7 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,77 @@ 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_CHK : RuntimeLibcall<Ptr, [Ptr, Int, SizeT, SizeT]>;
-def MallocFamily : AllocFamilyAttr<"malloc">;
+def MEMSET : RuntimeLibcall<Ptr, [Ptr, Int, SizeT]> {
+ let FnAttrs = CommonFnAttrs;
+ let Memory = ArgMemWriteOnly;
+ let ParamAttrs = [[Returned, WriteOnly]];
+}
-def MALLOC : RuntimeLibcall<Ptr, [SizeT]> {
+def MEMSET_CHK : RuntimeLibcall<Ptr, [Ptr, Int, SizeT, 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 {
@@ -1007,8 +1050,13 @@ 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]>;
@@ -1238,9 +1286,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..338ab2b7972923 100644
--- a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
+++ b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
@@ -159,8 +159,19 @@ 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 +235,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 +244,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 47e966733bcf04..c2d763922aa7ea 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,10 +595,12 @@
; LINUX-NEXT: declare double @trunc(double)
; LINUX-NEXT: declare float @truncf(float)
; LINUX-NEXT: declare fp128 @truncl(fp128)
+; LINUX-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; LINUX-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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
@@ -911,7 +913,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)
@@ -1024,7 +1026,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]+]]
@@ -1088,9 +1090,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)
@@ -1131,10 +1133,12 @@
; DARWIN-NEXT: declare float @tgammaf(float)
; DARWIN-NEXT: declare double @trunc(double)
; DARWIN-NEXT: declare float @truncf(float)
+; DARWIN-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; DARWIN-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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
@@ -1448,7 +1452,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)
@@ -1620,9 +1624,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)
@@ -1661,9 +1665,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
@@ -1977,7 +1983,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)
@@ -2151,9 +2157,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)
@@ -2194,10 +2200,12 @@
; MINGW-NEXT: declare float @tgammaf(float)
; MINGW-NEXT: declare double @trunc(double)
; MINGW-NEXT: declare float @truncf(float)
+; MINGW-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; MINGW-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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
@@ -2515,7 +2523,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)
@@ -2725,9 +2733,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))
@@ -2788,8 +2796,10 @@
; ANDROID-NEXT: declare double @trunc(double)
; ANDROID-NEXT: declare float @truncf(float)
; ANDROID-NEXT: declare fp128 @truncl(fp128)
+; ANDROID-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; ANDROID-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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 abd4d88498f2a9..24d653c50684b1 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,10 +474,12 @@
; 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 [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; SJLJ-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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
@@ -729,7 +731,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)
@@ -903,9 +905,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)
@@ -947,8 +949,10 @@
; 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 [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; DWARF-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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 0c49d6aaf967bf..a9c0b07b8ef54c 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,8 +404,10 @@
; 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 [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; CHECK-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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 2af3bc391437d4..73c1ea6c772d6a 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,10 +550,12 @@
; LINUX-NEXT: declare float @truncf(float)
; LINUX-NEXT: declare fp128 @truncf128(fp128)
; LINUX-NEXT: declare x86_fp80 @truncl(x86_fp80)
+; LINUX-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; LINUX-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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
@@ -772,7 +774,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)
@@ -987,9 +989,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))
@@ -1047,10 +1049,12 @@
; FREEBSD-NEXT: declare double @trunc(double)
; FREEBSD-NEXT: declare float @truncf(float)
; FREEBSD-NEXT: declare x86_fp80 @truncl(x86_fp80)
+; FREEBSD-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; FREEBSD-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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
@@ -1269,7 +1273,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)
@@ -1484,9 +1488,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))
@@ -1544,8 +1548,10 @@
; OPENBSD-NEXT: declare double @trunc(double)
; OPENBSD-NEXT: declare float @truncf(float)
; OPENBSD-NEXT: declare x86_fp80 @truncl(x86_fp80)
+; OPENBSD-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; OPENBSD-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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 01f31f4ab99c53..60f237e99c4976 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,10 +440,12 @@
; 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 [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; CHECK-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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
@@ -662,7 +664,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)
@@ -838,9 +840,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)
@@ -882,7 +884,9 @@
; 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 [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; LINUX-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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/m68k.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/m68k.ll
index 0a3e259c0e060d..26e8007e6ab385 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/m68k.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/m68k.ll
@@ -199,7 +199,7 @@
; M68K-NEXT: declare double @__muldf3(double, double)
; M68K-NEXT: declare i64 @__muldi3(i64, i64)
; M68K-NEXT: declare signext i16 @__mulhi3(i16 signext, i16 signext)
-; M68K-NEXT: declare i32 @__mulosi4(i32, i32, ptr)
+; M68K-NEXT: declare i32 @__mulosi4(i32, i32, ptr noalias nonnull writeonly align 2 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; M68K-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; M68K-NEXT: declare float @__mulsf3(float, float)
; M68K-NEXT: declare i32 @__mulsi3(i32, i32)
@@ -374,9 +374,9 @@
; M68K-NEXT: declare i32 @lround(double)
; M68K-NEXT: declare i32 @lroundf(float)
; M68K-NEXT: declare noalias noundef ptr @malloc(i32 noundef) [[MALLOC_ATTRS:#[0-9]+]]
-; M68K-NEXT: declare ptr @memcpy(ptr, ptr, i32)
-; M68K-NEXT: declare ptr @memmove(ptr, ptr, i32)
-; M68K-NEXT: declare ptr @memset(ptr, i32, i32)
+; M68K-NEXT: declare ptr @memcpy(ptr noalias returned writeonly, ptr noalias readonly captures(none), i32) [[ARGMEM_ATTRS:#[0-9]+]]
+; M68K-NEXT: declare ptr @memmove(ptr returned writeonly, ptr readonly captures(none), i32) [[ARGMEM_ATTRS]]
+; M68K-NEXT: declare ptr @memset(ptr returned writeonly, i32, i32) [[ARGMEM_WRITE_ATTRS]]
; M68K-NEXT: declare double @modf(double, ptr noalias nonnull writeonly align 8 dereferenceable(8))
; M68K-NEXT: declare float @modff(float, ptr noalias nonnull writeonly align 4 dereferenceable(4))
; M68K-NEXT: declare double @nan(ptr)
@@ -415,8 +415,10 @@
; M68K-NEXT: declare float @tgammaf(float)
; M68K-NEXT: declare double @trunc(double)
; M68K-NEXT: declare float @truncf(float)
+; M68K-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; M68K-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; M68K-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
-; M68K-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
-; M68K-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; M68K-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; M68K-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
+; M68K-NEXT: attributes [[MALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite, errnomem: readwrite) "alloc-family"="malloc" }
+; M68K-NEXT: attributes [[ARGMEM_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; M68K-NEXT: attributes [[SQRT_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(errnomem: write) }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/mips.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/mips.ll
index a7560fe40761f9..7b28422e795197 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,10 +452,12 @@
; MIPS32-NEXT: declare float @tgammaf(float)
; MIPS32-NEXT: declare double @trunc(double)
; MIPS32-NEXT: declare float @truncf(float)
+; MIPS32-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; MIPS32-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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
@@ -661,7 +663,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)
@@ -870,9 +872,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))
@@ -933,8 +935,10 @@
; MIPS64-NEXT: declare double @trunc(double)
; MIPS64-NEXT: declare float @truncf(float)
; MIPS64-NEXT: declare fp128 @truncl(fp128)
+; MIPS64-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; MIPS64-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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 da572317a38f25..c40e2d76d1d516 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,8 +457,10 @@
; CHECK-NEXT: declare float @tgammaf(float)
; CHECK-NEXT: declare double @trunc(double)
; CHECK-NEXT: declare float @truncf(float)
+; CHECK-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; CHECK-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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 bcd025ad6b598e..2eb6be5ebc38f0 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,27 +553,33 @@
; 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 [[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 [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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)
@@ -802,7 +808,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)
@@ -1042,8 +1048,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))
@@ -1114,15 +1120,21 @@
; 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 [[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 [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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)
@@ -1354,7 +1366,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)
@@ -1594,9 +1606,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))
@@ -1670,8 +1682,10 @@
; LINUX-NEXT: declare float @truncf(float)
; LINUX-NEXT: declare fp128 @truncf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @truncl(ppc_fp128)
+; LINUX-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; LINUX-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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 e56a7a9b705667..b474913d52c538 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,10 +474,12 @@
; RV32-NEXT: declare double @trunc(double)
; RV32-NEXT: declare float @truncf(float)
; RV32-NEXT: declare fp128 @truncl(fp128)
+; RV32-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; RV32-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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
@@ -683,7 +685,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)
@@ -893,9 +895,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))
@@ -953,8 +955,10 @@
; RV64-NEXT: declare double @trunc(double)
; RV64-NEXT: declare float @truncf(float)
; RV64-NEXT: declare fp128 @truncl(fp128)
+; RV64-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; RV64-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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 377cc5c3a912a5..c445f8fde50e84 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,10 +479,12 @@
; SPARC32-NEXT: declare double @trunc(double)
; SPARC32-NEXT: declare float @truncf(float)
; SPARC32-NEXT: declare fp128 @truncl(fp128)
+; SPARC32-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; SPARC32-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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
@@ -692,7 +694,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)
@@ -901,9 +903,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))
@@ -964,8 +966,10 @@
; SPARC64-NEXT: declare double @trunc(double)
; SPARC64-NEXT: declare float @truncf(float)
; SPARC64-NEXT: declare fp128 @truncl(fp128)
+; SPARC64-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; SPARC64-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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 ad1bde25f7407e..c138171fbca6a5 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,10 +479,12 @@
; LINUX-NEXT: declare double @trunc(double)
; LINUX-NEXT: declare float @truncf(float)
; LINUX-NEXT: declare fp128 @truncl(fp128)
+; LINUX-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; LINUX-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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
@@ -792,7 +794,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)
@@ -1001,9 +1003,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))
@@ -1062,7 +1064,9 @@
; 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 [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; ZOS-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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/ve.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ve.ll
index afdeb37bacbbc0..9d2340859ea93e 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ve.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ve.ll
@@ -206,7 +206,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 signext i32 @__mulosi4(i32 signext, i32 signext, ptr)
+; CHECK-NEXT: declare signext i32 @__mulosi4(i32 signext, i32 signext, ptr noalias nonnull writeonly align 4 dereferenceable(4)) [[ARGMEM_WRITE_ATTRS:#[0-9]+]]
; CHECK-NEXT: declare signext i8 @__mulqi3(i8 signext, i8 signext)
; CHECK-NEXT: declare float @__mulsf3(float, float)
; CHECK-NEXT: declare signext i32 @__mulsi3(i32 signext, i32 signext)
@@ -415,9 +415,9 @@
; CHECK-NEXT: declare i64 @lroundf(float)
; CHECK-NEXT: declare i64 @lroundl(fp128)
; 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 signext, 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 signext, 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 fp128 @modfl(fp128, ptr noalias nonnull writeonly align 16 dereferenceable(16))
@@ -475,8 +475,10 @@
; CHECK-NEXT: declare double @trunc(double)
; CHECK-NEXT: declare float @truncf(float)
; CHECK-NEXT: declare fp128 @truncl(fp128)
+; CHECK-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; CHECK-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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/windows.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/windows.ll
index 1db5138c3ce34c..ad825cac6187b4 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,10 +986,12 @@
; MINGW-NEXT: declare float @truncf(float)
; MINGW-NEXT: declare fp128 @truncf128(fp128)
; MINGW-NEXT: declare x86_fp80 @truncl(x86_fp80)
+; MINGW-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; MINGW-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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
@@ -1207,7 +1211,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)
@@ -1422,9 +1426,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))
@@ -1482,10 +1486,12 @@
; CYGWIN-NEXT: declare double @trunc(double)
; CYGWIN-NEXT: declare float @truncf(float)
; CYGWIN-NEXT: declare x86_fp80 @truncl(x86_fp80)
+; CYGWIN-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; CYGWIN-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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
@@ -1700,7 +1706,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)
@@ -1882,9 +1888,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)
@@ -1923,8 +1929,10 @@
; UEFI-NEXT: declare float @tgammaf(float)
; UEFI-NEXT: declare double @trunc(double)
; UEFI-NEXT: declare float @truncf(float)
+; UEFI-NEXT: attributes [[ARGMEM_WRITE_ATTRS]] = { nocallback nofree nosync nounwind willreturn memory(argmem: write) }
; UEFI-NEXT: attributes [[NORETURN_ATTRS]] = { nofree noreturn nounwind }
-; 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 [[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