Skip to content

[clang][NFCI] Clarify ownership of PragmaHandlers #117703

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
Fznamznon wants to merge 1 commit into from
Closed

[clang][NFCI] Clarify ownership of PragmaHandlers #117703

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 3 additions & 3 deletions clang/include/clang/Lex/Pragma.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -96,7 +96,7 @@ class EmptyPragmaHandler : public PragmaHandler {
class PragmaNamespace : public PragmaHandler {
/// Handlers - This is a map of the handlers in this namespace with their name
/// as key.
llvm::StringMap<std::unique_ptr<PragmaHandler>> Handlers;
llvm::StringMap<std::shared_ptr<PragmaHandler>> Handlers;

public:
explicit PragmaNamespace(StringRef Name) : PragmaHandler(Name) {}
Expand All @@ -109,11 +109,11 @@ class PragmaNamespace : public PragmaHandler {
bool IgnoreNull = true) const;

/// AddPragma - Add a pragma to this namespace.
void AddPragma(PragmaHandler *Handler);
void AddPragma(std::shared_ptr<PragmaHandler> Handler);

/// RemovePragmaHandler - Remove the given handler from the
/// namespace.
void RemovePragmaHandler(PragmaHandler *Handler);
void RemovePragmaHandler(StringRef Name);

bool IsEmpty() const { return Handlers.empty(); }

Expand Down
13 changes: 7 additions & 6 deletions clang/include/clang/Lex/Preprocessor.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1530,19 +1530,20 @@ class Preprocessor {
///
/// If \p Namespace is non-null, then it is a token required to exist on the
/// pragma line before the pragma string starts, e.g. "STDC" or "GCC".
void AddPragmaHandler(StringRef Namespace, PragmaHandler *Handler);
void AddPragmaHandler(PragmaHandler *Handler) {
void AddPragmaHandler(StringRef Namespace,
std::shared_ptr<PragmaHandler> Handler);
void AddPragmaHandler(std::shared_ptr<PragmaHandler> Handler) {
AddPragmaHandler(StringRef(), Handler);
}

/// Remove the specific pragma handler from this preprocessor.
///
/// If \p Namespace is non-null, then it should be the namespace that
/// \p Handler was added to. It is an error to remove a handler that
/// \p HandlerName was added to. It is an error to remove a handler that
/// has not been registered.
void RemovePragmaHandler(StringRef Namespace, PragmaHandler *Handler);
void RemovePragmaHandler(PragmaHandler *Handler) {
RemovePragmaHandler(StringRef(), Handler);
void RemovePragmaHandler(StringRef Namespace, StringRef HandlerName);
void RemovePragmaHandler(StringRef HandlerName) {
RemovePragmaHandler(StringRef(), HandlerName);
}

/// Install empty handlers for all pragmas (making them ignored).
Expand Down
102 changes: 51 additions & 51 deletions clang/include/clang/Parse/Parser.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -173,54 +173,57 @@ class Parser : public CodeCompletionHandler {
// used as type traits.
llvm::SmallDenseMap<IdentifierInfo *, tok::TokenKind> RevertibleTypeTraits;

std::unique_ptr<PragmaHandler> AlignHandler;
std::unique_ptr<PragmaHandler> GCCVisibilityHandler;
std::unique_ptr<PragmaHandler> OptionsHandler;
std::unique_ptr<PragmaHandler> PackHandler;
std::unique_ptr<PragmaHandler> MSStructHandler;
std::unique_ptr<PragmaHandler> UnusedHandler;
std::unique_ptr<PragmaHandler> WeakHandler;
std::unique_ptr<PragmaHandler> RedefineExtnameHandler;
std::unique_ptr<PragmaHandler> FPContractHandler;
std::unique_ptr<PragmaHandler> OpenCLExtensionHandler;
std::unique_ptr<PragmaHandler> OpenMPHandler;
std::unique_ptr<PragmaHandler> OpenACCHandler;
std::unique_ptr<PragmaHandler> PCSectionHandler;
std::unique_ptr<PragmaHandler> MSCommentHandler;
std::unique_ptr<PragmaHandler> MSDetectMismatchHandler;
std::unique_ptr<PragmaHandler> FPEvalMethodHandler;
std::unique_ptr<PragmaHandler> FloatControlHandler;
std::unique_ptr<PragmaHandler> MSPointersToMembers;
std::unique_ptr<PragmaHandler> MSVtorDisp;
std::unique_ptr<PragmaHandler> MSInitSeg;
std::unique_ptr<PragmaHandler> MSDataSeg;
std::unique_ptr<PragmaHandler> MSBSSSeg;
std::unique_ptr<PragmaHandler> MSConstSeg;
std::unique_ptr<PragmaHandler> MSCodeSeg;
std::unique_ptr<PragmaHandler> MSSection;
std::unique_ptr<PragmaHandler> MSStrictGuardStackCheck;
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> MSAllocText;
std::unique_ptr<PragmaHandler> CUDAForceHostDeviceHandler;
std::unique_ptr<PragmaHandler> OptimizeHandler;
std::unique_ptr<PragmaHandler> LoopHintHandler;
std::unique_ptr<PragmaHandler> UnrollHintHandler;
std::unique_ptr<PragmaHandler> NoUnrollHintHandler;
std::unique_ptr<PragmaHandler> UnrollAndJamHintHandler;
std::unique_ptr<PragmaHandler> NoUnrollAndJamHintHandler;
std::unique_ptr<PragmaHandler> FPHandler;
std::unique_ptr<PragmaHandler> STDCFenvAccessHandler;
std::unique_ptr<PragmaHandler> STDCFenvRoundHandler;
std::unique_ptr<PragmaHandler> STDCCXLIMITHandler;
std::unique_ptr<PragmaHandler> STDCUnknownHandler;
std::unique_ptr<PragmaHandler> AttributePragmaHandler;
std::unique_ptr<PragmaHandler> MaxTokensHerePragmaHandler;
std::unique_ptr<PragmaHandler> MaxTokensTotalPragmaHandler;
std::unique_ptr<PragmaHandler> RISCVPragmaHandler;
/// Factory object for creating ParsedAttr objects.
AttributeFactory AttrFactory;

std::shared_ptr<PragmaHandler> AlignHandler;
std::shared_ptr<PragmaHandler> GCCVisibilityHandler;
std::shared_ptr<PragmaHandler> OptionsHandler;
std::shared_ptr<PragmaHandler> PackHandler;
std::shared_ptr<PragmaHandler> MSStructHandler;
std::shared_ptr<PragmaHandler> UnusedHandler;
std::shared_ptr<PragmaHandler> WeakHandler;
std::shared_ptr<PragmaHandler> RedefineExtnameHandler;
std::shared_ptr<PragmaHandler> FPContractHandler;
std::shared_ptr<PragmaHandler> OpenCLExtensionHandler;
std::shared_ptr<PragmaHandler> OpenMPHandler;
std::shared_ptr<PragmaHandler> OpenACCHandler;
std::shared_ptr<PragmaHandler> PCSectionHandler;
std::shared_ptr<PragmaHandler> MSCommentHandler;
std::shared_ptr<PragmaHandler> MSDetectMismatchHandler;
std::shared_ptr<PragmaHandler> FPEvalMethodHandler;
std::shared_ptr<PragmaHandler> FloatControlHandler;
std::shared_ptr<PragmaHandler> MSPointersToMembers;
std::shared_ptr<PragmaHandler> MSVtorDisp;
std::shared_ptr<PragmaHandler> MSInitSeg;
std::shared_ptr<PragmaHandler> MSDataSeg;
std::shared_ptr<PragmaHandler> MSBSSSeg;
std::shared_ptr<PragmaHandler> MSConstSeg;
std::shared_ptr<PragmaHandler> MSCodeSeg;
std::shared_ptr<PragmaHandler> MSSection;
std::shared_ptr<PragmaHandler> MSStrictGuardStackCheck;
std::shared_ptr<PragmaHandler> MSRuntimeChecks;
std::shared_ptr<PragmaHandler> MSIntrinsic;
std::shared_ptr<PragmaHandler> MSFunction;
std::shared_ptr<PragmaHandler> MSOptimize;
std::shared_ptr<PragmaHandler> MSFenvAccess;
std::shared_ptr<PragmaHandler> MSAllocText;
std::shared_ptr<PragmaHandler> CUDAForceHostDeviceHandler;
std::shared_ptr<PragmaHandler> OptimizeHandler;
std::shared_ptr<PragmaHandler> LoopHintHandler;
std::shared_ptr<PragmaHandler> UnrollHintHandler;
std::shared_ptr<PragmaHandler> NoUnrollHintHandler;
std::shared_ptr<PragmaHandler> UnrollAndJamHintHandler;
std::shared_ptr<PragmaHandler> NoUnrollAndJamHintHandler;
std::shared_ptr<PragmaHandler> FPHandler;
std::shared_ptr<PragmaHandler> STDCFenvAccessHandler;
std::shared_ptr<PragmaHandler> STDCFenvRoundHandler;
std::shared_ptr<PragmaHandler> STDCCXLIMITHandler;
std::shared_ptr<PragmaHandler> STDCUnknownHandler;
std::shared_ptr<PragmaHandler> AttributePragmaHandler;
std::shared_ptr<PragmaHandler> MaxTokensHerePragmaHandler;
std::shared_ptr<PragmaHandler> MaxTokensTotalPragmaHandler;
std::shared_ptr<PragmaHandler> RISCVPragmaHandler;

std::unique_ptr<CommentHandler> CommentSemaHandler;

Expand Down Expand Up @@ -311,9 +314,6 @@ class Parser : public CodeCompletionHandler {
unsigned getOriginalDepth() const { return Depth - AddedLevels; }
};

/// Factory object for creating ParsedAttr objects.
AttributeFactory AttrFactory;

/// Gathers and cleans up TemplateIdAnnotations when parsing of a
/// top-level declaration is finished.
SmallVector<TemplateIdAnnotation *, 16> TemplateIds;
Expand Down
24 changes: 12 additions & 12 deletions clang/lib/Frontend/PrintPreprocessedOutput.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1095,32 +1095,32 @@ void clang::DoPrintPreprocessedInput(Preprocessor &PP, raw_ostream *OS,
// Expand macros in pragmas with -fms-extensions. The assumption is that
// the majority of pragmas in such a file will be Microsoft pragmas.
// Remember the handlers we will add so that we can remove them later.
std::unique_ptr<UnknownPragmaHandler> MicrosoftExtHandler(
std::shared_ptr<UnknownPragmaHandler> MicrosoftExtHandler(
new UnknownPragmaHandler(
"#pragma", Callbacks,
/*RequireTokenExpansion=*/PP.getLangOpts().MicrosoftExt));

std::unique_ptr<UnknownPragmaHandler> GCCHandler(new UnknownPragmaHandler(
std::shared_ptr<UnknownPragmaHandler> GCCHandler(new UnknownPragmaHandler(
"#pragma GCC", Callbacks,
/*RequireTokenExpansion=*/PP.getLangOpts().MicrosoftExt));

std::unique_ptr<UnknownPragmaHandler> ClangHandler(new UnknownPragmaHandler(
std::shared_ptr<UnknownPragmaHandler> ClangHandler(new UnknownPragmaHandler(
"#pragma clang", Callbacks,
/*RequireTokenExpansion=*/PP.getLangOpts().MicrosoftExt));

PP.AddPragmaHandler(MicrosoftExtHandler.get());
PP.AddPragmaHandler("GCC", GCCHandler.get());
PP.AddPragmaHandler("clang", ClangHandler.get());
PP.AddPragmaHandler(MicrosoftExtHandler);
PP.AddPragmaHandler("GCC", GCCHandler);
PP.AddPragmaHandler("clang", ClangHandler);

// The tokens after pragma omp need to be expanded.
//
// OpenMP [2.1, Directive format]
// Preprocessing tokens following the #pragma omp are subject to macro
// replacement.
std::unique_ptr<UnknownPragmaHandler> OpenMPHandler(
std::shared_ptr<UnknownPragmaHandler> OpenMPHandler(
new UnknownPragmaHandler("#pragma omp", Callbacks,
/*RequireTokenExpansion=*/true));
PP.AddPragmaHandler("omp", OpenMPHandler.get());
PP.AddPragmaHandler("omp", OpenMPHandler);

PP.addPPCallbacks(std::unique_ptr<PPCallbacks>(Callbacks));

Expand Down Expand Up @@ -1153,8 +1153,8 @@ void clang::DoPrintPreprocessedInput(Preprocessor &PP, raw_ostream *OS,

// Remove the handlers we just added to leave the preprocessor in a sane state
// so that it can be reused (for example by a clang::Parser instance).
PP.RemovePragmaHandler(MicrosoftExtHandler.get());
PP.RemovePragmaHandler("GCC", GCCHandler.get());
PP.RemovePragmaHandler("clang", ClangHandler.get());
PP.RemovePragmaHandler("omp", OpenMPHandler.get());
PP.RemovePragmaHandler(MicrosoftExtHandler->getName());
PP.RemovePragmaHandler("GCC", GCCHandler->getName());
PP.RemovePragmaHandler("clang", ClangHandler->getName());
PP.RemovePragmaHandler("omp", OpenMPHandler->getName());
}
Loading
Loading