[Clang][Attr] Introduce the `assume` function attribute

[jdoerfert]

Summary

The assume attribute is a way to provide additional, arbitrary
information to the optimizer. For now, assumptions are restricted to
strings which will be accumulated for a function and emitted as comma
separated string function attribute. The key of the LLVM-IR function
attribute is llvm.assume. Similar to llvm.assume and
__builtin_assume, the assume attribute provides a user defined
assumption to the compiler.

A follow up patch will introduce an LLVM-core API to query the
assumptions attached to a function. We also expect to add more options,
e.g., expression arguments, to the assume attribute later on.

The omp [begin] asssumes pragma will leverage this attribute and
expose the functionality in the absence of OpenMP.

[tschuett]

Swift uses a similar mechanism:
https://github.com/apple/swift/blob/887464b7b67d5202bfa7adc4e3f045ff1027a5a7/stdlib/public/core/Array.swift#L829

[jdoerfert]

Generalize check lines [NFC]

[aaron.ballman]

Thank you for your patience with the delays getting to your review! Along with the documentation question, one line of thinking I'm also not clear on is whether this should be a type-based attribute rather than a declaration-based attribute. For instance, if you want to write an assumption about the parameters to a function, those are not in scope for a declaration attribute but are for a type attribute. But also, it seems like this assumption information is something that would be useful to carry around as part of the function's identity. For instance, would users want to be able to make a call through a function pointer and have the same set of assumptions conveyed to the backend?

clang/include/clang/Basic/AttrDocs.td

3932

It's not clear to me how this string literal relates to program constructs being assumed. I think adding some example usage would be very instructive, but I also think the string literal needs more documentation. e.g.,

__attribute__((assume("the parameter 'i' will be nonnegative"))) void func(int i);

seems reasonable from the existing text but probably isn't what we're looking for. ;-)

If we're going to require the assumption to be a valid expression, then I'm not certain a string literal is doing us any favors given that there won't be any expression validity checking done on the string. Why not support an expression as the argument directly?

[jdoerfert]

List known assumptions and warn if unknown.

[jdoerfert]

I added the warning and typo recognition as discussed in IRC. We list known assumption strings in the documentation and SemaDeclAttr. As we add new ones we should include a short description or link to their meaning. The ones I added so far are OpenMP specific (dubbed omp_XXX) and the OpenMP standard is given as reference.

In D91979#2440554, @aaron.ballman wrote:

Thank you for your patience with the delays getting to your review! Along with the documentation question, one line of thinking I'm also not clear on is whether this should be a type-based attribute rather than a declaration-based attribute. For instance, if you want to write an assumption about the parameters to a function, those are not in scope for a declaration attribute but are for a type attribute.

I would like to see that, in our last proposal of something similar we suggested to add something like __attribute__((arg_attr(3, "nofree"))) which would translate to the nofree IR attribute for argument 3. I can also envision a type based assumption attribute but I feel a declaration one will be needed nevertheless. We'll also add expression assumptions as they are required by OpenMP and generally useful. The "payload" of the assume attribute will then be a union, similar to the AlignedAttribute.

But also, it seems like this assumption information is something that would be useful to carry around as part of the function's identity. For instance, would users want to be able to make a call through a function pointer and have the same set of assumptions conveyed to the backend?

Like other IR attributes, if you can go from the function pointer to a (set of) declaration(s) you can use the attributes from that declaration. I don't think this is any different than other function attributes, e.g., readnone in this aspect.

[jdoerfert]

minor spelling improvements

[aaron.ballman]

In D91979#2444327, @jdoerfert wrote:

In D91979#2440554, @aaron.ballman wrote:

Thank you for your patience with the delays getting to your review! Along with the documentation question, one line of thinking I'm also not clear on is whether this should be a type-based attribute rather than a declaration-based attribute. For instance, if you want to write an assumption about the parameters to a function, those are not in scope for a declaration attribute but are for a type attribute.

I would like to see that, in our last proposal of something similar we suggested to add something like __attribute__((arg_attr(3, "nofree"))) which would translate to the nofree IR attribute for argument 3. I can also envision a type based assumption attribute but I feel a declaration one will be needed nevertheless. We'll also add expression assumptions as they are required by OpenMP and generally useful. The "payload" of the assume attribute will then be a union, similar to the AlignedAttribute.

