diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td --- a/clang/include/clang/Basic/Attr.td +++ b/clang/include/clang/Basic/Attr.td @@ -3412,3 +3412,10 @@ let Subjects = SubjectList<[NonParmVar, Function, Block, ObjCMethod]>; let Documentation = [ObjCExternallyRetainedDocs]; } + +def NoBuiltin : InheritableAttr { + let Spellings = [Clang<"no_builtin">]; + let Args = [VariadicStringArgument<"FunctionNames">]; + let Subjects = SubjectList<[Function]>; + let Documentation = [NoBuiltinDocs]; +} diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td --- a/clang/include/clang/Basic/AttrDocs.td +++ b/clang/include/clang/Basic/AttrDocs.td @@ -4391,3 +4391,37 @@ }]; } + +def NoBuiltinDocs : Documentation { + let Category = DocCatFunction; + let Content = [{ +.. Note:: This attribute is not yet fully implemented, it is validated but has +no effect on the generated code. + +The ``__attribute__((no_builtin))`` is similar to the ``-fno-builtin`` flag +except it is specific to the body of a function. + +It accepts one or more strings corresponding to the name of the builtin +(e.g. "memcpy", "memset") or "*" which disables all builtins at once. + +.. code-block:: c++ + + // The compiler is not allowed to replace parts of foo's body with builtins. + void foo(char* data, size_t count) __attribute__((no_builtin("*"))) { + // The compiler is not allowed to convert the loop into + // `__builtin_memset(data, 0xFE, count);`. + for (size_t i = 0; i < count; ++i) + data[i] = 0xFE; + } + + // The compiler is not allowed to replace parts of bar's body with the memcpy + // builtin. + void bar(char* data, size_t count) __attribute__((no_builtin("memcpy"))) { + // The compiler is allowed to convert the loop into + // `__builtin_memset(data, 0xFE, count);` but cannot generate any + // `__builtin_memcpy` + for (size_t i = 0; i < count; ++i) + data[i] = 0xFE; + } + }]; +} diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -3597,6 +3597,12 @@ def err_attribute_overloadable_multiple_unmarked_overloads : Error< "at most one overload for a given name may lack the 'overloadable' " "attribute">; +def err_attribute_no_builtin_invalid_functionname : Error< + "'%0' is not a valid function name for %1">; +def err_attribute_no_builtin_wildcard_or_functionname : Error< + "%0 wildcard (*) cannot be composed with other function names">; +def err_attribute_no_builtin_on_non_definition : Error< + "%0 attribute is permitted on definitions only">; def warn_ns_attribute_wrong_return_type : Warning< "%0 attribute only applies to %select{functions|methods|properties}1 that " "return %select{an Objective-C object|a pointer|a non-retainable pointer}2">, diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -2691,6 +2691,8 @@ MSInheritanceAttr * mergeMSInheritanceAttr(Decl *D, const AttributeCommonInfo &CI, bool BestCase, MSInheritanceAttr::Spelling SemanticSpelling); + NoBuiltinAttr *mergeNoBuiltinAttr(Decl *D, const AttributeCommonInfo &CI, + llvm::ArrayRef FunctionNames); FormatAttr *mergeFormatAttr(Decl *D, const AttributeCommonInfo &CI, IdentifierInfo *Format, int FormatIdx, int FirstArg); diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp --- a/clang/lib/CodeGen/CGCall.cpp +++ b/clang/lib/CodeGen/CGCall.cpp @@ -1849,6 +1849,18 @@ FuncAttrs.addAttribute(llvm::Attribute::NoDuplicate); if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::Convergent); + if (const auto *Attr = TargetDecl->getAttr()) { + bool HasWildcard = llvm::is_contained(Attr->functionNames(), "*"); + if (HasWildcard) + FuncAttrs.addAttribute("no-builtins"); + else + for (StringRef FunctionName : Attr->functionNames()) { + SmallString<32> AttributeName; + AttributeName += "no-builtin-"; + AttributeName += FunctionName; + FuncAttrs.addAttribute(AttributeName); + } + } if (const FunctionDecl *Fn = dyn_cast(TargetDecl)) { AddAttributesFromFunctionProtoType( diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -2531,6 +2531,11 @@ NewAttr = S.mergeNoSpeculativeLoadHardeningAttr(D, *SLHA); else if (Attr->shouldInheritEvenIfAlreadyPresent() || !DeclHasAttr(D, Attr)) NewAttr = cast(Attr->clone(S.Context)); + else if (const auto *NBA = dyn_cast(Attr)) + NewAttr = + S.mergeNoBuiltinAttr(D, *NBA, + llvm::makeArrayRef(NBA->functionNames_begin(), + NBA->functionNames_end())); if (NewAttr) { NewAttr->setInherited(true); @@ -9493,6 +9498,11 @@ } } + if (!D.isFunctionDefinition()) + if (const auto *NBA = NewFD->getAttr()) + Diag(NBA->getLocation(), diag::err_attribute_no_builtin_on_non_definition) + << NBA->getSpelling(); + return NewFD; } diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp --- a/clang/lib/Sema/SemaDeclAttr.cpp +++ b/clang/lib/Sema/SemaDeclAttr.cpp @@ -1068,6 +1068,56 @@ S.Context, AL, Cond, Msg, DiagType, ArgDependent, cast(D))); } +NoBuiltinAttr * +Sema::mergeNoBuiltinAttr(Decl *D, const AttributeCommonInfo &CI, + llvm::ArrayRef FunctionNames) { + llvm::SmallVector Names; + bool HasWildcard = false; + + const auto TestAndPushBack = [&Names, &HasWildcard](StringRef Name) { + HasWildcard |= (Name == "*"); + Names.push_back(Name); + }; + + if (const auto *NBA = D->getAttr()) + for (StringRef FunctionName : NBA->functionNames()) + TestAndPushBack(FunctionName); + + for (StringRef FunctionName : FunctionNames) + TestAndPushBack(FunctionName); + + if (HasWildcard && Names.size() > 1) + Diag(D->getLocation(), + diag::err_attribute_no_builtin_wildcard_or_functionname) + << CI.getAttrName()->getName(); + + llvm::sort(Names); + Names.erase(std::unique(Names.begin(), Names.end()), Names.end()); + return ::new (Context) NoBuiltinAttr(Context, CI, Names.data(), Names.size()); +} + +static void handleNoBuiltin(Sema &S, Decl *D, const ParsedAttr &AL) { + if (!checkAttributeAtLeastNumArgs(S, AL, 1)) + return; + + llvm::SmallVector FunctionNames; + for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) { + StringRef FunctionName; + SourceLocation LiteralLoc; + if (!S.checkStringLiteralArgumentAttr(AL, I, FunctionName, &LiteralLoc)) + return; + + bool IsValidBuiltin = Builtin::Context::isBuiltinFunc(FunctionName.data()); + bool IsValidFunctionName = FunctionName == "*" || IsValidBuiltin; + if (!IsValidFunctionName) + S.Diag(LiteralLoc, diag::err_attribute_no_builtin_invalid_functionname) + << FunctionName << AL.getAttrName()->getName(); + + FunctionNames.push_back(FunctionName); + } + D->addAttr(S.mergeNoBuiltinAttr(D, AL, FunctionNames)); +} + static void handlePassObjectSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) { if (D->hasAttr()) { S.Diag(D->getBeginLoc(), diag::err_attribute_only_once_per_parameter) << AL; @@ -6578,6 +6628,9 @@ case ParsedAttr::AT_DiagnoseIf: handleDiagnoseIfAttr(S, D, AL); break; + case ParsedAttr::AT_NoBuiltin: + handleNoBuiltin(S, D, AL); + break; case ParsedAttr::AT_ExtVectorType: handleExtVectorTypeAttr(S, D, AL); break; diff --git a/clang/test/CodeGen/no-builtin.c b/clang/test/CodeGen/no-builtin.c new file mode 100644 --- /dev/null +++ b/clang/test/CodeGen/no-builtin.c @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -S -emit-llvm -o - %s | FileCheck %s + +// CHECK-LABEL: define void @foo_no_mempcy() #0 +void foo_no_mempcy() __attribute__((no_builtin("memcpy"))) {} + +// CHECK-LABEL: define void @foo_no_builtins() #1 +void foo_no_builtins() __attribute__((no_builtin("*"))) {} + +// CHECK-LABEL: define void @foo_no_mempcy_memset() #2 +void foo_no_mempcy_memset() __attribute__((no_builtin("memset", "memcpy"))) {} + +// CHECK-LABEL: define void @separate_attrs() #2 +void separate_attrs() __attribute__((no_builtin("memset"))) __attribute__((no_builtin("memcpy"))) {} + +// CHECK: attributes #0 = {{{.*}}"no-builtin-memcpy"{{.*}}} +// CHECK: attributes #1 = {{{.*}}"no-builtins"{{.*}}} +// CHECK: attributes #2 = {{{.*}}"no-builtin-memcpy"{{.*}}"no-builtin-memset"{{.*}}} diff --git a/clang/test/Misc/pragma-attribute-supported-attributes-list.test b/clang/test/Misc/pragma-attribute-supported-attributes-list.test --- a/clang/test/Misc/pragma-attribute-supported-attributes-list.test +++ b/clang/test/Misc/pragma-attribute-supported-attributes-list.test @@ -74,6 +74,7 @@ // CHECK-NEXT: NSConsumed (SubjectMatchRule_variable_is_parameter) // CHECK-NEXT: NSConsumesSelf (SubjectMatchRule_objc_method) // CHECK-NEXT: Naked (SubjectMatchRule_function) +// CHECK-NEXT: NoBuiltin (SubjectMatchRule_function) // CHECK-NEXT: NoCommon (SubjectMatchRule_variable) // CHECK-NEXT: NoDebug (SubjectMatchRule_type_alias, SubjectMatchRule_hasType_functionType, SubjectMatchRule_objc_method, SubjectMatchRule_variable_not_is_parameter) // CHECK-NEXT: NoDestroy (SubjectMatchRule_variable) diff --git a/clang/test/Sema/no-builtin.c b/clang/test/Sema/no-builtin.c new file mode 100644 --- /dev/null +++ b/clang/test/Sema/no-builtin.c @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -S -emit-llvm -o - -fsyntax-only -verify %s + +void valid_attribute_wildcard() __attribute__((no_builtin("*"))) {} +void valid_attribute_function() __attribute__((no_builtin("memcpy"))) {} +void valid_attribute_functions() __attribute__((no_builtin("memcpy"))) __attribute__((no_builtin("memcmp"))) {} + +void no_builtin_no_argument() __attribute__((no_builtin)) {} +// expected-error@-1 {{'no_builtin' attribute takes at least 1 argument}} + +void no_builtin_no_argument2() __attribute__((no_builtin())) {} +// expected-error@-1 {{'no_builtin' attribute takes at least 1 argument}} + +void invalid_builtin() __attribute__((no_builtin("not_a_builtin"))) {} +// expected-error@-1 {{'not_a_builtin' is not a valid function name for no_builtin}} + +void wildcard_and_functionname() __attribute__((no_builtin("*", "memcpy"))) {} +// expected-error@-1 {{no_builtin wildcard (*) cannot be composed with other function names}} + +void wildcard_and_functionname2() __attribute__((no_builtin("*"))) __attribute__((no_builtin("memcpy"))) {} +// expected-error@-1 {{no_builtin wildcard (*) cannot be composed with other function names}} + +void nobuiltin_on_declaration() __attribute__((no_builtin("memcpy"))); +// expected-error@-1 {{no_builtin attribute is permitted on definitions only}} + +int __attribute__((no_builtin("*"))) variable; +// expected-warning@-1 {{'no_builtin' attribute only applies to functions}}