From 260854bfaf8053cf3663ec0cd5c642e18f1168aa Mon Sep 17 00:00:00 2001 From: Justin Lebar Date: Tue, 9 Feb 2016 23:03:22 +0000 Subject: [PATCH] Add convergent-removing bits to FunctionAttrs pass. Summary: Remove the convergent attribute on any functions which provably do not contain or invoke any convergent functions. After this change, we'll be able to modify clang to conservatively add 'convergent' to all functions when compiling CUDA. Reviewers: jingyue, joker.eph Subscribers: llvm-commits, tra, jhen, hfinkel, resistor, chandlerc, arsenm Differential Revision: http://reviews.llvm.org/D17013 llvm-svn: 260319 --- llvm/include/llvm/IR/Function.h | 3 + llvm/lib/Transforms/IPO/FunctionAttrs.cpp | 63 +++++++++++++ .../Transforms/FunctionAttrs/convergent.ll | 94 +++++++++++++++++++ 3 files changed, 160 insertions(+) create mode 100644 llvm/test/Transforms/FunctionAttrs/convergent.ll diff --git a/llvm/include/llvm/IR/Function.h b/llvm/include/llvm/IR/Function.h index 1ed200f0e183..c00f80fa3aa2 100644 --- a/llvm/include/llvm/IR/Function.h +++ b/llvm/include/llvm/IR/Function.h @@ -339,6 +339,9 @@ public: void setConvergent() { addFnAttr(Attribute::Convergent); } + void setNotConvergent() { + removeFnAttr(Attribute::Convergent); + } /// Determine if the function is known not to recurse, directly or /// indirectly. diff --git a/llvm/lib/Transforms/IPO/FunctionAttrs.cpp b/llvm/lib/Transforms/IPO/FunctionAttrs.cpp index 60cc874d4d4d..2445b7f3c8ab 100644 --- a/llvm/lib/Transforms/IPO/FunctionAttrs.cpp +++ b/llvm/lib/Transforms/IPO/FunctionAttrs.cpp @@ -935,6 +935,68 @@ static bool addNonNullAttrs(const SCCNodeSet &SCCNodes, return MadeChange; } +/// Removes convergent attributes where we can prove that none of the SCC's +/// callees are themselves convergent. Returns true if successful at removing +/// the attribute. +static bool removeConvergentAttrs(const CallGraphSCC &SCC, + const SCCNodeSet &SCCNodes) { + // Determines whether a function can be made non-convergent, ignoring all + // other functions in SCC. (A function can *actually* be made non-convergent + // only if all functions in its SCC can be made convergent.) + auto CanRemoveConvergent = [&] (CallGraphNode *CGN) { + Function *F = CGN->getFunction(); + if (!F) return false; + + if (!F->isConvergent()) return true; + + // Can't remove convergent from declarations. + if (F->isDeclaration()) return false; + + // Don't remove convergent from optnone functions. + if (F->hasFnAttribute(Attribute::OptimizeNone)) + return false; + + // Can't remove convergent if any of F's callees -- ignoring functions in the + // SCC itself -- are convergent. + if (llvm::any_of(*CGN, [&](const CallGraphNode::CallRecord &CR) { + Function *F = CR.second->getFunction(); + return SCCNodes.count(F) == 0 && (!F || F->isConvergent()); + })) + return false; + + // CGN doesn't contain calls to intrinsics, so iterate over all of F's + // callsites, looking for any calls to convergent intrinsics. If we find one, + // F must remain marked as convergent. + auto IsConvergentIntrinsicCall = [](Instruction &I) { + CallSite CS(cast(&I)); + if (!CS) + return false; + Function *Callee = CS.getCalledFunction(); + return Callee && Callee->isIntrinsic() && Callee->isConvergent(); + }; + return !llvm::any_of(*F, [=](BasicBlock &BB) { + return llvm::any_of(BB, IsConvergentIntrinsicCall); + }); + }; + + // We can remove the convergent attr from functions in the SCC if they all can + // be made non-convergent (because they call only non-convergent functions, + // other than each other). + if (!llvm::all_of(SCC, CanRemoveConvergent)) return false; + + // If we got here, all of the SCC's callees are non-convergent, and none of + // the optnone functions in the SCC are marked as convergent. Therefore all + // of the SCC's functions can be marked as non-convergent. + for (CallGraphNode *CGN : SCC) + if (Function *F = CGN->getFunction()) { + if (F->isConvergent()) + DEBUG(dbgs() << "Removing convergent attr from " << F->getName() + << "\n"); + F->setNotConvergent(); + } + return true; +} + static bool setDoesNotRecurse(Function &F) { if (F.doesNotRecurse()) return false; @@ -1011,6 +1073,7 @@ bool PostOrderFunctionAttrs::runOnSCC(CallGraphSCC &SCC) { if (!ExternalNode) { Changed |= addNoAliasAttrs(SCCNodes); Changed |= addNonNullAttrs(SCCNodes, *TLI); + Changed |= removeConvergentAttrs(SCC, SCCNodes); } Changed |= addNoRecurseAttrs(SCC); diff --git a/llvm/test/Transforms/FunctionAttrs/convergent.ll b/llvm/test/Transforms/FunctionAttrs/convergent.ll new file mode 100644 index 000000000000..46370d7bf303 --- /dev/null +++ b/llvm/test/Transforms/FunctionAttrs/convergent.ll @@ -0,0 +1,94 @@ +; RUN: opt < %s -basicaa -functionattrs -rpo-functionattrs -S | FileCheck %s + +; CHECK: Function Attrs +; CHECK-NOT: convergent +; CHECK-NEXT: define i32 @nonleaf() +define i32 @nonleaf() convergent { + %a = call i32 @leaf() + ret i32 %a +} + +; CHECK: Function Attrs +; CHECK-NOT: convergent +; CHECK-NEXT: define i32 @leaf() +define i32 @leaf() convergent { + ret i32 0 +} + +; CHECK: Function Attrs +; CHECK-SAME: convergent +; CHECK-NEXT: declare i32 @k() +declare i32 @k() convergent + +; CHECK: Function Attrs +; CHECK-SAME: convergent +; CHECK-NEXT: define i32 @extern() +define i32 @extern() convergent { + %a = call i32 @k() + ret i32 %a +} + +; CHECK: Function Attrs +; CHECK-SAME: convergent +; CHECK-NEXT: define i32 @call_extern() +define i32 @call_extern() convergent { + %a = call i32 @extern() + ret i32 %a +} + +; CHECK: Function Attrs +; CHECK-SAME: convergent +; CHECK-NEXT: declare void @llvm.cuda.syncthreads() +declare void @llvm.cuda.syncthreads() convergent + +; CHECK: Function Attrs +; CHECK-SAME: convergent +; CHECK-NEXT: define i32 @intrinsic() +define i32 @intrinsic() convergent { + call void @llvm.cuda.syncthreads() + ret i32 0 +} + +@xyz = global i32 ()* null +; CHECK: Function Attrs +; CHECK-SAME: convergent +; CHECK-NEXT: define i32 @functionptr() +define i32 @functionptr() convergent { + %1 = load i32 ()*, i32 ()** @xyz + %2 = call i32 %1() + ret i32 %2 +} + +; CHECK: Function Attrs +; CHECK-NOT: convergent +; CHECK-NEXT: define i32 @recursive1() +define i32 @recursive1() convergent { + %a = call i32 @recursive2() + ret i32 %a +} + +; CHECK: Function Attrs +; CHECK-NOT: convergent +; CHECK-NEXT: define i32 @recursive2() +define i32 @recursive2() convergent { + %a = call i32 @recursive1() + ret i32 %a +} + +; CHECK: Function Attrs +; CHECK-SAME: convergent +; CHECK-NEXT: define i32 @noopt() +define i32 @noopt() convergent optnone noinline { + %a = call i32 @noopt_friend() + ret i32 0 +} + +; A function which is mutually-recursive with a convergent, optnone function +; shouldn't have its convergent attribute stripped. +; CHECK: Function Attrs +; CHECK-SAME: convergent +; CHECK-NEXT: define i32 @noopt_friend() +define i32 @noopt_friend() convergent { + %a = call i32 @noopt() + ret i32 0 +}