Mordante updated this revision to Diff 287264.
Mordante marked 2 inline comments as done.
Mordante added a comment.
Addresses review comments:
- Adds support for c2x using `[[clang::likely]]` and `[[clang::unlikely]]`
- Remove warnings about conflicting likelihoods, except those required by the
Standard
- The attributes can now be placed inside the compound statement in of the
`ThenStmt` and `ElseStmt`
The current implementation matches GCC's behaviour. This behaviour aligns best
with my interpretation of the standard and GCC seems to have the most mature
implementation. I would like to get the current implementation in Clang and
proceed to work on the missing pieces. In parallel we can align with the other
vendors and, if needed, adjust our implementation.
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D85091/new/
https://reviews.llvm.org/D85091
Files:
clang/include/clang/Basic/Attr.td
clang/include/clang/Basic/AttrDocs.td
clang/lib/CodeGen/CGStmt.cpp
clang/lib/CodeGen/CodeGenFunction.cpp
clang/lib/CodeGen/CodeGenFunction.h
clang/lib/Parse/ParseDeclCXX.cpp
clang/lib/Sema/SemaStmtAttr.cpp
clang/test/CodeGenCXX/attr-likelihood-if-branch-weights.cpp
clang/test/Preprocessor/has_attribute.cpp
clang/test/Sema/attr-likelihood.c
clang/test/SemaCXX/attr-likelihood.cpp
clang/www/cxx_status.html
llvm/include/llvm/Transforms/Scalar/LowerExpectIntrinsic.h
llvm/lib/Transforms/Scalar/LowerExpectIntrinsic.cpp
Index: llvm/lib/Transforms/Scalar/LowerExpectIntrinsic.cpp
===================================================================
--- llvm/lib/Transforms/Scalar/LowerExpectIntrinsic.cpp
+++ llvm/lib/Transforms/Scalar/LowerExpectIntrinsic.cpp
@@ -24,7 +24,6 @@
#include "llvm/IR/Metadata.h"
#include "llvm/InitializePasses.h"
#include "llvm/Pass.h"
-#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Transforms/Utils/MisExpect.h"
@@ -48,10 +47,10 @@
// 'select' instructions. It may be worthwhile to hoist these values to some
// shared space, so they can be used directly by other passes.
-static cl::opt<uint32_t> LikelyBranchWeight(
+cl::opt<uint32_t> llvm::LikelyBranchWeight(
"likely-branch-weight", cl::Hidden, cl::init(2000),
cl::desc("Weight of the branch likely to be taken (default = 2000)"));
-static cl::opt<uint32_t> UnlikelyBranchWeight(
+cl::opt<uint32_t> llvm::UnlikelyBranchWeight(
"unlikely-branch-weight", cl::Hidden, cl::init(1),
cl::desc("Weight of the branch unlikely to be taken (default = 1)"));
Index: llvm/include/llvm/Transforms/Scalar/LowerExpectIntrinsic.h
===================================================================
--- llvm/include/llvm/Transforms/Scalar/LowerExpectIntrinsic.h
+++ llvm/include/llvm/Transforms/Scalar/LowerExpectIntrinsic.h
@@ -17,6 +17,7 @@
#include "llvm/IR/Function.h"
#include "llvm/IR/PassManager.h"
+#include "llvm/Support/CommandLine.h"
namespace llvm {
@@ -31,6 +32,8 @@
PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
};
+extern cl::opt<uint32_t> LikelyBranchWeight;
+extern cl::opt<uint32_t> UnlikelyBranchWeight;
}
#endif
Index: clang/www/cxx_status.html
===================================================================
--- clang/www/cxx_status.html
+++ clang/www/cxx_status.html
@@ -987,7 +987,7 @@
<tr>
<td><tt>[[likely]]</tt> and <tt>[[unlikely]]</tt> attributes</td>
<td><a href="https://wg21.link/p0479r5";>P0479R5</a></td>
- <td class="none" align="center">No</td>
+ <td class="none" align="center">Clang 12 (partial)</td>
</tr>
<tr>
<td><tt>typename</tt> optional in more contexts</td>
Index: clang/test/SemaCXX/attr-likelihood.cpp
===================================================================
--- /dev/null
+++ clang/test/SemaCXX/attr-likelihood.cpp
@@ -0,0 +1,132 @@
+// RUN: %clang_cc1 %s -fsyntax-only -verify
+// RUN: %clang_cc1 %s -DPEDANTIC -pedantic -fsyntax-only -verify
+
+#if PEDANTIC
+void g() {
+ if (true)
+ [[likely]] {} // expected-warning {{use of the 'likely' attribute is a C++20 extension}}
+ else
+ [[unlikely]] {} // expected-warning {{use of the 'unlikely' attribute is a C++20 extension}}
+}
+#else
+void a() {
+ if (true)
+ [[likely]] // expected-note {{conflicting attribute is here}}
+ [[unlikely]] // expected-error {{unlikely and likely attributes are not compatible}}
+ ;
+}
+
+void b() {
+ if (true)
+ [[unlikely]] // expected-note {{conflicting attribute is here}}
+ [[likely]] // expected-error {{likely and unlikely attributes are not compatible}}
+ ;
+}
+
+void c() {
+ if (true)
+ [[likely]];
+}
+
+void d() {
+ if (true)
+ [[unlikely]];
+}
+
+void g() {
+ if (true)
+ [[likely]] {}
+ else
+ [[unlikely]] {}
+}
+
+void h() {
+ if (true)
+ [[likely]] {}
+ else {
+ }
+}
+
+void i() {
+ if (true)
+ [[unlikely]] {}
+ else {
+ }
+}
+
+void j() {
+ if (true) {
+ } else
+ [[likely]] {}
+}
+
+void k() {
+ if (true) {
+ } else
+ [[likely]] {}
+}
+
+void l() {
+ if (true)
+ [[likely]] {}
+ else
+ [[unlikely]] if (false) [[likely]] {}
+}
+
+void m() {
+ [[likely]] int x = 42; // expected-error {{'likely' attribute cannot be applied to a declaration}}
+
+ if (x)
+ [[unlikely]] {}
+ if (x) {
+ [[unlikely]];
+ }
+ switch (x) {
+ case 1:
+ [[likely]] {}
+ break;
+ [[likely]] case 2 : case 3 : {}
+ break;
+ }
+
+ do {
+ [[unlikely]];
+ } while (x);
+ do
+ [[unlikely]] {}
+ while (x);
+ do { // expected-note {{to match this 'do'}}
+ }
+ [[unlikely]] while (x); // expected-error {{expected 'while' in do/while loop}}
+ for (;;)
+ [[unlikely]] {}
+ for (;;) {
+ [[unlikely]];
+ }
+ while (x)
+ [[unlikely]] {}
+ while (x) {
+ [[unlikely]];
+ }
+
+ switch (x)
+ [[unlikely]] {}
+
+ if (x)
+ goto lbl;
+
+ // FIXME: allow the attribute on the label
+ [[unlikely]] lbl : // expected-error {{'unlikely' attribute cannot be applied to a declaration}}
+ [[likely]] x = x + 1;
+
+ [[likely]]++ x;
+}
+
+void n() [[likely]] // expected-error {{'likely' attribute cannot be applied to types}}
+{
+ try
+ [[likely]] {} // expected-error {{expected '{'}}
+ catch (...) [[likely]] { // expected-error {{expected expression}}
+ }
+}
+#endif
Index: clang/test/Sema/attr-likelihood.c
===================================================================
--- /dev/null
+++ clang/test/Sema/attr-likelihood.c
@@ -0,0 +1,51 @@
+// RUN: %clang_cc1 %s -fsyntax-only -fdouble-square-bracket-attributes -verify
+
+void g() {
+ if (1)
+ [[clang::likely]] {}
+}
+void m() {
+ [[clang::likely]] int x = 42; // expected-error {{'likely' attribute cannot be applied to a declaration}}
+
+ if (x)
+ [[clang::unlikely]] {}
+ if (x) {
+ [[clang::unlikely]];
+ }
+ switch (x) {
+ case 1:
+ [[clang::likely]] {}
+ break;
+ [[clang::likely]] case 2 : case 3 : {}
+ break;
+ }
+
+ do {
+ [[clang::unlikely]];
+ } while (x);
+ do
+ [[clang::unlikely]] {}
+ while (x);
+ do { // expected-note {{to match this 'do'}}
+ }
+ [[clang::unlikely]] while (x); // expected-error {{expected 'while' in do/while loop}}
+ for (;;)
+ [[clang::unlikely]] {}
+ for (;;) {
+ [[clang::unlikely]];
+ }
+ while (x)
+ [[clang::unlikely]] {}
+ while (x) {
+ [[clang::unlikely]];
+ }
+
+ if (x)
+ goto lbl;
+
+ // FIXME: allow the attribute on the label
+ [[clang::unlikely]] lbl : // expected-error {{'unlikely' attribute cannot be applied to a declaration}}
+ [[clang::likely]] x = x + 1;
+
+ [[clang::likely]]++ x;
+}
Index: clang/test/Preprocessor/has_attribute.cpp
===================================================================
--- clang/test/Preprocessor/has_attribute.cpp
+++ clang/test/Preprocessor/has_attribute.cpp
@@ -62,13 +62,13 @@
// FIXME(201806L) CHECK: ensures: 0
// FIXME(201806L) CHECK: expects: 0
// CHECK: fallthrough: 201603L
-// FIXME(201803L) CHECK: likely: 0
+// FIXME(201803L) CHECK: likely: 2L
// CHECK: maybe_unused: 201603L
// ITANIUM: no_unique_address: 201803L
// WINDOWS: no_unique_address: 0
// CHECK: nodiscard: 201907L
// CHECK: noreturn: 200809L
-// FIXME(201803L) CHECK: unlikely: 0
+// FIXME(201803L) CHECK: unlikely: 2L
// Test for Microsoft __declspec attributes
Index: clang/test/CodeGenCXX/attr-likelihood-if-branch-weights.cpp
===================================================================
--- /dev/null
+++ clang/test/CodeGenCXX/attr-likelihood-if-branch-weights.cpp
@@ -0,0 +1,162 @@
+// RUN: %clang_cc1 -O1 -emit-llvm %s -o - -triple=x86_64-linux-gnu | FileCheck -DLIKELY=2000 -DUNLIKELY=1 %s
+// RUN: %clang_cc1 -O1 -emit-llvm %s -triple=x86_64-linux-gnu -mllvm -likely-branch-weight=99 -mllvm -unlikely-branch-weight=42 -o - | FileCheck -DLIKELY=99 -DUNLIKELY=42 %s
+
+extern volatile bool b;
+extern volatile int i;
+extern bool A();
+extern bool B();
+
+bool f() {
+ // CHECK-LABEL: define zeroext i1 @_Z1fv
+ // CHECK: br {{.*}} !prof !7
+ if (b)
+ [[likely]] {
+ return A();
+ }
+ return B();
+}
+
+bool g() {
+ // CHECK-LABEL: define zeroext i1 @_Z1gv
+ // CHECK: br {{.*}} !prof !8
+ if (b)
+ [[unlikely]] {
+ return A();
+ }
+
+ return B();
+}
+
+bool h() {
+ // CHECK-LABEL: define zeroext i1 @_Z1hv
+ // CHECK: br {{.*}} !prof !8
+ if (b)
+ [[unlikely]] return A();
+
+ return B();
+}
+
+void NullStmt() {
+ // CHECK-LABEL: define{{.*}}NullStmt
+ // CHECK: br {{.*}} !prof !8
+ if (b) {
+ [[unlikely]];
+ } else {
+ // Make sure the branches aren't optimized away.
+ b = true;
+ }
+}
+
+void CompoundStmt() {
+ // CHECK-LABEL: define{{.*}}CompoundStmt
+ // CHECK: br {{.*}} !prof !8
+ if (b) {
+ {
+ [[unlikely]] {}
+ }
+ } else {
+ // Make sure the branches aren't optimized away.
+ b = true;
+ }
+}
+
+void IfStmt() {
+ // CHECK-LABEL: define{{.*}}IfStmt
+ // CHECK: br {{.*}} !prof !8
+ if (b) {
+ [[unlikely]] if (B()) {}
+ }
+ // CHECK-NOT: br {{.*}} !prof
+ // CHECK: br {{.*}} !prof
+ if (b) {
+ if (B())
+ [[unlikely]] { b = false; }
+ }
+}
+
+void WhileStmt() {
+ // CHECK-LABEL: define{{.*}}WhileStmt
+ // CHECK: br {{.*}} !prof !8
+ if (b) {
+ [[unlikely]] while (B()) {}
+ }
+ // CHECK-NOT: br {{.*}} %if.end{{.*}} !prof
+ if (b) {
+ while (B())
+ [[unlikely]] { b = false; }
+ }
+}
+
+void DoStmt() {
+ // CHECK-LABEL: define{{.*}}DoStmt
+ // CHECK: br {{.*}} !prof !8
+ if (b) {
+ [[unlikely]] do {}
+ while (B())
+ ;
+ }
+ // CHECK-NOT: br {{.*}} %if.end{{.*}} !prof
+ if (b) {
+ do
+ [[unlikely]] {}
+ while (B());
+ }
+}
+
+void ForStmt() {
+ // CHECK-LABEL: define{{.*}}ForStmt
+ // CHECK: br {{.*}} !prof !8
+ if (b) {
+ [[unlikely]] for (; B();) {}
+ }
+ // CHECK-NOT: br {{.*}} %if.end{{.*}} !prof
+ if (b) {
+ for (; B();)
+ [[unlikely]] {}
+ }
+}
+
+void GotoStmt() {
+ // CHECK-LABEL: define{{.*}}GotoStmt
+ // CHECK: br {{.*}} !prof !8
+ if (b) {
+ [[unlikely]] goto end;
+ } else {
+ // Make sure the branches aren't optimized away.
+ b = true;
+ }
+end:;
+}
+
+void ReturnStmt() {
+ // CHECK-LABEL: define{{.*}}ReturnStmt
+ // CHECK: br {{.*}} !prof !8
+ if (b) {
+ [[unlikely]] return;
+ } else {
+ // Make sure the branches aren't optimized away.
+ b = true;
+ }
+}
+
+void SwitchStmt() {
+ // CHECK-LABEL: define{{.*}}SwitchStmt
+ // CHECK: br {{.*}} !prof !8
+ if (b) {
+ [[unlikely]] switch (i) {}
+ } else {
+ // Make sure the branches aren't optimized away.
+ b = true;
+ }
+ // CHECK-NOT: br {{.*}} %if.end{{.*}} !prof
+ if (b) {
+ switch (i)
+ [[unlikely]] {}
+ } else {
+ // Make sure the branches aren't optimized away.
+ b = true;
+ }
+}
+
+// CHECK: !7 = !{!"branch_weights", i32 [[UNLIKELY]], i32 [[LIKELY]]}
+// CHECK: !8 = !{!"branch_weights", i32 [[LIKELY]], i32 [[UNLIKELY]]}
Index: clang/lib/Sema/SemaStmtAttr.cpp
===================================================================
--- clang/lib/Sema/SemaStmtAttr.cpp
+++ clang/lib/Sema/SemaStmtAttr.cpp
@@ -210,6 +210,24 @@
return ::new (S.Context) NoMergeAttr(S.Context, A);
}
+static Attr *handleLikely(Sema &S, Stmt *St, const ParsedAttr &A,
+ SourceRange Range) {
+
+ if (!S.getLangOpts().CPlusPlus20 && A.isCXX11Attribute() && !A.getScopeName())
+ S.Diag(A.getLoc(), diag::ext_cxx20_attr) << A << Range;
+
+ return ::new (S.Context) LikelyAttr(S.Context, A);
+}
+
+static Attr *handleUnlikely(Sema &S, Stmt *St, const ParsedAttr &A,
+ SourceRange Range) {
+
+ if (!S.getLangOpts().CPlusPlus20 && A.isCXX11Attribute() && !A.getScopeName())
+ S.Diag(A.getLoc(), diag::ext_cxx20_attr) << A << Range;
+
+ return ::new (S.Context) UnlikelyAttr(S.Context, A);
+}
+
static void
CheckForIncompatibleAttributes(Sema &S,
const SmallVectorImpl<const Attr *> &Attrs) {
@@ -315,6 +333,33 @@
<< CategoryState.NumericAttr->getDiagnosticName(Policy);
}
}
+
+ // C++20 [dcl.attr.likelihood]p1 The attribute-token likely shall not appear
+ // in an attribute-specifier-seq that contains the attribute-token unlikely.
+ const LikelyAttr *Likely = nullptr;
+ const UnlikelyAttr *Unlikely = nullptr;
+ for (const auto *I : Attrs) {
+ if (const auto *Attr = dyn_cast<LikelyAttr>(I)) {
+ if (Unlikely) {
+ S.Diag(Attr->getLocation(), diag::err_attributes_are_not_compatible)
+ << Attr->getSpelling() << Unlikely->getSpelling()
+ << Attr->getRange();
+ S.Diag(Unlikely->getLocation(), diag::note_conflicting_attribute)
+ << Unlikely->getRange();
+ return;
+ }
+ Likely = Attr;
+ } else if (const auto *Attr = dyn_cast<UnlikelyAttr>(I)) {
+ if (Likely) {
+ S.Diag(Attr->getLocation(), diag::err_attributes_are_not_compatible)
+ << Attr->getSpelling() << Likely->getSpelling() << Attr->getRange();
+ S.Diag(Likely->getLocation(), diag::note_conflicting_attribute)
+ << Likely->getRange();
+ return;
+ }
+ Unlikely = Attr;
+ }
+ }
}
static Attr *handleOpenCLUnrollHint(Sema &S, Stmt *St, const ParsedAttr &A,
@@ -377,6 +422,10 @@
return handleSuppressAttr(S, St, A, Range);
case ParsedAttr::AT_NoMerge:
return handleNoMergeAttr(S, St, A, Range);
+ case ParsedAttr::AT_Likely:
+ return handleLikely(S, St, A, Range);
+ case ParsedAttr::AT_Unlikely:
+ return handleUnlikely(S, St, A, Range);
default:
// if we're here, then we parsed a known attribute, but didn't recognize
// it as a statement attribute => it is declaration attribute
Index: clang/lib/Parse/ParseDeclCXX.cpp
===================================================================
--- clang/lib/Parse/ParseDeclCXX.cpp
+++ clang/lib/Parse/ParseDeclCXX.cpp
@@ -4018,6 +4018,8 @@
case ParsedAttr::AT_FallThrough:
case ParsedAttr::AT_CXX11NoReturn:
case ParsedAttr::AT_NoUniqueAddress:
+ case ParsedAttr::AT_Likely:
+ case ParsedAttr::AT_Unlikely:
return true;
case ParsedAttr::AT_WarnUnusedResult:
return !ScopeName && AttrName->getName().equals("nodiscard");
Index: clang/lib/CodeGen/CodeGenFunction.h
===================================================================
--- clang/lib/CodeGen/CodeGenFunction.h
+++ clang/lib/CodeGen/CodeGenFunction.h
@@ -4360,7 +4360,8 @@
/// TrueCount should be the number of times we expect the condition to
/// evaluate to true based on PGO data.
void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock,
- llvm::BasicBlock *FalseBlock, uint64_t TrueCount);
+ llvm::BasicBlock *FalseBlock, uint64_t TrueCount,
+ llvm::MDNode *Weights = nullptr);
/// Given an assignment `*LHS = RHS`, emit a test that checks if \p RHS is
/// nonnull, if \p LHS is marked _Nonnull.
Index: clang/lib/CodeGen/CodeGenFunction.cpp
===================================================================
--- clang/lib/CodeGen/CodeGenFunction.cpp
+++ clang/lib/CodeGen/CodeGenFunction.cpp
@@ -1462,16 +1462,15 @@
return true;
}
-
-
/// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if
/// statement) to the specified blocks. Based on the condition, this might try
/// to simplify the codegen of the conditional based on the branch.
-///
+/// \param Weights The weights determined by the likelihood attributes.
void CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond,
llvm::BasicBlock *TrueBlock,
llvm::BasicBlock *FalseBlock,
- uint64_t TrueCount) {
+ uint64_t TrueCount,
+ llvm::MDNode *Weights) {
Cond = Cond->IgnoreParens();
if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) {
@@ -1486,7 +1485,7 @@
// br(1 && X) -> br(X).
incrementProfileCounter(CondBOp);
return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock,
- TrueCount);
+ TrueCount, Weights);
}
// If we have "X && 1", simplify the code to use an uncond branch.
@@ -1495,7 +1494,7 @@
ConstantBool) {
// br(X && 1) -> br(X).
return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock,
- TrueCount);
+ TrueCount, Weights);
}
// Emit the LHS as a conditional. If the LHS conditional is false, we
@@ -1508,7 +1507,8 @@
ConditionalEvaluation eval(*this);
{
ApplyDebugLocation DL(*this, Cond);
- EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock, RHSCount);
+ EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock, RHSCount,
+ Weights);
EmitBlock(LHSTrue);
}
@@ -1517,7 +1517,8 @@
// Any temporaries created here are conditional.
eval.begin(*this);
- EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock, TrueCount);
+ EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock, TrueCount,
+ Weights);
eval.end(*this);
return;
@@ -1532,7 +1533,7 @@
// br(0 || X) -> br(X).
incrementProfileCounter(CondBOp);
return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock,
- TrueCount);
+ TrueCount, Weights);
}
// If we have "X || 0", simplify the code to use an uncond branch.
@@ -1541,7 +1542,7 @@
!ConstantBool) {
// br(X || 0) -> br(X).
return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock,
- TrueCount);
+ TrueCount, Weights);
}
// Emit the LHS as a conditional. If the LHS conditional is true, we
@@ -1557,7 +1558,8 @@
ConditionalEvaluation eval(*this);
{
ApplyDebugLocation DL(*this, Cond);
- EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse, LHSCount);
+ EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse, LHSCount,
+ Weights);
EmitBlock(LHSFalse);
}
@@ -1566,7 +1568,8 @@
// Any temporaries created here are conditional.
eval.begin(*this);
- EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock, RHSCount);
+ EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock, RHSCount,
+ Weights);
eval.end(*this);
@@ -1581,7 +1584,7 @@
uint64_t FalseCount = getCurrentProfileCount() - TrueCount;
// Negate the condition and swap the destination blocks.
return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock,
- FalseCount);
+ FalseCount, Weights);
}
}
@@ -1592,7 +1595,7 @@
ConditionalEvaluation cond(*this);
EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock,
- getProfileCount(CondOp));
+ getProfileCount(CondOp), Weights);
// When computing PGO branch weights, we only know the overall count for
// the true block. This code is essentially doing tail duplication of the
@@ -1612,14 +1615,14 @@
{
ApplyDebugLocation DL(*this, Cond);
EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock,
- LHSScaledTrueCount);
+ LHSScaledTrueCount, Weights);
}
cond.end(*this);
cond.begin(*this);
EmitBlock(RHSBlock);
EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock,
- TrueCount - LHSScaledTrueCount);
+ TrueCount - LHSScaledTrueCount, Weights);
cond.end(*this);
return;
@@ -1650,9 +1653,10 @@
// Create branch weights based on the number of times we get here and the
// number of times the condition should be true.
- uint64_t CurrentCount = std::max(getCurrentProfileCount(), TrueCount);
- llvm::MDNode *Weights =
- createProfileWeights(TrueCount, CurrentCount - TrueCount);
+ if (!Weights) {
+ uint64_t CurrentCount = std::max(getCurrentProfileCount(), TrueCount);
+ Weights = createProfileWeights(TrueCount, CurrentCount - TrueCount);
+ }
// Emit the code with the fully general case.
llvm::Value *CondV;
Index: clang/lib/CodeGen/CGStmt.cpp
===================================================================
--- clang/lib/CodeGen/CGStmt.cpp
+++ clang/lib/CodeGen/CGStmt.cpp
@@ -27,6 +27,7 @@
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/MDBuilder.h"
#include "llvm/Support/SaveAndRestore.h"
+#include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
using namespace clang;
using namespace CodeGen;
@@ -651,6 +652,94 @@
EmitBranch(IndGotoBB);
}
+namespace {
+//! Searches of the likelihood attributes of a statement.
+//!
+//! Depending on the type of statement it:
+//! - AttributedStmt check for the proper attribute, if not found
+//! visit its sub statement. This is only required for a CompoundStmt, but
+//! let the visitor handle it.
+//! - VisitCompoundStmt visit all statements in its body to search for an
+//! AttributedStmt.
+//! - All other statements should be ignored, the attributes used on them
+//! should not affect us. E.g.
+//! \code if(b) {...} else if (c) [[likely]]{} \endcode
+//! The attribute is part of the second if, not the first.
+struct LikelihoodAttributeFinder : ConstStmtVisitor<LikelihoodAttributeFinder> {
+ enum Attribute { None, Likely, Unlikely };
+
+ Attribute Result{None};
+ LikelihoodAttributeFinder(const Stmt *S) { Visit(S); }
+
+ void VisitAttributedStmt(const AttributedStmt *S) {
+ for (const auto *A : S->getAttrs()) {
+ if (isa<LikelyAttr>(A)) {
+ Result = Likely;
+ return;
+ }
+ if (isa<UnlikelyAttr>(A)) {
+ Result = Unlikely;
+ return;
+ }
+ }
+ Visit(S->getSubStmt());
+ }
+
+ void VisitCompoundStmt(const CompoundStmt *CS) {
+ for (const auto *S : CS->body()) {
+ Visit(S);
+ if (Result != None)
+ return;
+ }
+ }
+
+ void VisitStmt(const Stmt *) {}
+};
+} // end anonymous namespace
+
+static std::pair<bool, bool> getLikelihood(const Stmt *Stmt) {
+ auto R = std::make_pair(false, false);
+
+ LikelihoodAttributeFinder LH(Stmt);
+ switch (LH.Result) {
+ case LikelihoodAttributeFinder::None:
+ break;
+ case LikelihoodAttributeFinder::Likely:
+ R.first = true;
+ break;
+ case LikelihoodAttributeFinder::Unlikely:
+ R.second = true;
+ break;
+ }
+
+ return R;
+}
+
+static Optional<std::pair<uint32_t, uint32_t>>
+getLikelihoodWeights(const Stmt *Then, const Stmt *Else) {
+ assert(Then && "IfStmt without a ThenStmt");
+
+ // The user can use conflicting likelihood attributes within one of the
+ // statements or between the statements. These conflicts are ignored and the
+ // first match is used.
+ std::pair<bool, bool> LH = getLikelihood(Then);
+ if (LH.first)
+ return std::pair<uint32_t, uint32_t>(llvm::LikelyBranchWeight,
+ llvm::UnlikelyBranchWeight);
+ if (LH.second)
+ return std::pair<uint32_t, uint32_t>(llvm::UnlikelyBranchWeight,
+ llvm::LikelyBranchWeight);
+ if (Else) {
+ LH = LH = getLikelihood(Else);
+ if (LH.first)
+ return std::pair<uint32_t, uint32_t>(llvm::UnlikelyBranchWeight,
+ llvm::LikelyBranchWeight);
+ if (LH.second)
+ return std::pair<uint32_t, uint32_t>(llvm::LikelyBranchWeight,
+ llvm::UnlikelyBranchWeight);
+ }
+ return Optional<std::pair<uint32_t, uint32_t>>{};
+}
void CodeGenFunction::EmitIfStmt(const IfStmt &S) {
// C99 6.8.4.1: The first substatement is executed if the expression compares
@@ -695,8 +784,21 @@
if (S.getElse())
ElseBlock = createBasicBlock("if.else");
- EmitBranchOnBoolExpr(S.getCond(), ThenBlock, ElseBlock,
- getProfileCount(S.getThen()));
+ // Prefer the PGO based weights over the likelihood attribute.
+ // When the build isn't optimized the metadata isn't used, so don't generate
+ // it.
+ llvm::MDNode *Weights = nullptr;
+ uint64_t Count = getProfileCount(S.getThen());
+ if (!Count && CGM.getCodeGenOpts().OptimizationLevel) {
+ Optional<std::pair<uint32_t, uint32_t>> LHW =
+ getLikelihoodWeights(S.getThen(), S.getElse());
+ if (LHW) {
+ llvm::MDBuilder MDHelper(CGM.getLLVMContext());
+ Weights = MDHelper.createBranchWeights(LHW->first, LHW->second);
+ }
+ }
+
+ EmitBranchOnBoolExpr(S.getCond(), ThenBlock, ElseBlock, Count, Weights);
// Emit the 'then' code.
EmitBlock(ThenBlock);
Index: clang/include/clang/Basic/AttrDocs.td
===================================================================
--- clang/include/clang/Basic/AttrDocs.td
+++ clang/include/clang/Basic/AttrDocs.td
@@ -1683,6 +1683,49 @@
}];
}
+def LikelihoodDocs : Documentation {
+ let Category = DocCatStmt;
+ let Heading = "likely and unlikely";
+ let Content = [{
+The ``likely`` and ``unlikely`` attributes are used as compiler hints. When
+the next executed statement depends on a condition this attribute can
+annotate all possible statements with either ``likely`` or ``unlikely``.
+Using ``likely`` will hint the statement is more likely to be executed.
+Using ``unlikely`` will hint the statement is less likely to be executed.
+
+It's not allowed to annotate a statement with both ``likely`` and
+``unlikely``.
+
+These attributes have no effect when using PGO or optimization level 0.
+
+At the moment the attribute only has effect when used in an ``if`` statement.
+
+Here is an example:
+
+.. code-block:: c++
+
+ if (b) [[likely]] {
+ // The compiler will optimize to execute the code here.
+ } else {
+ }
+
+ if (b) [[unlikely]] {
+ } else {
+ // The compiler will optimize to execute the code here.
+ }
+
+ if (b) {
+ } else [[likely]] {
+ // The compiler will optimize to execute the code here.
+ }
+ if (b) {
+ } else {
+ // The compiler will optimize to execute the code here.
+ [[likely]] b = f();
+ }
+ }];
+}
+
def ARMInterruptDocs : Documentation {
let Category = DocCatFunction;
let Heading = "interrupt (ARM)";
Index: clang/include/clang/Basic/Attr.td
===================================================================
--- clang/include/clang/Basic/Attr.td
+++ clang/include/clang/Basic/Attr.td
@@ -1284,6 +1284,18 @@
let Documentation = [FallthroughDocs];
}
+def Likely : StmtAttr {
+ // FIXME: Change the date to 201803 once the implementation is finished.
+ let Spellings = [CXX11<"", "likely", 2>, C2x<"clang", "likely">];
+ let Documentation = [LikelihoodDocs];
+}
+
+def Unlikely : StmtAttr {
+ // FIXME: Change the date to 201803 once the implementation is finished.
+ let Spellings = [CXX11<"", "unlikely", 2>, C2x<"clang", "unlikely">];
+ let Documentation = [LikelihoodDocs];
+}
+
def NoMerge : StmtAttr {
let Spellings = [Clang<"nomerge">];
let Documentation = [NoMergeDocs];
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
