Index: include/clang/Basic/DiagnosticGroups.td =================================================================== --- include/clang/Basic/DiagnosticGroups.td (revision 166550) +++ include/clang/Basic/DiagnosticGroups.td (working copy) @@ -251,6 +251,7 @@ def UninitializedSometimes : DiagGroup<"sometimes-uninitialized">; def Uninitialized : DiagGroup<"uninitialized", [UninitializedSometimes]>; def UnknownPragmas : DiagGroup<"unknown-pragmas">; +def OpenMPPragmas : DiagGroup<"openmp-pragmas">; def NSobjectAttribute : DiagGroup<"NSObject-attribute">; def UnknownAttributes : DiagGroup<"attributes">; def IgnoredAttributes : DiagGroup<"ignored-attributes">; Index: include/clang/Basic/DiagnosticParseKinds.td =================================================================== --- include/clang/Basic/DiagnosticParseKinds.td (revision 166550) +++ include/clang/Basic/DiagnosticParseKinds.td (working copy) @@ -734,6 +734,11 @@ "'#pragma fp_contract' should only appear at file scope or at the start of a " "compound expression">; +// OpenMP +def warn_pragma_omp_ignored : Warning< + "pragma omp ignored; did you forget to add '-fopenmp' flag?">, + InGroup; + // OpenCL Section 6.8.g def err_not_opencl_storage_class_specifier : Error< "OpenCL does not support the '%0' storage class specifier">; Index: include/clang/Basic/TokenKinds.def =================================================================== --- include/clang/Basic/TokenKinds.def (revision 166550) +++ include/clang/Basic/TokenKinds.def (working copy) @@ -637,6 +637,25 @@ // handles them. ANNOTATION(pragma_opencl_extension) +// Annotations for OpenMP pragma directive statements - "\#pragam omp ..." +// The lexer produces these so that they only take effect when the parser +// handles them. +ANNOTATION(pragma_omp_parallel) +ANNOTATION(pragma_omp_for) +ANNOTATION(pragma_omp_sections) +ANNOTATION(pragma_omp_section) +ANNOTATION(pragma_omp_single) +ANNOTATION(pragma_omp_task) +ANNOTATION(pragma_omp_master) +ANNOTATION(pragma_omp_critical) +ANNOTATION(pragma_omp_barrier) +ANNOTATION(pragma_omp_taskwait) +ANNOTATION(pragma_omp_taskyield) +ANNOTATION(pragma_omp_atomic) +ANNOTATION(pragma_omp_flush) +ANNOTATION(pragma_omp_ordered) +ANNOTATION(pragma_omp_threadprivate) + #undef ANNOTATION #undef TESTING_KEYWORD #undef OBJC2_AT_KEYWORD Index: include/clang/Parse/Parser.h =================================================================== --- include/clang/Parse/Parser.h (revision 166550) +++ include/clang/Parse/Parser.h (working copy) @@ -43,6 +43,7 @@ class InMessageExpressionRAIIObject; class PoisonSEHIdentifiersRAIIObject; class VersionTuple; + class OpenMP; /// PrettyStackTraceParserEntry - If a crash happens while the parser is active, /// an entry is printed for it. @@ -180,6 +181,8 @@ OwningPtr OpenCLExtensionHandler; OwningPtr CommentSemaHandler; + OwningPtr OpenMPHandler; + /// Whether the '>' token acts as an operator or not. This will be /// true except when we are parsing an expression within a C++ /// template argument list, where the '>' closes the template Index: lib/Parse/Parser.cpp =================================================================== --- lib/Parse/Parser.cpp (revision 166550) +++ lib/Parse/Parser.cpp (working copy) @@ -23,6 +23,208 @@ #include "clang/AST/ASTConsumer.h" using namespace clang; + +namespace clang { + +//===----------------------------------------------------------------------===// +// OpenMP - An instance of this interface is defined to initiate OpenMP parsing, +// and to help Parser during subsequent parsing of OpenMP constrcuts. +//===----------------------------------------------------------------------===// +class OpenMP { + // Private Member Objects. +private: + // brief The member object reference to the Preprocessor. + Preprocessor &PP; + + // -brief Handler objects which handle different OpenMP pragma directive + // statements. + OwningPtr ParallelHandler; + OwningPtr ForHandler; + OwningPtr SectionsHandler; + OwningPtr SectionHandler; + OwningPtr SingleHandler; + OwningPtr TaskHandler; + OwningPtr MasterHandler; + OwningPtr CriticalHandler; + OwningPtr BarrierHandler; + OwningPtr TaskwaitHandler; + OwningPtr TaskyieldHandler; + OwningPtr AtomicHandler; + OwningPtr FlushHandler; + OwningPtr OrderedHandler; + OwningPtr ThreadPrivateHandler; + + // \brief When an OpenMP pragma is ignored, we emit a warning message + // saying so, but only once per translation unit irrespective of the + // number of OpenMP pragmas appeared in the translation unit. This flag + // keeps track of whether the unkown pragma warning message is emitted + // or not for the current translation unit. + bool PragmaOmpUnknownWarning; + + // Private Member Methods. +private: + // \brief When source contains omp pragmas, but user does not pass the + // '-fopenmp' flag, we emit a warning message saying so, but only once per + // source file. + void SetPragmaOmpUnknownWarning() { PragmaOmpUnknownWarning = true; } + void ResetPragmaOmpUnknownWarning() { PragmaOmpUnknownWarning = false; } + bool GetPragmaOmpUnknownWarning() { return PragmaOmpUnknownWarning; } + + // \brief Handles "\#pragma omp ...". + // It checks if the user has passed the flag, '-fopenmp', if so, + // enters the *token* which is *representing* the current OpenMP + // pragma *directive* into the TokenStream, so that the Parser can + // recognizes it and can parse the respective OpenMP pragma directive + // statement. Otherwise, it reports a warning that the current OpenMP + // directive statement will be ignored. However, note that only + // *one* warning message per translation unit is reported + // irrespective of the number of OpenMP directive statments which + // appear in the translation unit. + void HandlePragma(Token &OmpTok, tok::TokenKind TKind) { + if (!PP.getLangOpts().OpenMP) { + if (!GetPragmaOmpUnknownWarning()) { + PP.Diag(OmpTok, diag::warn_pragma_omp_ignored); + SetPragmaOmpUnknownWarning(); + } + } else { + Token *Toks = new Token[1]; + Toks[0].startToken(); + Toks[0].setKind(TKind); + Toks[0].setLocation(OmpTok.getLocation()); + PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, + /*OwnsTokens=*/false); + } + } + + // Constructors and Destructors. +public: + OpenMP(Preprocessor &pp); + ~OpenMP(); + +private: + // PragmaOmpHandler - An OpenMP pragma handler interface. + // \brief It acts as an intermediate between the Preprocessor class and + // the OpenMP (this) class. It by passes the omp pragma handling call to + // OpenMP class upon requested by the Preprocessor. + struct PragmaOmpHandler : public PragmaHandler { + friend class OpenMP; + tok::TokenKind TKind; + OpenMP *Omp; + PragmaOmpHandler(tok::TokenKind Kind, StringRef Name, OpenMP *omp) + : PragmaHandler(Name), TKind(Kind), Omp(omp) {} + virtual ~PragmaOmpHandler() { Omp = 0; } + virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &OmpTok) { + Omp->HandlePragma(OmpTok, TKind); + } + }; +}; + +} // end of namespace clang + +OpenMP::OpenMP(Preprocessor &pp) + : PP(pp) { + // Add "#pragma omp ..." handlers. These are removed and destroyed + // in the destructor. + ParallelHandler.reset(new PragmaOmpHandler( + tok::annot_pragma_omp_parallel, "parallel", this)); + PP.AddPragmaHandler("omp", ParallelHandler.get()); + + ForHandler.reset(new PragmaOmpHandler( + tok::annot_pragma_omp_for, "for", this)); + PP.AddPragmaHandler("omp", ForHandler.get()); + + SectionsHandler.reset(new PragmaOmpHandler( + tok::annot_pragma_omp_sections, "sections", this)); + PP.AddPragmaHandler("omp", SectionsHandler.get()); + + SectionHandler.reset(new PragmaOmpHandler( + tok::annot_pragma_omp_section, "section", this)); + PP.AddPragmaHandler("omp", SectionHandler.get()); + + SingleHandler.reset(new PragmaOmpHandler( + tok::annot_pragma_omp_single, "single", this)); + PP.AddPragmaHandler("omp", SingleHandler.get()); + + TaskHandler.reset(new PragmaOmpHandler( + tok::annot_pragma_omp_task, "task", this)); + PP.AddPragmaHandler("omp", TaskHandler.get()); + + MasterHandler.reset(new PragmaOmpHandler( + tok::annot_pragma_omp_master, "master", this)); + PP.AddPragmaHandler("omp", MasterHandler.get()); + + CriticalHandler.reset(new PragmaOmpHandler( + tok::annot_pragma_omp_critical, "critical", this)); + PP.AddPragmaHandler("omp", CriticalHandler.get()); + + BarrierHandler.reset(new PragmaOmpHandler( + tok::annot_pragma_omp_barrier, "barrier", this)); + PP.AddPragmaHandler("omp", BarrierHandler.get()); + + TaskwaitHandler.reset(new PragmaOmpHandler( + tok::annot_pragma_omp_taskwait, "taskwait", this)); + PP.AddPragmaHandler("omp", TaskwaitHandler.get()); + + TaskyieldHandler.reset(new PragmaOmpHandler( + tok::annot_pragma_omp_taskyield, "taskyield", this)); + PP.AddPragmaHandler("omp", TaskyieldHandler.get()); + + AtomicHandler.reset(new PragmaOmpHandler( + tok::annot_pragma_omp_atomic, "atomic", this)); + PP.AddPragmaHandler("omp", AtomicHandler.get()); + + FlushHandler.reset(new PragmaOmpHandler( + tok::annot_pragma_omp_flush, "flush", this)); + PP.AddPragmaHandler("omp", FlushHandler.get()); + + OrderedHandler.reset(new PragmaOmpHandler( + tok::annot_pragma_omp_ordered, "ordered", this)); + PP.AddPragmaHandler("omp", OrderedHandler.get()); + + ThreadPrivateHandler.reset(new PragmaOmpHandler( + tok::annot_pragma_omp_threadprivate, "threadprivate", this)); + PP.AddPragmaHandler("omp", ThreadPrivateHandler.get()); + + // We have not yet reported the unknown OpenMP pragma *warning* message + // as we have not yet started the processing of translation unit. + ResetPragmaOmpUnknownWarning(); +} + +OpenMP::~OpenMP() { + // Remove the "#pragma omp ..." handlers we installed. + PP.RemovePragmaHandler("omp", ParallelHandler.get()); + ParallelHandler.reset(); + PP.RemovePragmaHandler("omp", ForHandler.get()); + ForHandler.reset(); + PP.RemovePragmaHandler("omp", SectionsHandler.get()); + SectionsHandler.reset(); + PP.RemovePragmaHandler("omp", SectionHandler.get()); + SectionHandler.reset(); + PP.RemovePragmaHandler("omp", SingleHandler.get()); + SingleHandler.reset(); + PP.RemovePragmaHandler("omp", TaskHandler.get()); + TaskHandler.reset(); + PP.RemovePragmaHandler("omp", MasterHandler.get()); + MasterHandler.reset(); + PP.RemovePragmaHandler("omp", CriticalHandler.get()); + CriticalHandler.reset(); + PP.RemovePragmaHandler("omp", BarrierHandler.get()); + BarrierHandler.reset(); + PP.RemovePragmaHandler("omp", TaskwaitHandler.get()); + TaskwaitHandler.reset(); + PP.RemovePragmaHandler("omp", TaskyieldHandler.get()); + TaskyieldHandler.reset(); + PP.RemovePragmaHandler("omp", AtomicHandler.get()); + AtomicHandler.reset(); + PP.RemovePragmaHandler("omp", FlushHandler.get()); + FlushHandler.reset(); + PP.RemovePragmaHandler("omp", OrderedHandler.get()); + OrderedHandler.reset(); + PP.RemovePragmaHandler("omp", ThreadPrivateHandler.get()); + ThreadPrivateHandler.reset(); +} + namespace { /// \brief A comment handler that passes comments found by the preprocessor /// to the parser action. @@ -98,6 +300,8 @@ PP.addCommentHandler(CommentSemaHandler.get()); PP.setCodeCompletionHandler(*this); + + OpenMPHandler.reset(new OpenMP(pp)); } /// If a crash happens while the parser is active, print out a line indicating @@ -456,6 +660,8 @@ PP.clearCodeCompletionHandler(); + OpenMPHandler.reset(); + assert(TemplateIds.empty() && "Still alive TemplateIdAnnotations around?"); } Index: test/Preprocessor/pragma_omp.c =================================================================== --- test/Preprocessor/pragma_omp.c (revision 0) +++ test/Preprocessor/pragma_omp.c (revision 0) @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -E -verify %s +// RUN: %clang_cc1 -E -verify -fopenmp %s +// RUN: %clang_cc1 -Eonly -verify %s +// RUN: %clang_cc1 -Eonly -verify -fopenmp %s +// RUN: %clang_cc1 -E -P -verify %s +// RUN: %clang_cc1 -E -P -verify -fopenmp %s + +int pragma_omp_test() { + int i, VarA; + #pragma omp parallel // expected-no-diagnostics + { + #pragma omp for // expected-no-diagnostics + for(i=0; i<10; i++) { + VarA = 29; + } + } + return VarA; +} Index: test/Preprocessor/pragma_omp_ignored_warning.c =================================================================== --- test/Preprocessor/pragma_omp_ignored_warning.c (revision 0) +++ test/Preprocessor/pragma_omp_ignored_warning.c (revision 0) @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +int pragma_omp_ignored_warning_test() { + int i, VarA; + #pragma omp parallel // expected-warning {{pragma omp ignored; did you forget to add '-fopenmp' flag?}} + { + #pragma omp for + for(i=0; i<10; i++) { + VarA = 29; + } + } + return VarA; +}