[funcattrs] Infer nosync from readnone and non-convergent

[reames]

Summary

This implements the most basic possible nosync inference. The choice of inference rule is taken from the comments in attributor and the discussion on the review of the change which introduced the nosync attribute (0626367202c).

This is deliberately minimal. As noted in code comments, I do plan to add a more robust inference which actually scans the function IR directly, but a) I need to do some refactoring of the attributor code to use common interfaces, and b) I wanted to get something in. I also wanted to minimize the "interesting" analysis discussion since that's time intensive.

Context: This combines with existing nofree attribute inference to help prove dereferenceability in the ongoing deref-at-point semantics work.

[jdoerfert]

Every time I ask myself why we don't create a lightweight Attributor pass and run it by default instead :(

LGTM.

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

 STATISTIC(NumReadNoneArg, "Number of arguments marked readnone");
 STATISTIC(NumReadOnlyArg, "Number of arguments marked readonly");
 STATISTIC(NumNoAlias, "Number of function returns marked noalias");
 STATISTIC(NumNonNullReturn, "Number of function returns marked nonnull");
 STATISTIC(NumNoRecurse, "Number of functions marked as norecurse");
 STATISTIC(NumNoUnwind, "Number of functions marked as nounwind");
 STATISTIC(NumNoFree, "Number of functions marked as nofree");
 STATISTIC(NumWillReturn, "Number of functions marked as willreturn");
+STATISTIC(NumNoSync, "Number of functions marked as nosync");
 
 static cl::opt<bool> EnableNonnullArgPropagation(
     "enable-nonnull-arg-prop", cl::init(true), cl::Hidden,
     cl::desc("Try to propagate nonnull argument attributes from callsites to "
              "caller functions."));
 
 static cl::opt<bool> DisableNoUnwindInference(
     "disable-nounwind-inference", cl::Hidden,
for (Function *F : SCCNodes) {
     F->setWillReturn();
     NumWillReturn++;
     Changed = true;
   }
 
   return Changed;
 }
 
