tests: add attributes that would normally come from inferattrs

[durin42]

Summary

As my goal is to remove at least _some_ functions from the static list
in MemoryBuiltins.cpp, these tests either need to run inferattrs or
statically declare these attributes to keep passing. A couple of tests
had alternate cases which are no longer meaningful, e.g.
malloc-load-removal.ll.

[nikic]

I think the general preference would be to explicitly add necessary attributes to test cases, rather than running inferattrs. In some of these cases it's not clear to me why the test would need extra attributes, e.g. in case of llvm/test/Transforms/MemCpyOpt/memcpy.ll -- it does test @malloc, but I don't think it needs anything beyond the noalias attribute that's already present.

[durin42]

In D123087#3522318, @nikic wrote:

I think the general preference would be to explicitly add necessary attributes to test cases, rather than running inferattrs. In some of these cases it's not clear to me why the test would need extra attributes, e.g. in case of llvm/test/Transforms/MemCpyOpt/memcpy.ll -- it does test @malloc, but I don't think it needs anything beyond the noalias attribute that's already present.

Done. A couple of variants of some tests became nonsense (as mentioned in the log message) but for the most part this was straightforward. PTAL?

(This also now comes later in the series, since it has to happen after allockind() exists.)

[durin42]

@nikic where do I stand on this series? Am I waiting on you or should I try and rustle up another reviewer?

[nikic]

This looks good, just wondering whether we can reduce to only allocsize for some of these?

llvm/test/Instrumentation/BoundsChecking/simple.ll

11

Do we need more than allocsize for this test?

llvm/test/Transforms/InstCombine/objsize-64.ll

5

Does this and the following test need more than allocsize?

llvm/test/Transforms/LowerConstantIntrinsics/builtin-object-size-phi.ll

8

Does this need more than just allocsize(0)?

llvm/test/Transforms/MemCpyOpt/memcpy.ll

331

Still don't understand why this one would need extra attributes.

[durin42]

llvm/test/Transforms/InstCombine/objsize-64.ll

5

They seem to! If I golf them the tests eventually end up failing later in the series.

llvm/test/Transforms/MemCpyOpt/memcpy.ll

331

I think so that the analysis knows it's an uninitialized block. In any case, if I remove the allockind() the test fails once we're relying on attributes instead of the hard-coded list.

[nikic]

LGTM

llvm/test/Transforms/MemCpyOpt/memcpy.ll

331

Oh duh, we need allockind to allow eliminating the dead malloc call. The allocsize is not necessary.

[nikic]

llvm/test/Transforms/Attributor/heap_to_stack.ll

186

This is missing an allocalign attribute. I think this will avoid the regression of this test in D130107.

[durin42]

Nice catch on the missing allocalign!