I want to make sure we're on the same page with this.

If the assumption is a unit of information that applies to a single parameter, then the attribute should be written on the parameter itself rather than using positional information. e.g., void func(int i [[clang::whatever]]); is preferable to void func(int i) [[clang::whatever(1)]]; By writing the attribute directly on the parameter, we remove confusion over things like "are parameter indexes one-based or zero-based?" and "does the implicit 'this' parameter count?".

If the assumption is unit of information that applies to the function but involves one or more parameters, then writing the attribute *might* makes sense as a type attribute. e.g., void func(int i, int j) [[clang::whatever(i < j)]];

It sounds to me like we may wind up with both kinds of situations, which is fine.

But also, it seems like this assumption information is something that would be useful to carry around as part of the function's identity. For instance, would users want to be able to make a call through a function pointer and have the same set of assumptions conveyed to the backend?

Like other IR attributes, if you can go from the function pointer to a (set of) declaration(s) you can use the attributes from that declaration. I don't think this is any different than other function attributes, e.g., readnone in this aspect.

But what about the behavior the user sees? e.g., should the user be alerted to this being a potentially bad thing?

void func(int *ip) [[clang::assume(ip != 0)]];
void other_func(int *ip); // No assumptions about ip
int *get_ip(); // May return null

...
void (*fp)(int *);

if (rand() % 10 == 0)
  fp = other_func;
else
  fp = func; // Should we warn about this?

fp(get_ip()); // This could do bad things if fp == func because get_ip() may return null

clang/include/clang/Basic/Attr.td

3482

Should this be supported on ObjCMethod declarations as well?

clang/include/clang/Basic/AttrDocs.td

3930

wrap to 80-col

3940

3950

Can you link to that standard here so users don't have to hunt for it?

clang/include/clang/Basic/DiagnosticSemaKinds.td

742

This changes behavior for users because -Wno-assume now needs to be spelled -Wno-assumption -- I think we may want to keep the diagnostics for the assumption attribute separate from the diagnostics for builtin assume.

For instance, I think the assumption attribute warnings will all wind up leading to an ignored attribute, so perhaps the new grouping should be under the existing ignored attributes group.

744

I'd say that this case should probably be worded unknown assumption string '%0'; attribute ignored

747

Similarly: unknown assumption string '%0' may be misspelled; attribute ignored, did you mean '%1'?

clang/include/clang/Sema/Sema.h

10007

I think this should probably return something so that the caller knows whether to drop the attribute or not?

clang/lib/Sema/SemaDeclAttr.cpp

1681

No need to check the count manually, the common attribute handler should do that for you already.

1684

Does it make sense to warn about an unknown assumption string but then keep the attribute anyway? This seems like a situation where I'd expect the attribute to be dropped as it appears to be meaningless.

