[Clang] Add C++2b attribute [[assume(expression)]]

[Izaron]

Summary

Clang already supports assumes for optimizing. Now it is standardized
in C++2b via a new attribute - https://wg21.link/p1774r8.

[Izaron]

A small fix for def FutureAttrs

[Izaron]

clang/include/clang/Basic/Attr.td

1448

Honestly I don't have a clue what these numbers 202302 (apparently the yyyymm format) would mean :( I'd be grateful if you could help me with the right value for this.

[philnik]

clang/include/clang/Basic/Attr.td

1448

https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations has generally the correct values for this. In this case it's 202207.

[Izaron]

More thorough AST test.

Set the right macros number - thanks to @philnik!

[Izaron]

If you are not familiar with the [[assume(expr]] concept and want to know more, I wrote a small article about it recently, with a lot of additional links (including to the author of the proposal) - https://izaron.github.io/posts/assume/

[nikic]

(not a clang reviewer)

clang/test/CodeGenCXX/cxx2b-assume.cpp

55

Isn't the assume expression supposed to be unevaluated?

[cor3ntin]

Can you add a test to check __has_cpp_attribute(assume) ?

clang/lib/CodeGen/CGStmt.cpp

723–727

I'm not familiar with codegen. what makes the expression non-evaluated here?

[erichkeane]

So one thing to note here: I'm on the fence as to whether we want to implement this feature at all. As was discussed extensively during the EWG meetings on this: multiple implementers are against this attribute for a variety of reasons, and at least 1 other implementer has stated they might 'implementer veto' this. I think there is discussion to be had among the code owners here as to whether we even want this.

clang/include/clang/Basic/AttrDocs.td

2107

2112

This last sentence is inaccurate. As discussed in EWG, this attribute has some pretty painful side-effects (instantiation, lambda creation/etc).

clang/test/CodeGenCXX/cxx2b-assume.cpp

2

Having a CFE test depend on the optimizer like this is EXTREMELY frowned upon. We shouldn't have clang tests depend on optimizer performance.

55

We need MUCH more complicated tests (including just any expression/function call/etc) to ensure that the side-effects aren't going to cause problems, particularly in -O0. I am somewhat confident that the middle-end is going to be willing to do the work to figure out that something passed to 'assume' is passed out correctly, but I'm not convinced that this will prevent all side-effects from escaping.

[tahonermann]

clang/include/clang/Basic/Attr.td

1448

The draft standard is a better reference (http://eel.is/c++draft/cpp.cond#6). Fortunately, it agrees with SD6.

[philnik]

clang/include/clang/Basic/Attr.td

1448

The problem with the standard is that it doesn't list the old values, so it's useless if you want to implement a paper for which the FTM has already been bumped by another paper (or you don't know whether there is another paper).

[Izaron]

In D144334#4141646, @erichkeane wrote:

I'm on the fence as to whether we want to implement this feature at all. As was discussed extensively during the EWG meetings on this: multiple implementers are against this attribute for a variety of reasons, and at least 1 other implementer has stated they might 'implementer veto' this.

I don't quite understand how it works. The feature has been approved for C++2b, but it should have not been approved if there were concerns from implementers.

A friend of mine got his proposal rejected because MSVC said they are unable to support the new feature.

But it seems like not the case with the assume attribute. Could you please elaborate: if you decide to not implement this feature, you will kind of revoke the proposal or just deliberately do not support a part of C++2b in Clang?

[erichkeane]

In D144334#4142462, @Izaron wrote:

In D144334#4141646, @erichkeane wrote:

I'm on the fence as to whether we want to implement this feature at all. As was discussed extensively during the EWG meetings on this: multiple implementers are against this attribute for a variety of reasons, and at least 1 other implementer has stated they might 'implementer veto' this.

I don't quite understand how it works. The feature has been approved for C++2b, but it should have not been approved if there were concerns from implementers.

You're preaching to the choir on that one. Two of the implementers (including our code owner, and MSVC reps) stated a distinct dislike for this, and that they were considering implementer veto on it.

A friend of mine got his proposal rejected because MSVC said they are unable to support the new feature.

"Unable to support" and "dont want to support" are different, but EWG is nothing if not consistently inconsistent.

But it seems like not the case with the assume attribute. Could you please elaborate: if you decide to not implement this feature, you will kind of revoke the proposal or just deliberately do not support a part of C++2b in Clang?

Just deliberately not support a part of C++2b. Implementers have veto'ed features in the past exactly that way.

[Izaron]

In D144334#4142490, @erichkeane wrote:

Just deliberately not support a part of C++2b. Implementers have veto'ed features in the past exactly that way.

That's sad. Let's at least write some warning on the cxx_status.html like "we aren't gonna implement it".

clang/lib/CodeGen/CGStmt.cpp

723–727

The LLVM docs says it: https://llvm.org/docs/LangRef.html#llvm-assume-intrinsic

No code is generated for this intrinsic, and instructions that contribute only to the provided condition are not used for code generation

The ArgValue and FnAssume are the instructions to be discarded according to this sentence.

I guess they do it via dead code elimination (at any optimization level).

[erichkeane]

clang/lib/CodeGen/CGStmt.cpp

723–727

So interestingly, with __builtin_assume, we have some code that checks for side-effects (https://godbolt.org/z/fo73TvY68) and just doesn't emit the assume at all into IR. I believe we are not able to do that (as side-effects don't prevent attribute-assume from having 'an effect'), so additional work needs to happen to make sure an example like the above has those side effects removed, but considered by the backend.

[aaron.ballman]

In D144334#4142462, @Izaron wrote:

In D144334#4141646, @erichkeane wrote:

I'm on the fence as to whether we want to implement this feature at all. As was discussed extensively during the EWG meetings on this: multiple implementers are against this attribute for a variety of reasons, and at least 1 other implementer has stated they might 'implementer veto' this.

I don't quite understand how it works. The feature has been approved for C++2b, but it should have not been approved if there were concerns from implementers.

Agreed, (IMO) it should not have been approved given how many implementer concerns were expressed. But what goes into the standard is whatever gains consensus in the committee, so the committee occasionally runs the risk of voting in something that won't be implemented. We try to avoid it whenever possible, but it still happens with some regularity.

But it seems like not the case with the assume attribute. Could you please elaborate: if you decide to not implement this feature, you will kind of revoke the proposal or just deliberately do not support a part of C++2b in Clang?

To me, it's not clear whether we will or won't implement this particular attribute at the moment. Because Clang aims for compatibility with both GCC and MSVC, I'd like Clang to be the *last* to implement this attribute so we know exactly what we're signing up for in terms of compatibility requirements. We were bitten by no_unique_address and it's sporadic adoption and we do not want to get into the same situation with assumes because (as with no_unique_address) this attribute *cannot be ignored* (it can trigger template instantiations and other things that impact ABI, so a correct program with the attribute might not remain correct without the attribute). So that's not a "no, we'll never do it!" kind of situation so much as a "we're proceeding with extreme caution" situation. If every other C++ implementation supports this attribute, I see no reason why Clang wouldn't as well. But if either MSVC or GCC elect not to implement this attribute, we should understand why and decide our implementation strategy accordingly.

In terms of C++2b, we (the Clang community) have no more chances to change things. A national body comment was filed to consider removing the feature from C++2b or altering it to be acceptable to implementers with concerns and WG21 rejected the comment, so about the only other option left is for companies who are members of a WG21 national body to vote NO on the C++2b DIS.

clang/docs/ReleaseNotes.rst

- Improved ``-O0`` code generation for calls to ``std::forward_like``. Similarly to
   directly rather than instantiating the definition from the standard library.
 
 C++20 Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
 C++2b Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
+- Support the ``[[assume(expression)]]`` attribute (`P1774R8 <https://wg21.link/p1774r8>`_).
+
 CUDA/HIP Language Changes in Clang
 ----------------------------------
 
 Objective-C Language Changes in Clang
 -------------------------------------
 
 OpenCL C Language Changes in Clang
 ----------------------------------

clang/include/clang/Basic/Attr.td

 }
 
 def Unlikely : StmtAttr {
   let Spellings = [CXX11<"", "unlikely", 201803>, C2x<"clang", "unlikely">];
   let Documentation = [LikelihoodDocs];
 }
 def : MutualExclusions<[Likely, Unlikely]>;
 
+def Assume : StmtAttr {
+  let Spellings = [CXX11<"", "assume", 202207>];
+  let Documentation = [AssumeDocs];
+  let Subjects = SubjectList<[NullStmt], ErrorDiag, "empty statements">;
+  let Args = [ExprArgument<"Cond">];
+}
+
 def NoMerge : DeclOrStmtAttr {
   let Spellings = [Clang<"nomerge">];
   let Documentation = [NoMergeDocs];
   let Subjects = SubjectList<[Function, Stmt], ErrorDiag,
                              "functions and statements">;
   let SimpleHandler = 1;
 }
 

clang/include/clang/Basic/AttrDocs.td

.. code-block:: c++
   while(true) [[unlikely]] {
     ...               // The attribute has no effect
   }                   // Clang elides the comparison and generates an infinite
                       // loop
 
   }];
 }
 