+// Infer the nosync attribute.  For the moment, the inference is trivial
+// and relies on the readnone attribute already being infered.  This will
+// be replaced with a more robust implementation in the near future.
+static bool addNoSyncAttr(const SCCNodeSet &SCCNodes) {
+  bool Changed = false;
+
+  for (Function *F : SCCNodes) {
+    if (!F || F->hasNoSync())
+      continue;
+
+    // readnone + not convergent implies nosync
+    if (!F->doesNotAccessMemory() || F->isConvergent())
+      continue;
+
+    F->setNoSync();
+    NumNoSync++;
+    Changed = true;
+  }
+
+  return Changed;
+}
+
 static SCCNodesResult createSCCNodeSet(ArrayRef<Function *> Functions) {
   SCCNodesResult Res;
   Res.HasUnknownCall = false;
   for (Function *F : Functions) {
     if (!F || F->hasOptNone() || F->hasFnAttribute(Attribute::Naked)) {
       // Treat any function we're trying not to optimize as if it were an
       // indirect call and omit it from the node set used below.
       Res.HasUnknownCall = true;
static bool deriveAttrsInPostOrder(ArrayRef<Function *> Functions,
   // more precise attributes as well.
   if (!Nodes.HasUnknownCall) {
     Changed |= addNoAliasAttrs(Nodes.SCCNodes);
     Changed |= addNonNullAttrs(Nodes.SCCNodes);
     Changed |= inferAttrsFromFunctionBodies(Nodes.SCCNodes);
     Changed |= addNoRecurseAttrs(Nodes.SCCNodes);
   }
 
+  Changed |= addNoSyncAttr(Nodes.SCCNodes);
+
   return Changed;
 }
 
 PreservedAnalyses PostOrderFunctionAttrsPass::run(LazyCallGraph::SCC &C,
                                                   CGSCCAnalysisManager &AM,
                                                   LazyCallGraph &CG,
                                                   CGSCCUpdateResult &) {
   FunctionAnalysisManager &FAM =

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 nounwind readnone willreturn }
+; CHECK: attributes #0 = { norecurse nosync nounwind readnone willreturn }
 ; CHECK: attributes #1 = { nofree norecurse nounwind willreturn writeonly }
 ; CHECK: attributes #2 = { nounwind readonly }
 ; CHECK: attributes #3 = { nounwind }
-; CHECK: attributes #4 = { nounwind readnone willreturn }
+; CHECK: attributes #4 = { nosync nounwind readnone willreturn }
 ; CHECK: attributes #5 = { nofree nounwind willreturn }
 ; CHECK: attributes #6 = { nofree norecurse 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: readnone
+; AFTER: Function Attrs: 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: readnone
+; AFTER2: Function Attrs: 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: readnone
+; AFTER2: Function Attrs: 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() readnone
+declare void @readnone() nosync readnone
 declare void @unknown()
-declare void @reference_function_pointer(void()*) readnone
+declare void @reference_function_pointer(void()*) 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 = { readnone }
+; CHECK: attributes #0 = { 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() readnone
+declare void @readnone() 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 = { readnone }
+; CHECK: attributes #0 = { nosync readnone }

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 nounwind readnone ssp uwtable willreturn }
+; CHECK: attributes #0 = { 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 nounwind readnone willreturn }
+; CHECK: attributes #0 = { norecurse nosync nounwind readnone willreturn }
 ; CHECK-NOT: attributes

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

 ; RUN: opt -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 nounwind readnone uwtable
+; FNATTR: Function Attrs: 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 nounwind readnone uwtable
+; FNATTR: Function Attrs: 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 nounwind readnone uwtable
+; FNATTR: Function Attrs: 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 nounwind readnone uwtable
+; FNATTR: Function Attrs: 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 readnone speculatable
+; FNATTRS: Function Attrs: 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/norecurse.ll

 ; RUN: opt < %s -basic-aa -function-attrs -rpo-function-attrs -S | FileCheck %s 
 ; RUN: opt < %s -aa-pipeline=basic-aa -passes='cgscc(function-attrs),rpo-function-attrs' -S | FileCheck %s
 
 ; CHECK: Function Attrs
-; CHECK-SAME: norecurse nounwind readnone
+; CHECK-SAME: norecurse nosync nounwind readnone
 ; CHECK-NEXT: define i32 @leaf()
 define i32 @leaf() {
   ret i32 1
 }
 
 ; CHECK: Function Attrs
 ; CHECK-SAME: readnone
 ; CHECK-NOT: norecurse
define void @intrinsic(i8* %dest, i8* %src, i32 %len) {
   ret void
 }
 
 ; CHECK: Function Attrs
 ; CHECK-NEXT: declare void @llvm.memcpy.p0i8.p0i8.i32
 declare void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1)
 
 ; CHECK: Function Attrs
-; CHECK-SAME: norecurse readnone
+; CHECK-SAME: norecurse nosync readnone
 ; FIXME: missing "norecurse"
 ; CHECK-NEXT: define internal i32 @called_by_norecurse()
 define internal i32 @called_by_norecurse() {
   %a = call i32 @k()
   ret i32 %a
 }
 ; CHECK: Function Attrs
 ; CHECK-NEXT: define void @m()
 define void @m() norecurse {
   %a = call i32 @called_by_norecurse()
   ret void
 }
 
 ; CHECK: Function Attrs
-; CHECK-SAME: norecurse readnone
+; CHECK-SAME: norecurse nosync readnone
 ; FIXME: missing "norecurse"
 ; CHECK-NEXT: define internal i32 @called_by_norecurse_indirectly()
 define internal i32 @called_by_norecurse_indirectly() {
   %a = call i32 @k()
   ret i32 %a
 }
 define internal void @o() {
   %a = call i32 @called_by_norecurse_indirectly()
   ret void
 }
 define void @p() norecurse {
   call void @o()
   ret void
 }

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
 
 ; Base case, empty function
 define void @test1() {
-; CHECK: Function Attrs: norecurse nounwind readnone willreturn
+; CHECK: Function Attrs: 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 nounwind readnone willreturn
+; CHECK: Function Attrs: 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 nounwind readnone willreturn
+; CHECK: Function Attrs: 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
 }
 

llvm/test/Transforms/FunctionAttrs/nounwind.ll

 ; RUN: opt < %s -function-attrs -S | FileCheck %s
 
 ; TEST 1
-; CHECK: Function Attrs: norecurse nounwind readnone
+; CHECK: Function Attrs: norecurse nosync nounwind readnone
 ; CHECK-NEXT: define i32 @foo1()
 define i32 @foo1() {
   ret i32 1
 }
 
 ; TEST 2
-; CHECK: Function Attrs: nounwind readnone
+; CHECK: Function Attrs: 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: nounwind readnone
+; CHECK: Function Attrs: 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 nounwind readnone willreturn }
+; CHECK: = { norecurse nosync nounwind readnone willreturn }
 ; CHECK-LABEL: attributes #1
 ; CHECK: = { noinline optnone }

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 nounwind readnone
+; CHECK: Function Attrs: 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 nounwind readnone
+; CHECK: Function Attrs: 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 nounwind readnone
+; CHECK: Function Attrs: 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 nounwind readnone
+; CHECK: Function Attrs: 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 nounwind readnone
+; CHECK: Function Attrs: 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 nounwind readnone
+; CHECK: Function Attrs: 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
 }