steplong updated this revision to Diff 426998.
steplong added a comment.
Removed unnecessary braces (mentioned in the LLVM coding standard)
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D124702/new/
https://reviews.llvm.org/D124702
Files:
clang/include/clang/Parse/Parser.h
clang/include/clang/Sema/Sema.h
clang/lib/Parse/ParsePragma.cpp
clang/lib/Sema/SemaAttr.cpp
clang/lib/Sema/SemaDecl.cpp
Index: clang/lib/Sema/SemaDecl.cpp
===================================================================
--- clang/lib/Sema/SemaDecl.cpp
+++ 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.
Index: clang/lib/Sema/SemaAttr.cpp
===================================================================
--- clang/lib/Sema/SemaAttr.cpp
+++ clang/lib/Sema/SemaAttr.cpp
@@ -1065,6 +1065,19 @@
OptimizeOffPragmaLocation = PragmaLoc;
}
+void Sema::ActOnPragmaMSIntrinsic(const std::vector<StringRef> &Intrinsics) {
+ for (auto &Intrinsic : Intrinsics)
+ MSFunctionNoBuiltins.erase(std::remove(MSFunctionNoBuiltins.begin(),
+ MSFunctionNoBuiltins.end(),
+ Intrinsic),
+ MSFunctionNoBuiltins.end());
+}
+
+void Sema::ActOnPragmaMSFunction(const std::vector<StringRef> &NoBuiltins) {
+ 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 +1099,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<std::pair<unsigned, SourceLocation> > VisStack;
enum : unsigned { NoVisibility = ~0U };
Index: clang/lib/Parse/ParsePragma.cpp
===================================================================
--- clang/lib/Parse/ParsePragma.cpp
+++ 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<PragmaMSRuntimeChecksHandler>();
PP.AddPragmaHandler(MSRuntimeChecks.get());
- MSIntrinsic = std::make_unique<PragmaMSIntrinsicHandler>();
+ MSIntrinsic = std::make_unique<PragmaMSIntrinsicHandler>(Actions);
PP.AddPragmaHandler(MSIntrinsic.get());
+ MSFunction = std::make_unique<PragmaMSFunctionHandler>(Actions);
+ PP.AddPragmaHandler(MSFunction.get());
MSOptimize = std::make_unique<PragmaMSOptimizeHandler>();
PP.AddPragmaHandler(MSOptimize.get());
MSFenvAccess = std::make_unique<PragmaMSFenvAccessHandler>();
@@ -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());
@@ -3523,11 +3539,14 @@
bool SuggestIntrinH = !PP.isMacroDefined("__INTRIN_H");
+ std::vector<StringRef> 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.push_back(II->getName());
PP.Lex(Tok);
if (Tok.isNot(tok::comma))
@@ -3545,6 +3564,51 @@
if (Tok.isNot(tok::eod))
PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
<< "intrinsic";
+
+ Actions.ActOnPragmaMSIntrinsic(Intrinsics);
+}
+
+void PragmaMSFunctionHandler::HandlePragma(Preprocessor &PP,
+ PragmaIntroducer Introducer,
+ Token &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");
+
+ std::vector<StringRef> 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.push_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(NoBuiltins);
}
// #pragma optimize("gsty", on|off)
Index: clang/include/clang/Sema/Sema.h
===================================================================
--- clang/include/clang/Sema/Sema.h
+++ clang/include/clang/Sema/Sema.h
@@ -755,6 +755,8 @@
/// optimizations are currently "on", this is set to an invalid location.
SourceLocation OptimizeOffPragmaLocation;
+ std::vector<StringRef> MSFunctionNoBuiltins;
+
/// Flag indicating if Sema is building a recovery call expression.
///
/// This flag is used to avoid building recovery call expressions
@@ -10314,6 +10316,10 @@
/// Called on well formed \#pragma clang optimize.
void ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc);
+ void ActOnPragmaMSIntrinsic(const std::vector<StringRef> &Intrinsics);
+
+ void ActOnPragmaMSFunction(const std::vector<StringRef> &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 +10336,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);
Index: clang/include/clang/Parse/Parser.h
===================================================================
--- clang/include/clang/Parse/Parser.h
+++ clang/include/clang/Parse/Parser.h
@@ -196,6 +196,7 @@
std::unique_ptr<PragmaHandler> MSSection;
std::unique_ptr<PragmaHandler> MSRuntimeChecks;
std::unique_ptr<PragmaHandler> MSIntrinsic;
+ std::unique_ptr<PragmaHandler> MSFunction;
std::unique_ptr<PragmaHandler> MSOptimize;
std::unique_ptr<PragmaHandler> MSFenvAccess;
std::unique_ptr<PragmaHandler> CUDAForceHostDeviceHandler;
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
