//===--- ParsePragma.cpp - Language specific pragma parsing ---------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the language specific #pragma handlers. // //===----------------------------------------------------------------------===// #include "clang/AST/ASTContext.h" #include "clang/Basic/PragmaKinds.h" #include "clang/Basic/TargetInfo.h" #include "clang/Lex/Preprocessor.h" #include "clang/Lex/Token.h" #include "clang/Parse/LoopHint.h" #include "clang/Parse/ParseDiagnostic.h" #include "clang/Parse/Parser.h" #include "clang/Parse/RAIIObjectsForParser.h" #include "clang/Sema/EnterExpressionEvaluationContext.h" #include "clang/Sema/Scope.h" #include "clang/Sema/SemaCUDA.h" #include "clang/Sema/SemaCodeCompletion.h" #include "clang/Sema/SemaRISCV.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/StringSwitch.h" #include <optional> usingnamespaceclang; namespace { struct PragmaAlignHandler : public PragmaHandler { … }; struct PragmaGCCVisibilityHandler : public PragmaHandler { … }; struct PragmaOptionsHandler : public PragmaHandler { … }; struct PragmaPackHandler : public PragmaHandler { … }; struct PragmaClangSectionHandler : public PragmaHandler { … }; struct PragmaMSStructHandler : public PragmaHandler { … }; struct PragmaUnusedHandler : public PragmaHandler { … }; struct PragmaWeakHandler : public PragmaHandler { … }; struct PragmaRedefineExtnameHandler : public PragmaHandler { … }; struct PragmaOpenCLExtensionHandler : public PragmaHandler { … }; struct PragmaFPContractHandler : public PragmaHandler { … }; // Pragma STDC implementations. /// PragmaSTDC_FENV_ACCESSHandler - "\#pragma STDC FENV_ACCESS ...". struct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler { … }; /// PragmaSTDC_CX_LIMITED_RANGEHandler - "\#pragma STDC CX_LIMITED_RANGE ...". struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler { … }; /// Handler for "\#pragma STDC FENV_ROUND ...". struct PragmaSTDC_FENV_ROUNDHandler : public PragmaHandler { … }; /// PragmaSTDC_UnknownHandler - "\#pragma STDC ...". struct PragmaSTDC_UnknownHandler : public PragmaHandler { … }; struct PragmaFPHandler : public PragmaHandler { … }; // A pragma handler to be the base of the NoOpenMPHandler and NoOpenACCHandler, // which are identical other than the name given to them, and the diagnostic // emitted. template <diag::kind IgnoredDiag> struct PragmaNoSupportHandler : public PragmaHandler { … }; struct PragmaNoOpenMPHandler : public PragmaNoSupportHandler<diag::warn_pragma_omp_ignored> { … }; struct PragmaNoOpenACCHandler : public PragmaNoSupportHandler<diag::warn_pragma_acc_ignored> { … }; // A pragma handler to be the base for the OpenMPHandler and OpenACCHandler, // which are identical other than the tokens used for the start/end of a pragma // section, and some diagnostics. template <tok::TokenKind StartTok, tok::TokenKind EndTok, diag::kind UnexpectedDiag> struct PragmaSupportHandler : public PragmaHandler { … }; struct PragmaOpenMPHandler : public PragmaSupportHandler<tok::annot_pragma_openmp, tok::annot_pragma_openmp_end, diag::err_omp_unexpected_directive> { … }; struct PragmaOpenACCHandler : public PragmaSupportHandler<tok::annot_pragma_openacc, tok::annot_pragma_openacc_end, diag::err_acc_unexpected_directive> { … }; /// PragmaCommentHandler - "\#pragma comment ...". struct PragmaCommentHandler : public PragmaHandler { … }; struct PragmaDetectMismatchHandler : public PragmaHandler { … }; struct PragmaFloatControlHandler : public PragmaHandler { … }; struct PragmaMSPointersToMembers : public PragmaHandler { … }; struct PragmaMSVtorDisp : public PragmaHandler { … }; struct PragmaMSPragma : public PragmaHandler { … }; /// PragmaOptimizeHandler - "\#pragma clang optimize on/off". struct PragmaOptimizeHandler : public PragmaHandler { … }; struct PragmaLoopHintHandler : public PragmaHandler { … }; struct PragmaUnrollHintHandler : public PragmaHandler { … }; struct PragmaMSRuntimeChecksHandler : public EmptyPragmaHandler { … }; struct PragmaMSIntrinsicHandler : public PragmaHandler { … }; // "\#pragma fenv_access (on)". struct PragmaMSFenvAccessHandler : public PragmaHandler { … }; struct PragmaForceCUDAHostDeviceHandler : public PragmaHandler { … }; /// PragmaAttributeHandler - "\#pragma clang attribute ...". struct PragmaAttributeHandler : public PragmaHandler { … }; struct PragmaMaxTokensHereHandler : public PragmaHandler { … }; struct PragmaMaxTokensTotalHandler : public PragmaHandler { … }; struct PragmaRISCVHandler : public PragmaHandler { … }; void markAsReinjectedForRelexing(llvm::MutableArrayRef<clang::Token> Toks) { … } } // end namespace void Parser::initializePragmaHandlers() { … } void Parser::resetPragmaHandlers() { … } /// Handle the annotation token produced for #pragma unused(...) /// /// Each annot_pragma_unused is followed by the argument token so e.g. /// "#pragma unused(x,y)" becomes: /// annot_pragma_unused 'x' annot_pragma_unused 'y' void Parser::HandlePragmaUnused() { … } void Parser::HandlePragmaVisibility() { … } void Parser::HandlePragmaPack() { … } void Parser::HandlePragmaMSStruct() { … } void Parser::HandlePragmaAlign() { … } void Parser::HandlePragmaDump() { … } void Parser::HandlePragmaWeak() { … } void Parser::HandlePragmaWeakAlias() { … } void Parser::HandlePragmaRedefineExtname() { … } void Parser::HandlePragmaFPContract() { … } void Parser::HandlePragmaFloatControl() { … } void Parser::HandlePragmaFEnvAccess() { … } void Parser::HandlePragmaFEnvRound() { … } void Parser::HandlePragmaCXLimitedRange() { … } StmtResult Parser::HandlePragmaCaptured() { … } namespace { enum OpenCLExtState : char { … }; OpenCLExtData; } void Parser::HandlePragmaOpenCLExtension() { … } void Parser::HandlePragmaMSPointersToMembers() { … } void Parser::HandlePragmaMSVtorDisp() { … } void Parser::HandlePragmaMSPragma() { … } bool Parser::HandlePragmaMSSection(StringRef PragmaName, SourceLocation PragmaLocation) { … } bool Parser::HandlePragmaMSSegment(StringRef PragmaName, SourceLocation PragmaLocation) { … } // #pragma init_seg({ compiler | lib | user | "section-name" [, func-name]} ) bool Parser::HandlePragmaMSInitSeg(StringRef PragmaName, SourceLocation PragmaLocation) { … } // #pragma strict_gs_check(pop) // #pragma strict_gs_check(push, "on" | "off") // #pragma strict_gs_check("on" | "off") bool Parser::HandlePragmaMSStrictGuardStackCheck( StringRef PragmaName, SourceLocation PragmaLocation) { … } bool Parser::HandlePragmaMSAllocText(StringRef PragmaName, SourceLocation PragmaLocation) { … } static std::string PragmaLoopHintString(Token PragmaName, Token Option) { … } bool Parser::HandlePragmaLoopHint(LoopHint &Hint) { … } namespace { struct PragmaAttributeInfo { … }; #include "clang/Parse/AttrSubMatchRulesParserStringSwitches.inc" } // end anonymous namespace static StringRef getIdentifier(const Token &Tok) { … } static bool isAbstractAttrMatcherRule(attr::SubjectMatchRule Rule) { … } static void diagnoseExpectedAttributeSubjectSubRule( Parser &PRef, attr::SubjectMatchRule PrimaryRule, StringRef PrimaryRuleName, SourceLocation SubRuleLoc) { … } static void diagnoseUnknownAttributeSubjectSubRule( Parser &PRef, attr::SubjectMatchRule PrimaryRule, StringRef PrimaryRuleName, StringRef SubRuleName, SourceLocation SubRuleLoc) { … } bool Parser::ParsePragmaAttributeSubjectMatchRuleSet( attr::ParsedSubjectMatchRuleSet &SubjectMatchRules, SourceLocation &AnyLoc, SourceLocation &LastMatchRuleEndLoc) { … } namespace { /// Describes the stage at which attribute subject rule parsing was interrupted. enum class MissingAttributeSubjectRulesRecoveryPoint { … }; MissingAttributeSubjectRulesRecoveryPoint getAttributeSubjectRulesRecoveryPointForToken(const Token &Tok) { … } /// Creates a diagnostic for the attribute subject rule parsing diagnostic that /// suggests the possible attribute subject rules in a fix-it together with /// any other missing tokens. DiagnosticBuilder createExpectedAttributeSubjectRulesTokenDiagnostic( unsigned DiagID, ParsedAttributes &Attrs, MissingAttributeSubjectRulesRecoveryPoint Point, Parser &PRef) { … } } // end anonymous namespace void Parser::HandlePragmaAttribute() { … } // #pragma GCC visibility comes in two variants: // 'push' '(' [visibility] ')' // 'pop' void PragmaGCCVisibilityHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &VisTok) { … } // #pragma pack(...) comes in the following delicious flavors: // pack '(' [integer] ')' // pack '(' 'show' ')' // pack '(' ('push' | 'pop') [',' identifier] [, integer] ')' void PragmaPackHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &PackTok) { … } // #pragma ms_struct on // #pragma ms_struct off void PragmaMSStructHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &MSStructTok) { … } // #pragma clang section bss="abc" data="" rodata="def" text="" relro="" void PragmaClangSectionHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) { … } // #pragma 'align' '=' {'native','natural','mac68k','power','reset'} // #pragma 'options 'align' '=' {'native','natural','mac68k','power','reset'} // #pragma 'align' '(' {'native','natural','mac68k','power','reset'} ')' static void ParseAlignPragma(Preprocessor &PP, Token &FirstTok, bool IsOptions) { … } void PragmaAlignHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &AlignTok) { … } void PragmaOptionsHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &OptionsTok) { … } // #pragma unused(identifier) void PragmaUnusedHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &UnusedTok) { … } // #pragma weak identifier // #pragma weak identifier '=' identifier void PragmaWeakHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &WeakTok) { … } // #pragma redefine_extname identifier identifier void PragmaRedefineExtnameHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &RedefToken) { … } void PragmaFPContractHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) { … } void PragmaOpenCLExtensionHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) { … } /// Handle '#pragma omp ...' when OpenMP is disabled and '#pragma acc ...' when /// OpenACC is disabled. template <diag::kind IgnoredDiag> void PragmaNoSupportHandler<IgnoredDiag>::HandlePragma( Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstTok) { … } /// Handle '#pragma omp ...' when OpenMP is enabled, and handle '#pragma acc...' /// when OpenACC is enabled. template <tok::TokenKind StartTok, tok::TokenKind EndTok, diag::kind UnexpectedDiag> void PragmaSupportHandler<StartTok, EndTok, UnexpectedDiag>::HandlePragma( Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstTok) { … } /// Handle '#pragma pointers_to_members' // The grammar for this pragma is as follows: // // <inheritance model> ::= ('single' | 'multiple' | 'virtual') '_inheritance' // // #pragma pointers_to_members '(' 'best_case' ')' // #pragma pointers_to_members '(' 'full_generality' [',' inheritance-model] ')' // #pragma pointers_to_members '(' inheritance-model ')' void PragmaMSPointersToMembers::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) { … } /// Handle '#pragma vtordisp' // The grammar for this pragma is as follows: // // <vtordisp-mode> ::= ('off' | 'on' | '0' | '1' | '2' ) // // #pragma vtordisp '(' ['push' ','] vtordisp-mode ')' // #pragma vtordisp '(' 'pop' ')' // #pragma vtordisp '(' ')' void PragmaMSVtorDisp::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) { … } /// Handle all MS pragmas. Simply forwards the tokens after inserting /// an annotation token. void PragmaMSPragma::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) { … } /// Handle the \#pragma float_control extension. /// /// The syntax is: /// \code /// #pragma float_control(keyword[, setting] [,push]) /// \endcode /// Where 'keyword' and 'setting' are identifiers. // 'keyword' can be: precise, except, push, pop // 'setting' can be: on, off /// The optional arguments 'setting' and 'push' are supported only /// when the keyword is 'precise' or 'except'. void PragmaFloatControlHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) { … } /// Handle the Microsoft \#pragma detect_mismatch extension. /// /// The syntax is: /// \code /// #pragma detect_mismatch("name", "value") /// \endcode /// Where 'name' and 'value' are quoted strings. The values are embedded in /// the object file and passed along to the linker. If the linker detects a /// mismatch in the object file's values for the given name, a LNK2038 error /// is emitted. See MSDN for more details. void PragmaDetectMismatchHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) { … } /// Handle the microsoft \#pragma comment extension. /// /// The syntax is: /// \code /// #pragma comment(linker, "foo") /// \endcode /// 'linker' is one of five identifiers: compiler, exestr, lib, linker, user. /// "foo" is a string, which is fully macro expanded, and permits string /// concatenation, embedded escape characters etc. See MSDN for more details. void PragmaCommentHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) { … } // #pragma clang optimize off // #pragma clang optimize on void PragmaOptimizeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) { … } namespace { /// Used as the annotation value for tok::annot_pragma_fp. struct TokFPAnnotValue { … }; } // end anonymous namespace void PragmaFPHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) { … } void PragmaSTDC_FENV_ROUNDHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) { … } void Parser::HandlePragmaFP() { … } /// Parses loop or unroll pragma hint value and fills in Info. static bool ParseLoopHintValue(Preprocessor &PP, Token &Tok, Token PragmaName, Token Option, bool ValueInParens, PragmaLoopHintInfo &Info) { … } /// Handle the \#pragma clang loop directive. /// #pragma clang 'loop' loop-hints /// /// loop-hints: /// loop-hint loop-hints[opt] /// /// loop-hint: /// 'vectorize' '(' loop-hint-keyword ')' /// 'interleave' '(' loop-hint-keyword ')' /// 'unroll' '(' unroll-hint-keyword ')' /// 'vectorize_predicate' '(' loop-hint-keyword ')' /// 'vectorize_width' '(' loop-hint-value ')' /// 'interleave_count' '(' loop-hint-value ')' /// 'unroll_count' '(' loop-hint-value ')' /// 'pipeline' '(' disable ')' /// 'pipeline_initiation_interval' '(' loop-hint-value ')' /// /// loop-hint-keyword: /// 'enable' /// 'disable' /// 'assume_safety' /// /// unroll-hint-keyword: /// 'enable' /// 'disable' /// 'full' /// /// loop-hint-value: /// constant-expression /// /// Specifying vectorize(enable) or vectorize_width(_value_) instructs llvm to /// try vectorizing the instructions of the loop it precedes. Specifying /// interleave(enable) or interleave_count(_value_) instructs llvm to try /// interleaving multiple iterations of the loop it precedes. The width of the /// vector instructions is specified by vectorize_width() and the number of /// interleaved loop iterations is specified by interleave_count(). Specifying a /// value of 1 effectively disables vectorization/interleaving, even if it is /// possible and profitable, and 0 is invalid. The loop vectorizer currently /// only works on inner loops. /// /// The unroll and unroll_count directives control the concatenation /// unroller. Specifying unroll(enable) instructs llvm to unroll the loop /// completely if the trip count is known at compile time and unroll partially /// if the trip count is not known. Specifying unroll(full) is similar to /// unroll(enable) but will unroll the loop only if the trip count is known at /// compile time. Specifying unroll(disable) disables unrolling for the /// loop. Specifying unroll_count(_value_) instructs llvm to try to unroll the /// loop the number of times indicated by the value. void PragmaLoopHintHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) { … } /// Handle the loop unroll optimization pragmas. /// #pragma unroll /// #pragma unroll unroll-hint-value /// #pragma unroll '(' unroll-hint-value ')' /// #pragma nounroll /// #pragma unroll_and_jam /// #pragma unroll_and_jam unroll-hint-value /// #pragma unroll_and_jam '(' unroll-hint-value ')' /// #pragma nounroll_and_jam /// /// unroll-hint-value: /// constant-expression /// /// Loop unrolling hints can be specified with '#pragma unroll' or /// '#pragma nounroll'. '#pragma unroll' can take a numeric argument optionally /// contained in parentheses. With no argument the directive instructs llvm to /// try to unroll the loop completely. A positive integer argument can be /// specified to indicate the number of times the loop should be unrolled. To /// maximize compatibility with other compilers the unroll count argument can be /// specified with or without parentheses. Specifying, '#pragma nounroll' /// disables unrolling of the loop. void PragmaUnrollHintHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) { … } /// Handle the Microsoft \#pragma intrinsic extension. /// /// The syntax is: /// \code /// #pragma intrinsic(memset) /// #pragma intrinsic(strlen, memcpy) /// \endcode /// /// Pragma intrisic tells the compiler to use a builtin version of the /// function. Clang does it anyway, so the pragma doesn't really do anything. /// Anyway, we emit a warning if the function specified in \#pragma intrinsic /// isn't an intrinsic in clang and suggest to include intrin.h. void PragmaMSIntrinsicHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) { … } bool Parser::HandlePragmaMSFunction(StringRef PragmaName, SourceLocation PragmaLocation) { … } // #pragma optimize("gsty", on|off) bool Parser::HandlePragmaMSOptimize(StringRef PragmaName, SourceLocation PragmaLocation) { … } void PragmaForceCUDAHostDeviceHandler::HandlePragma( Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) { … } /// Handle the #pragma clang attribute directive. /// /// The syntax is: /// \code /// #pragma clang attribute push (attribute, subject-set) /// #pragma clang attribute push /// #pragma clang attribute (attribute, subject-set) /// #pragma clang attribute pop /// \endcode /// /// There are also 'namespace' variants of push and pop directives. The bare /// '#pragma clang attribute (attribute, subject-set)' version doesn't require a /// namespace, since it always applies attributes to the most recently pushed /// group, regardless of namespace. /// \code /// #pragma clang attribute namespace.push (attribute, subject-set) /// #pragma clang attribute namespace.push /// #pragma clang attribute namespace.pop /// \endcode /// /// The subject-set clause defines the set of declarations which receive the /// attribute. Its exact syntax is described in the LanguageExtensions document /// in Clang's documentation. /// /// This directive instructs the compiler to begin/finish applying the specified /// attribute to the set of attribute-specific declarations in the active range /// of the pragma. void PragmaAttributeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) { … } // Handle '#pragma clang max_tokens 12345'. void PragmaMaxTokensHereHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) { … } // Handle '#pragma clang max_tokens_total 12345'. void PragmaMaxTokensTotalHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) { … } // Handle '#pragma clang riscv intrinsic vector'. // '#pragma clang riscv intrinsic sifive_vector'. void PragmaRISCVHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) { … }
Codebase Browser
llvm