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 function/intrinsic' 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,8 @@ /// optimizations are currently "on", this is set to an invalid location. SourceLocation OptimizeOffPragmaLocation; + SmallVector MSFunctionNoBuiltins; + /// Flag indicating if Sema is building a recovery call expression. /// /// This flag is used to avoid building recovery call expressions @@ -10314,6 +10316,12 @@ /// Called on well formed \#pragma clang optimize. void ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc); + void ActOnPragmaMSIntrinsic(SourceLocation Loc, + const SmallVectorImpl &Intrinsics); + + void ActOnPragmaMSFunction(SourceLocation Loc, + const 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 { @@ -10330,6 +10338,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 @@ -250,9 +250,21 @@ }; struct PragmaMSIntrinsicHandler : public PragmaHandler { - PragmaMSIntrinsicHandler() : PragmaHandler("intrinsic") {} + PragmaMSIntrinsicHandler(Sema &S) : PragmaHandler("intrinsic"), Actions(S) {} void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) override; + +private: + Sema &Actions; +}; + +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 { @@ -447,8 +459,10 @@ PP.AddPragmaHandler(MSSection.get()); MSRuntimeChecks = std::make_unique(); PP.AddPragmaHandler(MSRuntimeChecks.get()); - MSIntrinsic = std::make_unique(); + MSIntrinsic = std::make_unique(Actions); 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 +572,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()); @@ -3512,6 +3528,7 @@ void PragmaMSIntrinsicHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) { + Token FirstTok = Tok; PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { @@ -3523,11 +3540,14 @@ bool SuggestIntrinH = !PP.isMacroDefined("__INTRIN_H"); + SmallVector Intrinsics; while (Tok.is(tok::identifier)) { IdentifierInfo *II = Tok.getIdentifierInfo(); if (!II->getBuiltinID()) PP.Diag(Tok.getLocation(), diag::warn_pragma_intrinsic_builtin) << II << SuggestIntrinH; + else + Intrinsics.emplace_back(II->getName()); PP.Lex(Tok); if (Tok.isNot(tok::comma)) @@ -3545,6 +3565,52 @@ if (Tok.isNot(tok::eod)) PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "intrinsic"; + + Actions.ActOnPragmaMSIntrinsic(FirstTok.getLocation(), Intrinsics); +} + +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"); + + 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) 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,31 @@ OptimizeOffPragmaLocation = PragmaLoc; } +void Sema::ActOnPragmaMSIntrinsic( + SourceLocation Loc, const SmallVectorImpl &Intrinsics) { + if (!CurContext->getRedeclContext()->isFileContext()) { + Diag(Loc, diag::err_pragma_intrinsic_function_scope); + return; + } + + for (auto &Intrinsic : Intrinsics) + MSFunctionNoBuiltins.erase(std::remove(MSFunctionNoBuiltins.begin(), + MSFunctionNoBuiltins.end(), + Intrinsic), + MSFunctionNoBuiltins.end()); +} + +void Sema::ActOnPragmaMSFunction(SourceLocation Loc, + const SmallVectorImpl &NoBuiltins) { + if (!CurContext->getRedeclContext()->isFileContext()) { + Diag(Loc, diag::err_pragma_intrinsic_function_scope); + return; + } + + MSFunctionNoBuiltins.insert(MSFunctionNoBuiltins.end(), + 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 +1111,12 @@ FD->addAttr(NoInlineAttr::CreateImplicit(Context, Loc)); } +void Sema::AddRangeBasedNoBuiltin(FunctionDecl *FD) { + if (!MSFunctionNoBuiltins.empty()) + FD->addAttr(NoBuiltinAttr::CreateImplicit(Context, + MSFunctionNoBuiltins.data(), MSFunctionNoBuiltins.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-intrinsic.c b/clang/test/CodeGen/pragma-ms-function-intrinsic.c new file mode 100644 --- /dev/null +++ b/clang/test/CodeGen/pragma-ms-function-intrinsic.c @@ -0,0 +1,78 @@ +// 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); +} + +#pragma intrinsic(memset, strlen) + +// CHECK: define{{.*}} void @foo4({{.*}}) #[[NOBUILTIN_MEMCPY:[0-9]+]] +// CHECK: call void @bar +// CHECK: call void @llvm.memset +// CHECK: {{.*}}call {{.*}} @memcpy +void foo4(char *s, char *d, size_t n) +{ + bar(s); + memset(s, 3, n); + memcpy(d, s, n); +} + +#pragma intrinsic(memcpy) + +// CHECK: define{{.*}} void @foo5({{.*}}) #[[NO_NOBUILTIN]] +// CHECK: call void @bar +// CHECK: call void @llvm.memset +// CHECK: call void @llvm.memcpy +void foo5(char *s, char *d, size_t n) +{ + bar(s); + memset(s, 4, 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"{{.*}}} +// CHECK: attributes #[[NOBUILTIN_MEMCPY]] = {{{.*}}"no-builtin-memcpy"{{.*}}} +// CHECK-NOT: attributes #[[NOBUILTIN_MEMCPY]] = {{{.*}}"no-builtin-memcpy"{{.*}}"no-builtin-memset"{{.*}}}