[funcattrs] Add the maximal set of implied attributes to definitions

[reames]

Summary

Have funcattrs expand all implied attributes into the IR. This expands the infrastructure from D100400, but for definitions not declarations this time.

Somewhat subtly, this mostly isn't semantic. Because the accessors did the inference, any client which used the accessor was already getting the stronger result. Clients that directly checked presence of attributes (there are some), will see a stronger result now.

The old behavior can end up quite confusing for two reasons:

• Without this change, we have situations where function-attrs appears to fail when inferring an attribute (as seen by a human reading IR), but that consuming code will see that it should have been implied. As a human trying to sanity check test results and study IR for optimization possibilities, this is exceeding error prone and confusing. (I'll note that I wasted several hours recently because of this.)
• We can have transforms which trigger without the IR appearing (on inspection) to meet the preconditions. This change doesn't prevent this from happening (as the accessors still involve multiple checks), but it should make it less frequent.

I'd argue in favor of deleting the extra checks out of the accessors after this lands, but I want that in it's own review as a) it's purely stylistic, and b) I already know there's some disagreement.

Once this lands, I'm also going to do a cleanup change which will delete some now redundant duplicate predicates in the inference code, but again, that deserves to be a change of it's own.

[nikic]

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

1276

Do I understand right that this is here for declarations that have been annotated as __attribute___((readonly))? Rather than handling it here, maybe this should be done in InferFunctionAttrsPass? It currently only handles libcalls, but I think it fits there conceptually.

[reames]

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

1276

I agree with this suggestion, and will reformulate the patch to that effect.

[reames]

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

1276