Also, I think this should pass in the source location to the argument, not the attribute itself. You can get this information out of the call to checkStringLiteralArgumentAttr() (it's an optional parameter).

1689

The current approach is reasonable, but I wonder if there's a way we can force this list to be filled out by the backend pass authors such that the frontend can query the backend for the supported list?

[jdoerfert]

Addressed remarks

[jdoerfert]

Dropping the attribute and forcing the attribute to be somehow registered makes various use cases impossible. All we would allow is an integrated compilation where the consumers are available and the FE is aware of them. This is hard for optional LLVM plugins, potentially impossible if you separate the FE and compilation steps, e.g., as you do in LTO builds. I don't see the benefit in dropping the string if it is unknown, the warning is giving the user all the information we have, namely that the FE cannot verify this is a known assumption. Keeping the string attributes doesn't cost us anything and there is no immediate benefit by dropping it (IMHO), it just makes certain compilation scenarios harder/impossible.

clang/include/clang/Basic/Attr.td

3482

Sure, why not I guess.

clang/lib/Sema/SemaDeclAttr.cpp

1681

Copied from the generic templated handler.

[jdoerfert]

Allow to register assumption stings through llvm-core.

[jdoerfert]

Move into LLVMCore and provide more helper to extracts assumptions

[jdoerfert]

Remove accidental test change and ensure users create KnownAssumptionString objects

[aaron.ballman]

clang/include/clang/Basic/DiagnosticSemaKinds.td

742

I think we can ignore this comment now, but I do wonder whether we should split the diagnostic group somewhat. To me, the "may be misspelled" warning is going to always be a serious warning -- it means the user fat-fingered something and the attribute is likely to not do anything useful. But the non-misspelling warning seems like a less severe warning because I may be relying on an undocumented string from a pass. So I could imagine wanting to turn off all of the warnings for using an undocumented string from a pass but wanting to retain all of the misspelling warnings. However, you may be envisioning a different usage pattern for this than I am. WDYT?

744

In light of wanting to keep the attribute around, I think this should be unknown assumption string '%0'; attribute is potentially ignored or something along those lines. Basically, I think the diagnostic should focus on the fact that the user cannot predict what happens with this attribute.

747

Similar here. unknown assumption string '%0' may be misspelled; attribute is potentially ignored, did you mean '%1'?

clang/include/clang/Sema/Sema.h

10003

Should this be a static function in SemaDeclAttr.cpp rather than a public part of the Sema interface? I can't think of any other callers for this aside from handleAssumptionAttr().

clang/lib/Sema/SemaDeclAttr.cpp

1681

Ah, yeah, that one needs to do the test because it may be called for an attribute expecting a variadic number of arguments.

llvm/include/llvm/IR/Assumptions.h

15 ↗

(On Diff #311070)

Should probably fix the lint warning here.

[jdoerfert]

Addressed comments

clang/lib/Sema/SemaDeclAttr.cpp

1689

We do, kinda. A backend that wants to query an assumption from the llvm.assume function attribute needs to provide a KnownAssumptionStr which has a comment people might read.

[aaron.ballman]

LGTM (found one very minor late nit in a cmake file though). Thank you for the discussion on this!

clang/lib/Sema/CMakeLists.txt

3 ↗

(On Diff #311922)

Might as well keep this list alphabetized.

clang/docs/LanguageExtensions.rst

 Please note that Clang does not and will not support all of the GCC builtins
 for vector operations.  Instead of using builtins, you should use the functions
 defined in target-specific header files like ``<xmmintrin.h>``, which define
 portable wrappers for these.  Many of the Clang versions of these functions are
 implemented directly in terms of :ref:`extended vector support
 <langext-vectors>` instead of builtins, in order to reduce the number of
 builtins that we need to implement.
 
+.. _langext-__builtin_assume:
+
 ``__builtin_assume``
 ------------------------------
 
 ``__builtin_assume`` is used to provide the optimizer with a boolean
 invariant that is defined to be true.
 
 **Syntax**:
 

clang/include/clang/Basic/Attr.td

def OMPDeclareVariant : InheritableAttr {
   ];
   let AdditionalMembers = [{
     OMPTraitInfo &getTraitInfo() { return *traitInfos; }
     void printPrettyPragma(raw_ostream & OS, const PrintingPolicy &Policy)
         const;
   }];
 }
 
+def Assumption : InheritableAttr {
+  let Spellings = [Clang<"assume">];
+  let Subjects = SubjectList<[Function]>;
+  let InheritEvenIfAlreadyPresent = 1;
+  let Documentation = [AssumptionDocs];
+  let Args = [StringArgument<"Assumption">];
+}
+
 def InternalLinkage : InheritableAttr {
   let Spellings = [Clang<"internal_linkage">];
   let Subjects = SubjectList<[Var, Function, CXXRecord]>;
   let Documentation = [InternalLinkageDocs];
 }
 
 def ExcludeFromExplicitInstantiation : InheritableAttr {
   let Spellings = [Clang<"exclude_from_explicit_instantiation">];

clang/include/clang/Basic/AttrDocs.td

 applied to a definition. If ``allow_templates`` is given, template function
 definitions are considered as specializations of existing or assumed template
 declarations with the same name. The template parameters for the base functions
 are used to instantiate the specialization.
 
   }];
 }
 
