From 97a9fd0f0bb09e56451c58319dd4aacb71ba748c Mon Sep 17 00:00:00 2001 From: Justin Lebar Date: Wed, 17 Feb 2016 17:46:41 +0000 Subject: [PATCH] Update langref to indicate that calls may be convergent. Summary: As previously written, only functions could be convergent. But calls need to have a notion of convergence as well. To see why this is important, consider an indirect call. We may or may not want to disable optimizations around it and behave as though we're calling a convergent function -- it depends on the semantics of the language we're compiling. Thus the need for this attr on the call. Reviewers: jingyue, joker.eph Subscribers: llvm-commits, tra, jhen, arsenm, chandlerc, hfinkel, resistor Differential Revision: http://reviews.llvm.org/D17314 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@261111 91177308-0d34-0410-b5e6-96231b3b80d8 --- docs/LangRef.rst | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/docs/LangRef.rst b/docs/LangRef.rst index 2073304f67e..d93ae17434a 100644 --- a/docs/LangRef.rst +++ b/docs/LangRef.rst @@ -1240,15 +1240,24 @@ example: ``convergent`` In some parallel execution models, there exist operations that cannot be made control-dependent on any additional values. We call such operations - ``convergent``, and mark them with this function attribute. + ``convergent``, and mark them with this attribute. + The ``convergent`` attribute may appear on functions or call/invoke + instructions. When it appears on a function, it indicates that calls to + this function should not be made control-dependent on additional values. For example, the intrinsic ``llvm.cuda.syncthreads`` is ``convergent``, so calls to this intrinsic cannot be made control-dependent on additional - values. Other functions may also be marked as convergent; this prevents - the same optimization on those functions. + values. + + When it appears on a call/invoke, the ``convergent`` attribute indicates + that we should treat the call as though we're calling a convergent + function. This is particularly useful on indirect calls; without this we + may treat such calls as though the target is non-convergent. - The optimizer may remove the ``convergent`` attribute when it can prove - that the function does not execute any convergent operations. + The optimizer may remove the ``convergent`` attribute on functions when it + can prove that the function does not execute any convergent operations. + Similarly, the optimizer may remove ``convergent`` on calls/invokes when it + can prove that the call/invoke cannot call a convergent function. ``inaccessiblememonly`` This attribute indicates that the function may only access memory that is not accessible by the module being compiled. This is a weaker form -- 2.11.0