This suggestion is now implemented and ready for review (https://reviews.llvm.org/D100400).

Once that lands, I'll rewrite this patch using the function introduced there. (We have the same problem for non-declarations when our logic for inference is not equally strong.)

[reames]

Adjust patch and description to be in line with the direction suggested by reviewer, and started in D100400.

[reames]

ping

[nikic]

LGTM

[thopre]

llvm/test/Transforms/FunctionAttrs/2008-09-03-ReadOnly.ll

14–15

I'm getting #0 for both functions. Any idea why that might happen?

[jdoerfert]

llvm/test/Transforms/FunctionAttrs/2008-09-03-ReadOnly.ll

14–15

Random guess: your cmake was not rebuild since we switched to the new-PM and opt defaults to the old one?

[thopre]

llvm/test/Transforms/FunctionAttrs/2008-09-03-ReadOnly.ll

14–15

That's a good guess! We are still using the old PM. Thanks!

llvm/include/llvm/IR/Function.h

public:
   bool isSpeculatable() const {
     return hasFnAttribute(Attribute::Speculatable);
   }
   void setSpeculatable() {
     addFnAttr(Attribute::Speculatable);
   }
 
   /// Determine if the call might deallocate memory.
   bool doesNotFreeMemory() const {
-    return onlyReadsMemory() || hasFnAttribute(Attribute::NoFree);
+    return hasFnAttribute(Attribute::NoFree);
   }
   void setDoesNotFreeMemory() {
     addFnAttr(Attribute::NoFree);
   }
 
   /// Determine if the call can synchroize with other threads
   bool hasNoSync() const {
     return hasFnAttribute(Attribute::NoSync);

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

 static bool InstrBreaksNoFree(Instruction &I, const SCCNodeSet &SCCNodes) {
   CallBase *CB = dyn_cast<CallBase>(&I);
   if (!CB)
     return false;
 
   if (CB->hasFnAttr(Attribute::NoFree))
     return false;
 
+  // readnone/readonly implies nofree
+  // (This helps bootstrap from partially annotated functions)
+  if (CB->onlyReadsMemory())
+    return false;
+
   Function *Callee = CB->getCalledFunction();
   if (!Callee)
     return true;
 
   if (Callee->doesNotFreeMemory())
     return false;
 
   if (SCCNodes.contains(Callee))
AI.registerAttrInference(AttributeInferer::InferenceDescriptor{
           LLVM_DEBUG(dbgs()
                      << "Adding nofree attr to fn " << F.getName() << "\n");
           F.setDoesNotFreeMemory();
           ++NumNoFree;
         },
         /* RequiresExactDefinition= */ true});
 
   // Perform all the requested attribute inference actions.
-  return AI.run(SCCNodes);
+  bool Changed = AI.run(SCCNodes);
+  // readonly implies nofree
+  // (This is here so that we don't have to duplicate the function local
+  //  memory reasoning of the readonly analysis.)
+  for (Function *F : SCCNodes) {
+    if (!F || F->doesNotFreeMemory())
+      continue;
+    if (!F->onlyReadsMemory())
+      continue;
+    F->setDoesNotFreeMemory();
+    NumNoFree++;
+    Changed = true;
+  }
+  return Changed;
 }
 
 static bool addNoRecurseAttrs(const SCCNodeSet &SCCNodes) {
   // Try and identify functions that do not recurse.
 
   // If the SCC contains multiple nodes we know for sure there is recursion.
   if (SCCNodes.size() != 1)
     return false;

llvm/test/Analysis/TypeBasedAliasAnalysis/functionattrs.ll

 define i32 @test3_no(i8* %p) nounwind {
   %t = va_arg i8* %p, i32, !tbaa !2
   ret i32 %t
 }
 
 declare void @callee(i32* %p) nounwind
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8*, i8*, i64, i1) nounwind
 
-; CHECK: attributes #0 = { norecurse nosync nounwind readnone willreturn }
+; CHECK: attributes #0 = { nofree norecurse nosync nounwind readnone willreturn }
 ; CHECK: attributes #1 = { nofree norecurse nosync nounwind willreturn writeonly }
-; CHECK: attributes #2 = { nounwind readonly }
+; CHECK: attributes #2 = { nofree nounwind readonly }
 ; CHECK: attributes #3 = { nounwind }
-; CHECK: attributes #4 = { nosync nounwind readnone willreturn }
+; CHECK: attributes #4 = { nofree nosync nounwind readnone willreturn }
 ; CHECK: attributes #5 = { nofree nosync nounwind willreturn }
 ; CHECK: attributes #6 = { nofree norecurse nosync nounwind willreturn }
 ; CHECK: attributes #7 = { argmemonly nofree nosync nounwind willreturn }
 
 ; Root note.
 !0 = !{ }
 
 ; Invariant memory.
 !1 = !{!3, !3, i64 0, i1 1 }
 ; Not invariant memory.
 !2 = !{!3, !3, i64 0, i1 0 }
 !3 = !{ !"foo", !0 }

llvm/test/Other/cgscc-devirt-iteration.ll

 ; CHECK-LABEL: declare void @unknown(){{ *$}}
 
 ; The @test1 function checks that when we refine an indirect call to a direct
 ; call we revisit the SCC passes to reflect the more precise information. This
 ; is the basic functionality.
 
 define void @test1() {
 ; BEFORE-NOT: Function Attrs
-; AFTER: Function Attrs: nosync readnone
+; AFTER: Function Attrs: nofree nosync readnone
 ; CHECK-LABEL: define void @test1()
 entry:
   %fptr = alloca void ()*
   store void ()* @readnone, void ()** %fptr
   %f = load void ()*, void ()** %fptr
   call void %f()
   ret void
 }

 
 declare void @readnone_with_arg(void ()**) readnone
 ; CHECK: Function Attrs: readnone
 ; CHECK-LABEL: declare void @readnone_with_arg(void ()**)
 
 define void @test2_a(void ()** %ignore) {
 ; BEFORE-NOT: Function Attrs
 ; AFTER1: Function Attrs: readonly
-; AFTER2: Function Attrs: nosync readnone
+; AFTER2: Function Attrs: nofree nosync readnone
 ; BEFORE: define void @test2_a(void ()** %ignore)
 ; AFTER: define void @test2_a(void ()** readnone %ignore)
 entry:
   %f1ptr = alloca void (void ()**)*
   store void (void ()**)* @readnone_with_arg, void (void ()**)** %f1ptr
   %f1 = load void (void ()**)*, void (void ()**)** %f1ptr
   ; This indirect call is the first to be resolved, allowing us to deduce
   ; readonly but not (yet) readnone.
   call void %f1(void ()** %ignore)
 ; CHECK: call void @readnone_with_arg(void ()** %ignore)
 
   ; Bogus call to test2_b to make this a cycle.
   call void @test2_b()
 
   ret void
 }
 
 define void @test2_b() {
 ; BEFORE-NOT: Function Attrs
 ; AFTER1: Function Attrs: readonly
-; AFTER2: Function Attrs: nosync readnone
+; AFTER2: Function Attrs: nofree nosync readnone
 ; CHECK-LABEL: define void @test2_b()
 entry:
   %f2ptr = alloca void ()*
   store void ()* @readnone, void ()** %f2ptr
   ; Call the other function here to prevent forwarding until the SCC has had
   ; function attrs deduced.
   call void @test2_a(void ()** %f2ptr)
 

llvm/test/Other/cgscc-iterate-function-mutation.ll

 ; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(function-attrs,function(simplify-cfg))' -S < %s | FileCheck %s
 
-declare void @readnone() nosync readnone
+declare void @readnone() nofree nosync readnone
 declare void @unknown()
-declare void @reference_function_pointer(void()*) nosync readnone
+declare void @reference_function_pointer(void()*) nofree nosync readnone
 
 ; The @test1_* set of functions checks that when we mutate functions with
 ; simplify-cfg to delete call edges and this ends up splitting both the SCCs
 ; and the RefSCCs that those functions are in, we re-run the CGSCC passes to
 ; observe the refined call graph structure.
 
 ; CHECK: define void @test1_a() {
 define void @test1_a() {

 dead:
   call void @test4_a()
   br label %exit
 
 exit:
   ret void
 }
 
-; CHECK: attributes #0 = { nosync readnone }
+; CHECK: attributes #0 = { nofree nosync readnone }

llvm/test/Other/cgscc-observe-devirt.ll

 ; Make sure that even without some external devirtualization iteration tool,
 ; the CGSCC pass manager correctly observes and re-visits SCCs that change
 ; structure due to devirtualization. We trigger devirtualization here with GVN
 ; which forwards a store through a load and to an indirect call.
 ;
 ; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(function-attrs)' -S < %s | FileCheck %s --check-prefix=BEFORE
 ; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(function-attrs,function(gvn))' -S < %s | FileCheck %s --check-prefix=AFTER
 ;
 ; Also check that adding an extra CGSCC pass after the function update but
 ; without requiring the outer manager to iterate doesn't break any invariant.
 ; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(function-attrs,function(gvn),function-attrs)' -S < %s | FileCheck %s --check-prefix=AFTER
 
-declare void @readnone() nosync readnone
+declare void @readnone() nofree nosync readnone
 declare void @unknown()
 
 ; The @test1_* checks that if we refine an indirect call to a direct call and
 ; in the process change the very structure of the call graph we also revisit
 ; that component of the graph and do so in an up-to-date fashion.
 
 ; BEFORE: define void @test1_a1() {
 ; AFTER: define void @test1_a1() {
define void @test2_b3() {
   store void()* @test2_b2, void()** %fptr
   store void()* @test2_b3, void()** %fptr
   store void()* @test2_b1, void()** %fptr
   %f = load void()*, void()** %fptr
   call void %f()
   ret void
 }
 
-; CHECK: attributes #0 = { nosync readnone }
+; CHECK: attributes #0 = { nofree nosync readnone }

llvm/test/Transforms/FunctionAttrs/2008-09-03-ReadOnly.ll

 ; RUN: opt < %s -basic-aa -function-attrs -S | FileCheck %s
 ; RUN: opt < %s -aa-pipeline=basic-aa -passes=function-attrs -S | FileCheck %s
 
 ; CHECK: define i32 @f() #0
 define i32 @f() {
 entry:
   %tmp = call i32 @e( )
   ret i32 %tmp
 }
 
-; CHECK: declare i32 @e() #0
+; CHECK: declare i32 @e() #1
 declare i32 @e() readonly
 
-; CHECK: attributes #0 = { readonly }
+; CHECK: attributes #0 = { nofree readonly }
+; CHECK: attributes #1 = { readonly }

llvm/test/Transforms/FunctionAttrs/atomic.ll

 ; A function with an Acquire load is not readonly.
 define i32 @test2(i32* %x) uwtable ssp {
 ; CHECK: define i32 @test2(i32* nocapture readonly %x) #1 {
 entry:
   %r = load atomic i32, i32* %x seq_cst, align 4
   ret i32 %r
 }
 
-; CHECK: attributes #0 = { norecurse nosync nounwind readnone ssp uwtable willreturn }
+; CHECK: attributes #0 = { nofree norecurse nosync nounwind readnone ssp uwtable willreturn }
 ; CHECK: attributes #1 = { nofree norecurse nounwind ssp uwtable willreturn }

llvm/test/Transforms/FunctionAttrs/incompatible_fn_attrs.ll

 ; CHECK: define i32* @given_inaccessible_or_argmem_infer_readnone(i32* readnone returned %p) #0 {
 entry:
   ret i32* %p
 }
 
 attributes #0 = { argmemonly }
 attributes #1 = { inaccessiblememonly }
 attributes #2 = { inaccessiblemem_or_argmemonly }
-; CHECK: attributes #0 = { norecurse nosync nounwind readnone willreturn }
+; CHECK: attributes #0 = { nofree norecurse nosync nounwind readnone willreturn }
 ; CHECK-NOT: attributes

llvm/test/Transforms/FunctionAttrs/nofree-attributor.ll

 ; RUN: opt -enable-new-pm=1 -function-attrs --disable-nofree-inference=false -S < %s | FileCheck %s --check-prefix=FNATTR
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; Test cases specifically designed for the "nofree" function attribute.
 ; We use FIXME's to indicate problems and missing attributes.
 
 ; Free functions
 declare void @free(i8* nocapture) local_unnamed_addr #1
 declare noalias i8* @realloc(i8* nocapture, i64) local_unnamed_addr #0
 declare void @_ZdaPv(i8*) local_unnamed_addr #2
 
 
 ; TEST 1 (positive case)
-; FNATTR: Function Attrs: noinline norecurse nosync nounwind readnone uwtable
+; FNATTR: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable
 ; FNATTR-NEXT: define void @only_return()
 define void @only_return() #0 {
     ret void
 }
 
 
 ; TEST 2 (negative case)
 ; Only free

 ; void mutual_recursion1(){
 ;    mutual_recursion2();
 ; }
 ; void mutual_recursion2(){
 ;     mutual_recursion1();
 ; }
 
 
-; FNATTR: Function Attrs: noinline nosync nounwind readnone uwtable
+; FNATTR: Function Attrs: nofree noinline nosync nounwind readnone uwtable
 ; FNATTR-NEXT: define void @mutual_recursion1()
 define void @mutual_recursion1() #0 {
   call void @mutual_recursion2()
   ret void
 }
 
-; FNATTR: Function Attrs: noinline nosync nounwind readnone uwtable
+; FNATTR: Function Attrs: nofree noinline nosync nounwind readnone uwtable
 ; FNATTR-NEXT: define void @mutual_recursion2()
 define void @mutual_recursion2() #0 {
   call void @mutual_recursion1()
   ret void
 }
 
 
 ; TEST 5

 ; TEST 7 (positive case)
 ; Call function declaration with "nofree"
 
 
 ; FNATTR: Function Attrs: nofree noinline nounwind readnone uwtable
 ; FNATTR-NEXT: declare void @nofree_function()
 declare void @nofree_function() nofree readnone #0
 
-; FNATTR: Function Attrs: noinline nosync nounwind readnone uwtable
+; FNATTR: Function Attrs: nofree noinline nosync nounwind readnone uwtable
 ; FNATTR-NEXT: define void @call_nofree_function()
 define void @call_nofree_function() #0 {
     tail call void @nofree_function()
     ret void
 }
 
 ; TEST 8 (negative case)
 ; Call function declaration without "nofree"