+def AssumptionDocs : Documentation {
+  let Category = DocCatFunction;
+  let Heading = "assume";
+  let Content = [{
+Clang supports the ``__attribute__((assume("assumption")))`` attribute to
+provide additional information to the optimizer. The string-literal, here
+"assumption", will be attached to the function declaration such that later
+analysis and optimization passes can assume the "assumption" to hold.
+This is similar to :ref:`__builtin_assume <langext-__builtin_assume>` but instead of an
+expression that can be assumed to be non-zero, the assumption is expressed as
+a string and it holds for the entire function.
+
+A function can have multiple assume attributes and they propagate from prior
+declarations to later definitions. Multiple assumptions are aggregated into a
+single comma separated string. Thus, one can provide multiple assumptions via
+a comma separated string, i.a.,
+``__attribute__((assume("assumption1,assumption2")))``.
+
+While LLVM plugins might utilize more assumption strings, the default LLVM
+optimization passes are aware of the following assumptions:
+
+  .. code-block:: none
+
+    "omp_no_openmp"
+    "omp_no_openmp_routines"
+    "omp_no_parallelism"
+
+The OpenMP standard defines the meaning of OpenMP assumptions ("omp_XYZ" is
+spelled "XYZ" in the OpenMP standard).
+
+}];
+}
+
 def NoStackProtectorDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 Clang supports the ``__attribute__((no_stack_protector))`` attribute which disables
 the stack protector on the specified function. This attribute is useful for
 selectively disabling the stack protector on some functions when building with
 ``-fstack-protector`` compiler option.
 

clang/include/clang/Basic/DiagnosticGroups.td

def Implicit : DiagGroup<"implicit", [
     ImplicitFunctionDeclare,
     ImplicitInt
 ]>;
 
 // Empty DiagGroups are recognized by clang but ignored.
 def ODR : DiagGroup<"odr">;
 def : DiagGroup<"abi">;
 def AbsoluteValue : DiagGroup<"absolute-value">;
+def Assumption : DiagGroup<"assumption">;
 def AddressOfTemporary : DiagGroup<"address-of-temporary">;
 def : DiagGroup<"aggregate-return">;
 def GNUAlignofExpression : DiagGroup<"gnu-alignof-expression">;
 def AmbigMemberTemplate : DiagGroup<"ambiguous-member-template">;
 def GNUAnonymousStruct : DiagGroup<"gnu-anonymous-struct">;
 def GNUAutoType : DiagGroup<"gnu-auto-type">;
 def ArrayBounds : DiagGroup<"array-bounds">;
 def ArrayBoundsPointerArithmetic : DiagGroup<"array-bounds-pointer-arithmetic">;

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def warn_strncat_wrong_size : Warning<
   "the value of the size argument to 'strncat' is wrong">, InGroup<StrncatSize>;
 def note_strncat_wrong_size : Note<
   "change the argument to be the free space in the destination buffer minus "
   "the terminating null byte">;
 
 def warn_assume_side_effects : Warning<
   "the argument to %0 has side effects that will be discarded">,
-  InGroup<DiagGroup<"assume">>;
+  InGroup<Assumption>;
+def warn_assume_attribute_string_unknown : Warning<
+  "the assumption string '%0' is not known and might be misspelled">,
+  InGroup<Assumption>;
+def warn_assume_attribute_string_unknown_suggested : Warning<
+  "the assumption string '%0' is not known and might be misspelled; "
+  "did you mean '%1'?">,
+  InGroup<Assumption>;
 
 def warn_builtin_chk_overflow : Warning<
   "'%0' will always overflow; destination buffer has size %1,"
   " but size argument is %2">,
   InGroup<DiagGroup<"builtin-memcpy-chk-size">>;
 
 def warn_fortify_source_overflow
   : Warning<warn_builtin_chk_overflow.Text>, InGroup<FortifySource>;

clang/include/clang/Sema/Sema.h

 #include "clang/Sema/Scope.h"
 #include "clang/Sema/SemaConcept.h"
 #include "clang/Sema/TypoCorrection.h"
 #include "clang/Sema/Weak.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallBitVector.h"