llvm/test/Analysis/GlobalsModRef/indirect-global.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -basic-aa -globals-aa -gvn -instcombine -S -enable-unsafe-globalsmodref-alias-results | FileCheck %s
 ; RUN: opt < %s -aa-pipeline=basic-aa,globals-aa -passes="require<globals-aa>,function(gvn,instcombine)" -S -enable-unsafe-globalsmodref-alias-results | FileCheck %s
 ;
 ; Note that this test relies on an unsafe feature of GlobalsModRef. While this
 ; test is correct and safe, GMR's technique for handling this isn't generally.
 
 target datalayout = "p:32:32:32"
 
 @G = internal global i32* null    ; <i32**> [#uses=3]
 
-declare noalias i8* @malloc(i32)
+declare noalias i8* @malloc(i32) allockind("alloc,uninitialized") allocsize(0) inaccessiblememonly
 define void @malloc_init() {
 ; CHECK-LABEL: @malloc_init(
 ; CHECK-NEXT:    [[A:%.*]] = call dereferenceable_or_null(4) i8* @malloc(i32 4)
 ; CHECK-NEXT:    store i8* [[A]], i8** bitcast (i32** @G to i8**), align 4
 ; CHECK-NEXT:    ret void
 ;
   %a = call i8* @malloc(i32 4)
   %A = bitcast i8* %a to i32*
;
   %g2 = load i32*, i32** @G    ; <i32*> [#uses=0]
   %h2 = load i32, i32* %g1    ; <i32> [#uses=1]
   %X = sub i32 %h1, %h2   ; <i32> [#uses=1]
   ret i32 %X
 }
 
 @G2 = internal global i32* null   ; <i32**> [#uses=3]
 
-declare noalias i8* @calloc(i32, i32)
+declare noalias i8* @calloc(i32, i32) allockind("alloc,zeroed") allocsize(0,1) inaccessiblememonly
 define void @calloc_init() {
 ; CHECK-LABEL: @calloc_init(
 ; CHECK-NEXT:    [[A:%.*]] = call dereferenceable_or_null(4) i8* @calloc(i32 4, i32 1)
 ; CHECK-NEXT:    store i8* [[A]], i8** bitcast (i32** @G2 to i8**), align 4
 ; CHECK-NEXT:    ret void
 ;
   %a = call i8* @calloc(i32 4, i32 1)
   %A = bitcast i8* %a to i32*

llvm/test/Instrumentation/BoundsChecking/simple.ll

 ; RUN: opt < %s -passes=bounds-checking -S | FileCheck %s
 target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 @.str = private constant [8 x i8] c"abcdefg\00"   ; <[8 x i8]*>
 
 @.str_as1 = private addrspace(1) constant [8 x i8] c"abcdefg\00"   ; <[8 x i8] addrspace(1)*>
 
 
-declare noalias i8* @malloc(i64) nounwind
-declare noalias i8* @calloc(i64, i64) nounwind
-declare noalias i8* @realloc(i8* nocapture, i64) nounwind
+declare noalias i8* @malloc(i64) nounwind allocsize(0)
+declare noalias i8* @calloc(i64, i64) nounwind allocsize(0,1)
+declare noalias i8* @realloc(i8* nocapture allocptr, i64) nounwind allocsize(1)
 
 ; CHECK: @f1
 define void @f1() nounwind {
   %1 = tail call i8* @malloc(i64 32)
   %2 = bitcast i8* %1 to i32*
   %idx = getelementptr inbounds i32, i32* %2, i64 2
 ; CHECK-NOT: trap
   store i32 3, i32* %idx, align 4

llvm/test/Transforms/Attributor/heap_to_stack.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
 ; RUN: opt -attributor -enable-new-pm=0 -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=5 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM
 ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=8 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM
 ; RUN: opt -attributor-cgscc -enable-new-pm=0 -attributor-manifest-internal  -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_NPM,IS__CGSCC____,IS________OPM,IS__CGSCC_OPM
 ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_OPM,IS__CGSCC____,IS________NPM,IS__CGSCC_NPM
 
-declare noalias i8* @malloc(i64)
+declare noalias i8* @malloc(i64) allockind("alloc,uninitialized") allocsize(0)
 
 declare void @nocapture_func_frees_pointer(i8* nocapture)
 
 declare void @func_throws(...)
 
 declare void @sync_func(i8* %p)
 
 declare void @sync_will_return(i8* %p) willreturn nounwind
 
 declare void @no_sync_func(i8* nocapture %p) nofree nosync willreturn
 
 declare void @nofree_func(i8* nocapture %p) nofree  nosync willreturn
 
 declare void @foo(i32* %p)
 
 declare void @foo_nounw(i32* %p) nounwind nofree
 
 declare void @usei8(i8)
 
 declare i32 @no_return_call() noreturn
 
-declare void @free(i8* nocapture)
+declare void @free(i8* nocapture) allockind("free")
 
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
 
 define void @h2s_value_simplify_interaction(i1 %c, i8* %A) {
 ; IS________OPM-LABEL: define {{[^@]+}}@h2s_value_simplify_interaction
 ; IS________OPM-SAME: (i1 [[C:%.*]], i8* nocapture nofree readnone [[A:%.*]]) {
 ; IS________OPM-NEXT:  entry:
 ; IS________OPM-NEXT:    [[M:%.*]] = tail call noalias align 16 i8* @malloc(i64 noundef 4)
 ; IS________OPM-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
 ; IS________OPM:       t:
 ; IS________OPM-NEXT:    br i1 false, label [[DEAD:%.*]], label [[F2:%.*]]
 ; IS________OPM:       f:
 ; IS________OPM-NEXT:    br label [[J:%.*]]
 ; IS________OPM:       f2:
 ; IS________OPM-NEXT:    [[C1:%.*]] = bitcast i8* [[M]] to i32*
 ; IS________OPM-NEXT:    [[C2:%.*]] = bitcast i32* [[C1]] to i8*
 ; IS________OPM-NEXT:    [[L:%.*]] = load i8, i8* [[C2]], align 16
 ; IS________OPM-NEXT:    call void @usei8(i8 [[L]])
-; IS________OPM-NEXT:    call void @no_sync_func(i8* nocapture nofree noundef align 16 [[C2]]) #[[ATTR5:[0-9]+]]
+; IS________OPM-NEXT:    call void @no_sync_func(i8* nocapture nofree noundef align 16 [[C2]]) #[[ATTR9:[0-9]+]]
 ; IS________OPM-NEXT:    br label [[J]]
 ; IS________OPM:       dead:
 ; IS________OPM-NEXT:    unreachable
 ; IS________OPM:       j:
 ; IS________OPM-NEXT:    [[PHI:%.*]] = phi i8* [ [[M]], [[F]] ], [ null, [[F2]] ]
-; IS________OPM-NEXT:    tail call void @no_sync_func(i8* nocapture nofree noundef align 16 [[PHI]]) #[[ATTR5]]
+; IS________OPM-NEXT:    tail call void @no_sync_func(i8* nocapture nofree noundef align 16 [[PHI]]) #[[ATTR9]]
 ; IS________OPM-NEXT:    ret void
 ;
 ; IS________NPM-LABEL: define {{[^@]+}}@h2s_value_simplify_interaction
 ; IS________NPM-SAME: (i1 [[C:%.*]], i8* nocapture nofree readnone [[A:%.*]]) {
 ; IS________NPM-NEXT:  entry:
 ; IS________NPM-NEXT:    [[M_H2S:%.*]] = alloca i8, i64 4, align 16
 ; IS________NPM-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
 ; IS________NPM:       t:
 ; IS________NPM-NEXT:    br i1 false, label [[DEAD:%.*]], label [[F2:%.*]]
 ; IS________NPM:       f:
 ; IS________NPM-NEXT:    br label [[J:%.*]]
 ; IS________NPM:       f2:
 ; IS________NPM-NEXT:    [[L:%.*]] = load i8, i8* [[M_H2S]], align 16
 ; IS________NPM-NEXT:    call void @usei8(i8 [[L]])
-; IS________NPM-NEXT:    call void @no_sync_func(i8* nocapture nofree noundef align 16 [[M_H2S]]) #[[ATTR6:[0-9]+]]
+; IS________NPM-NEXT:    call void @no_sync_func(i8* nocapture nofree noundef align 16 [[M_H2S]]) #[[ATTR10:[0-9]+]]
 ; IS________NPM-NEXT:    br label [[J]]
 ; IS________NPM:       dead:
 ; IS________NPM-NEXT:    unreachable
 ; IS________NPM:       j:
 ; IS________NPM-NEXT:    [[PHI:%.*]] = phi i8* [ [[M_H2S]], [[F]] ], [ null, [[F2]] ]
-; IS________NPM-NEXT:    tail call void @no_sync_func(i8* nocapture nofree noundef align 16 [[PHI]]) #[[ATTR6]]
+; IS________NPM-NEXT:    tail call void @no_sync_func(i8* nocapture nofree noundef align 16 [[PHI]]) #[[ATTR10]]
 ; IS________NPM-NEXT:    ret void
 ;
 entry:
   %add = add i64 2, 2
   %m = tail call align 16 noalias i8* @malloc(i64 %add)
   br i1 %c, label %t, label %f
 t:
   br i1 false, label %dead, label %f2

 ; IS________NPM-NEXT:    ret void
 ;
   %1 = tail call noalias i8* @malloc(i64 4)
   tail call void @nofree_arg_only(i8* %1, i8* %p)
   tail call void @free(i8* %1)
   ret void
 }
 
-declare noalias i8* @aligned_alloc(i64, i64)
+declare noalias i8* @aligned_alloc(i64, i64) allockind("alloc,uninitialized,aligned") allocsize(1)
 
 define void @test3b(i8* %p) {
 ; IS________OPM-LABEL: define {{[^@]+}}@test3b
 ; IS________OPM-SAME: (i8* nocapture [[P:%.*]]) {
 ; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 noundef 32, i64 noundef 128)
 ; IS________OPM-NEXT:    tail call void @nofree_arg_only(i8* nocapture nofree [[TMP1]], i8* nocapture [[P]])
 ; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture [[TMP1]])
 ; IS________OPM-NEXT:    ret void

 ;
 ; CHECK-SAME; (i8* nocapture [[P:%.*]]) {
   %1 = tail call noalias i8* @aligned_alloc(i64 33, i64 128)
   tail call void @nofree_arg_only(i8* %1, i8* %p)
   tail call void @free(i8* %1)
   ret void
 }
 
-declare noalias i8* @calloc(i64, i64)
+declare noalias i8* @calloc(i64, i64) allockind("alloc,zeroed") allocsize(0,1)
 
 define void @test0() {
 ; IS________OPM-LABEL: define {{[^@]+}}@test0() {
 ; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @calloc(i64 noundef 2, i64 noundef 4)
 ; IS________OPM-NEXT:    tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
 ; IS________OPM-NEXT:    tail call void @free(i8* noalias nocapture [[TMP1]])
 ; IS________OPM-NEXT:    ret void
 ;
6:                                                ; preds = %5, %4
   ret void
 }
 
 ; TEST 7 - free is dead.
 
 define void @test7() {
 ; IS________OPM-LABEL: define {{[^@]+}}@test7() {
 ; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; IS________OPM-NEXT:    [[TMP2:%.*]] = tail call i32 @no_return_call() #[[ATTR3:[0-9]+]]
+; IS________OPM-NEXT:    [[TMP2:%.*]] = tail call i32 @no_return_call() #[[ATTR4:[0-9]+]]
 ; IS________OPM-NEXT:    unreachable
 ;
 ; IS________NPM-LABEL: define {{[^@]+}}@test7() {
 ; IS________NPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    [[TMP1:%.*]] = tail call i32 @no_return_call() #[[ATTR3:[0-9]+]]
+; IS________NPM-NEXT:    [[TMP1:%.*]] = tail call i32 @no_return_call() #[[ATTR4:[0-9]+]]
 ; IS________NPM-NEXT:    unreachable
 ;
   %1 = tail call noalias i8* @malloc(i64 4)
   tail call i32 @no_return_call()
   tail call void @free(i8* %1)
   ret void
 }
 

 
 ; TEST 9 - FIXME: malloc should be converted.
 define void @test9() {
 ; IS________OPM-LABEL: define {{[^@]+}}@test9() {
 ; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
 ; IS________OPM-NEXT:    tail call void @no_sync_func(i8* nocapture nofree [[TMP1]])
 ; IS________OPM-NEXT:    [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
 ; IS________OPM-NEXT:    store i32 10, i32* [[TMP2]], align 4
-; IS________OPM-NEXT:    tail call void @foo_nounw(i32* nofree noundef align 4 [[TMP2]]) #[[ATTR5]]
+; IS________OPM-NEXT:    tail call void @foo_nounw(i32* nofree noundef align 4 [[TMP2]]) #[[ATTR9]]
 ; IS________OPM-NEXT:    tail call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
 ; IS________OPM-NEXT:    ret void
 ;
 ; IS________NPM-LABEL: define {{[^@]+}}@test9() {
 ; IS________NPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
 ; IS________NPM-NEXT:    tail call void @no_sync_func(i8* nocapture nofree [[TMP1]])
 ; IS________NPM-NEXT:    [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
 ; IS________NPM-NEXT:    store i32 10, i32* [[TMP2]], align 4
-; IS________NPM-NEXT:    tail call void @foo_nounw(i32* nofree noundef align 4 [[TMP2]]) #[[ATTR6]]
+; IS________NPM-NEXT:    tail call void @foo_nounw(i32* nofree noundef align 4 [[TMP2]]) #[[ATTR10]]
 ; IS________NPM-NEXT:    tail call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
 ; IS________NPM-NEXT:    ret void
 ;
   %1 = tail call noalias i8* @malloc(i64 4)
   tail call void @no_sync_func(i8* %1)
   %2 = bitcast i8* %1 to i32*
   store i32 10, i32* %2
   %3 = load i32, i32* %2
;
   ret i32 %3
 }
 
 ; TEST 11
 
 define void @test11() {
 ; IS________OPM-LABEL: define {{[^@]+}}@test11() {
 ; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; IS________OPM-NEXT:    tail call void @sync_will_return(i8* [[TMP1]]) #[[ATTR5]]
+; IS________OPM-NEXT:    tail call void @sync_will_return(i8* [[TMP1]]) #[[ATTR9]]
 ; IS________OPM-NEXT:    tail call void @free(i8* nocapture [[TMP1]])
 ; IS________OPM-NEXT:    ret void
 ;
 ; IS________NPM-LABEL: define {{[^@]+}}@test11() {
 ; IS________NPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; IS________NPM-NEXT:    tail call void @sync_will_return(i8* [[DOTH2S]]) #[[ATTR6]]
+; IS________NPM-NEXT:    tail call void @sync_will_return(i8* [[DOTH2S]]) #[[ATTR10]]
 ; IS________NPM-NEXT:    ret void
 ;
   %1 = tail call noalias i8* @malloc(i64 4)
   tail call void @sync_will_return(i8* %1)
   tail call void @free(i8* %1)
   ret void
 }
 
;
   ret void
 }
 
 define void @test16c(i8 %v, i8** %P) {
 ; IS________OPM-LABEL: define {{[^@]+}}@test16c
 ; IS________OPM-SAME: (i8 [[V:%.*]], i8** nocapture nofree writeonly [[P:%.*]]) {
 ; IS________OPM-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
 ; IS________OPM-NEXT:    store i8* [[TMP1]], i8** [[P]], align 8
-; IS________OPM-NEXT:    tail call void @no_sync_func(i8* nocapture nofree [[TMP1]]) #[[ATTR5]]
+; IS________OPM-NEXT:    tail call void @no_sync_func(i8* nocapture nofree [[TMP1]]) #[[ATTR9]]
 ; IS________OPM-NEXT:    tail call void @free(i8* nocapture [[TMP1]])
 ; IS________OPM-NEXT:    ret void
 ;
 ; IS________NPM-LABEL: define {{[^@]+}}@test16c
 ; IS________NPM-SAME: (i8 [[V:%.*]], i8** nocapture nofree writeonly [[P:%.*]]) {
 ; IS________NPM-NEXT:    [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
 ; IS________NPM-NEXT:    store i8* [[DOTH2S]], i8** [[P]], align 8
-; IS________NPM-NEXT:    tail call void @no_sync_func(i8* nocapture nofree [[DOTH2S]]) #[[ATTR6]]
+; IS________NPM-NEXT:    tail call void @no_sync_func(i8* nocapture nofree [[DOTH2S]]) #[[ATTR10]]
 ; IS________NPM-NEXT:    ret void
 ;
   %1 = tail call noalias i8* @malloc(i64 4)
   store i8* %1, i8** %P
   tail call void @no_sync_func(i8* %1) nounwind
   tail call void @free(i8* %1)
   ret void
 }
 
 define void @test16d(i8 %v, i8** %P) {
 ; CHECK-LABEL: define {{[^@]+}}@test16d
 ; CHECK-SAME: (i8 [[V:%.*]], i8** nocapture nofree writeonly [[P:%.*]]) {
 ; CHECK-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
 ; CHECK-NEXT:    store i8* [[TMP1]], i8** [[P]], align 8
 ; CHECK-NEXT:    ret void
 ;
   %1 = tail call noalias i8* @malloc(i64 4)
   store i8* %1, i8** %P
   ret void
 }
 ;.
-; IS________OPM: attributes #[[ATTR0:[0-9]+]] = { nounwind willreturn }
-; IS________OPM: attributes #[[ATTR1:[0-9]+]] = { nofree nosync willreturn }
-; IS________OPM: attributes #[[ATTR2:[0-9]+]] = { nofree nounwind }
-; IS________OPM: attributes #[[ATTR3]] = { noreturn }
-; IS________OPM: attributes #[[ATTR4:[0-9]+]] = { argmemonly nocallback nofree nosync nounwind willreturn }
-; IS________OPM: attributes #[[ATTR5]] = { nounwind }
+; IS________OPM: attributes #[[ATTR0:[0-9]+]] = { allockind("alloc,uninitialized") allocsize(0) }
+; IS________OPM: attributes #[[ATTR1:[0-9]+]] = { nounwind willreturn }
+; IS________OPM: attributes #[[ATTR2:[0-9]+]] = { nofree nosync willreturn }
+; IS________OPM: attributes #[[ATTR3:[0-9]+]] = { nofree nounwind }
+; IS________OPM: attributes #[[ATTR4]] = { noreturn }
+; IS________OPM: attributes #[[ATTR5:[0-9]+]] = { allockind("free") }
+; IS________OPM: attributes #[[ATTR6:[0-9]+]] = { argmemonly nocallback nofree nosync nounwind willreturn }
+; IS________OPM: attributes #[[ATTR7:[0-9]+]] = { allockind("alloc,uninitialized,aligned") allocsize(1) }
+; IS________OPM: attributes #[[ATTR8:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) }
+; IS________OPM: attributes #[[ATTR9]] = { nounwind }
 ;.
-; IS________NPM: attributes #[[ATTR0:[0-9]+]] = { nounwind willreturn }
-; IS________NPM: attributes #[[ATTR1:[0-9]+]] = { nofree nosync willreturn }
-; IS________NPM: attributes #[[ATTR2:[0-9]+]] = { nofree nounwind }
-; IS________NPM: attributes #[[ATTR3]] = { noreturn }
-; IS________NPM: attributes #[[ATTR4:[0-9]+]] = { argmemonly nocallback nofree nosync nounwind willreturn }
-; IS________NPM: attributes #[[ATTR5:[0-9]+]] = { argmemonly nofree nounwind willreturn writeonly }
-; IS________NPM: attributes #[[ATTR6]] = { nounwind }
+; IS________NPM: attributes #[[ATTR0:[0-9]+]] = { allockind("alloc,uninitialized") allocsize(0) }
+; IS________NPM: attributes #[[ATTR1:[0-9]+]] = { nounwind willreturn }
+; IS________NPM: attributes #[[ATTR2:[0-9]+]] = { nofree nosync willreturn }
+; IS________NPM: attributes #[[ATTR3:[0-9]+]] = { nofree nounwind }
+; IS________NPM: attributes #[[ATTR4]] = { noreturn }
+; IS________NPM: attributes #[[ATTR5:[0-9]+]] = { allockind("free") }
+; IS________NPM: attributes #[[ATTR6:[0-9]+]] = { argmemonly nocallback nofree nosync nounwind willreturn }
+; IS________NPM: attributes #[[ATTR7:[0-9]+]] = { allockind("alloc,uninitialized,aligned") allocsize(1) }
+; IS________NPM: attributes #[[ATTR8:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) }
+; IS________NPM: attributes #[[ATTR9:[0-9]+]] = { argmemonly nofree nounwind willreturn writeonly }
+; IS________NPM: attributes #[[ATTR10]] = { nounwind }
 ;.

llvm/test/Transforms/Attributor/lowerheap.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
 ; RUN: opt -max-heap-to-stack-size=-1 -attributor -enable-new-pm=0 -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM
 ; RUN: opt -max-heap-to-stack-size=-1 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM
 ; RUN: opt -max-heap-to-stack-size=-1 -attributor-cgscc -enable-new-pm=0 -attributor-manifest-internal  -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_NPM,IS__CGSCC____,IS________OPM,IS__CGSCC_OPM
 ; RUN: opt -max-heap-to-stack-size=-1 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_OPM,IS__CGSCC____,IS________NPM,IS__CGSCC_NPM
 
 declare i64 @subfn(i8*) #0
 
-declare noalias i8* @malloc(i64)
-declare noalias i8* @calloc(i64, i64)
-declare void @free(i8*)
+declare noalias i8* @malloc(i64) allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc"
+declare noalias i8* @calloc(i64, i64) allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc"
+declare void @free(i8*) allockind("free") "alloc-family"="malloc"
 
 define i64 @f(i64 %len) {
 ; IS________OPM-LABEL: define {{[^@]+}}@f
 ; IS________OPM-SAME: (i64 [[LEN:%.*]]) {
 ; IS________OPM-NEXT:  entry:
 ; IS________OPM-NEXT:    [[MEM:%.*]] = call noalias i8* @malloc(i64 [[LEN]])
-; IS________OPM-NEXT:    [[RES:%.*]] = call i64 @subfn(i8* [[MEM]]) #[[ATTR1:[0-9]+]]
+; IS________OPM-NEXT:    [[RES:%.*]] = call i64 @subfn(i8* [[MEM]]) #[[ATTR4:[0-9]+]]
 ; IS________OPM-NEXT:    call void @free(i8* [[MEM]])
 ; IS________OPM-NEXT:    ret i64 [[RES]]
 ;
 ; IS________NPM-LABEL: define {{[^@]+}}@f
 ; IS________NPM-SAME: (i64 [[LEN:%.*]]) {
 ; IS________NPM-NEXT:  entry:
 ; IS________NPM-NEXT:    [[TMP0:%.*]] = alloca i8, i64 [[LEN]], align 1
-; IS________NPM-NEXT:    [[RES:%.*]] = call i64 @subfn(i8* [[TMP0]]) #[[ATTR2:[0-9]+]]
+; IS________NPM-NEXT:    [[RES:%.*]] = call i64 @subfn(i8* [[TMP0]]) #[[ATTR5:[0-9]+]]
 ; IS________NPM-NEXT:    ret i64 [[RES]]
 ;
 entry:
   %mem = call i8* @malloc(i64 %len)
   %res = call i64 @subfn(i8* %mem)
   call void @free(i8* %mem)
   ret i64 %res
 }
 
 
 define i64 @g(i64 %len) {
 ; IS________OPM-LABEL: define {{[^@]+}}@g
 ; IS________OPM-SAME: (i64 [[LEN:%.*]]) {
 ; IS________OPM-NEXT:  entry:
 ; IS________OPM-NEXT:    [[MEM:%.*]] = call noalias i8* @calloc(i64 [[LEN]], i64 noundef 8)
-; IS________OPM-NEXT:    [[RES:%.*]] = call i64 @subfn(i8* [[MEM]]) #[[ATTR1]]
+; IS________OPM-NEXT:    [[RES:%.*]] = call i64 @subfn(i8* [[MEM]]) #[[ATTR4]]
 ; IS________OPM-NEXT:    call void @free(i8* [[MEM]])
 ; IS________OPM-NEXT:    ret i64 [[RES]]
 ;
 ; IS________NPM-LABEL: define {{[^@]+}}@g
 ; IS________NPM-SAME: (i64 [[LEN:%.*]]) {
 ; IS________NPM-NEXT:  entry:
 ; IS________NPM-NEXT:    [[TMP0:%.*]] = mul i64 [[LEN]], 8
 ; IS________NPM-NEXT:    [[TMP1:%.*]] = alloca i8, i64 [[TMP0]], align 1
 ; IS________NPM-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[TMP1]], i8 0, i64 [[TMP0]], i1 false)
-; IS________NPM-NEXT:    [[RES:%.*]] = call i64 @subfn(i8* [[TMP1]]) #[[ATTR2]]
+; IS________NPM-NEXT:    [[RES:%.*]] = call i64 @subfn(i8* [[TMP1]]) #[[ATTR5]]
 ; IS________NPM-NEXT:    ret i64 [[RES]]
 ;
 entry:
   %mem = call i8* @calloc(i64 %len, i64 8)
   %res = call i64 @subfn(i8* %mem)
   call void @free(i8* %mem)
   ret i64 %res
 }
 
 attributes #0 = { nounwind willreturn }
 ;.
 ; IS________OPM: attributes #[[ATTR0:[0-9]+]] = { nounwind willreturn }
-; IS________OPM: attributes #[[ATTR1]] = { nounwind }
+; IS________OPM: attributes #[[ATTR1:[0-9]+]] = { allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; IS________OPM: attributes #[[ATTR2:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc" }
+; IS________OPM: attributes #[[ATTR3:[0-9]+]] = { allockind("free") "alloc-family"="malloc" }
+; IS________OPM: attributes #[[ATTR4]] = { nounwind }
 ;.
 ; IS________NPM: attributes #[[ATTR0:[0-9]+]] = { nounwind willreturn }
-; IS________NPM: attributes #[[ATTR1:[0-9]+]] = { argmemonly nofree nounwind willreturn writeonly }
-; IS________NPM: attributes #[[ATTR2]] = { nounwind }
+; IS________NPM: attributes #[[ATTR1:[0-9]+]] = { allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
+; IS________NPM: attributes #[[ATTR2:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc" }
+; IS________NPM: attributes #[[ATTR3:[0-9]+]] = { allockind("free") "alloc-family"="malloc" }
+; IS________NPM: attributes #[[ATTR4:[0-9]+]] = { argmemonly nofree nounwind willreturn writeonly }
+; IS________NPM: attributes #[[ATTR5]] = { nounwind }
 ;.

llvm/test/Transforms/Coroutines/coro-split-00.ll

 declare void @llvm.coro.resume(i8*)
 declare void @llvm.coro.destroy(i8*)
 
 declare token @llvm.coro.id(i32, i8*, i8*, i8*)
 declare i1 @llvm.coro.alloc(token)
 declare i8* @llvm.coro.begin(token, i8*)
 declare i1 @llvm.coro.end(i8*, i1) 
 
-declare noalias i8* @malloc(i32)
+declare noalias i8* @malloc(i32) allockind("alloc,uninitialized") "alloc-family"="malloc"
 declare void @print(i32)
-declare void @free(i8*) willreturn
+declare void @free(i8*) willreturn allockind("free") "alloc-family"="malloc"
 
 !0 = !{i32 846595819, i8** null}

llvm/test/Transforms/Coroutines/coro-split-hidden.ll

 declare void @llvm.coro.resume(i8*)
 declare void @llvm.coro.destroy(i8*)
 
 declare token @llvm.coro.id(i32, i8*, i8*, i8*)
 declare i1 @llvm.coro.alloc(token)
 declare i8* @llvm.coro.begin(token, i8*)
 declare i1 @llvm.coro.end(i8*, i1)
 
-declare noalias i8* @malloc(i32)
+declare noalias i8* @malloc(i32) allockind("alloc,uninitialized")
 declare void @print(i32)
-declare void @free(i8*) willreturn
+declare void @free(i8*) willreturn allockind("free")

llvm/test/Transforms/Coroutines/no-suspend.ll

 lpad:
   %lpval = landingpad { i8*, i32 }
      cleanup
 
   call void @print(i32 2)
   resume { i8*, i32 } %lpval
 }
 
-declare i8* @malloc(i32)
-declare void @free(i8*) willreturn
+declare i8* @malloc(i32) allockind("alloc,uninitialized") allocsize(0)
+declare void @free(i8*) willreturn allockind("free")
 declare void @print(i32)
 declare void @foo()
 
 declare token @llvm.coro.id(i32, i8*, i8*, i8*)
 declare i1 @llvm.coro.alloc(token)
 declare i32 @llvm.coro.size.i32()
 declare i8* @llvm.coro.begin(token, i8*)
 declare token @llvm.coro.save(i8* %hdl)
 declare i8 @llvm.coro.suspend(token, i1)
 declare i8* @llvm.coro.free(token, i8*)
 declare i1 @llvm.coro.end(i8*, i1)
 
 declare i8* @llvm.coro.subfn.addr(i8*, i8)
 
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1)

llvm/test/Transforms/DeadStoreElimination/2016-07-17-UseAfterFree.ll

; CHECK-NOT: store i32 -1, i32* %addr
   store i32 -1, i32* %addr, align 8
 
 ; CHECK: tail call void @free
   tail call void @free(i8* nonnull %ptr)
   ret void
 }
 
 ; Function Attrs: nounwind
-declare void @free(i8* nocapture) local_unnamed_addr #0
+declare void @free(i8* nocapture allocptr) local_unnamed_addr #0
 
 ; Function Attrs: argmemonly nounwind
 declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1) #1
 
-attributes #0 = { nounwind }
+attributes #0 = { nounwind allockind("free")}
 attributes #1 = { argmemonly nounwind }

llvm/test/Transforms/DeadStoreElimination/calloc-store.ll

 ; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
-declare noalias i8* @calloc(i64, i64) inaccessiblememonly
+declare noalias i8* @calloc(i64, i64) inaccessiblememonly allockind("alloc,zeroed")
 
 define i32* @test1() {
 ; CHECK-LABEL: test1
   %1 = tail call noalias i8* @calloc(i64 1, i64 4)
   %2 = bitcast i8* %1 to i32*
   ; This store is dead and should be removed
   store i32 0, i32* %2, align 4
 ; CHECK-NOT: store i32 0, i32* %2, align 4

llvm/test/Transforms/DeadStoreElimination/free.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
 target datalayout = "e-p:64:64:64"
 
-declare void @free(i8* nocapture)
-declare noalias i8* @malloc(i64)
+declare void @free(i8* nocapture) allockind("free")
+declare noalias i8* @malloc(i64) allockind("alloc,uninitialized")
 
 define void @test(i32* %Q, i32* %P) {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32* [[P:%.*]] to i8*
 ; CHECK-NEXT:    tail call void @free(i8* [[TMP1]]) [[ATTR0:#.*]]
 ; CHECK-NEXT:    ret void
 ;
   %DEAD = load i32, i32* %Q            ; <i32> [#uses=1]

llvm/test/Transforms/DeadStoreElimination/multiblock-malloc-free.ll

if.end5:                                          ; preds = %if.end
   store i32 %bitsNeeded, i32* %bitsNeeded6, align 8
   br label %cleanup
 
 cleanup:                                          ; preds = %entry, %if.end5, %if.then4
   %retval.0 = phi %struct.BitfieldStruct* [ %0, %if.end5 ], [ null, %if.then4 ], [ null, %entry ]
   ret %struct.BitfieldStruct* %retval.0
 }
 
-attributes #0 = { nofree nounwind allocsize(0) }
+attributes #0 = { nofree nounwind allocsize(0) allockind("alloc,uninitialized") }
 attributes #1 = { nofree nounwind }
-attributes #2 = { nounwind }
+attributes #2 = { nounwind allockind("free") }
 attributes #3 = { allocsize(0,1) }
 attributes #4 = { allocsize(0) }
-attributes #5 = { nofree nounwind allocsize(0,1) }
+attributes #5 = { nofree nounwind allocsize(0,1) allockind("alloc,zeroed") }

llvm/test/Transforms/DeadStoreElimination/operand-bundles.ll

define void @test3() {
   ; since it could be observed from the deopt continuation.
   ; CHECK: store i64 1, i64* %s
   store i64 1, i64* %s
   call void @foo() [ "deopt"(i64* %s) ]
   store i64 0, i64* %s
   ret void
 }
 
-declare noalias i8* @calloc(i64, i64) inaccessiblememonly
+declare noalias i8* @calloc(i64, i64) inaccessiblememonly allockind("alloc,zeroed")
 
 define void @test4() {
 ; CHECK-LABEL: @test4
   %local_obj = call i8* @calloc(i64 1, i64 4)
   call void @foo() ["deopt" (i8* %local_obj)]
   store i8 0, i8* %local_obj, align 4
   ; CHECK-NOT: store i8 0, i8* %local_obj, align 4
   call void @bar(i8* nocapture %local_obj)
   ret void
 }

llvm/test/Transforms/DeadStoreElimination/simple.ll

;
   %DEAD2 = add i32 %DEAD, 1
   store i32 %DEAD2, i32 addrspace(1)* %P
   call void @may_unwind()
   store i32 0, i32 addrspace(1)* %P
   ret i32 addrspace(1)* %P
 }
 
 
-declare noalias i8* @malloc(i64) willreturn
+declare noalias i8* @malloc(i64) willreturn allockind("alloc,uninitialized")
 declare noalias i8* @custom_malloc(i32) willreturn
-declare noalias i8* @calloc(i32, i32) willreturn
+declare noalias i8* @calloc(i32, i32) willreturn allockind("alloc,zeroed")
 
 define void @test14(i32* %Q) {
 ; CHECK-LABEL: @test14(
 ; CHECK-NEXT:    ret void
 ;
   %P = alloca i32
   %DEAD = load i32, i32* %Q
   store i32 %DEAD, i32* %P
entry:
   %Pc = load i8*, i8** %0, align 8
   %Qc = bitcast i32* %Q to i8*
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 4 %Ac, i8* align 4 %Qc, i64 4, i1 false)
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %Pc, i8* nonnull align 4 %Ac, i64 4, i1 true)
   call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %Ac)
   ret void
 }
 
-declare void @free(i8* nocapture)
+declare void @free(i8* nocapture) allockind("free")
 
 ; We cannot remove `store i32 1, i32* %p`, because @unknown_func may unwind
 ; and the caller may read %p while unwinding.
 define void @test41(i32* noalias %P) {
 ; CHECK-LABEL: @test41(
 ; CHECK-NEXT:    [[P2:%.*]] = bitcast i32* [[P:%.*]] to i8*
 ; CHECK-NEXT:    store i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    call void @unknown_func()

llvm/test/Transforms/GVN/calloc-load-removal.ll

 ; RUN: opt -S -basic-aa -gvn < %s | FileCheck %s
-; RUN: opt -S -basic-aa -gvn -disable-simplify-libcalls < %s | FileCheck %s -check-prefix=CHECK_NO_LIBCALLS
 ; Check that loads from calloc are recognized as being zero.
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 ; Function Attrs: nounwind uwtable
 define i32 @test1() {
   %1 = tail call noalias i8* @calloc(i64 1, i64 4)
   %2 = bitcast i8* %1 to i32*

 ; CHECK-NOT: %3 = load i32, i32* %2, align 4
 ; CHECK: ret i32 0
 
 ; CHECK_NO_LIBCALLS-LABEL: @as_invoke(
 ; CHECK_NO_LIBCALLS: load
 ; CHECK_NO_LIBCALLS: ret i32 %
 }
 
-declare noalias i8* @calloc(i64, i64)
+declare noalias i8* @calloc(i64, i64) allockind("alloc,zeroed") allocsize(0,1)

llvm/test/Transforms/GVN/malloc-load-removal.ll

 ; RUN: opt -S -basic-aa -gvn < %s | FileCheck %s
-; RUN: opt -S -basic-aa -gvn -disable-simplify-libcalls < %s | FileCheck %s -check-prefix=CHECK_NO_LIBCALLS
 ; PR13694
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.8.0"
 
-declare noalias i8* @malloc(i64) nounwind
+declare noalias i8* @malloc(i64) nounwind allockind("alloc,uninitialized") allocsize(0)
 
 define noalias i8* @test1() nounwind uwtable ssp {
 entry:
   %call = tail call i8* @malloc(i64 100) nounwind
   %0 = load i8, i8* %call, align 1
   %tobool = icmp eq i8 %0, 0
   br i1 %tobool, label %if.end, label %if.then
 

 ; CHECK-NOT: load
 ; CHECK-NOT: icmp
 
 ; CHECK_NO_LIBCALLS-LABEL: @test2(
 ; CHECK_NO_LIBCALLS: load
 ; CHECK_NO_LIBCALLS: icmp
 }
 
-declare noalias i8* @aligned_alloc(i64, i64) nounwind
+declare noalias i8* @aligned_alloc(i64 allocalign, i64) nounwind allockind("alloc,uninitialized,aligned") allocsize(1)
 
 define noalias i8* @test3() nounwind uwtable ssp {
 entry:
   %call = tail call i8* @aligned_alloc(i64 256, i64 32) nounwind
   %0 = load i8, i8* %call, align 32
   %tobool = icmp eq i8 %0, 0
   br i1 %tobool, label %if.end, label %if.then
 

llvm/test/Transforms/GVN/nonescaping-malloc.ll

entry:
   %tmp2.i = getelementptr inbounds %"struct.llvm::StringRef", %"struct.llvm::StringRef"* %tmp, i64 0, i32 1
   store i64 %tmp1.i, i64* %tmp2.i, align 8
   %tmp1 = call %"struct.llvm::StringMapEntry<void*>"* @_ZN4llvm9StringMapIPvNS_15MallocAllocatorEE16GetOrCreateValueERKNS_9StringRefE(%"struct.llvm::StringMap<void*,llvm::MallocAllocator>"* %X, %"struct.llvm::StringRef"* %tmp) ssp
   ret %"struct.llvm::StringMapEntry<void*>"* %tmp1
 }
 
 declare i64 @strlen(i8* nocapture) nounwind readonly
 
-declare noalias i8* @malloc(i64) nounwind
+declare noalias i8* @malloc(i64) nounwind allockind("alloc,uninitialized") allocsize(0) inaccessiblememonly
 
 declare i32 @_ZN4llvm13StringMapImpl15LookupBucketForENS_9StringRefE(%"struct.llvm::StringMapImpl"*, i64, i64)
 
 define linkonce_odr %"struct.llvm::StringMapEntry<void*>"* @_ZN4llvm9StringMapIPvNS_15MallocAllocatorEE16GetOrCreateValueERKNS_9StringRefE(%"struct.llvm::StringMap<void*,llvm::MallocAllocator>"* %this, %"struct.llvm::StringRef"* nocapture %Key) ssp align 2 {
 entry:
   %elt = bitcast %"struct.llvm::StringRef"* %Key to i64*
   %val = load i64, i64* %elt
   %tmp = getelementptr inbounds %"struct.llvm::StringRef", %"struct.llvm::StringRef"* %Key, i64 0, i32 1

llvm/test/Transforms/GVN/nonescaping.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -S -basic-aa -gvn 2>&1 | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
 target triple = "x86_64-apple-darwin10.0"
 
-declare noalias i8* @malloc(i64) nounwind
-declare noalias i8* @calloc(i64, i64)
+declare noalias i8* @malloc(i64) nounwind allockind("alloc,uninitialized") allocsize(0) inaccessiblememonly
+declare noalias i8* @calloc(i64, i64) allockind("alloc,zeroed") allocsize(0,1) inaccessiblememonly
 declare noalias i8* @_Znwm(i64)
 declare void @escape(i8*)
 
 define i8 @test_malloc(i8* %p) {
 ; CHECK-LABEL: @test_malloc(
 ; CHECK-NEXT:    [[OBJ:%.*]] = call i8* @malloc(i64 16)
 ; CHECK-NEXT:    call void @escape(i8* [[OBJ]])
 ; CHECK-NEXT:    ret i8 0

llvm/test/Transforms/GlobalOpt/2009-11-16-BrokenPerformHeapAllocSRoA.ll

define void @test() nounwind ssp {
   %3 = mul i64 %2, ptrtoint (%struct.strchartype* getelementptr (%struct.strchartype, %struct.strchartype* null, i64 1) to i64) ; <i64> [#uses=1]
   %4 = tail call i8* @malloc(i64 %3)              ; <i8*> [#uses=1]
 ; CHECK-NOT: call i8* @malloc(i64
   %5 = bitcast i8* %4 to %struct.strchartype*     ; <%struct.strchartype*> [#uses=1]
   store %struct.strchartype* %5, %struct.strchartype** @chartypes, align 8
   ret void
 }
 
-declare noalias i8* @malloc(i64)
+declare noalias i8* @malloc(i64) allockind("alloc,uninitialized")

llvm/test/Transforms/GlobalOpt/2021-08-03-StoreOnceLoadMultiCasts.ll

 ;
 entry:
   %call = call signext i32 @f()
   %0 = load i32*, i32** @g, align 8
   %1 = load i32, i32* %0, align 4
   ret i32 %1
 }
 
-declare noalias align 16 i8* @malloc(i64)
+declare noalias align 16 i8* @malloc(i64) allockind("alloc,uninitialized") allocsize(0)
 declare void @f1()

llvm/test/Transforms/GlobalOpt/calloc-promote.ll

entry:
   %v1 = load i8*, i8** bitcast (i32** @g to i8**), align 8
   store i8 2, i8* %v1, align 4
   call void @f1()
   %v2 = load i32*, i32** @g, align 8
   %res = load i32, i32* %v2, align 4
   ret i32 %res
 }
 
-declare noalias align 16 i8* @calloc(i64, i64)
+declare noalias align 16 i8* @calloc(i64, i64) allockind("alloc,zeroed") allocsize(0,1)
 declare void @f1()

llvm/test/Transforms/GlobalOpt/malloc-promote-1.ll

;
   %malloccall = tail call i8* @malloc(i64 4)
   %P = bitcast i8* %malloccall to i32*
   store i32* %P, i32** @G
   %GV = load i32*, i32** @G
   store i32 0, i32* %GV
   ret void
 }
 
-declare noalias i8* @malloc(i64)
+declare noalias i8* @malloc(i64) allockind("alloc,uninitialized") allocsize(0)
 
 define i32 @get() {
 ; CHECK-LABEL: @get(
 ; CHECK-NEXT:    ret i32 0
 ;
   %GV = load i32*, i32** @G
   %V = load i32, i32* %GV
   ret i32 %V

llvm/test/Transforms/GlobalOpt/malloc-promote-2.ll

;
   %P = bitcast i8* %malloccall to i32*
   store i32* %P, i32** @G
   %GV = load i32*, i32** @G
   %GVe = getelementptr i32, i32* %GV, i32 40
   store i32 20, i32* %GVe
   ret void
 }
 
-declare noalias i8* @malloc(i64)
+declare noalias i8* @malloc(i64) allockind("alloc,uninitialized") allocsize(0)
 
 define void @foo(i64 %Size) nounwind noinline #0 {
 ; CHECK-LABEL: @foo(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %0 = load i32*, i32** @G, align 4
   ret void
 }
 
 attributes #0 = { null_pointer_is_valid }
 ;.
 ; CHECK: attributes #[[ATTR0:[0-9]+]] = { noinline nounwind null_pointer_is_valid }
 ;.

llvm/test/Transforms/GlobalOpt/malloc-promote-4.ll

 ; CHECK-NEXT:    [[TMP1:%.*]] = call fastcc i32 @f1()
 ; CHECK-NEXT:    ret i32 [[TMP1]]
 ;
   store i32* null, i32** @g, align 8
   %1 = call i32 @f1()
   ret i32 %1
 }
 
-declare dso_local noalias i8* @malloc(i64)
+declare dso_local noalias i8* @malloc(i64) allockind("alloc,uninitialized") allocsize(0)

llvm/test/Transforms/GlobalOpt/malloc-promote-5.ll

entry:
   %v1 = load i8*, i8** bitcast (i32** @g to i8**), align 8
   store i8 2, i8* %v1, align 4
   call void @f1()
   %v2 = load i32*, i32** @g, align 8
   %res = load i32, i32* %v2, align 4
   ret i32 %res
 }
 
-declare noalias align 16 i8* @malloc(i64)
+declare noalias align 16 i8* @malloc(i64) allockind("alloc,uninitialized") allocsize(0)
 declare void @f1()

llvm/test/Transforms/GlobalOpt/malloc-promote-opaque-ptr.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals
 ; RUN: opt -S -globalopt -opaque-pointers < %s | FileCheck %s
 
 @g1 = internal global ptr null
 @g2 = internal global ptr null
 @g3 = internal global ptr null
 
-declare noalias i8* @malloc(i64)
+declare noalias i8* @malloc(i64) allockind("alloc,uninitialized") allocsize(0)
 
 ;.
 ; CHECK: @[[G1_BODY_0:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr global i64 undef
 ; CHECK: @[[G2_BODY_0:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr global i32 undef
 ; CHECK: @[[G2_BODY_1:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr global i32 undef
 ; CHECK: @[[G2_BODY_2:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr global i32 undef
 ; CHECK: @[[G3_BODY:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr global [8 x i8] undef
 ;.

llvm/test/Transforms/GlobalOpt/null-check-is-use-pr35760.ll

 7:                                                ; preds = %0
   %8 = call i32 @puts(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
   br label %9
 
 9:                                                ; preds = %7, %3
   ret void
 }
 
-declare dso_local noalias i8* @malloc(i64)
+declare dso_local noalias i8* @malloc(i64) inaccessiblememonly allockind("alloc,uninitialized") allocsize(0)
 
 declare dso_local i32 @puts(i8* nocapture readonly)

llvm/test/Transforms/InstCombine/alloc-realloc-free.ll

 }
 
 declare dso_local noalias noundef i8* @malloc(i64 noundef) local_unnamed_addr #1
 declare dso_local noalias noundef i8* @realloc(i8* nocapture, i64 noundef) local_unnamed_addr #2
 declare dso_local void @free(i8* nocapture noundef) local_unnamed_addr #2
 declare void @llvm.dbg.value(metadata, metadata, metadata) #3
 
 attributes #0 = { mustprogress nounwind uwtable willreturn }
-attributes #1 = { inaccessiblememonly mustprogress nofree nounwind willreturn }
-attributes #2 = { inaccessiblemem_or_argmemonly mustprogress nounwind willreturn }
-attributes #3 = { nofree nosync nounwind readnone speculatable willreturn }
+attributes #1 = { inaccessiblememonly mustprogress nofree nounwind willreturn allockind("alloc,uninitialized") "alloc-family"="malloc" }
+attributes #2 = { inaccessiblemem_or_argmemonly mustprogress nounwind willreturn allockind("realloc") "alloc-family"="malloc" }
+attributes #3 = { nofree nosync nounwind readnone speculatable willreturn allockind("free") "alloc-family"="malloc" }
 attributes #4 = { nounwind }
 

llvm/test/Transforms/InstCombine/badmalloc.ll

 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
 target triple = "x86_64-apple-darwin10.0"
 
-declare noalias i8* @malloc(i64) nounwind
-declare void @free(i8*)
+declare noalias i8* @malloc(i64) nounwind allockind("alloc,uninitialized") "alloc-family"="malloc"
+declare void @free(i8*) allockind("free") "alloc-family"="malloc"
 
 ; PR5130
 define i1 @test1() {
   %A = call noalias i8* @malloc(i64 4) nounwind
   %B = icmp eq i8* %A, null
   store i8 0, i8* %A
 
   call void @free(i8* %A)

llvm/test/Transforms/InstCombine/builtin-dynamic-object-size.ll

entry:
   %select = select i1 %c, i8* %p0, i8* addrspacecast (i8 addrspace(7)* getelementptr (i8, i8 addrspace(7)* @p7, i32 1) to i8*)
   %calc_size = tail call i64 @llvm.objectsize.i64.p0i8(i8* %select, i1 false, i1 true, i1 true)
   ret i64 %calc_size
 }
 
 declare void @bury(i32) local_unnamed_addr #2
 
 ; Function Attrs: nounwind allocsize(0)
-declare i8* @malloc(i64)
+declare i8* @malloc(i64) nounwind allocsize(0) allockind("alloc,uninitialized") "alloc-family"="malloc"
 
 declare i8* @get_unknown_buffer()
 
 ; Function Attrs: nounwind
-declare void @free(i8* nocapture)
+declare void @free(i8* nocapture) nounwind allockind("free") "alloc-family"="malloc"
 
 ; Function Attrs: nounwind readnone speculatable
 declare i64 @llvm.objectsize.i64.p0i8(i8*, i1, i1, i1)
 
 declare void @fortified_chk(i8*, i64)
 
 declare void @unfortified(i8*, i64)

llvm/test/Transforms/InstCombine/compare-unescaped.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
 
 @gp = global i32* null, align 8
 
-declare noalias i8* @malloc(i64)
+declare noalias i8* @malloc(i64) allockind("alloc,uninitialized") allocsize(0)
 
 define i1 @compare_global_trivialeq() {
 ; CHECK-LABEL: @compare_global_trivialeq(
 ; CHECK-NEXT:    ret i1 false
 ;
   %m = call i8* @malloc(i64 4)
   %bc = bitcast i8* %m to i32*
   %lgp = load i32*, i32** @gp, align 8

llvm/test/Transforms/InstCombine/deref-alloc-fns.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=instcombine  -S < %s | FileCheck %s
 ; RUN: opt -mtriple=x86_64-unknown-linux-gnu < %s -passes=instcombine -S | FileCheck %s --check-prefixes=CHECK,GNU
 
 
-declare noalias i8* @malloc(i64)
-declare noalias i8* @calloc(i64, i64)
-declare noalias i8* @realloc(i8* nocapture, i64)
+declare noalias i8* @malloc(i64) allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc"
+declare noalias i8* @calloc(i64, i64) allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc"
+declare noalias i8* @realloc(i8* nocapture, i64) allockind("realloc") allocsize(1) "alloc-family"="malloc"
 declare noalias nonnull i8* @_Znam(i64) ; throwing version of 'new'
 declare noalias nonnull i8* @_Znwm(i64) ; throwing version of 'new'
 declare noalias i8* @strdup(i8*)
-declare noalias i8* @aligned_alloc(i64, i64)
+declare noalias i8* @aligned_alloc(i64 allocalign, i64) allockind("alloc,uninitialized,aligned") allocsize(1) "alloc-family"="malloc"
 declare noalias align 16 i8* @memalign(i64, i64)
 ; new[](unsigned int, align_val_t)
 declare noalias i8* @_ZnajSt11align_val_t(i64 %size, i64 %align)
 
 @.str = private unnamed_addr constant [6 x i8] c"hello\00", align 1
 
 define noalias i8* @malloc_nonconstant_size(i64 %n) {
 ; CHECK-LABEL: @malloc_nonconstant_size(

llvm/test/Transforms/InstCombine/getelementptr.ll

 define i32 @test27(%struct.compat_siginfo* %to, %struct.siginfo_t* %from) {
 ; CHECK-LABEL: @test27(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[FROM_ADDR:%.*]] = alloca %struct.siginfo_t*, align 8
 ; CHECK-NEXT:    [[T344:%.*]] = load %struct.siginfo_t*, %struct.siginfo_t** [[FROM_ADDR]], align 8
 ; CHECK-NEXT:    [[T349:%.*]] = getelementptr [[STRUCT_SIGINFO_T:%.*]], %struct.siginfo_t* [[T344]], i64 0, i32 3, i32 0, i32 3, i32 0
 ; CHECK-NEXT:    [[T349350:%.*]] = bitcast i8** [[T349]] to i32*
 ; CHECK-NEXT:    [[T351:%.*]] = load i32, i32* [[T349350]], align 8
-; CHECK-NEXT:    [[T360:%.*]] = call i32 asm sideeffect "...", "=r,ir,*m,i,0,~{dirflag},~{fpsr},~{flags}"(i32 [[T351]], %struct.__large_struct* elementtype([[STRUCT___LARGE_STRUCT:%.*]]) null, i32 -14, i32 0) #[[ATTR0:[0-9]+]]
+; CHECK-NEXT:    [[T360:%.*]] = call i32 asm sideeffect "...", "=r,ir,*m,i,0,~{dirflag},~{fpsr},~{flags}"(i32 [[T351]], %struct.__large_struct* elementtype(%struct.__large_struct) null, i32 -14, i32 0) #[[ATTR0:[0-9]+]]
 ; CHECK-NEXT:    unreachable
 ;
 entry:
   %from_addr = alloca %struct.siginfo_t*
   %t344 = load %struct.siginfo_t*, %struct.siginfo_t** %from_addr, align 8
   %t345 = getelementptr %struct.siginfo_t, %struct.siginfo_t* %t344, i32 0, i32 3
   %t346 = getelementptr { { i32, i32, [0 x i8], %struct.sigval_t, i32 }, [88 x i8] }, { { i32, i32, [0 x i8], %struct.sigval_t, i32 }, [88 x i8] }* %t345, i32 0, i32 0
   %t346347 = bitcast { i32, i32, [0 x i8], %struct.sigval_t, i32 }* %t346 to { i32, i32, %struct.sigval_t }*
;
   %c2_next = getelementptr inbounds i64, i64* %c2, i64 %offset
   %ptrtoint1 = ptrtoint i8* %c1 to i64
   %ptrtoint2 = ptrtoint i64* %c2_next to i64
   %sub = sub i64 %ptrtoint2, %ptrtoint1 ; C2 - C1
   %gep = getelementptr inbounds i8, i8* %c1, i64 %sub ; C1 + (C2 - C1)
   ret i8* %gep
 }
 
-declare noalias i8* @malloc(i64) nounwind
+declare noalias i8* @malloc(i64) nounwind allockind("alloc,uninitialized") allocsize(0)
 
 define i32 @test_gep_bitcast_malloc(%struct.A* %a) {
 ; CHECK-LABEL: @test_gep_bitcast_malloc(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CALL:%.*]] = call noalias dereferenceable_or_null(16) i8* @malloc(i64 16)
 ; CHECK-NEXT:    [[B:%.*]] = bitcast i8* [[CALL]] to %struct.A*
 ; CHECK-NEXT:    [[G3:%.*]] = getelementptr [[STRUCT_A:%.*]], %struct.A* [[B]], i64 0, i32 2
 ; CHECK-NEXT:    [[A_C:%.*]] = load i32, i32* [[G3]], align 4

llvm/test/Transforms/InstCombine/malloc-free-mismatched.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
 define dso_local i32 @_Z6answeri(i32 %0) {
 ; CHECK-LABEL: @_Z6answeri(
-; CHECK-NEXT:    [[TMP2:%.*]] = call noalias nonnull dereferenceable(80) i8* @_Znam(i64 80) #[[ATTR1:[0-9]+]]
+; CHECK-NEXT:    [[TMP2:%.*]] = call noalias nonnull dereferenceable(80) i8* @_Znam(i64 80) #[[ATTR2:[0-9]+]]
 ; CHECK-NEXT:    call void @free(i8* [[TMP2]])
 ; CHECK-NEXT:    ret i32 42
 ;
   %2 = call noalias nonnull i8* @_Znam(i64 80) #0
   call void @free(i8* %2)
   ret i32 42
 }
 
 ; All we care about with this function is that LLVM doesn't crash
 ; when optimizing it.
 define void @test_alloca() {
   %1 = alloca i8
   call void @free(i8* %1)
   ret void
 }
 
 ; Function Attrs: nobuiltin allocsize(0)
 declare dso_local nonnull i8* @_Znam(i64) #1
 
 ; Function Attrs: nounwind
-declare dso_local void @free(i8*)
+declare dso_local void @free(i8*) allockind("free") "alloc-family"="malloc"
 
 attributes #0 = { builtin allocsize(0) }
-attributes #1 = { nobuiltin allocsize(0) }
+attributes #1 = { nobuiltin allocsize(0) allockind("alloc,uninitialized") "alloc-family"="_Znam" }

llvm/test/Transforms/InstCombine/malloc-free.ll

 ; CHECK-NEXT:    ret i32 0
 ;
   %aligned_allocation = tail call i8* @aligned_alloc(i32 %alignment, i32 %size)
   store i8 %value, i8* %aligned_allocation
   tail call void @free(i8* %aligned_allocation)
   ret i32 0
 }
 
-declare noalias i8* @calloc(i32, i32) nounwind
-declare noalias i8* @malloc(i32)
-declare noalias i8* @aligned_alloc(i32, i32)
-declare void @free(i8*)
+declare noalias i8* @calloc(i32, i32) nounwind allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc"
+declare noalias i8* @malloc(i32) allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc"
+declare noalias i8* @aligned_alloc(i32, i32) allockind("alloc,uninitialized,aligned") allocsize(1) "alloc-family"="malloc"
+declare void @free(i8*) allockind("free") "alloc-family"="malloc"
 
 define i1 @foo() {
 ; CHECK-LABEL: @foo(
 ; CHECK-NEXT:    ret i1 false
 ;
   %m = call i8* @malloc(i32 1)
   %z = icmp eq i8* %m, null
   call void @free(i8* %m)

llvm/test/Transforms/InstCombine/malloc_free_delete_nvptx.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
 
 target triple = "nvptx64"
 
 declare void @user(i8*)
-declare i8* @malloc(i64)
-declare void @free(i8*)
+declare i8* @malloc(i64) allockind("alloc,uninitialized") "alloc-family"="malloc" allocsize(0)
+declare void @free(i8*) allockind("free") "alloc-family"="malloc"
 
 ; Ensure the nvptx backend states malloc & free are a thing so we can recognize
 ; so we will optimize them properly. In the test below the malloc-free chain is
 ; useless and we can remove it *if* we know about malloc & free.
 define void @malloc_then_free_not_needed() {
 ; CHECK-LABEL: @malloc_then_free_not_needed(
 ; CHECK-NEXT:    ret void
 ;

llvm/test/Transforms/InstCombine/objsize-64.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
-declare noalias i8* @malloc(i64) nounwind
+declare noalias i8* @malloc(i64) nounwind allockind("alloc,uninitialized") allocsize(0)
 declare noalias nonnull i8* @_Znwm(i64)  ; new(unsigned long)
 declare i32 @__gxx_personality_v0(...)
 declare void @__cxa_call_unexpected(i8*)
 declare i64 @llvm.objectsize.i64(i8*, i1) nounwind readonly
 
 define i64 @f1(i8 **%esc) {
 ; CHECK-LABEL: @f1(
 ; CHECK-NEXT:    [[CALL:%.*]] = call dereferenceable_or_null(4) i8* @malloc(i64 4)

llvm/test/Transforms/InstCombine/objsize.ll

entry:
   %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %0, i1 false, i1 false, i1 false)
   %2 = load i8*, i8** @s, align 8
   %3 = tail call i8* @__memcpy_chk(i8* %0, i8* %2, i32 30, i32 %1) nounwind
   ret void
 }
 
 declare i8* @__memset_chk(i8*, i32, i32, i32) nounwind
 
-declare noalias i8* @malloc(i32) nounwind
+declare noalias i8* @malloc(i32) nounwind allockind("alloc,uninitialized") allocsize(0)
 
 define i32 @test7(i8** %esc) {
 ; CHECK-LABEL: @test7(
 ; CHECK-NEXT:    [[ALLOC:%.*]] = call noalias dereferenceable_or_null(48) i8* @malloc(i32 48) #[[ATTR0]]
 ; CHECK-NEXT:    store i8* [[ALLOC]], i8** [[ESC:%.*]], align 4
 ; CHECK-NEXT:    ret i32 32
 ;
   %alloc = call noalias i8* @malloc(i32 48) nounwind
   store i8* %alloc, i8** %esc
   %gep = getelementptr inbounds i8, i8* %alloc, i32 16
   %objsize = call i32 @llvm.objectsize.i32.p0i8(i8* %gep, i1 false, i1 false, i1 false) nounwind readonly
   ret i32 %objsize
 }
 
-declare noalias i8* @calloc(i32, i32) nounwind
+declare noalias i8* @calloc(i32, i32) nounwind allockind("alloc,zeroed") allocsize(0,1)
 
 define i32 @test8(i8** %esc) {
 ; CHECK-LABEL: @test8(
 ; CHECK-NEXT:    [[ALLOC:%.*]] = call noalias dereferenceable_or_null(35) i8* @calloc(i32 5, i32 7) #[[ATTR0]]
 ; CHECK-NEXT:    store i8* [[ALLOC]], i8** [[ESC:%.*]], align 4
 ; CHECK-NEXT:    ret i32 30
 ;
   %alloc = call noalias i8* @calloc(i32 5, i32 7) nounwind

llvm/test/Transforms/InstCombine/realloc-free.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --scrub-attributes
 ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
 
 define dso_local void @_Z3fooPv(i8* nocapture %0) local_unnamed_addr #0 {
 ; CHECK-LABEL: @_Z3fooPv(
 ; CHECK-NEXT:    tail call void @free(i8* [[TMP0:%.*]])
 ; CHECK-NEXT:    ret void
 ;
-  %2 = tail call align 16 dereferenceable_or_null(6) i8* @realloc(i8* %0, i64 6) #2
-  tail call void @free(i8* %2) #2
+  %2 = tail call align 16 dereferenceable_or_null(6) i8* @realloc(i8* %0, i64 6) #3
+  tail call void @free(i8* %2) #3
   ret void
 }
 
 declare dso_local noalias noundef i8* @realloc(i8* nocapture, i64 noundef) local_unnamed_addr #1
-declare dso_local void @free(i8* nocapture noundef) local_unnamed_addr #1
+declare dso_local void @free(i8* nocapture noundef) local_unnamed_addr #2
 
 attributes #0 = { mustprogress nounwind uwtable willreturn }
-attributes #1 = { inaccessiblemem_or_argmemonly mustprogress nounwind willreturn }
-attributes #2 = { nounwind }
+attributes #1 = { inaccessiblemem_or_argmemonly mustprogress nounwind willreturn allockind("realloc") }
+attributes #2 = { inaccessiblemem_or_argmemonly mustprogress nounwind willreturn allockind("free") }
+attributes #3 = { nounwind }

llvm/test/Transforms/InstCombine/realloc.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
 
-declare i8* @realloc(i8*, i64) #1
-declare noalias i8* @malloc(i64) #1
+declare i8* @realloc(i8* allocptr, i64) allockind("realloc") allocsize(1)
+declare noalias i8* @malloc(i64) allockind("alloc,uninitialized")
 
 
 define i8* @realloc_null_ptr() #0 {
 ; CHECK-LABEL: @realloc_null_ptr(
 ; CHECK-NEXT:    [[MALLOC:%.*]] = call dereferenceable_or_null(100) i8* @malloc(i64 100)
 ; CHECK-NEXT:    ret i8* [[MALLOC]]
 ;
   %call = call i8* @realloc(i8* null, i64 100) #2

llvm/test/Transforms/LowerConstantIntrinsics/builtin-object-size-phi.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -lower-constant-intrinsics  -S < %s | FileCheck %s
 
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
-declare dso_local noalias noundef i8* @malloc(i64 noundef) local_unnamed_addr
+declare dso_local noalias noundef i8* @malloc(i64 noundef) local_unnamed_addr allocsize(0)
 declare i64 @llvm.objectsize.i64.p0i8(i8*, i1 immarg, i1 immarg, i1 immarg)
 
 @buffer = dso_local global [4 x i8] zeroinitializer, align 1
 
 define dso_local i64 @pick_max(i32 noundef %n) local_unnamed_addr {
 ; CHECK-LABEL: @pick_max(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[COND:%.*]] = icmp eq i32 [[N:%.*]], 0

llvm/test/Transforms/LowerConstantIntrinsics/objectsize_basic.ll

 ; CHECK-NEXT:    ret i64 [[TMP5]]
 ;
   %A = alloca i8, i42 %x, align 1
   %G1 = getelementptr i8, i8* %A, i8 17
   %objsize = call i64 @llvm.objectsize.i64(i8* %G1, i1 false, i1 true, i1 true)
   ret i64 %objsize
 }
 
-declare i8* @malloc(i64)
+declare i8* @malloc(i64) allocsize(0)
 
 define i64 @test_objectsize_malloc() {
 ; CHECK-LABEL: @test_objectsize_malloc(
 ; CHECK-NEXT:    [[PTR:%.*]] = call i8* @malloc(i64 16)
 ; CHECK-NEXT:    ret i64 16
 ;
   %ptr = call i8* @malloc(i64 16)
   %objsize = call i64 @llvm.objectsize.i64(i8* %ptr, i1 false, i1 true, i1 true)
   ret i64 %objsize
 }

llvm/test/Transforms/MemCpyOpt/memcpy.ll

;
   %B = getelementptr inbounds i8, i8* %A, i64 2
   tail call void @llvm.memcpy.p0i8.p0i8.i32(i8* %B, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @test8.str, i64 0, i64 0), i32 7, i1 false)
   %C = tail call i8* @malloc(i32 10)
   %D = getelementptr inbounds i8, i8* %C, i64 2
   tail call void @llvm.memcpy.p0i8.p0i8.i32(i8* %D, i8* %B, i32 7, i1 false)
   ret void
 }
 
-declare noalias i8* @malloc(i32) willreturn
+declare noalias i8* @malloc(i32) willreturn allockind("alloc,uninitialized") allocsize(0)
 
 ; rdar://11341081
 %struct.big = type { [50 x i32] }
 
 define void @test9_addrspacecast() nounwind ssp uwtable {
 ; CHECK-LABEL: @test9_addrspacecast(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[B:%.*]] = alloca [[STRUCT_BIG:%.*]], align 4