define void @call_both() #0 {
     tail call void @maybe_free()
     tail call void @nofree_function()
     ret void
 }
 
 
 ; TEST 10 (positive case)
 ; Call intrinsic function
-; FNATTRS: Function Attrs: noinline nosync readnone speculatable
+; FNATTRS: Function Attrs: nofree noinline nosync readnone speculatable
 ; FNATTRS-NEXT: declare float @llvm.floor.f32(float %0)
 declare float @llvm.floor.f32(float)
 
 ; FNATTRS: Function Attrs: noinline nounwind uwtable
 ; FNATTRS-NEXT: define void @call_floor(float %a)
 ; FIXME: missing nofree
 
 define void @call_floor(float %a) #0 {

llvm/test/Transforms/FunctionAttrs/nofree.ll

entry:
   %0 = bitcast i32* %a to i8*
   tail call void @free(i8* %0) #2
   ret void
 }
 
 declare void @free(i8* nocapture) local_unnamed_addr #2
 
 define i32 @_Z4foo3Pi(i32* nocapture readonly %a) local_unnamed_addr #3 {
-; CHECK: Function Attrs: norecurse nosync nounwind readonly uwtable willreturn
+; CHECK: Function Attrs: nofree norecurse nosync nounwind readonly uwtable willreturn
 ; CHECK-LABEL: @_Z4foo3Pi(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[A:%.*]], align 4
 ; CHECK-NEXT:    ret i32 [[TMP0]]
 ;
 entry:
   %0 = load i32, i32* %a, align 4
   ret i32 %0