-#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
 #include <deque>
 #include <memory>
 #include <string>
 #include <tuple>
 #include <vector>
 

   /// AddAlignValueAttr - Adds an align_value attribute to a particular
   /// declaration.
   void AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E);
 
   /// AddAnnotationAttr - Adds an annotation Annot with Args arguments to D.
   void AddAnnotationAttr(Decl *D, const AttributeCommonInfo &CI,
                          StringRef Annot, MutableArrayRef<Expr *> Args);
 
+  /// A set of known assumption strings that are accepted without warning and
+  /// which can be recommended as typo correction.
+  static llvm::StringSet<> KnownAssumptionStrings;
+
+  /// Check if \p AssumptionStr is a known assumption and warn if not.
+  void CheckAssumptionAttr(SourceLocation Loc, StringRef AssumptionStr);
+
   /// AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular
   /// declaration.
   void AddLaunchBoundsAttr(Decl *D, const AttributeCommonInfo &CI,
                            Expr *MaxThreads, Expr *MinBlocks);
 
   /// AddModeAttr - Adds a mode attribute to a particular declaration.
   void AddModeAttr(Decl *D, const AttributeCommonInfo &CI, IdentifierInfo *Name,
                    bool InInstantiation = false);

clang/lib/CodeGen/CGCall.cpp

if (hasSpecificAttr<OpenCLKernelAttr>(Attrs)) {
         // '-cl-uniform-work-group-size' compile option gets a hint
         // to the compiler that the global work-size be a multiple of
         // the work-group size specified to clEnqueueNDRangeKernel
         // (i.e. work groups are uniform).
         FuncAttrs.addAttribute("uniform-work-group-size",
                                llvm::toStringRef(CodeGenOpts.UniformWGSize));
       }
     }
+
+    std::string AssumptionValueStr;
+    for (AssumptionAttr *AssumptionA :
+         TargetDecl->specific_attrs<AssumptionAttr>()) {
+      std::string AS = AssumptionA->getAssumption().str();
+      if (!AS.empty() && !AssumptionValueStr.empty())
+        AssumptionValueStr += ",";
+      AssumptionValueStr += AS;
+    }
+
+    if (!AssumptionValueStr.empty())
+      FuncAttrs.addAttribute("llvm.assume", AssumptionValueStr);
   }
 
   // Attach "no-builtins" attributes to:
   // * call sites: both `nobuiltin` and "no-builtins" or "no-builtin-<name>".
   // * definitions: "no-builtins" or "no-builtin-<name>" only.
   // The attributes can come from:
   // * LangOpts: -ffreestanding, -fno-builtin, -fno-builtin-<name>
   // * FunctionDecl attributes: __attribute__((no_builtin(...)))

clang/lib/Sema/SemaDeclAttr.cpp

Diag(ParamExpr->getBeginLoc(), diag::err_attribute_integers_only)
         << &TmpAttr
         << FuncDecl->getParamDecl(Idx.getASTIndex())->getSourceRange();
     return;
   }
 
   D->addAttr(::new (Context) AllocAlignAttr(Context, CI, Idx));
 }
 