+def AssumeDocs : Documentation {
+  let Category = DocCatStmt;
+  let Heading = "assume";
+  let Content = [{
+The ``assume`` attribute used to provide the optimizer with an expression that
+is defined to evaluate to ``true`` at the place the assumption occurs. The
+optimizer may analyze the form of the expression provided as the argument and
+deduce from that information used to optimize the program. If the condition is
+violated during execution, the behavior is undefined. The argument itself is
+never evaluated, so any side effects of the expression will be discarded.
+
+Example usage:
+
+.. code-block:: c++
+
+  int divide_by_32(int x) {
+    [[assume(x >= 0)]];
+    return x/32; // is equivalent to `return x>>5;`
+  }
+
+  int increment(int y) {
+    [[assume(++y == 43)]];
+    return y; // is equivalent to `return 42;`
+  }
+
+``[[assume(expression)]]`` is a standard C++23 attribute. Clang supports its
+use in C++11 onwards.
+  }];
+}
+
 def ARMInterruptDocs : Documentation {
   let Category = DocCatFunction;
   let Heading = "interrupt (ARM)";
   let Content = [{
 Clang supports the GNU style ``__attribute__((interrupt("TYPE")))`` attribute on
 ARM targets. This attribute may be attached to a function definition and
 instructs the backend to generate appropriate function entry/exit code so that
 it can be used directly as an interrupt service routine.

clang/include/clang/Basic/DiagnosticGroups.td

 // A warning group for warnings that we want to have on by default in clang,
 // but which aren't on by default in GCC.
 def NonGCC : DiagGroup<"non-gcc",
     [SignCompare, Conversion, LiteralRange]>;
 
 def CXX14Attrs : DiagGroup<"c++14-attribute-extensions">;
 def CXX17Attrs : DiagGroup<"c++17-attribute-extensions">;
 def CXX20Attrs : DiagGroup<"c++20-attribute-extensions">;
+def CXX2bAttrs : DiagGroup<"c++2b-attribute-extensions">;
 def FutureAttrs : DiagGroup<"future-attribute-extensions", [CXX14Attrs,
                                                             CXX17Attrs,
-                                                            CXX20Attrs]>;
+                                                            CXX20Attrs,
+                                                            CXX2bAttrs]>;
 
 // A warning group for warnings about using C++11 features as extensions in
 // earlier C++ versions.
 def CXX11 : DiagGroup<"c++11-extensions", [CXX11ExtraSemi, CXX11InlineNamespace,
                                            CXX11LongLong]>;
 
 // A warning group for warnings about using C++14 features as extensions in
 // earlier C++ versions.

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_unused_volatile : Warning<
   InGroup<DiagGroup<"unused-volatile-lvalue">>;
 
 def ext_cxx14_attr : Extension<
   "use of the %0 attribute is a C++14 extension">, InGroup<CXX14Attrs>;
 def ext_cxx17_attr : Extension<
   "use of the %0 attribute is a C++17 extension">, InGroup<CXX17Attrs>;
 def ext_cxx20_attr : Extension<
   "use of the %0 attribute is a C++20 extension">, InGroup<CXX20Attrs>;
+def ext_cxx2b_attr : Extension<
+  "use of the %0 attribute is a C++2b extension">, InGroup<CXX2bAttrs>;
 
 def warn_unused_comparison : Warning<
   "%select{equality|inequality|relational|three-way}0 comparison result unused">,
   InGroup<UnusedComparison>;
 def note_inequality_comparison_to_or_assign : Note<
   "use '|=' to turn this inequality comparison into an or-assignment">;
 
 def err_incomplete_type_used_in_type_trait_expr : Error<

clang/lib/CodeGen/CGStmt.cpp

case attr::NoMerge:
       nomerge = true;
       break;
     case attr::NoInline:
       noinline = true;
       break;
     case attr::AlwaysInline:
       alwaysinline = true;
       break;
-    case attr::MustTail:
+    case attr::MustTail: {
       const Stmt *Sub = S.getSubStmt();
       const ReturnStmt *R = cast<ReturnStmt>(Sub);
       musttail = cast<CallExpr>(R->getRetValue()->IgnoreParens());
       break;
     }
+    case attr::Assume: {
+      llvm::Value *ArgValue = EmitScalarExpr(cast<AssumeAttr>(A)->getCond());
+      llvm::Function *FnAssume = CGM.getIntrinsic(llvm::Intrinsic::assume);
+      Builder.CreateCall(FnAssume, ArgValue);
+      break;
+    }
+    }
   }
   SaveAndRestore save_nomerge(InNoMergeAttributedStmt, nomerge);
   SaveAndRestore save_noinline(InNoInlineAttributedStmt, noinline);
   SaveAndRestore save_alwaysinline(InAlwaysInlineAttributedStmt, alwaysinline);
   SaveAndRestore save_musttail(MustTailCall, musttail);
   EmitStmt(S.getSubStmt(), S.getAttrs());
 }
 

