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 @@ -984,6 +984,9 @@ def err_super_in_lambda_unsupported : Error< "use of '__super' inside a lambda is unsupported">; +def err_pragma_intrinsic_function_scope : Error< + "'#pragma %0' can only appear outside a function, at the global level">; + def warn_pragma_unused_undeclared_var : Warning< "undeclared variable %0 used as an argument for '#pragma unused'">, InGroup; diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h --- a/clang/include/clang/Parse/Parser.h +++ b/clang/include/clang/Parse/Parser.h @@ -196,6 +196,7 @@ std::unique_ptr MSSection; std::unique_ptr MSRuntimeChecks; std::unique_ptr MSIntrinsic; + std::unique_ptr MSFunction; std::unique_ptr MSOptimize; std::unique_ptr MSFenvAccess; std::unique_ptr CUDAForceHostDeviceHandler; 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 @@ -755,6 +755,9 @@ /// optimizations are currently "on", this is set to an invalid location. SourceLocation OptimizeOffPragmaLocation; + /// Set of no-builtin functions listed by \#pragma function. + llvm::SmallSetVector MSFunctionNoBuiltins; + /// Flag indicating if Sema is building a recovery call expression. /// /// This flag is used to avoid building recovery call expressions @@ -10322,6 +10325,11 @@ /// Called on well formed \#pragma clang optimize. void ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc); + /// Call on well formed \#pragma function. + void + ActOnPragmaMSFunction(SourceLocation Loc, + const llvm::SmallVectorImpl &NoBuiltins); + /// Get the location for the currently active "\#pragma clang optimize /// off". If this location is invalid, then the state of the pragma is "on". SourceLocation getOptimizeOffPragmaLocation() const { @@ -10338,6 +10346,11 @@ /// attribute to be added (usually because of a pragma). void AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, SourceLocation Loc); + /// Only called on function definitions; if there is a pragma in scope + /// with the effect of a range-based no_builtin, consider marking the function + /// with attribute no_builtin. + void AddRangeBasedNoBuiltin(FunctionDecl *FD); + /// AddAlignedAttr - Adds an aligned attribute to a particular declaration. void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, bool IsPackExpansion); diff --git a/clang/lib/Parse/ParsePragma.cpp b/clang/lib/Parse/ParsePragma.cpp --- a/clang/lib/Parse/ParsePragma.cpp +++ b/clang/lib/Parse/ParsePragma.cpp @@ -255,6 +255,15 @@ Token &FirstToken) override; }; +struct PragmaMSFunctionHandler : public PragmaHandler { + PragmaMSFunctionHandler(Sema &S) : PragmaHandler("function"), Actions(S) {} + void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, + Token &FirstToken) override; + +private: + Sema &Actions; +}; + struct PragmaMSOptimizeHandler : public PragmaHandler { PragmaMSOptimizeHandler() : PragmaHandler("optimize") {} void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, @@ -449,6 +458,8 @@ PP.AddPragmaHandler(MSRuntimeChecks.get()); MSIntrinsic = std::make_unique(); PP.AddPragmaHandler(MSIntrinsic.get()); + MSFunction = std::make_unique(Actions); + PP.AddPragmaHandler(MSFunction.get()); MSOptimize = std::make_unique(); PP.AddPragmaHandler(MSOptimize.get()); MSFenvAccess = std::make_unique(); @@ -558,6 +569,8 @@ MSRuntimeChecks.reset(); PP.RemovePragmaHandler(MSIntrinsic.get()); MSIntrinsic.reset(); + PP.RemovePragmaHandler(MSFunction.get()); + MSFunction.reset(); PP.RemovePragmaHandler(MSOptimize.get()); MSOptimize.reset(); PP.RemovePragmaHandler(MSFenvAccess.get()); @@ -3547,6 +3560,48 @@ << "intrinsic"; } +void PragmaMSFunctionHandler::HandlePragma(Preprocessor &PP, + PragmaIntroducer Introducer, + Token &Tok) { + Token FirstTok = Tok; + PP.Lex(Tok); + + if (Tok.isNot(tok::l_paren)) { + PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "function"; + return; + } + PP.Lex(Tok); // ( + + bool SuggestIntrinH = !PP.isMacroDefined("__INTRIN_H"); + + llvm::SmallVector NoBuiltins; + while (Tok.is(tok::identifier)) { + IdentifierInfo *II = Tok.getIdentifierInfo(); + if (!II->getBuiltinID()) + PP.Diag(Tok.getLocation(), diag::warn_pragma_intrinsic_builtin) + << II << SuggestIntrinH; + else + NoBuiltins.emplace_back(II->getName()); + + PP.Lex(Tok); + if (Tok.isNot(tok::comma)) + break; + PP.Lex(Tok); // , + } + + if (Tok.isNot(tok::r_paren)) { + PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "function"; + return; + } + PP.Lex(Tok); // ) + + if (Tok.isNot(tok::eod)) + PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) + << "function"; + + Actions.ActOnPragmaMSFunction(FirstTok.getLocation(), NoBuiltins); +} + // #pragma optimize("gsty", on|off) void PragmaMSOptimizeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, diff --git a/clang/lib/Sema/SemaAttr.cpp b/clang/lib/Sema/SemaAttr.cpp --- a/clang/lib/Sema/SemaAttr.cpp +++ b/clang/lib/Sema/SemaAttr.cpp @@ -1065,6 +1065,16 @@ OptimizeOffPragmaLocation = PragmaLoc; } +void Sema::ActOnPragmaMSFunction( + SourceLocation Loc, const llvm::SmallVectorImpl &NoBuiltins) { + // if (!CurContext->getRedeclContext()->isFileContext()) { + // Diag(Loc, diag::err_pragma_intrinsic_function_scope) << "function"; + // return; + //} + + MSFunctionNoBuiltins.insert(NoBuiltins.begin(), NoBuiltins.end()); +} + void Sema::AddRangeBasedOptnone(FunctionDecl *FD) { // In the future, check other pragmas if they're implemented (e.g. pragma // optimize 0 will probably map to this functionality too). @@ -1086,6 +1096,13 @@ FD->addAttr(NoInlineAttr::CreateImplicit(Context, Loc)); } +void Sema::AddRangeBasedNoBuiltin(FunctionDecl *FD) { + SmallVector V(MSFunctionNoBuiltins.begin(), + MSFunctionNoBuiltins.end()); + if (!MSFunctionNoBuiltins.empty()) + FD->addAttr(NoBuiltinAttr::CreateImplicit(Context, V.data(), V.size())); +} + typedef std::vector > VisStack; enum : unsigned { NoVisibility = ~0U }; 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 @@ -10218,10 +10218,12 @@ // marking the function. AddCFAuditedAttribute(NewFD); - // If this is a function definition, check if we have to apply optnone due to - // a pragma. - if(D.isFunctionDefinition()) + // If this is a function definition, check if we have to apply any + // attributes (i.e. optnone and no_builtin) due to a pragma. + if (D.isFunctionDefinition()) { AddRangeBasedOptnone(NewFD); + AddRangeBasedNoBuiltin(NewFD); + } // If this is the first declaration of an extern C variable, update // the map of such variables. diff --git a/clang/test/CodeGen/pragma-ms-function.c b/clang/test/CodeGen/pragma-ms-function.c new file mode 100644 --- /dev/null +++ b/clang/test/CodeGen/pragma-ms-function.c @@ -0,0 +1,47 @@ +// RUN: %clang_cc1 -emit-llvm -fms-extensions -o - %s | FileCheck %s + +typedef typeof(sizeof(0)) size_t; + +void bar(char *s); +void *memset(void *s, int c, size_t n); +void *memcpy(void *d, const void *s, size_t n); + +// CHECK: define{{.*}} void @foo1({{.*}}) #[[NO_NOBUILTIN:[0-9]+]] +// CHECK: call void @bar +// CHECK: call void @llvm.memset +// CHECK: call void @llvm.memcpy +void foo1(char *s, char *d, size_t n) { + bar(s); + memset(s, 0, n); + memcpy(d, s, n); +} + +#pragma function(strlen, memset) + +// CHECK: define{{.*}} void @foo2({{.*}}) #[[NOBUILTIN_MEMSET:[0-9]+]] +// CHECK: call void @bar +// CHECK: {{.*}}call {{.*}} @memset +// CHECK: call void @llvm.memcpy +void foo2(char *s, char *d, size_t n) { + bar(s); + memset(s, 1, n); + memcpy(d, s, n); +} + +#pragma function(memcpy) + +// CHECK: define{{.*}} void @foo3({{.*}}) #[[NOBUILTIN_MEMSET_MEMCPY:[0-9]+]] +// CHECK: call void @bar +// CHECK: {{.*}}call {{.*}} @memset +// CHECK: {{.*}}call {{.*}} @memcpy +void foo3(char *s, char *d, size_t n) { + bar(s); + memset(s, 2, n); + memcpy(d, s, n); +} + +// CHECK-NOT: attributes #[[NO_NOBUILTIN]] = {{{.*}}"no-builtin-memset"{{.*}}} +// CHECK-NOT: attributes #[[NO_NOBUILTIN]] = {{{.*}}"no-builtin-memcpy"{{.*}}"no-builtin-memset"{{.*}}} +// CHECK: attributes #[[NOBUILTIN_MEMSET]] = {{{.*}}"no-builtin-memset"{{.*}}} +// CHECK-NOT: attributes #[[NOBUILTIN_MEMSET]] = {{{.*}}"no-builtin-memcpy"{{.*}}"no-builtin-memset"{{.*}}} +// CHECK: attributes #[[NOBUILTIN_MEMSET_MEMCPY]] = {{{.*}}"no-builtin-memcpy"{{.*}}"no-builtin-memset"{{.*}}} diff --git a/clang/test/Preprocessor/pragma_microsoft.c b/clang/test/Preprocessor/pragma_microsoft.c --- a/clang/test/Preprocessor/pragma_microsoft.c +++ b/clang/test/Preprocessor/pragma_microsoft.c @@ -201,6 +201,31 @@ #pragma clang diagnostic pop #pragma intrinsic(asdf) // expected-warning {{'asdf' is not a recognized builtin; consider including }} +// Test pragma function +#pragma function(memset) // no-warning +#pragma function(memcpy, strlen, strlen) // no-warning +#pragma function() // no-warning +#pragma function(asdf) // expected-warning {{'asdf' is not a recognized builtin; consider including }} +#pragma function(main) // expected-warning {{'main' is not a recognized builtin; consider including }} +#pragma function( // expected-warning {{missing ')' after}} +#pragma function(int) // expected-warning {{missing ')' after}} +#pragma function(strcmp) asdf // expected-warning {{extra tokens at end}} + +#define __INTRIN_H // there should be no notes after defining __INTRIN_H +#pragma function(asdf) // expected-warning-re {{'asdf' is not a recognized builtin{{$}}}} +#pragma function(memset) // no-warning +#undef __INTRIN_H +#pragma function(asdf) // expected-warning {{'asdf' is not a recognized builtin; consider including }} + +struct pragma_function_S { +#pragma function(memset) // no-warning + int a; +}; + +void pragma_function_foo() { +#pragma function(memset) // expected-error {{'#pragma function' can only appear outside a function, at the global level}} +} + #pragma optimize // expected-warning{{missing '(' after '#pragma optimize'}} #pragma optimize( // expected-warning{{expected string literal in '#pragma optimize'}} #pragma optimize(a // expected-warning{{expected string literal in '#pragma optimize'}}