llvm/test/Transforms/FunctionAttrs/nosync.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-attributes
 ; RUN: opt < %s -function-attrs -S | FileCheck %s
 ; RUN: opt < %s -passes=function-attrs -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; Base case, empty function
 define void @test1() {
-; CHECK: Function Attrs: norecurse nosync nounwind readnone willreturn
+; CHECK: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:    ret void
 ;
   ret void
 }
 
 ; Show the bottom up walk
 define void @test2() {
-; CHECK: Function Attrs: norecurse nosync nounwind readnone willreturn
+; CHECK: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; CHECK-LABEL: @test2(
 ; CHECK-NEXT:    call void @test1()
 ; CHECK-NEXT:    ret void
 ;
   call void @test1()
   ret void
 }
 
 declare void @unknown() convergent
 
 ; Negative case with convergent function
 define void @test3() convergent {
 ; CHECK: Function Attrs: convergent
 ; CHECK-LABEL: @test3(
 ; CHECK-NEXT:    call void @unknown()
 ; CHECK-NEXT:    ret void
 ;
   call void @unknown()
   ret void
 }
 
 define i32 @test4(i32 %a, i32 %b) {
-; CHECK: Function Attrs: norecurse nosync nounwind readnone willreturn
+; CHECK: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; CHECK-LABEL: @test4(
 ; CHECK-NEXT:    [[ADD:%.*]] = add i32 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i32 [[A]]
 ;
   %add = add i32 %a, %b
   ret i32 %a
 }
 

 ; CHECK-NEXT:    [[TMP2:%.*]] = load atomic i32, i32* [[TMP0:%.*]] acquire, align 4
 ; CHECK-NEXT:    ret i32 [[TMP2]]
 ;
   %2 = load atomic i32, i32* %0 acquire, align 4
   ret i32 %2
 }
 
 define i32 @load_unordered(i32* nocapture readonly %0) norecurse nounwind uwtable {
-; CHECK: Function Attrs: norecurse nosync nounwind readonly uwtable willreturn
+; CHECK: Function Attrs: nofree norecurse nosync nounwind readonly uwtable willreturn
 ; CHECK-LABEL: @load_unordered(
 ; CHECK-NEXT:    [[TMP2:%.*]] = load atomic i32, i32* [[TMP0:%.*]] unordered, align 4
 ; CHECK-NEXT:    ret i32 [[TMP2]]
 ;
   %2 = load atomic i32, i32* %0 unordered, align 4
   ret i32 %2
 }
 
;
   call i32 asm "bswap $0", "=r,r"(i32 %x)
   ret i32 4
 }
 
 declare void @readnone_test() convergent readnone
 
 ; negative. Convergent
 define void @convergent_readnone(){
-; CHECK: Function Attrs: nosync readnone
+; CHECK: Function Attrs: nofree nosync readnone
 ; CHECK-LABEL: @convergent_readnone(
 ; CHECK-NEXT:    call void @readnone_test()
 ; CHECK-NEXT:    ret void
 ;
   call void @readnone_test()
   ret void
 }
 

 ;
   tail call void @llvm.x86.sse2.clflush(i8* bitcast (i32* @a to i8*))
   ret void
 }
 
 declare float @llvm.cos(float %val) readnone
 
 define float @cos_test(float %x) {
-; CHECK: Function Attrs: nosync nounwind readnone willreturn
+; CHECK: Function Attrs: nofree nosync nounwind readnone willreturn
 ; CHECK-LABEL: @cos_test(
 ; CHECK-NEXT:    [[C:%.*]] = call float @llvm.cos.f32(float [[X:%.*]])
 ; CHECK-NEXT:    ret float [[C]]
 ;
   %c = call float @llvm.cos(float %x)
   ret float %c
 }

llvm/test/Transforms/FunctionAttrs/nounwind.ll

 ; RUN: opt < %s -function-attrs -S | FileCheck %s
 
 ; TEST 1
-; CHECK: Function Attrs: norecurse nosync nounwind readnone
+; CHECK: Function Attrs: nofree norecurse nosync nounwind readnone
 ; CHECK-NEXT: define i32 @foo1()
 define i32 @foo1() {
   ret i32 1
 }
 
 ; TEST 2
-; CHECK: Function Attrs: nosync nounwind readnone
+; CHECK: Function Attrs: nofree nosync nounwind readnone
 ; CHECK-NEXT: define i32 @scc1_foo()
 define i32 @scc1_foo() {
   %1 = call i32 @scc1_bar()
   ret i32 1
 }
 
 
 ; TEST 3
-; CHECK: Function Attrs: nosync nounwind readnone
+; CHECK: Function Attrs: nofree nosync nounwind readnone
 ; CHECK-NEXT: define i32 @scc1_bar()
 define i32 @scc1_bar() {
   %1 = call i32 @scc1_foo()
   ret i32 1
 }
 
 ; CHECK: declare i32 @non_nounwind()
 declare i32 @non_nounwind()

llvm/test/Transforms/FunctionAttrs/optnone.ll

; CHECK: (i8* %p) #1 {
   ret void
 }
 
 declare i8 @strlen(i8*) noinline optnone
 ; CHECK-LABEL: @strlen
 ; CHECK: (i8*) #1
 
 ; CHECK-LABEL: attributes #0
-; CHECK: = { norecurse nosync nounwind readnone willreturn }
+; CHECK: = { nofree norecurse nosync nounwind readnone willreturn }
 ; CHECK-LABEL: attributes #1
 ; CHECK: = { noinline optnone }

llvm/test/Transforms/FunctionAttrs/willreturn-callsites.ll

;
   call void @decl_readonly()
   call void @decl_readnone()
   call void @decl_unknown()
   call void @decl_argmemonly(i32* %ptr)
   ret void
 }
 
 define void @test_fn_mustprogress_readonly_calls(i32* %ptr) mustprogress {
-; CHECK: Function Attrs: readonly willreturn mustprogress
+; CHECK: Function Attrs: nofree readonly willreturn mustprogress
 ; CHECK-LABEL: @test_fn_mustprogress_readonly_calls(
 ; CHECK-NOT:     call void @decl_readonly() #
 ; CHECK-NOT:     call void @decl_readnone() #
 ; CHECK:         ret void
 ;
   call void @decl_readonly()
   call void @decl_readnone()
   ret void

llvm/test/Transforms/Inline/cgscc-update.ll

 ; CHECK-NOT: @test1_f()
 define internal void @test1_f(void()* %p) {
 entry:
   call void %p()
   ret void
 }
 
 ; This function should have had 'readnone' deduced for its SCC.
-; CHECK: Function Attrs: noinline nosync nounwind readnone
+; CHECK: Function Attrs: nofree noinline nosync nounwind readnone
 ; CHECK-NEXT: define void @test1_g()
 define void @test1_g() noinline {
 entry:
   call void @test1_f(void()* @test1_h)
   ret void
 }
 
 ; This function should have had 'readnone' deduced for its SCC.
-; CHECK: Function Attrs: noinline nosync nounwind readnone
+; CHECK: Function Attrs: nofree noinline nosync nounwind readnone
 ; CHECK-NEXT: define void @test1_h()
 define void @test1_h() noinline {
 entry:
   call void @test1_g()
   call void @readnone()
   ret void
 }
 
 
 ; The 'test2_' prefixed functions are designed to trigger forming a new direct
 ; call due to RAUW-ing the returned value of a called function into the caller.
 ; This too should form a new SCC which can then be reasoned about to compute
 ; precise function attrs.
 
 ; This function should no longer exist.
 ; CHECK-NOT: @test2_f()
 define internal void()* @test2_f() {
 entry:
   ret void()* @test2_h
 }
 
 ; This function should have had 'readnone' deduced for its SCC.
-; CHECK: Function Attrs: noinline nosync nounwind readnone
+; CHECK: Function Attrs: nofree noinline nosync nounwind readnone
 ; CHECK-NEXT: define void @test2_g()
 define void @test2_g() noinline {
 entry:
   %p = call void()* @test2_f()
   call void %p()
   ret void
 }
 
 ; This function should have had 'readnone' deduced for its SCC.
-; CHECK: Function Attrs: noinline nosync nounwind readnone
+; CHECK: Function Attrs: nofree noinline nosync nounwind readnone
 ; CHECK-NEXT: define void @test2_h()
 define void @test2_h() noinline {
 entry:
   call void @test2_g()
   call void @readnone()
   ret void
 }
 

 
 ; The 'test4_' prefixed functions are designed to trigger forming a new direct
 ; call in the inlined body of the function similar to 'test1_'. However, after
 ; that we continue to inline another edge of the graph forcing us to do a more
 ; interesting call graph update for the new call edge. Eventually, we still
 ; form a new SCC and should use that can deduce precise function attrs.
 
 ; This function should have had 'readnone' deduced for its SCC.
-; CHECK: Function Attrs: noinline nosync nounwind readnone
+; CHECK: Function Attrs: nofree noinline nosync nounwind readnone
 ; CHECK-NEXT: define void @test4_f1()
 define void @test4_f1() noinline {
 entry:
   call void @test4_h()
   ret void
 }
 
 ; CHECK-NOT: @test4_f2
 define internal void @test4_f2() {
 entry:
   call void @test4_f1()
   ret void
 }
 
 ; CHECK-NOT: @test4_g
 define internal void @test4_g(void()* %p) {
 entry:
   call void %p()
   ret void
 }
 
 ; This function should have had 'readnone' deduced for its SCC.
-; CHECK: Function Attrs: noinline nosync nounwind readnone
+; CHECK: Function Attrs: nofree noinline nosync nounwind readnone
 ; CHECK-NEXT: define void @test4_h()
 define void @test4_h() noinline {
 entry:
   call void @test4_g(void()* @test4_f2)
   ret void
 }