clang/lib/Sema/SemaStmtAttr.cpp

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 Attr *handleAssume(Sema &S, Stmt *St, const ParsedAttr &A,
+                          SourceRange Range) {
+
+  if (!S.getLangOpts().CPlusPlus2b)
+    S.Diag(A.getLoc(), diag::ext_cxx2b_attr) << A << Range;
+
+  return ::new (S.Context) AssumeAttr(S.Context, A, A.getArgAsExpr(0));
+}
+
 #define WANT_STMT_MERGE_LOGIC
 #include "clang/Sema/AttrParsedAttrImpl.inc"
 #undef WANT_STMT_MERGE_LOGIC
 
 static void
 CheckForIncompatibleAttributes(Sema &S,
                                const SmallVectorImpl<const Attr *> &Attrs) {
   // The vast majority of attributed statements will only have one attribute
static Attr *ProcessStmtAttribute(Sema &S, Stmt *St, const ParsedAttr &A,
   case ParsedAttr::AT_NoInline:
     return handleNoInlineAttr(S, St, A, Range);
   case ParsedAttr::AT_MustTail:
     return handleMustTailAttr(S, St, A, Range);
   case ParsedAttr::AT_Likely:
     return handleLikely(S, St, A, Range);
   case ParsedAttr::AT_Unlikely:
     return handleUnlikely(S, St, A, Range);
+  case ParsedAttr::AT_Assume:
+    return handleAssume(S, St, A, Range);
   default:
     // N.B., ClangAttrEmitter.cpp emits a diagnostic helper that ensures a
     // declaration attribute is not written on a statement, but this code is
     // needed for attributes in Attr.td that do not list any subjects.
     S.Diag(A.getRange().getBegin(), diag::err_decl_attribute_invalid_on_stmt)
         << A << St->getBeginLoc();
     return nullptr;
   }

clang/test/AST/ast-dump-attr.cpp

 // CHECK-NEXT: AnnotateAttr{{.*}}
 
 // CHECK: FunctionDecl{{.*}} mergeAttrTest
 // CHECK-NEXT: DeprecatedAttr{{.*}} Inherited
 // CHECK-NEXT: WarnUnusedResultAttr{{.*}} Inherited
 // CHECK-NEXT: AnnotateAttr{{.*}} Inherited
 // CHECK-NEXT: UnusedAttr
 // CHECK-NEXT: NoThreadSafetyAnalysisAttr
+
+namespace TestAssume {
+  int DivideBy32(int x) {
+      [[assume(x >= 0)]];
+      return x/32;
+  }
+  // CHECK:      FunctionDecl{{.*}}DivideBy32
+  // CHECK:      |-AttributedStmt
+  // CHECK-NEXT: | |-AssumeAttr
+  // CHECK-NEXT: | | `-BinaryOperator
+  // CHECK-NEXT: | |   |-ImplicitCastExpr
+  // CHECK-NEXT: | |   | `-DeclRefExpr
+  // CHECK-NEXT: | |   `-IntegerLiteral
+  // CHECK-NEXT: | `-NullStmt
+} // namespace TestAssume

clang/test/CXX/dcl.dcl/dcl.attr/dcl.attr.assume/p1.cpp

+// RUN: %clang_cc1 -fsyntax-only -Wunused -std=c++2b -verify %s
+
+int divide_by_32(int x) {
+    [[assume(x >= 0)]];
+    return x/32;
+}
+
+int increment(int y) {
+    [[assume(++y == 43)]];
+    return y;
+}
+
+[[assume(true)]] int incorrects(int y) { // expected-error {{'assume' attribute cannot be applied to a declaration}}
+    [[assume(++y == 43)]] int x = 0; // expected-error {{'assume' attribute cannot be applied to a declaration}}
+    [[assume(++y == 43)]] x = 0; // expected-error {{'assume' attribute only applies to empty statements}}
+    [[assume(++y == 43 && ++y == 44)]];
+    [[assume(++y == 43, ++y == 43)]]; // expected-error {{'assume' attribute takes one argument}}
+    [[assume]]; // expected-error {{'assume' attribute takes one argument}}
+    return y;
+}

clang/test/CodeGenCXX/cxx2b-assume.cpp

+// RUN: %clang_cc1 -std=c++2b %s -emit-llvm -o - -triple x86_64-linux-gnu -disable-llvm-passes -DUSE_ASSUME | FileCheck %s
+// RUN: %clang_cc1 -std=c++2b %s -emit-llvm -o - -triple x86_64-linux-gnu -O3 | FileCheck --check-prefixes=CHECK-OPT-NOASSUME %s
+// RUN: %clang_cc1 -std=c++2b %s -emit-llvm -o - -triple x86_64-linux-gnu -O3 -DUSE_ASSUME | FileCheck --check-prefixes=CHECK-OPT %s
+
+// CHECK-LABEL: @_Z12divide_by_32i
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   %[[VAR:.*]] = alloca i32, align 4
+// CHECK-NEXT:   store i32 %x, ptr %[[VAR]], align 4
+// CHECK-NEXT:   %0 = load i32, ptr %[[VAR]], align 4
+// CHECK-NEXT:   %[[CMP:.*]] = icmp sge i32 %0, 0
+// CHECK-NEXT:   call void @llvm.assume(i1 %[[CMP]])
+// CHECK-NEXT:   %1 = load i32, ptr %[[VAR]], align 4
+// CHECK-NEXT:   %[[DIV:.*]] = sdiv i32 %1, 32
+// CHECK-NEXT:   ret i32 %[[DIV]]
+//
+// CHECK-OPT-NOASSUME-LABEL: @_Z12divide_by_32i
+// CHECK-OPT-NOASSUME-NEXT: entry:
+// CHECK-OPT-NOASSUME-NEXT:   %[[DIV:.*]] = sdiv i32 %x, 32
+// CHECK-OPT-NOASSUME-NEXT:   ret i32 %[[DIV]]
+//
+// CHECK-OPT-LABEL: @_Z12divide_by_32i
+// CHECK-OPT-NEXT: entry:
+// CHECK-OPT-NEXT:   %[[CMP:.*]] = icmp sgt i32 %x, -1
+// CHECK-OPT-NEXT:   tail call void @llvm.assume(i1 %[[CMP]])
+// CHECK-OPT-NEXT:   %[[DIV:.*]] = lshr i32 %x, 5
+// CHECK-OPT-NEXT:   ret i32 %[[DIV]]
+//
+int divide_by_32(int x) {
+#ifdef USE_ASSUME
+    [[assume(x >= 0)]];
+#endif
+    return x/32;
+}
+
+// CHECK-LABEL: @_Z9incrementi
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   %[[VAR:.*]] = alloca i32, align 4
+// CHECK-NEXT:   store i32 %y, ptr %[[VAR]], align 4
+// CHECK-NEXT:   %0 = load i32, ptr %[[VAR]], align 4
+// CHECK-NEXT:   %[[VARP1:.*]] = add nsw i32 %0, 1
+// CHECK-NEXT:   store i32 %[[VARP1]], ptr %[[VAR]], align 4
+// CHECK-NEXT:   %[[CMP:.*]] = icmp eq i32 %[[VARP1]], 43
+// CHECK-NEXT:   call void @llvm.assume(i1 %[[CMP]])
+// CHECK-NEXT:   %1 = load i32, ptr %[[VAR]], align 4
+// CHECK-NEXT:   ret i32 %1
+//
+// CHECK-OPT-NOASSUME-LABEL: @_Z9incrementi
+// CHECK-OPT-NOASSUME-NEXT: entry:
+// CHECK-OPT-NOASSUME-NEXT:   ret i32 %y
+//
+// CHECK-OPT-LABEL: @_Z9incrementi
+// CHECK-OPT-NEXT: entry:
+// CHECK-OPT-NEXT:   %[[CMP:.*]] = icmp eq i32 %y, 42
+// CHECK-OPT-NEXT:   tail call void @llvm.assume(i1 %[[CMP]])
+// CHECK-OPT-NEXT:   ret i32 43
+//
+int increment(int y) {
+#ifdef USE_ASSUME
+    [[assume(++y == 43)]];
+#endif
+    return y;
+}

clang/www/cxx_status.html

</tr>
     <tr>
       <td>Class template argument deduction from inherited constructors</td>
       <td><a href="https://wg21.link/P2582R1">P2582R1</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td>Portable assumptions</td>
       <td><a href="https://wg21.link/P1774R8">P1774R8</a></td>
-      <td class="none" align="center">No</td>
+      <td class="unreleased" align="center">Clang 17</td>
     </tr>
     <tr>
       <td>Support for UTF-8 as a portable source file encoding</td>
       <td><a href="https://wg21.link/P2295R6">P2295R6</a></td>
       <td class="full" align="center">Clang 15</td>
     </tr>
     <tr>
       <td><code>char8_t</code> Compatibility and Portability Fix</td>