+static void handleAssumumptionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+  // Handle the case where the attribute has a text message.
+  StringRef Str;
+  if (AL.getNumArgs() == 1 && !S.checkStringLiteralArgumentAttr(AL, 0, Str))
+    return;
+
+  S.CheckAssumptionAttr(AL.getLoc(), Str);
+
+  D->addAttr(::new (S.Context) AssumptionAttr(S.Context, AL, Str));
+}
+
+llvm::StringSet<> Sema::KnownAssumptionStrings({
+    "omp_no_openmp",          // OpenMP 5.1
+    "omp_no_openmp_routines", // OpenMP 5.1
+    "omp_no_parallelism",     // OpenMP 5.1
+});
+
+void Sema::CheckAssumptionAttr(SourceLocation Loc, StringRef AssumptionStr) {
+  if (KnownAssumptionStrings.count(AssumptionStr))
+    return;
+
+  unsigned BestEditDistance = 3;
+  StringRef Suggestion;
+  for (const auto &KnownAssumptionIt : KnownAssumptionStrings) {
+    unsigned EditDistance =
+        AssumptionStr.edit_distance(KnownAssumptionIt.getKey());
+    if (EditDistance < BestEditDistance) {
+      Suggestion = KnownAssumptionIt.getKey();
+      BestEditDistance = EditDistance;
+    }
+  }
+
+  if (!Suggestion.empty())
+    Diag(Loc, diag::warn_assume_attribute_string_unknown_suggested)
+        << AssumptionStr << Suggestion;
+  else
+    Diag(Loc, diag::warn_assume_attribute_string_unknown) << AssumptionStr;
+}
+
 /// Normalize the attribute, __foo__ becomes foo.
 /// Returns true if normalization was applied.
 static bool normalizeName(StringRef &AttrName) {
   if (AttrName.size() > 4 && AttrName.startswith("__") &&
       AttrName.endswith("__")) {
     AttrName = AttrName.drop_front(2).drop_back(2);
     return true;
   }
case ParsedAttr::AT_Target:
     handleTargetAttr(S, D, AL);
     break;
   case ParsedAttr::AT_MinVectorWidth:
     handleMinVectorWidthAttr(S, D, AL);
     break;
   case ParsedAttr::AT_Unavailable:
     handleAttrWithMessage<UnavailableAttr>(S, D, AL);
     break;
+  case ParsedAttr::AT_Assumption:
+    handleAssumumptionAttr(S, D, AL);
+    break;
   case ParsedAttr::AT_ObjCDirect:
     handleObjCDirectAttr(S, D, AL);
     break;
   case ParsedAttr::AT_ObjCNonRuntimeProtocol:
     handleObjCNonRuntimeProtocolAttr(S, D, AL);
     break;
   case ParsedAttr::AT_ObjCDirectMembers:
     handleObjCDirectMembersAttr(S, D, AL);

clang/test/CodeGen/assume_attr.c

+// RUN: %clang_cc1 -emit-llvm -triple i386-linux-gnu %s -o - | FileCheck %s
+// RUN: %clang_cc1 -x c -emit-pch -o %t %s
+// RUN: %clang_cc1 -include-pch %t %s -emit-llvm -o - | FileCheck %s
+
+// TODO: for "foo" and "bar", "after" is not added as it appears "after" the first use or definition respectively. There might be a way to allow that.
+
+// CHECK:   define{{.*}} void @bar() #0
+// CHECK:   define{{.*}} void @baz() #1
+// CHECK:   declare{{.*}} void @foo() #2
+// CHECK:      attributes #0
+// CHECK-SAME:   "llvm.assume"="bar:before1,bar:before2,bar:before3,bar:def1,bar:def2"
+// CHECK:      attributes #1
+// CHECK-SAME:   "llvm.assume"="baz:before1,baz:before2,baz:before3,baz:def1,baz:def2,baz:after"
+// CHECK:      attributes #2
+// CHECK-SAME:   "llvm.assume"="foo:before1,foo:before2,foo:before3"
+
+#ifndef HEADER
+#define HEADER
+
+/// foo: declarations only
+
+__attribute__((assume("foo:before1"))) void foo(void);
+
+__attribute__((assume("foo:before2")))
+__attribute__((assume("foo:before3"))) void
+foo(void);
+
+/// baz: static function declarations and a definition
+
+__attribute__((assume("baz:before1"))) static void baz(void);
+
+__attribute__((assume("baz:before2")))
+__attribute__((assume("baz:before3"))) static void
+baz(void);
+
+// Definition
+__attribute__((assume("baz:def1,baz:def2"))) static void baz(void) { foo(); }
+
+__attribute__((assume("baz:after"))) static void baz(void);
+
+/// bar: external function declarations and a definition
+
+__attribute__((assume("bar:before1"))) void bar(void);
+
+__attribute__((assume("bar:before2")))
+__attribute__((assume("bar:before3"))) void
+bar(void);
+
+// Definition
+__attribute__((assume("bar:def1,bar:def2"))) void bar(void) { baz(); }
+
+__attribute__((assume("bar:after"))) void bar(void);
+
+/// back to foo
+
+__attribute__((assume("foo:after"))) void foo(void);
+
+#endif

clang/test/CodeGenCXX/assume_attr.cpp

+// RUN: %clang_cc1 -emit-llvm -triple i386-linux-gnu %s -o - | FileCheck %s
+// RUN: %clang_cc1 -x c++ -emit-pch -triple i386-linux-gnu -o %t %s
+// RUN: %clang_cc1 -include-pch %t %s -triple i386-linux-gnu -emit-llvm -o - | FileCheck %s
+// expected-no-diagnostics
+
+#ifndef HEADER
+#define HEADER
+
+/// foo: declarations only
+
+__attribute__((assume("foo:before1"))) void foo();
+
+__attribute__((assume("foo:before2")))
+__attribute__((assume("foo:before3"))) void
+foo();
+
+/// baz: static function declarations and a definition
+
+__attribute__((assume("baz:before1"))) static void baz();
+
+__attribute__((assume("baz:before2")))
+__attribute__((assume("baz:before3"))) static void
+baz();
+
+// Definition
+__attribute__((assume("baz:def1,baz:def2"))) static void baz() { foo(); }
+
+__attribute__((assume("baz:after"))) static void baz();
+
+/// bar: external function declarations and a definition
+
+__attribute__((assume("bar:before1"))) void bar();
+
+__attribute__((assume("bar:before2")))
+__attribute__((assume("bar:before3"))) void
+bar();
+
+// Definition
+__attribute__((assume("bar:def1,bar:def2"))) void bar() { baz(); }
+
+__attribute__((assume("bar:after"))) void bar();
+
+/// back to foo
+
+__attribute__((assume("foo:after"))) void foo();
+
+/// class tests
+class C {
+  __attribute__((assume("C:private_method"))) void private_method();
+  __attribute__((assume("C:private_static"))) static void private_static();
+
+public:
+  __attribute__((assume("C:public_method1"))) void public_method();
+  __attribute__((assume("C:public_static1"))) static void public_static();
+};
+
+__attribute__((assume("C:public_method2"))) void C::public_method() {
+  private_method();
+}
+
+__attribute__((assume("C:public_static2"))) void C::public_static() {
+  private_static();
+}
+
+/// template tests
+template <typename T>
+__attribute__((assume("template_func<T>"))) void template_func() {}
+
+template <>
+__attribute__((assume("template_func<float>"))) void template_func<float>() {}
+
+template <>
+void template_func<int>() {}
+
+template <typename T>
+struct S {
+  __attribute__((assume("S<T>::method"))) void method();
+};
+
+template <>
+__attribute__((assume("S<float>::method"))) void S<float>::method() {}
+
+template <>
+void S<int>::method() {}
+
+// CHECK:         define{{.*}} void @_Z3barv() #0
+// CHECK:         define{{.*}} void @_ZL3bazv() #1
+// CHECK:         define{{.*}} void @_ZN1C13public_methodEv({{.*}}) #2
+// CHECK:         declare{{.*}} void @_ZN1C14private_methodEv({{.*}}) #3
+// CHECK:         define{{.*}} void @_ZN1C13public_staticEv() #4
+// CHECK:         declare{{.*}} void @_ZN1C14private_staticEv() #5
+// CHECK:         define{{.*}} void @_Z13template_funcIfEvv() #6
+// CHECK:         define{{.*}} void @_Z13template_funcIiEvv() #7
+// CHECK:         define{{.*}} void @_ZN1SIfE6methodEv({{.*}}) #8
+// CHECK:         define{{.*}} void @_ZN1SIiE6methodEv({{.*}}) #9
+// CHECK:         declare{{.*}} void @_Z3foov() #10
+// CHECK:         attributes #0
+// CHECK-SAME:      "llvm.assume"="bar:before1,bar:before2,bar:before3,bar:def1,bar:def2"
+// CHECK:         attributes #1
+// CHECK-SAME:      "llvm.assume"="baz:before1,baz:before2,baz:before3,baz:def1,baz:def2,baz:after"
+// CHECK:         attributes #2
+// CHECK-SAME:      "llvm.assume"="C:public_method1,C:public_method2"
+// CHECK:         attributes #3
+// CHECK-SAME:      "llvm.assume"="C:private_method"
+// CHECK:         attributes #4
+// CHECK-SAME:      "llvm.assume"="C:public_static1,C:public_static2"
+// CHECK:         attributes #5
+// CHECK-SAME:      "llvm.assume"="C:private_static"
+// CHECK:         attributes #6
+// CHECK-SAME:      "llvm.assume"="template_func<T>,template_func<float>"
+// CHECK:         attributes #7
+// CHECK-SAME:      "llvm.assume"="template_func<T>"
+// CHECK:         attributes #8
+// CHECK-SAME:      "llvm.assume"="S<T>::method,S<float>::method"
+// CHECK:         attributes #9
+// CHECK-SAME:      "llvm.assume"="S<T>::method"
+// CHECK:         attributes #10
+// CHECK-SAME:      "llvm.assume"="foo:before1,foo:before2,foo:before3"
+
+#endif

clang/test/Misc/pragma-attribute-supported-attributes-list.test

 // CHECK-NEXT: AllocSize (SubjectMatchRule_function)
 // CHECK-NEXT: AlwaysDestroy (SubjectMatchRule_variable)
 // CHECK-NEXT: AlwaysInline (SubjectMatchRule_function)
 // CHECK-NEXT: Annotate ()
 // CHECK-NEXT: AnyX86NoCfCheck (SubjectMatchRule_hasType_functionType)
 // CHECK-NEXT: ArcWeakrefUnavailable (SubjectMatchRule_objc_interface)
 // CHECK-NEXT: ArmBuiltinAlias (SubjectMatchRule_function)
 // CHECK-NEXT: AssumeAligned (SubjectMatchRule_objc_method, SubjectMatchRule_function)
+// CHECK-NEXT: Assumption (SubjectMatchRule_function)
 // CHECK-NEXT: Availability ((SubjectMatchRule_record, SubjectMatchRule_enum, SubjectMatchRule_enum_constant, SubjectMatchRule_field, SubjectMatchRule_function, SubjectMatchRule_namespace, SubjectMatchRule_objc_category, SubjectMatchRule_objc_implementation, SubjectMatchRule_objc_interface, SubjectMatchRule_objc_method, SubjectMatchRule_objc_property, SubjectMatchRule_objc_protocol, SubjectMatchRule_record, SubjectMatchRule_type_alias, SubjectMatchRule_variable))
 // CHECK-NEXT: BPFPreserveAccessIndex (SubjectMatchRule_record)
 // CHECK-NEXT: CFAuditedTransfer (SubjectMatchRule_function)
 // CHECK-NEXT: CFConsumed (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: CFICanonicalJumpTable (SubjectMatchRule_function)
 // CHECK-NEXT: CFUnknownTransfer (SubjectMatchRule_function)
 // CHECK-NEXT: CPUDispatch (SubjectMatchRule_function)
 // CHECK-NEXT: CPUSpecific (SubjectMatchRule_function)

clang/test/Sema/attr-assume.c

+// RUN: %clang_cc1 -triple i386-apple-darwin9 -fsyntax-only -verify %s
+
+void f1() __attribute__((assume(3))); // expected-error {{'assume' attribute requires a string}}
+void f2() __attribute__((assume(int))); // expected-error {{expected expression}}
+void f3() __attribute__((assume(for))); // expected-error {{expected expression}}
+void f4() __attribute__((assume("QQQQ"))); // expected-warning {{the assumption string 'QQQQ' is not known and might be misspelled}}
+void f5() __attribute__((assume("omp_no_openmp")));
+void f6() __attribute__((assume("omp_noopenmp"))); // expected-warning {{the assumption string 'omp_noopenmp' is not known and might be misspelled; did you mean 'omp_no_openmp'?}}
+void f7() __attribute__((assume("omp_no_openmp_routine"))); // expected-warning {{the assumption string 'omp_no_openmp_routine' is not known and might be misspelled; did you mean 'omp_no_openmp_routines'?}}
+void f8() __attribute__((assume("omp_no_openmp1"))); // expected-warning {{the assumption string 'omp_no_openmp1' is not known and might be misspelled; did you mean 'omp_no_openmp'?}}
+
+int g1 __attribute__((assume(0))); // expected-warning {{'assume' attribute only applies to functions}}
+int g2 __attribute__((assume("omp_no_openmp"))); // expected-warning {{'assume' attribute only applies to functions}}