Home | History | Annotate | Line # | Download | only in Parse 
      1 //===--- ParsePragma.cpp - Language specific pragma parsing ---------------===//
      2 //
      3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
      4 // See https://llvm.org/LICENSE.txt for license information.
      5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
      6 //
      7 //===----------------------------------------------------------------------===//
      8 //
      9 // This file implements the language specific #pragma handlers.
     10 //
     11 //===----------------------------------------------------------------------===//
     12 
     13 #include "clang/AST/ASTContext.h"
     14 #include "clang/Basic/PragmaKinds.h"
     15 #include "clang/Basic/TargetInfo.h"
     16 #include "clang/Lex/Preprocessor.h"
     17 #include "clang/Lex/Token.h"
     18 #include "clang/Parse/LoopHint.h"
     19 #include "clang/Parse/ParseDiagnostic.h"
     20 #include "clang/Parse/Parser.h"
     21 #include "clang/Parse/RAIIObjectsForParser.h"
     22 #include "clang/Sema/Scope.h"
     23 #include "llvm/ADT/ArrayRef.h"
     24 #include "llvm/ADT/StringSwitch.h"
     25 using namespace clang;
     26 
     27 namespace {
     28 
     29 struct PragmaAlignHandler : public PragmaHandler {
     30   explicit PragmaAlignHandler() : PragmaHandler("align") {}
     31   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
     32                     Token &FirstToken) override;
     33 };
     34 
     35 struct PragmaGCCVisibilityHandler : public PragmaHandler {
     36   explicit PragmaGCCVisibilityHandler() : PragmaHandler("visibility") {}
     37   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
     38                     Token &FirstToken) override;
     39 };
     40 
     41 struct PragmaOptionsHandler : public PragmaHandler {
     42   explicit PragmaOptionsHandler() : PragmaHandler("options") {}
     43   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
     44                     Token &FirstToken) override;
     45 };
     46 
     47 struct PragmaPackHandler : public PragmaHandler {
     48   explicit PragmaPackHandler() : PragmaHandler("pack") {}
     49   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
     50                     Token &FirstToken) override;
     51 };
     52 
     53 struct PragmaClangSectionHandler : public PragmaHandler {
     54   explicit PragmaClangSectionHandler(Sema &S)
     55              : PragmaHandler("section"), Actions(S) {}
     56   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
     57                     Token &FirstToken) override;
     58 
     59 private:
     60   Sema &Actions;
     61 };
     62 
     63 struct PragmaMSStructHandler : public PragmaHandler {
     64   explicit PragmaMSStructHandler() : PragmaHandler("ms_struct") {}
     65   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
     66                     Token &FirstToken) override;
     67 };
     68 
     69 struct PragmaUnusedHandler : public PragmaHandler {
     70   PragmaUnusedHandler() : PragmaHandler("unused") {}
     71   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
     72                     Token &FirstToken) override;
     73 };
     74 
     75 struct PragmaWeakHandler : public PragmaHandler {
     76   explicit PragmaWeakHandler() : PragmaHandler("weak") {}
     77   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
     78                     Token &FirstToken) override;
     79 };
     80 
     81 struct PragmaRedefineExtnameHandler : public PragmaHandler {
     82   explicit PragmaRedefineExtnameHandler() : PragmaHandler("redefine_extname") {}
     83   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
     84                     Token &FirstToken) override;
     85 };
     86 
     87 struct PragmaOpenCLExtensionHandler : public PragmaHandler {
     88   PragmaOpenCLExtensionHandler() : PragmaHandler("EXTENSION") {}
     89   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
     90                     Token &FirstToken) override;
     91 };
     92 
     93 
     94 struct PragmaFPContractHandler : public PragmaHandler {
     95   PragmaFPContractHandler() : PragmaHandler("FP_CONTRACT") {}
     96   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
     97                     Token &FirstToken) override;
     98 };
     99 
    100 // Pragma STDC implementations.
    101 
    102 /// PragmaSTDC_FENV_ACCESSHandler - "\#pragma STDC FENV_ACCESS ...".
    103 struct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler {
    104   PragmaSTDC_FENV_ACCESSHandler() : PragmaHandler("FENV_ACCESS") {}
    105 
    106   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    107                     Token &Tok) override {
    108     Token PragmaName = Tok;
    109     if (!PP.getTargetInfo().hasStrictFP() && !PP.getLangOpts().ExpStrictFP) {
    110       PP.Diag(Tok.getLocation(), diag::warn_pragma_fp_ignored)
    111           << PragmaName.getIdentifierInfo()->getName();
    112       return;
    113     }
    114     tok::OnOffSwitch OOS;
    115     if (PP.LexOnOffSwitch(OOS))
    116      return;
    117 
    118     MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
    119                                 1);
    120     Toks[0].startToken();
    121     Toks[0].setKind(tok::annot_pragma_fenv_access);
    122     Toks[0].setLocation(Tok.getLocation());
    123     Toks[0].setAnnotationEndLoc(Tok.getLocation());
    124     Toks[0].setAnnotationValue(reinterpret_cast<void*>(
    125                                static_cast<uintptr_t>(OOS)));
    126     PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
    127                         /*IsReinject=*/false);
    128   }
    129 };
    130 
    131 /// PragmaSTDC_CX_LIMITED_RANGEHandler - "\#pragma STDC CX_LIMITED_RANGE ...".
    132 struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler {
    133   PragmaSTDC_CX_LIMITED_RANGEHandler() : PragmaHandler("CX_LIMITED_RANGE") {}
    134 
    135   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    136                     Token &Tok) override {
    137     tok::OnOffSwitch OOS;
    138     PP.LexOnOffSwitch(OOS);
    139   }
    140 };
    141 
    142 /// Handler for "\#pragma STDC FENV_ROUND ...".
    143 struct PragmaSTDC_FENV_ROUNDHandler : public PragmaHandler {
    144   PragmaSTDC_FENV_ROUNDHandler() : PragmaHandler("FENV_ROUND") {}
    145 
    146   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    147                     Token &Tok) override;
    148 };
    149 
    150 /// PragmaSTDC_UnknownHandler - "\#pragma STDC ...".
    151 struct PragmaSTDC_UnknownHandler : public PragmaHandler {
    152   PragmaSTDC_UnknownHandler() = default;
    153 
    154   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    155                     Token &UnknownTok) override {
    156     // C99 6.10.6p2, unknown forms are not allowed.
    157     PP.Diag(UnknownTok, diag::ext_stdc_pragma_ignored);
    158   }
    159 };
    160 
    161 struct PragmaFPHandler : public PragmaHandler {
    162   PragmaFPHandler() : PragmaHandler("fp") {}
    163   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    164                     Token &FirstToken) override;
    165 };
    166 
    167 struct PragmaNoOpenMPHandler : public PragmaHandler {
    168   PragmaNoOpenMPHandler() : PragmaHandler("omp") { }
    169   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    170                     Token &FirstToken) override;
    171 };
    172 
    173 struct PragmaOpenMPHandler : public PragmaHandler {
    174   PragmaOpenMPHandler() : PragmaHandler("omp") { }
    175   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    176                     Token &FirstToken) override;
    177 };
    178 
    179 /// PragmaCommentHandler - "\#pragma comment ...".
    180 struct PragmaCommentHandler : public PragmaHandler {
    181   PragmaCommentHandler(Sema &Actions)
    182     : PragmaHandler("comment"), Actions(Actions) {}
    183   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    184                     Token &FirstToken) override;
    185 
    186 private:
    187   Sema &Actions;
    188 };
    189 
    190 struct PragmaDetectMismatchHandler : public PragmaHandler {
    191   PragmaDetectMismatchHandler(Sema &Actions)
    192     : PragmaHandler("detect_mismatch"), Actions(Actions) {}
    193   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    194                     Token &FirstToken) override;
    195 
    196 private:
    197   Sema &Actions;
    198 };
    199 
    200 struct PragmaFloatControlHandler : public PragmaHandler {
    201   PragmaFloatControlHandler(Sema &Actions)
    202       : PragmaHandler("float_control") {}
    203   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    204                     Token &FirstToken) override;
    205 };
    206 
    207 struct PragmaMSPointersToMembers : public PragmaHandler {
    208   explicit PragmaMSPointersToMembers() : PragmaHandler("pointers_to_members") {}
    209   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    210                     Token &FirstToken) override;
    211 };
    212 
    213 struct PragmaMSVtorDisp : public PragmaHandler {
    214   explicit PragmaMSVtorDisp() : PragmaHandler("vtordisp") {}
    215   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    216                     Token &FirstToken) override;
    217 };
    218 
    219 struct PragmaMSPragma : public PragmaHandler {
    220   explicit PragmaMSPragma(const char *name) : PragmaHandler(name) {}
    221   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    222                     Token &FirstToken) override;
    223 };
    224 
    225 /// PragmaOptimizeHandler - "\#pragma clang optimize on/off".
    226 struct PragmaOptimizeHandler : public PragmaHandler {
    227   PragmaOptimizeHandler(Sema &S)
    228     : PragmaHandler("optimize"), Actions(S) {}
    229   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    230                     Token &FirstToken) override;
    231 
    232 private:
    233   Sema &Actions;
    234 };
    235 
    236 struct PragmaLoopHintHandler : public PragmaHandler {
    237   PragmaLoopHintHandler() : PragmaHandler("loop") {}
    238   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    239                     Token &FirstToken) override;
    240 };
    241 
    242 struct PragmaUnrollHintHandler : public PragmaHandler {
    243   PragmaUnrollHintHandler(const char *name) : PragmaHandler(name) {}
    244   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    245                     Token &FirstToken) override;
    246 };
    247 
    248 struct PragmaMSRuntimeChecksHandler : public EmptyPragmaHandler {
    249   PragmaMSRuntimeChecksHandler() : EmptyPragmaHandler("runtime_checks") {}
    250 };
    251 
    252 struct PragmaMSIntrinsicHandler : public PragmaHandler {
    253   PragmaMSIntrinsicHandler() : PragmaHandler("intrinsic") {}
    254   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    255                     Token &FirstToken) override;
    256 };
    257 
    258 struct PragmaMSOptimizeHandler : public PragmaHandler {
    259   PragmaMSOptimizeHandler() : PragmaHandler("optimize") {}
    260   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    261                     Token &FirstToken) override;
    262 };
    263 
    264 struct PragmaForceCUDAHostDeviceHandler : public PragmaHandler {
    265   PragmaForceCUDAHostDeviceHandler(Sema &Actions)
    266       : PragmaHandler("force_cuda_host_device"), Actions(Actions) {}
    267   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    268                     Token &FirstToken) override;
    269 
    270 private:
    271   Sema &Actions;
    272 };
    273 
    274 /// PragmaAttributeHandler - "\#pragma clang attribute ...".
    275 struct PragmaAttributeHandler : public PragmaHandler {
    276   PragmaAttributeHandler(AttributeFactory &AttrFactory)
    277       : PragmaHandler("attribute"), AttributesForPragmaAttribute(AttrFactory) {}
    278   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    279                     Token &FirstToken) override;
    280 
    281   /// A pool of attributes that were parsed in \#pragma clang attribute.
    282   ParsedAttributes AttributesForPragmaAttribute;
    283 };
    284 
    285 struct PragmaMaxTokensHereHandler : public PragmaHandler {
    286   PragmaMaxTokensHereHandler() : PragmaHandler("max_tokens_here") {}
    287   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    288                     Token &FirstToken) override;
    289 };
    290 
    291 struct PragmaMaxTokensTotalHandler : public PragmaHandler {
    292   PragmaMaxTokensTotalHandler() : PragmaHandler("max_tokens_total") {}
    293   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
    294                     Token &FirstToken) override;
    295 };
    296 
    297 void markAsReinjectedForRelexing(llvm::MutableArrayRef<clang::Token> Toks) {
    298   for (auto &T : Toks)
    299     T.setFlag(clang::Token::IsReinjected);
    300 }
    301 }  // end namespace
    302 
    303 void Parser::initializePragmaHandlers() {
    304   AlignHandler = std::make_unique<PragmaAlignHandler>();
    305   PP.AddPragmaHandler(AlignHandler.get());
    306 
    307   GCCVisibilityHandler = std::make_unique<PragmaGCCVisibilityHandler>();
    308   PP.AddPragmaHandler("GCC", GCCVisibilityHandler.get());
    309 
    310   OptionsHandler = std::make_unique<PragmaOptionsHandler>();
    311   PP.AddPragmaHandler(OptionsHandler.get());
    312 
    313   PackHandler = std::make_unique<PragmaPackHandler>();
    314   PP.AddPragmaHandler(PackHandler.get());
    315 
    316   MSStructHandler = std::make_unique<PragmaMSStructHandler>();
    317   PP.AddPragmaHandler(MSStructHandler.get());
    318 
    319   UnusedHandler = std::make_unique<PragmaUnusedHandler>();
    320   PP.AddPragmaHandler(UnusedHandler.get());
    321 
    322   WeakHandler = std::make_unique<PragmaWeakHandler>();
    323   PP.AddPragmaHandler(WeakHandler.get());
    324 
    325   RedefineExtnameHandler = std::make_unique<PragmaRedefineExtnameHandler>();
    326   PP.AddPragmaHandler(RedefineExtnameHandler.get());
    327 
    328   FPContractHandler = std::make_unique<PragmaFPContractHandler>();
    329   PP.AddPragmaHandler("STDC", FPContractHandler.get());
    330 
    331   STDCFenvAccessHandler = std::make_unique<PragmaSTDC_FENV_ACCESSHandler>();
    332   PP.AddPragmaHandler("STDC", STDCFenvAccessHandler.get());
    333 
    334   STDCFenvRoundHandler = std::make_unique<PragmaSTDC_FENV_ROUNDHandler>();
    335   PP.AddPragmaHandler("STDC", STDCFenvRoundHandler.get());
    336 
    337   STDCCXLIMITHandler = std::make_unique<PragmaSTDC_CX_LIMITED_RANGEHandler>();
    338   PP.AddPragmaHandler("STDC", STDCCXLIMITHandler.get());
    339 
    340   STDCUnknownHandler = std::make_unique<PragmaSTDC_UnknownHandler>();
    341   PP.AddPragmaHandler("STDC", STDCUnknownHandler.get());
    342 
    343   PCSectionHandler = std::make_unique<PragmaClangSectionHandler>(Actions);
    344   PP.AddPragmaHandler("clang", PCSectionHandler.get());
    345 
    346   if (getLangOpts().OpenCL) {
    347     OpenCLExtensionHandler = std::make_unique<PragmaOpenCLExtensionHandler>();
    348     PP.AddPragmaHandler("OPENCL", OpenCLExtensionHandler.get());
    349 
    350     PP.AddPragmaHandler("OPENCL", FPContractHandler.get());
    351   }
    352   if (getLangOpts().OpenMP)
    353     OpenMPHandler = std::make_unique<PragmaOpenMPHandler>();
    354   else
    355     OpenMPHandler = std::make_unique<PragmaNoOpenMPHandler>();
    356   PP.AddPragmaHandler(OpenMPHandler.get());
    357 
    358   if (getLangOpts().MicrosoftExt ||
    359       getTargetInfo().getTriple().isOSBinFormatELF()) {
    360     MSCommentHandler = std::make_unique<PragmaCommentHandler>(Actions);
    361     PP.AddPragmaHandler(MSCommentHandler.get());
    362   }
    363 
    364   FloatControlHandler = std::make_unique<PragmaFloatControlHandler>(Actions);
    365   PP.AddPragmaHandler(FloatControlHandler.get());
    366   if (getLangOpts().MicrosoftExt) {
    367     MSDetectMismatchHandler =
    368         std::make_unique<PragmaDetectMismatchHandler>(Actions);
    369     PP.AddPragmaHandler(MSDetectMismatchHandler.get());
    370     MSPointersToMembers = std::make_unique<PragmaMSPointersToMembers>();
    371     PP.AddPragmaHandler(MSPointersToMembers.get());
    372     MSVtorDisp = std::make_unique<PragmaMSVtorDisp>();
    373     PP.AddPragmaHandler(MSVtorDisp.get());
    374     MSInitSeg = std::make_unique<PragmaMSPragma>("init_seg");
    375     PP.AddPragmaHandler(MSInitSeg.get());
    376     MSDataSeg = std::make_unique<PragmaMSPragma>("data_seg");
    377     PP.AddPragmaHandler(MSDataSeg.get());
    378     MSBSSSeg = std::make_unique<PragmaMSPragma>("bss_seg");
    379     PP.AddPragmaHandler(MSBSSSeg.get());
    380     MSConstSeg = std::make_unique<PragmaMSPragma>("const_seg");
    381     PP.AddPragmaHandler(MSConstSeg.get());
    382     MSCodeSeg = std::make_unique<PragmaMSPragma>("code_seg");
    383     PP.AddPragmaHandler(MSCodeSeg.get());
    384     MSSection = std::make_unique<PragmaMSPragma>("section");
    385     PP.AddPragmaHandler(MSSection.get());
    386     MSRuntimeChecks = std::make_unique<PragmaMSRuntimeChecksHandler>();
    387     PP.AddPragmaHandler(MSRuntimeChecks.get());
    388     MSIntrinsic = std::make_unique<PragmaMSIntrinsicHandler>();
    389     PP.AddPragmaHandler(MSIntrinsic.get());
    390     MSOptimize = std::make_unique<PragmaMSOptimizeHandler>();
    391     PP.AddPragmaHandler(MSOptimize.get());
    392   }
    393 
    394   if (getLangOpts().CUDA) {
    395     CUDAForceHostDeviceHandler =
    396         std::make_unique<PragmaForceCUDAHostDeviceHandler>(Actions);
    397     PP.AddPragmaHandler("clang", CUDAForceHostDeviceHandler.get());
    398   }
    399 
    400   OptimizeHandler = std::make_unique<PragmaOptimizeHandler>(Actions);
    401   PP.AddPragmaHandler("clang", OptimizeHandler.get());
    402 
    403   LoopHintHandler = std::make_unique<PragmaLoopHintHandler>();
    404   PP.AddPragmaHandler("clang", LoopHintHandler.get());
    405 
    406   UnrollHintHandler = std::make_unique<PragmaUnrollHintHandler>("unroll");
    407   PP.AddPragmaHandler(UnrollHintHandler.get());
    408   PP.AddPragmaHandler("GCC", UnrollHintHandler.get());
    409 
    410   NoUnrollHintHandler = std::make_unique<PragmaUnrollHintHandler>("nounroll");
    411   PP.AddPragmaHandler(NoUnrollHintHandler.get());
    412   PP.AddPragmaHandler("GCC", NoUnrollHintHandler.get());
    413 
    414   UnrollAndJamHintHandler =
    415       std::make_unique<PragmaUnrollHintHandler>("unroll_and_jam");
    416   PP.AddPragmaHandler(UnrollAndJamHintHandler.get());
    417 
    418   NoUnrollAndJamHintHandler =
    419       std::make_unique<PragmaUnrollHintHandler>("nounroll_and_jam");
    420   PP.AddPragmaHandler(NoUnrollAndJamHintHandler.get());
    421 
    422   FPHandler = std::make_unique<PragmaFPHandler>();
    423   PP.AddPragmaHandler("clang", FPHandler.get());
    424 
    425   AttributePragmaHandler =
    426       std::make_unique<PragmaAttributeHandler>(AttrFactory);
    427   PP.AddPragmaHandler("clang", AttributePragmaHandler.get());
    428 
    429   MaxTokensHerePragmaHandler = std::make_unique<PragmaMaxTokensHereHandler>();
    430   PP.AddPragmaHandler("clang", MaxTokensHerePragmaHandler.get());
    431 
    432   MaxTokensTotalPragmaHandler = std::make_unique<PragmaMaxTokensTotalHandler>();
    433   PP.AddPragmaHandler("clang", MaxTokensTotalPragmaHandler.get());
    434 }
    435 
    436 void Parser::resetPragmaHandlers() {
    437   // Remove the pragma handlers we installed.
    438   PP.RemovePragmaHandler(AlignHandler.get());
    439   AlignHandler.reset();
    440   PP.RemovePragmaHandler("GCC", GCCVisibilityHandler.get());
    441   GCCVisibilityHandler.reset();
    442   PP.RemovePragmaHandler(OptionsHandler.get());
    443   OptionsHandler.reset();
    444   PP.RemovePragmaHandler(PackHandler.get());
    445   PackHandler.reset();
    446   PP.RemovePragmaHandler(MSStructHandler.get());
    447   MSStructHandler.reset();
    448   PP.RemovePragmaHandler(UnusedHandler.get());
    449   UnusedHandler.reset();
    450   PP.RemovePragmaHandler(WeakHandler.get());
    451   WeakHandler.reset();
    452   PP.RemovePragmaHandler(RedefineExtnameHandler.get());
    453   RedefineExtnameHandler.reset();
    454 
    455   if (getLangOpts().OpenCL) {
    456     PP.RemovePragmaHandler("OPENCL", OpenCLExtensionHandler.get());
    457     OpenCLExtensionHandler.reset();
    458     PP.RemovePragmaHandler("OPENCL", FPContractHandler.get());
    459   }
    460   PP.RemovePragmaHandler(OpenMPHandler.get());
    461   OpenMPHandler.reset();
    462 
    463   if (getLangOpts().MicrosoftExt ||
    464       getTargetInfo().getTriple().isOSBinFormatELF()) {
    465     PP.RemovePragmaHandler(MSCommentHandler.get());
    466     MSCommentHandler.reset();
    467   }
    468 
    469   PP.RemovePragmaHandler("clang", PCSectionHandler.get());
    470   PCSectionHandler.reset();
    471 
    472   PP.RemovePragmaHandler(FloatControlHandler.get());
    473   FloatControlHandler.reset();
    474   if (getLangOpts().MicrosoftExt) {
    475     PP.RemovePragmaHandler(MSDetectMismatchHandler.get());
    476     MSDetectMismatchHandler.reset();
    477     PP.RemovePragmaHandler(MSPointersToMembers.get());
    478     MSPointersToMembers.reset();
    479     PP.RemovePragmaHandler(MSVtorDisp.get());
    480     MSVtorDisp.reset();
    481     PP.RemovePragmaHandler(MSInitSeg.get());
    482     MSInitSeg.reset();
    483     PP.RemovePragmaHandler(MSDataSeg.get());
    484     MSDataSeg.reset();
    485     PP.RemovePragmaHandler(MSBSSSeg.get());
    486     MSBSSSeg.reset();
    487     PP.RemovePragmaHandler(MSConstSeg.get());
    488     MSConstSeg.reset();
    489     PP.RemovePragmaHandler(MSCodeSeg.get());
    490     MSCodeSeg.reset();
    491     PP.RemovePragmaHandler(MSSection.get());
    492     MSSection.reset();
    493     PP.RemovePragmaHandler(MSRuntimeChecks.get());
    494     MSRuntimeChecks.reset();
    495     PP.RemovePragmaHandler(MSIntrinsic.get());
    496     MSIntrinsic.reset();
    497     PP.RemovePragmaHandler(MSOptimize.get());
    498     MSOptimize.reset();
    499   }
    500 
    501   if (getLangOpts().CUDA) {
    502     PP.RemovePragmaHandler("clang", CUDAForceHostDeviceHandler.get());
    503     CUDAForceHostDeviceHandler.reset();
    504   }
    505 
    506   PP.RemovePragmaHandler("STDC", FPContractHandler.get());
    507   FPContractHandler.reset();
    508 
    509   PP.RemovePragmaHandler("STDC", STDCFenvAccessHandler.get());
    510   STDCFenvAccessHandler.reset();
    511 
    512   PP.RemovePragmaHandler("STDC", STDCFenvRoundHandler.get());
    513   STDCFenvRoundHandler.reset();
    514 
    515   PP.RemovePragmaHandler("STDC", STDCCXLIMITHandler.get());
    516   STDCCXLIMITHandler.reset();
    517 
    518   PP.RemovePragmaHandler("STDC", STDCUnknownHandler.get());
    519   STDCUnknownHandler.reset();
    520 
    521   PP.RemovePragmaHandler("clang", OptimizeHandler.get());
    522   OptimizeHandler.reset();
    523 
    524   PP.RemovePragmaHandler("clang", LoopHintHandler.get());
    525   LoopHintHandler.reset();
    526 
    527   PP.RemovePragmaHandler(UnrollHintHandler.get());
    528   PP.RemovePragmaHandler("GCC", UnrollHintHandler.get());
    529   UnrollHintHandler.reset();
    530 
    531   PP.RemovePragmaHandler(NoUnrollHintHandler.get());
    532   PP.RemovePragmaHandler("GCC", NoUnrollHintHandler.get());
    533   NoUnrollHintHandler.reset();
    534 
    535   PP.RemovePragmaHandler(UnrollAndJamHintHandler.get());
    536   UnrollAndJamHintHandler.reset();
    537 
    538   PP.RemovePragmaHandler(NoUnrollAndJamHintHandler.get());
    539   NoUnrollAndJamHintHandler.reset();
    540 
    541   PP.RemovePragmaHandler("clang", FPHandler.get());
    542   FPHandler.reset();
    543 
    544   PP.RemovePragmaHandler("clang", AttributePragmaHandler.get());
    545   AttributePragmaHandler.reset();
    546 
    547   PP.RemovePragmaHandler("clang", MaxTokensHerePragmaHandler.get());
    548   MaxTokensHerePragmaHandler.reset();
    549 
    550   PP.RemovePragmaHandler("clang", MaxTokensTotalPragmaHandler.get());
    551   MaxTokensTotalPragmaHandler.reset();
    552 }
    553 
    554 /// Handle the annotation token produced for #pragma unused(...)
    555 ///
    556 /// Each annot_pragma_unused is followed by the argument token so e.g.
    557 /// "#pragma unused(x,y)" becomes:
    558 /// annot_pragma_unused 'x' annot_pragma_unused 'y'
    559 void Parser::HandlePragmaUnused() {
    560   assert(Tok.is(tok::annot_pragma_unused));
    561   SourceLocation UnusedLoc = ConsumeAnnotationToken();
    562   Actions.ActOnPragmaUnused(Tok, getCurScope(), UnusedLoc);
    563   ConsumeToken(); // The argument token.
    564 }
    565 
    566 void Parser::HandlePragmaVisibility() {
    567   assert(Tok.is(tok::annot_pragma_vis));
    568   const IdentifierInfo *VisType =
    569     static_cast<IdentifierInfo *>(Tok.getAnnotationValue());
    570   SourceLocation VisLoc = ConsumeAnnotationToken();
    571   Actions.ActOnPragmaVisibility(VisType, VisLoc);
    572 }
    573 
    574 namespace {
    575 struct PragmaPackInfo {
    576   Sema::PragmaMsStackAction Action;
    577   StringRef SlotLabel;
    578   Token Alignment;
    579 };
    580 } // end anonymous namespace
    581 
    582 void Parser::HandlePragmaPack() {
    583   assert(Tok.is(tok::annot_pragma_pack));
    584   PragmaPackInfo *Info =
    585     static_cast<PragmaPackInfo *>(Tok.getAnnotationValue());
    586   SourceLocation PragmaLoc = Tok.getLocation();
    587   ExprResult Alignment;
    588   if (Info->Alignment.is(tok::numeric_constant)) {
    589     Alignment = Actions.ActOnNumericConstant(Info->Alignment);
    590     if (Alignment.isInvalid()) {
    591       ConsumeAnnotationToken();
    592       return;
    593     }
    594   }
    595   Actions.ActOnPragmaPack(PragmaLoc, Info->Action, Info->SlotLabel,
    596                           Alignment.get());
    597   // Consume the token after processing the pragma to enable pragma-specific
    598   // #include warnings.
    599   ConsumeAnnotationToken();
    600 }
    601 
    602 void Parser::HandlePragmaMSStruct() {
    603   assert(Tok.is(tok::annot_pragma_msstruct));
    604   PragmaMSStructKind Kind = static_cast<PragmaMSStructKind>(
    605       reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
    606   Actions.ActOnPragmaMSStruct(Kind);
    607   ConsumeAnnotationToken();
    608 }
    609 
    610 void Parser::HandlePragmaAlign() {
    611   assert(Tok.is(tok::annot_pragma_align));
    612   Sema::PragmaOptionsAlignKind Kind =
    613     static_cast<Sema::PragmaOptionsAlignKind>(
    614     reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
    615   Actions.ActOnPragmaOptionsAlign(Kind, Tok.getLocation());
    616   // Consume the token after processing the pragma to enable pragma-specific
    617   // #include warnings.
    618   ConsumeAnnotationToken();
    619 }
    620 
    621 void Parser::HandlePragmaDump() {
    622   assert(Tok.is(tok::annot_pragma_dump));
    623   IdentifierInfo *II =
    624       reinterpret_cast<IdentifierInfo *>(Tok.getAnnotationValue());
    625   Actions.ActOnPragmaDump(getCurScope(), Tok.getLocation(), II);
    626   ConsumeAnnotationToken();
    627 }
    628 
    629 void Parser::HandlePragmaWeak() {
    630   assert(Tok.is(tok::annot_pragma_weak));
    631   SourceLocation PragmaLoc = ConsumeAnnotationToken();
    632   Actions.ActOnPragmaWeakID(Tok.getIdentifierInfo(), PragmaLoc,
    633                             Tok.getLocation());
    634   ConsumeToken(); // The weak name.
    635 }
    636 
    637 void Parser::HandlePragmaWeakAlias() {
    638   assert(Tok.is(tok::annot_pragma_weakalias));
    639   SourceLocation PragmaLoc = ConsumeAnnotationToken();
    640   IdentifierInfo *WeakName = Tok.getIdentifierInfo();
    641   SourceLocation WeakNameLoc = Tok.getLocation();
    642   ConsumeToken();
    643   IdentifierInfo *AliasName = Tok.getIdentifierInfo();
    644   SourceLocation AliasNameLoc = Tok.getLocation();
    645   ConsumeToken();
    646   Actions.ActOnPragmaWeakAlias(WeakName, AliasName, PragmaLoc,
    647                                WeakNameLoc, AliasNameLoc);
    648 
    649 }
    650 
    651 void Parser::HandlePragmaRedefineExtname() {
    652   assert(Tok.is(tok::annot_pragma_redefine_extname));
    653   SourceLocation RedefLoc = ConsumeAnnotationToken();
    654   IdentifierInfo *RedefName = Tok.getIdentifierInfo();
    655   SourceLocation RedefNameLoc = Tok.getLocation();
    656   ConsumeToken();
    657   IdentifierInfo *AliasName = Tok.getIdentifierInfo();
    658   SourceLocation AliasNameLoc = Tok.getLocation();
    659   ConsumeToken();
    660   Actions.ActOnPragmaRedefineExtname(RedefName, AliasName, RedefLoc,
    661                                      RedefNameLoc, AliasNameLoc);
    662 }
    663 
    664 void Parser::HandlePragmaFPContract() {
    665   assert(Tok.is(tok::annot_pragma_fp_contract));
    666   tok::OnOffSwitch OOS =
    667     static_cast<tok::OnOffSwitch>(
    668     reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
    669 
    670   LangOptions::FPModeKind FPC;
    671   switch (OOS) {
    672   case tok::OOS_ON:
    673     FPC = LangOptions::FPM_On;
    674     break;
    675   case tok::OOS_OFF:
    676     FPC = LangOptions::FPM_Off;
    677     break;
    678   case tok::OOS_DEFAULT:
    679     FPC = getLangOpts().getDefaultFPContractMode();
    680     break;
    681   }
    682 
    683   SourceLocation PragmaLoc = ConsumeAnnotationToken();
    684   Actions.ActOnPragmaFPContract(PragmaLoc, FPC);
    685 }
    686 
    687 void Parser::HandlePragmaFloatControl() {
    688   assert(Tok.is(tok::annot_pragma_float_control));
    689 
    690   // The value that is held on the PragmaFloatControlStack encodes
    691   // the PragmaFloatControl kind and the MSStackAction kind
    692   // into a single 32-bit word. The MsStackAction is the high 16 bits
    693   // and the FloatControl is the lower 16 bits. Use shift and bit-and
    694   // to decode the parts.
    695   uintptr_t Value = reinterpret_cast<uintptr_t>(Tok.getAnnotationValue());
    696   Sema::PragmaMsStackAction Action =
    697       static_cast<Sema::PragmaMsStackAction>((Value >> 16) & 0xFFFF);
    698   PragmaFloatControlKind Kind = PragmaFloatControlKind(Value & 0xFFFF);
    699   SourceLocation PragmaLoc = ConsumeAnnotationToken();
    700   Actions.ActOnPragmaFloatControl(PragmaLoc, Action, Kind);
    701 }
    702 
    703 void Parser::HandlePragmaFEnvAccess() {
    704   assert(Tok.is(tok::annot_pragma_fenv_access));
    705   tok::OnOffSwitch OOS =
    706     static_cast<tok::OnOffSwitch>(
    707     reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
    708 
    709   bool IsEnabled;
    710   switch (OOS) {
    711   case tok::OOS_ON:
    712     IsEnabled = true;
    713     break;
    714   case tok::OOS_OFF:
    715     IsEnabled = false;
    716     break;
    717   case tok::OOS_DEFAULT: // FIXME: Add this cli option when it makes sense.
    718     IsEnabled = false;
    719     break;
    720   }
    721 
    722   SourceLocation PragmaLoc = ConsumeAnnotationToken();
    723   Actions.ActOnPragmaFEnvAccess(PragmaLoc, IsEnabled);
    724 }
    725 
    726 void Parser::HandlePragmaFEnvRound() {
    727   assert(Tok.is(tok::annot_pragma_fenv_round));
    728   auto RM = static_cast<llvm::RoundingMode>(
    729       reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
    730 
    731   SourceLocation PragmaLoc = ConsumeAnnotationToken();
    732   Actions.setRoundingMode(PragmaLoc, RM);
    733 }
    734 
    735 StmtResult Parser::HandlePragmaCaptured()
    736 {
    737   assert(Tok.is(tok::annot_pragma_captured));
    738   ConsumeAnnotationToken();
    739 
    740   if (Tok.isNot(tok::l_brace)) {
    741     PP.Diag(Tok, diag::err_expected) << tok::l_brace;
    742     return StmtError();
    743   }
    744 
    745   SourceLocation Loc = Tok.getLocation();
    746 
    747   ParseScope CapturedRegionScope(this, Scope::FnScope | Scope::DeclScope |
    748                                            Scope::CompoundStmtScope);
    749   Actions.ActOnCapturedRegionStart(Loc, getCurScope(), CR_Default,
    750                                    /*NumParams=*/1);
    751 
    752   StmtResult R = ParseCompoundStatement();
    753   CapturedRegionScope.Exit();
    754 
    755   if (R.isInvalid()) {
    756     Actions.ActOnCapturedRegionError();
    757     return StmtError();
    758   }
    759 
    760   return Actions.ActOnCapturedRegionEnd(R.get());
    761 }
    762 
    763 namespace {
    764   enum OpenCLExtState : char {
    765     Disable, Enable, Begin, End
    766   };
    767   typedef std::pair<const IdentifierInfo *, OpenCLExtState> OpenCLExtData;
    768 }
    769 
    770 void Parser::HandlePragmaOpenCLExtension() {
    771   assert(Tok.is(tok::annot_pragma_opencl_extension));
    772   OpenCLExtData *Data = static_cast<OpenCLExtData*>(Tok.getAnnotationValue());
    773   auto State = Data->second;
    774   auto Ident = Data->first;
    775   SourceLocation NameLoc = Tok.getLocation();
    776   ConsumeAnnotationToken();
    777 
    778   auto &Opt = Actions.getOpenCLOptions();
    779   auto Name = Ident->getName();
    780   // OpenCL 1.1 9.1: "The all variant sets the behavior for all extensions,
    781   // overriding all previously issued extension directives, but only if the
    782   // behavior is set to disable."
    783   if (Name == "all") {
    784     if (State == Disable)
    785       Opt.disableAll();
    786     else
    787       PP.Diag(NameLoc, diag::warn_pragma_expected_predicate) << 1;
    788   } else if (State == Begin) {
    789     if (!Opt.isKnown(Name) || !Opt.isSupported(Name, getLangOpts())) {
    790       Opt.support(Name);
    791       // FIXME: Default behavior of the extension pragma is not defined.
    792       // Therefore, it should never be added by default.
    793       Opt.acceptsPragma(Name);
    794     }
    795   } else if (State == End) {
    796     // There is no behavior for this directive. We only accept this for
    797     // backward compatibility.
    798   } else if (!Opt.isKnown(Name) || !Opt.isWithPragma(Name))
    799     PP.Diag(NameLoc, diag::warn_pragma_unknown_extension) << Ident;
    800   else if (Opt.isSupportedExtension(Name, getLangOpts()))
    801     Opt.enable(Name, State == Enable);
    802   else if (Opt.isSupportedCoreOrOptionalCore(Name, getLangOpts()))
    803     PP.Diag(NameLoc, diag::warn_pragma_extension_is_core) << Ident;
    804   else
    805     PP.Diag(NameLoc, diag::warn_pragma_unsupported_extension) << Ident;
    806 }
    807 
    808 void Parser::HandlePragmaMSPointersToMembers() {
    809   assert(Tok.is(tok::annot_pragma_ms_pointers_to_members));
    810   LangOptions::PragmaMSPointersToMembersKind RepresentationMethod =
    811       static_cast<LangOptions::PragmaMSPointersToMembersKind>(
    812           reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
    813   SourceLocation PragmaLoc = ConsumeAnnotationToken();
    814   Actions.ActOnPragmaMSPointersToMembers(RepresentationMethod, PragmaLoc);
    815 }
    816 
    817 void Parser::HandlePragmaMSVtorDisp() {
    818   assert(Tok.is(tok::annot_pragma_ms_vtordisp));
    819   uintptr_t Value = reinterpret_cast<uintptr_t>(Tok.getAnnotationValue());
    820   Sema::PragmaMsStackAction Action =
    821       static_cast<Sema::PragmaMsStackAction>((Value >> 16) & 0xFFFF);
    822   MSVtorDispMode Mode = MSVtorDispMode(Value & 0xFFFF);
    823   SourceLocation PragmaLoc = ConsumeAnnotationToken();
    824   Actions.ActOnPragmaMSVtorDisp(Action, PragmaLoc, Mode);
    825 }
    826 
    827 void Parser::HandlePragmaMSPragma() {
    828   assert(Tok.is(tok::annot_pragma_ms_pragma));
    829   // Grab the tokens out of the annotation and enter them into the stream.
    830   auto TheTokens =
    831       (std::pair<std::unique_ptr<Token[]>, size_t> *)Tok.getAnnotationValue();
    832   PP.EnterTokenStream(std::move(TheTokens->first), TheTokens->second, true,
    833                       /*IsReinject=*/true);
    834   SourceLocation PragmaLocation = ConsumeAnnotationToken();
    835   assert(Tok.isAnyIdentifier());
    836   StringRef PragmaName = Tok.getIdentifierInfo()->getName();
    837   PP.Lex(Tok); // pragma kind
    838 
    839   // Figure out which #pragma we're dealing with.  The switch has no default
    840   // because lex shouldn't emit the annotation token for unrecognized pragmas.
    841   typedef bool (Parser::*PragmaHandler)(StringRef, SourceLocation);
    842   PragmaHandler Handler = llvm::StringSwitch<PragmaHandler>(PragmaName)
    843     .Case("data_seg", &Parser::HandlePragmaMSSegment)
    844     .Case("bss_seg", &Parser::HandlePragmaMSSegment)
    845     .Case("const_seg", &Parser::HandlePragmaMSSegment)
    846     .Case("code_seg", &Parser::HandlePragmaMSSegment)
    847     .Case("section", &Parser::HandlePragmaMSSection)
    848     .Case("init_seg", &Parser::HandlePragmaMSInitSeg);
    849 
    850   if (!(this->*Handler)(PragmaName, PragmaLocation)) {
    851     // Pragma handling failed, and has been diagnosed.  Slurp up the tokens
    852     // until eof (really end of line) to prevent follow-on errors.
    853     while (Tok.isNot(tok::eof))
    854       PP.Lex(Tok);
    855     PP.Lex(Tok);
    856   }
    857 }
    858 
    859 bool Parser::HandlePragmaMSSection(StringRef PragmaName,
    860                                    SourceLocation PragmaLocation) {
    861   if (Tok.isNot(tok::l_paren)) {
    862     PP.Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName;
    863     return false;
    864   }
    865   PP.Lex(Tok); // (
    866   // Parsing code for pragma section
    867   if (Tok.isNot(tok::string_literal)) {
    868     PP.Diag(PragmaLocation, diag::warn_pragma_expected_section_name)
    869         << PragmaName;
    870     return false;
    871   }
    872   ExprResult StringResult = ParseStringLiteralExpression();
    873   if (StringResult.isInvalid())
    874     return false; // Already diagnosed.
    875   StringLiteral *SegmentName = cast<StringLiteral>(StringResult.get());
    876   if (SegmentName->getCharByteWidth() != 1) {
    877     PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
    878         << PragmaName;
    879     return false;
    880   }
    881   int SectionFlags = ASTContext::PSF_Read;
    882   bool SectionFlagsAreDefault = true;
    883   while (Tok.is(tok::comma)) {
    884     PP.Lex(Tok); // ,
    885     // Ignore "long" and "short".
    886     // They are undocumented, but widely used, section attributes which appear
    887     // to do nothing.
    888     if (Tok.is(tok::kw_long) || Tok.is(tok::kw_short)) {
    889       PP.Lex(Tok); // long/short
    890       continue;
    891     }
    892 
    893     if (!Tok.isAnyIdentifier()) {
    894       PP.Diag(PragmaLocation, diag::warn_pragma_expected_action_or_r_paren)
    895           << PragmaName;
    896       return false;
    897     }
    898     ASTContext::PragmaSectionFlag Flag =
    899       llvm::StringSwitch<ASTContext::PragmaSectionFlag>(
    900       Tok.getIdentifierInfo()->getName())
    901       .Case("read", ASTContext::PSF_Read)
    902       .Case("write", ASTContext::PSF_Write)
    903       .Case("execute", ASTContext::PSF_Execute)
    904       .Case("shared", ASTContext::PSF_Invalid)
    905       .Case("nopage", ASTContext::PSF_Invalid)
    906       .Case("nocache", ASTContext::PSF_Invalid)
    907       .Case("discard", ASTContext::PSF_Invalid)
    908       .Case("remove", ASTContext::PSF_Invalid)
    909       .Default(ASTContext::PSF_None);
    910     if (Flag == ASTContext::PSF_None || Flag == ASTContext::PSF_Invalid) {
    911       PP.Diag(PragmaLocation, Flag == ASTContext::PSF_None
    912                                   ? diag::warn_pragma_invalid_specific_action
    913                                   : diag::warn_pragma_unsupported_action)
    914           << PragmaName << Tok.getIdentifierInfo()->getName();
    915       return false;
    916     }
    917     SectionFlags |= Flag;
    918     SectionFlagsAreDefault = false;
    919     PP.Lex(Tok); // Identifier
    920   }
    921   // If no section attributes are specified, the section will be marked as
    922   // read/write.
    923   if (SectionFlagsAreDefault)
    924     SectionFlags |= ASTContext::PSF_Write;
    925   if (Tok.isNot(tok::r_paren)) {
    926     PP.Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName;
    927     return false;
    928   }
    929   PP.Lex(Tok); // )
    930   if (Tok.isNot(tok::eof)) {
    931     PP.Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol)
    932         << PragmaName;
    933     return false;
    934   }
    935   PP.Lex(Tok); // eof
    936   Actions.ActOnPragmaMSSection(PragmaLocation, SectionFlags, SegmentName);
    937   return true;
    938 }
    939 
    940 bool Parser::HandlePragmaMSSegment(StringRef PragmaName,
    941                                    SourceLocation PragmaLocation) {
    942   if (Tok.isNot(tok::l_paren)) {
    943     PP.Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName;
    944     return false;
    945   }
    946   PP.Lex(Tok); // (
    947   Sema::PragmaMsStackAction Action = Sema::PSK_Reset;
    948   StringRef SlotLabel;
    949   if (Tok.isAnyIdentifier()) {
    950     StringRef PushPop = Tok.getIdentifierInfo()->getName();
    951     if (PushPop == "push")
    952       Action = Sema::PSK_Push;
    953     else if (PushPop == "pop")
    954       Action = Sema::PSK_Pop;
    955     else {
    956       PP.Diag(PragmaLocation,
    957               diag::warn_pragma_expected_section_push_pop_or_name)
    958           << PragmaName;
    959       return false;
    960     }
    961     if (Action != Sema::PSK_Reset) {
    962       PP.Lex(Tok); // push | pop
    963       if (Tok.is(tok::comma)) {
    964         PP.Lex(Tok); // ,
    965         // If we've got a comma, we either need a label or a string.
    966         if (Tok.isAnyIdentifier()) {
    967           SlotLabel = Tok.getIdentifierInfo()->getName();
    968           PP.Lex(Tok); // identifier
    969           if (Tok.is(tok::comma))
    970             PP.Lex(Tok);
    971           else if (Tok.isNot(tok::r_paren)) {
    972             PP.Diag(PragmaLocation, diag::warn_pragma_expected_punc)
    973                 << PragmaName;
    974             return false;
    975           }
    976         }
    977       } else if (Tok.isNot(tok::r_paren)) {
    978         PP.Diag(PragmaLocation, diag::warn_pragma_expected_punc) << PragmaName;
    979         return false;
    980       }
    981     }
    982   }
    983   // Grab the string literal for our section name.
    984   StringLiteral *SegmentName = nullptr;
    985   if (Tok.isNot(tok::r_paren)) {
    986     if (Tok.isNot(tok::string_literal)) {
    987       unsigned DiagID = Action != Sema::PSK_Reset ? !SlotLabel.empty() ?
    988           diag::warn_pragma_expected_section_name :
    989           diag::warn_pragma_expected_section_label_or_name :
    990           diag::warn_pragma_expected_section_push_pop_or_name;
    991       PP.Diag(PragmaLocation, DiagID) << PragmaName;
    992       return false;
    993     }
    994     ExprResult StringResult = ParseStringLiteralExpression();
    995     if (StringResult.isInvalid())
    996       return false; // Already diagnosed.
    997     SegmentName = cast<StringLiteral>(StringResult.get());
    998     if (SegmentName->getCharByteWidth() != 1) {
    999       PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
   1000           << PragmaName;
   1001       return false;
   1002     }
   1003     // Setting section "" has no effect
   1004     if (SegmentName->getLength())
   1005       Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set);
   1006   }
   1007   if (Tok.isNot(tok::r_paren)) {
   1008     PP.Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName;
   1009     return false;
   1010   }
   1011   PP.Lex(Tok); // )
   1012   if (Tok.isNot(tok::eof)) {
   1013     PP.Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol)
   1014         << PragmaName;
   1015     return false;
   1016   }
   1017   PP.Lex(Tok); // eof
   1018   Actions.ActOnPragmaMSSeg(PragmaLocation, Action, SlotLabel,
   1019                            SegmentName, PragmaName);
   1020   return true;
   1021 }
   1022 
   1023 // #pragma init_seg({ compiler | lib | user | "section-name" [, func-name]} )
   1024 bool Parser::HandlePragmaMSInitSeg(StringRef PragmaName,
   1025                                    SourceLocation PragmaLocation) {
   1026   if (getTargetInfo().getTriple().getEnvironment() != llvm::Triple::MSVC) {
   1027     PP.Diag(PragmaLocation, diag::warn_pragma_init_seg_unsupported_target);
   1028     return false;
   1029   }
   1030 
   1031   if (ExpectAndConsume(tok::l_paren, diag::warn_pragma_expected_lparen,
   1032                        PragmaName))
   1033     return false;
   1034 
   1035   // Parse either the known section names or the string section name.
   1036   StringLiteral *SegmentName = nullptr;
   1037   if (Tok.isAnyIdentifier()) {
   1038     auto *II = Tok.getIdentifierInfo();
   1039     StringRef Section = llvm::StringSwitch<StringRef>(II->getName())
   1040                             .Case("compiler", "\".CRT$XCC\"")
   1041                             .Case("lib", "\".CRT$XCL\"")
   1042                             .Case("user", "\".CRT$XCU\"")
   1043                             .Default("");
   1044 
   1045     if (!Section.empty()) {
   1046       // Pretend the user wrote the appropriate string literal here.
   1047       Token Toks[1];
   1048       Toks[0].startToken();
   1049       Toks[0].setKind(tok::string_literal);
   1050       Toks[0].setLocation(Tok.getLocation());
   1051       Toks[0].setLiteralData(Section.data());
   1052       Toks[0].setLength(Section.size());
   1053       SegmentName =
   1054           cast<StringLiteral>(Actions.ActOnStringLiteral(Toks, nullptr).get());
   1055       PP.Lex(Tok);
   1056     }
   1057   } else if (Tok.is(tok::string_literal)) {
   1058     ExprResult StringResult = ParseStringLiteralExpression();
   1059     if (StringResult.isInvalid())
   1060       return false;
   1061     SegmentName = cast<StringLiteral>(StringResult.get());
   1062     if (SegmentName->getCharByteWidth() != 1) {
   1063       PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
   1064           << PragmaName;
   1065       return false;
   1066     }
   1067     // FIXME: Add support for the '[, func-name]' part of the pragma.
   1068   }
   1069 
   1070   if (!SegmentName) {
   1071     PP.Diag(PragmaLocation, diag::warn_pragma_expected_init_seg) << PragmaName;
   1072     return false;
   1073   }
   1074 
   1075   if (ExpectAndConsume(tok::r_paren, diag::warn_pragma_expected_rparen,
   1076                        PragmaName) ||
   1077       ExpectAndConsume(tok::eof, diag::warn_pragma_extra_tokens_at_eol,
   1078                        PragmaName))
   1079     return false;
   1080 
   1081   Actions.ActOnPragmaMSInitSeg(PragmaLocation, SegmentName);
   1082   return true;
   1083 }
   1084 
   1085 namespace {
   1086 struct PragmaLoopHintInfo {
   1087   Token PragmaName;
   1088   Token Option;
   1089   ArrayRef<Token> Toks;
   1090 };
   1091 } // end anonymous namespace
   1092 
   1093 static std::string PragmaLoopHintString(Token PragmaName, Token Option) {
   1094   StringRef Str = PragmaName.getIdentifierInfo()->getName();
   1095   std::string ClangLoopStr = (llvm::Twine("clang loop ") + Str).str();
   1096   return std::string(llvm::StringSwitch<StringRef>(Str)
   1097                          .Case("loop", ClangLoopStr)
   1098                          .Case("unroll_and_jam", Str)
   1099                          .Case("unroll", Str)
   1100                          .Default(""));
   1101 }
   1102 
   1103 bool Parser::HandlePragmaLoopHint(LoopHint &Hint) {
   1104   assert(Tok.is(tok::annot_pragma_loop_hint));
   1105   PragmaLoopHintInfo *Info =
   1106       static_cast<PragmaLoopHintInfo *>(Tok.getAnnotationValue());
   1107 
   1108   IdentifierInfo *PragmaNameInfo = Info->PragmaName.getIdentifierInfo();
   1109   Hint.PragmaNameLoc = IdentifierLoc::create(
   1110       Actions.Context, Info->PragmaName.getLocation(), PragmaNameInfo);
   1111 
   1112   // It is possible that the loop hint has no option identifier, such as
   1113   // #pragma unroll(4).
   1114   IdentifierInfo *OptionInfo = Info->Option.is(tok::identifier)
   1115                                    ? Info->Option.getIdentifierInfo()
   1116                                    : nullptr;
   1117   Hint.OptionLoc = IdentifierLoc::create(
   1118       Actions.Context, Info->Option.getLocation(), OptionInfo);
   1119 
   1120   llvm::ArrayRef<Token> Toks = Info->Toks;
   1121 
   1122   // Return a valid hint if pragma unroll or nounroll were specified
   1123   // without an argument.
   1124   auto IsLoopHint = llvm::StringSwitch<bool>(PragmaNameInfo->getName())
   1125                         .Cases("unroll", "nounroll", "unroll_and_jam",
   1126                                "nounroll_and_jam", true)
   1127                         .Default(false);
   1128 
   1129   if (Toks.empty() && IsLoopHint) {
   1130     ConsumeAnnotationToken();
   1131     Hint.Range = Info->PragmaName.getLocation();
   1132     return true;
   1133   }
   1134 
   1135   // The constant expression is always followed by an eof token, which increases
   1136   // the TokSize by 1.
   1137   assert(!Toks.empty() &&
   1138          "PragmaLoopHintInfo::Toks must contain at least one token.");
   1139 
   1140   // If no option is specified the argument is assumed to be a constant expr.
   1141   bool OptionUnroll = false;
   1142   bool OptionUnrollAndJam = false;
   1143   bool OptionDistribute = false;
   1144   bool OptionPipelineDisabled = false;
   1145   bool StateOption = false;
   1146   if (OptionInfo) { // Pragma Unroll does not specify an option.
   1147     OptionUnroll = OptionInfo->isStr("unroll");
   1148     OptionUnrollAndJam = OptionInfo->isStr("unroll_and_jam");
   1149     OptionDistribute = OptionInfo->isStr("distribute");
   1150     OptionPipelineDisabled = OptionInfo->isStr("pipeline");
   1151     StateOption = llvm::StringSwitch<bool>(OptionInfo->getName())
   1152                       .Case("vectorize", true)
   1153                       .Case("interleave", true)
   1154                       .Case("vectorize_predicate", true)
   1155                       .Default(false) ||
   1156                   OptionUnroll || OptionUnrollAndJam || OptionDistribute ||
   1157                   OptionPipelineDisabled;
   1158   }
   1159 
   1160   bool AssumeSafetyArg = !OptionUnroll && !OptionUnrollAndJam &&
   1161                          !OptionDistribute && !OptionPipelineDisabled;
   1162   // Verify loop hint has an argument.
   1163   if (Toks[0].is(tok::eof)) {
   1164     ConsumeAnnotationToken();
   1165     Diag(Toks[0].getLocation(), diag::err_pragma_loop_missing_argument)
   1166         << /*StateArgument=*/StateOption
   1167         << /*FullKeyword=*/(OptionUnroll || OptionUnrollAndJam)
   1168         << /*AssumeSafetyKeyword=*/AssumeSafetyArg;
   1169     return false;
   1170   }
   1171 
   1172   // Validate the argument.
   1173   if (StateOption) {
   1174     ConsumeAnnotationToken();
   1175     SourceLocation StateLoc = Toks[0].getLocation();
   1176     IdentifierInfo *StateInfo = Toks[0].getIdentifierInfo();
   1177 
   1178     bool Valid = StateInfo &&
   1179                  llvm::StringSwitch<bool>(StateInfo->getName())
   1180                      .Case("disable", true)
   1181                      .Case("enable", !OptionPipelineDisabled)
   1182                      .Case("full", OptionUnroll || OptionUnrollAndJam)
   1183                      .Case("assume_safety", AssumeSafetyArg)
   1184                      .Default(false);
   1185     if (!Valid) {
   1186       if (OptionPipelineDisabled) {
   1187         Diag(Toks[0].getLocation(), diag::err_pragma_pipeline_invalid_keyword);
   1188       } else {
   1189         Diag(Toks[0].getLocation(), diag::err_pragma_invalid_keyword)
   1190             << /*FullKeyword=*/(OptionUnroll || OptionUnrollAndJam)
   1191             << /*AssumeSafetyKeyword=*/AssumeSafetyArg;
   1192       }
   1193       return false;
   1194     }
   1195     if (Toks.size() > 2)
   1196       Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   1197           << PragmaLoopHintString(Info->PragmaName, Info->Option);
   1198     Hint.StateLoc = IdentifierLoc::create(Actions.Context, StateLoc, StateInfo);
   1199   } else if (OptionInfo && OptionInfo->getName() == "vectorize_width") {
   1200     PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/false,
   1201                         /*IsReinject=*/false);
   1202     ConsumeAnnotationToken();
   1203 
   1204     SourceLocation StateLoc = Toks[0].getLocation();
   1205     IdentifierInfo *StateInfo = Toks[0].getIdentifierInfo();
   1206     StringRef IsScalableStr = StateInfo ? StateInfo->getName() : "";
   1207 
   1208     // Look for vectorize_width(fixed|scalable)
   1209     if (IsScalableStr == "scalable" || IsScalableStr == "fixed") {
   1210       PP.Lex(Tok); // Identifier
   1211 
   1212       if (Toks.size() > 2) {
   1213         Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   1214             << PragmaLoopHintString(Info->PragmaName, Info->Option);
   1215         while (Tok.isNot(tok::eof))
   1216           ConsumeAnyToken();
   1217       }
   1218 
   1219       Hint.StateLoc =
   1220           IdentifierLoc::create(Actions.Context, StateLoc, StateInfo);
   1221 
   1222       ConsumeToken(); // Consume the constant expression eof terminator.
   1223     } else {
   1224       // Enter constant expression including eof terminator into token stream.
   1225       ExprResult R = ParseConstantExpression();
   1226 
   1227       if (R.isInvalid() && !Tok.is(tok::comma))
   1228         Diag(Toks[0].getLocation(),
   1229              diag::note_pragma_loop_invalid_vectorize_option);
   1230 
   1231       bool Arg2Error = false;
   1232       if (Tok.is(tok::comma)) {
   1233         PP.Lex(Tok); // ,
   1234 
   1235         StateInfo = Tok.getIdentifierInfo();
   1236         IsScalableStr = StateInfo->getName();
   1237 
   1238         if (IsScalableStr != "scalable" && IsScalableStr != "fixed") {
   1239           Diag(Tok.getLocation(),
   1240                diag::err_pragma_loop_invalid_vectorize_option);
   1241           Arg2Error = true;
   1242         } else
   1243           Hint.StateLoc =
   1244               IdentifierLoc::create(Actions.Context, StateLoc, StateInfo);
   1245 
   1246         PP.Lex(Tok); // Identifier
   1247       }
   1248 
   1249       // Tokens following an error in an ill-formed constant expression will
   1250       // remain in the token stream and must be removed.
   1251       if (Tok.isNot(tok::eof)) {
   1252         Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   1253             << PragmaLoopHintString(Info->PragmaName, Info->Option);
   1254         while (Tok.isNot(tok::eof))
   1255           ConsumeAnyToken();
   1256       }
   1257 
   1258       ConsumeToken(); // Consume the constant expression eof terminator.
   1259 
   1260       if (Arg2Error || R.isInvalid() ||
   1261           Actions.CheckLoopHintExpr(R.get(), Toks[0].getLocation()))
   1262         return false;
   1263 
   1264       // Argument is a constant expression with an integer type.
   1265       Hint.ValueExpr = R.get();
   1266     }
   1267   } else {
   1268     // Enter constant expression including eof terminator into token stream.
   1269     PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/false,
   1270                         /*IsReinject=*/false);
   1271     ConsumeAnnotationToken();
   1272     ExprResult R = ParseConstantExpression();
   1273 
   1274     // Tokens following an error in an ill-formed constant expression will
   1275     // remain in the token stream and must be removed.
   1276     if (Tok.isNot(tok::eof)) {
   1277       Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   1278           << PragmaLoopHintString(Info->PragmaName, Info->Option);
   1279       while (Tok.isNot(tok::eof))
   1280         ConsumeAnyToken();
   1281     }
   1282 
   1283     ConsumeToken(); // Consume the constant expression eof terminator.
   1284 
   1285     if (R.isInvalid() ||
   1286         Actions.CheckLoopHintExpr(R.get(), Toks[0].getLocation()))
   1287       return false;
   1288 
   1289     // Argument is a constant expression with an integer type.
   1290     Hint.ValueExpr = R.get();
   1291   }
   1292 
   1293   Hint.Range = SourceRange(Info->PragmaName.getLocation(),
   1294                            Info->Toks.back().getLocation());
   1295   return true;
   1296 }
   1297 
   1298 namespace {
   1299 struct PragmaAttributeInfo {
   1300   enum ActionType { Push, Pop, Attribute };
   1301   ParsedAttributes &Attributes;
   1302   ActionType Action;
   1303   const IdentifierInfo *Namespace = nullptr;
   1304   ArrayRef<Token> Tokens;
   1305 
   1306   PragmaAttributeInfo(ParsedAttributes &Attributes) : Attributes(Attributes) {}
   1307 };
   1308 
   1309 #include "clang/Parse/AttrSubMatchRulesParserStringSwitches.inc"
   1310 
   1311 } // end anonymous namespace
   1312 
   1313 static StringRef getIdentifier(const Token &Tok) {
   1314   if (Tok.is(tok::identifier))
   1315     return Tok.getIdentifierInfo()->getName();
   1316   const char *S = tok::getKeywordSpelling(Tok.getKind());
   1317   if (!S)
   1318     return "";
   1319   return S;
   1320 }
   1321 
   1322 static bool isAbstractAttrMatcherRule(attr::SubjectMatchRule Rule) {
   1323   using namespace attr;
   1324   switch (Rule) {
   1325 #define ATTR_MATCH_RULE(Value, Spelling, IsAbstract)                           \
   1326   case Value:                                                                  \
   1327     return IsAbstract;
   1328 #include "clang/Basic/AttrSubMatchRulesList.inc"
   1329   }
   1330   llvm_unreachable("Invalid attribute subject match rule");
   1331   return false;
   1332 }
   1333 
   1334 static void diagnoseExpectedAttributeSubjectSubRule(
   1335     Parser &PRef, attr::SubjectMatchRule PrimaryRule, StringRef PrimaryRuleName,
   1336     SourceLocation SubRuleLoc) {
   1337   auto Diagnostic =
   1338       PRef.Diag(SubRuleLoc,
   1339                 diag::err_pragma_attribute_expected_subject_sub_identifier)
   1340       << PrimaryRuleName;
   1341   if (const char *SubRules = validAttributeSubjectMatchSubRules(PrimaryRule))
   1342     Diagnostic << /*SubRulesSupported=*/1 << SubRules;
   1343   else
   1344     Diagnostic << /*SubRulesSupported=*/0;
   1345 }
   1346 
   1347 static void diagnoseUnknownAttributeSubjectSubRule(
   1348     Parser &PRef, attr::SubjectMatchRule PrimaryRule, StringRef PrimaryRuleName,
   1349     StringRef SubRuleName, SourceLocation SubRuleLoc) {
   1350 
   1351   auto Diagnostic =
   1352       PRef.Diag(SubRuleLoc, diag::err_pragma_attribute_unknown_subject_sub_rule)
   1353       << SubRuleName << PrimaryRuleName;
   1354   if (const char *SubRules = validAttributeSubjectMatchSubRules(PrimaryRule))
   1355     Diagnostic << /*SubRulesSupported=*/1 << SubRules;
   1356   else
   1357     Diagnostic << /*SubRulesSupported=*/0;
   1358 }
   1359 
   1360 bool Parser::ParsePragmaAttributeSubjectMatchRuleSet(
   1361     attr::ParsedSubjectMatchRuleSet &SubjectMatchRules, SourceLocation &AnyLoc,
   1362     SourceLocation &LastMatchRuleEndLoc) {
   1363   bool IsAny = false;
   1364   BalancedDelimiterTracker AnyParens(*this, tok::l_paren);
   1365   if (getIdentifier(Tok) == "any") {
   1366     AnyLoc = ConsumeToken();
   1367     IsAny = true;
   1368     if (AnyParens.expectAndConsume())
   1369       return true;
   1370   }
   1371 
   1372   do {
   1373     // Parse the subject matcher rule.
   1374     StringRef Name = getIdentifier(Tok);
   1375     if (Name.empty()) {
   1376       Diag(Tok, diag::err_pragma_attribute_expected_subject_identifier);
   1377       return true;
   1378     }
   1379     std::pair<Optional<attr::SubjectMatchRule>,
   1380               Optional<attr::SubjectMatchRule> (*)(StringRef, bool)>
   1381         Rule = isAttributeSubjectMatchRule(Name);
   1382     if (!Rule.first) {
   1383       Diag(Tok, diag::err_pragma_attribute_unknown_subject_rule) << Name;
   1384       return true;
   1385     }
   1386     attr::SubjectMatchRule PrimaryRule = *Rule.first;
   1387     SourceLocation RuleLoc = ConsumeToken();
   1388 
   1389     BalancedDelimiterTracker Parens(*this, tok::l_paren);
   1390     if (isAbstractAttrMatcherRule(PrimaryRule)) {
   1391       if (Parens.expectAndConsume())
   1392         return true;
   1393     } else if (Parens.consumeOpen()) {
   1394       if (!SubjectMatchRules
   1395                .insert(
   1396                    std::make_pair(PrimaryRule, SourceRange(RuleLoc, RuleLoc)))
   1397                .second)
   1398         Diag(RuleLoc, diag::err_pragma_attribute_duplicate_subject)
   1399             << Name
   1400             << FixItHint::CreateRemoval(SourceRange(
   1401                    RuleLoc, Tok.is(tok::comma) ? Tok.getLocation() : RuleLoc));
   1402       LastMatchRuleEndLoc = RuleLoc;
   1403       continue;
   1404     }
   1405 
   1406     // Parse the sub-rules.
   1407     StringRef SubRuleName = getIdentifier(Tok);
   1408     if (SubRuleName.empty()) {
   1409       diagnoseExpectedAttributeSubjectSubRule(*this, PrimaryRule, Name,
   1410                                               Tok.getLocation());
   1411       return true;
   1412     }
   1413     attr::SubjectMatchRule SubRule;
   1414     if (SubRuleName == "unless") {
   1415       SourceLocation SubRuleLoc = ConsumeToken();
   1416       BalancedDelimiterTracker Parens(*this, tok::l_paren);
   1417       if (Parens.expectAndConsume())
   1418         return true;
   1419       SubRuleName = getIdentifier(Tok);
   1420       if (SubRuleName.empty()) {
   1421         diagnoseExpectedAttributeSubjectSubRule(*this, PrimaryRule, Name,
   1422                                                 SubRuleLoc);
   1423         return true;
   1424       }
   1425       auto SubRuleOrNone = Rule.second(SubRuleName, /*IsUnless=*/true);
   1426       if (!SubRuleOrNone) {
   1427         std::string SubRuleUnlessName = "unless(" + SubRuleName.str() + ")";
   1428         diagnoseUnknownAttributeSubjectSubRule(*this, PrimaryRule, Name,
   1429                                                SubRuleUnlessName, SubRuleLoc);
   1430         return true;
   1431       }
   1432       SubRule = *SubRuleOrNone;
   1433       ConsumeToken();
   1434       if (Parens.consumeClose())
   1435         return true;
   1436     } else {
   1437       auto SubRuleOrNone = Rule.second(SubRuleName, /*IsUnless=*/false);
   1438       if (!SubRuleOrNone) {
   1439         diagnoseUnknownAttributeSubjectSubRule(*this, PrimaryRule, Name,
   1440                                                SubRuleName, Tok.getLocation());
   1441         return true;
   1442       }
   1443       SubRule = *SubRuleOrNone;
   1444       ConsumeToken();
   1445     }
   1446     SourceLocation RuleEndLoc = Tok.getLocation();
   1447     LastMatchRuleEndLoc = RuleEndLoc;
   1448     if (Parens.consumeClose())
   1449       return true;
   1450     if (!SubjectMatchRules
   1451              .insert(std::make_pair(SubRule, SourceRange(RuleLoc, RuleEndLoc)))
   1452              .second) {
   1453       Diag(RuleLoc, diag::err_pragma_attribute_duplicate_subject)
   1454           << attr::getSubjectMatchRuleSpelling(SubRule)
   1455           << FixItHint::CreateRemoval(SourceRange(
   1456                  RuleLoc, Tok.is(tok::comma) ? Tok.getLocation() : RuleEndLoc));
   1457       continue;
   1458     }
   1459   } while (IsAny && TryConsumeToken(tok::comma));
   1460 
   1461   if (IsAny)
   1462     if (AnyParens.consumeClose())
   1463       return true;
   1464 
   1465   return false;
   1466 }
   1467 
   1468 namespace {
   1469 
   1470 /// Describes the stage at which attribute subject rule parsing was interrupted.
   1471 enum class MissingAttributeSubjectRulesRecoveryPoint {
   1472   Comma,
   1473   ApplyTo,
   1474   Equals,
   1475   Any,
   1476   None,
   1477 };
   1478 
   1479 MissingAttributeSubjectRulesRecoveryPoint
   1480 getAttributeSubjectRulesRecoveryPointForToken(const Token &Tok) {
   1481   if (const auto *II = Tok.getIdentifierInfo()) {
   1482     if (II->isStr("apply_to"))
   1483       return MissingAttributeSubjectRulesRecoveryPoint::ApplyTo;
   1484     if (II->isStr("any"))
   1485       return MissingAttributeSubjectRulesRecoveryPoint::Any;
   1486   }
   1487   if (Tok.is(tok::equal))
   1488     return MissingAttributeSubjectRulesRecoveryPoint::Equals;
   1489   return MissingAttributeSubjectRulesRecoveryPoint::None;
   1490 }
   1491 
   1492 /// Creates a diagnostic for the attribute subject rule parsing diagnostic that
   1493 /// suggests the possible attribute subject rules in a fix-it together with
   1494 /// any other missing tokens.
   1495 DiagnosticBuilder createExpectedAttributeSubjectRulesTokenDiagnostic(
   1496     unsigned DiagID, ParsedAttr &Attribute,
   1497     MissingAttributeSubjectRulesRecoveryPoint Point, Parser &PRef) {
   1498   SourceLocation Loc = PRef.getEndOfPreviousToken();
   1499   if (Loc.isInvalid())
   1500     Loc = PRef.getCurToken().getLocation();
   1501   auto Diagnostic = PRef.Diag(Loc, DiagID);
   1502   std::string FixIt;
   1503   MissingAttributeSubjectRulesRecoveryPoint EndPoint =
   1504       getAttributeSubjectRulesRecoveryPointForToken(PRef.getCurToken());
   1505   if (Point == MissingAttributeSubjectRulesRecoveryPoint::Comma)
   1506     FixIt = ", ";
   1507   if (Point <= MissingAttributeSubjectRulesRecoveryPoint::ApplyTo &&
   1508       EndPoint > MissingAttributeSubjectRulesRecoveryPoint::ApplyTo)
   1509     FixIt += "apply_to";
   1510   if (Point <= MissingAttributeSubjectRulesRecoveryPoint::Equals &&
   1511       EndPoint > MissingAttributeSubjectRulesRecoveryPoint::Equals)
   1512     FixIt += " = ";
   1513   SourceRange FixItRange(Loc);
   1514   if (EndPoint == MissingAttributeSubjectRulesRecoveryPoint::None) {
   1515     // Gather the subject match rules that are supported by the attribute.
   1516     SmallVector<std::pair<attr::SubjectMatchRule, bool>, 4> SubjectMatchRuleSet;
   1517     Attribute.getMatchRules(PRef.getLangOpts(), SubjectMatchRuleSet);
   1518     if (SubjectMatchRuleSet.empty()) {
   1519       // FIXME: We can emit a "fix-it" with a subject list placeholder when
   1520       // placeholders will be supported by the fix-its.
   1521       return Diagnostic;
   1522     }
   1523     FixIt += "any(";
   1524     bool NeedsComma = false;
   1525     for (const auto &I : SubjectMatchRuleSet) {
   1526       // Ensure that the missing rule is reported in the fix-it only when it's
   1527       // supported in the current language mode.
   1528       if (!I.second)
   1529         continue;
   1530       if (NeedsComma)
   1531         FixIt += ", ";
   1532       else
   1533         NeedsComma = true;
   1534       FixIt += attr::getSubjectMatchRuleSpelling(I.first);
   1535     }
   1536     FixIt += ")";
   1537     // Check if we need to remove the range
   1538     PRef.SkipUntil(tok::eof, Parser::StopBeforeMatch);
   1539     FixItRange.setEnd(PRef.getCurToken().getLocation());
   1540   }
   1541   if (FixItRange.getBegin() == FixItRange.getEnd())
   1542     Diagnostic << FixItHint::CreateInsertion(FixItRange.getBegin(), FixIt);
   1543   else
   1544     Diagnostic << FixItHint::CreateReplacement(
   1545         CharSourceRange::getCharRange(FixItRange), FixIt);
   1546   return Diagnostic;
   1547 }
   1548 
   1549 } // end anonymous namespace
   1550 
   1551 void Parser::HandlePragmaAttribute() {
   1552   assert(Tok.is(tok::annot_pragma_attribute) &&
   1553          "Expected #pragma attribute annotation token");
   1554   SourceLocation PragmaLoc = Tok.getLocation();
   1555   auto *Info = static_cast<PragmaAttributeInfo *>(Tok.getAnnotationValue());
   1556   if (Info->Action == PragmaAttributeInfo::Pop) {
   1557     ConsumeAnnotationToken();
   1558     Actions.ActOnPragmaAttributePop(PragmaLoc, Info->Namespace);
   1559     return;
   1560   }
   1561   // Parse the actual attribute with its arguments.
   1562   assert((Info->Action == PragmaAttributeInfo::Push ||
   1563           Info->Action == PragmaAttributeInfo::Attribute) &&
   1564          "Unexpected #pragma attribute command");
   1565 
   1566   if (Info->Action == PragmaAttributeInfo::Push && Info->Tokens.empty()) {
   1567     ConsumeAnnotationToken();
   1568     Actions.ActOnPragmaAttributeEmptyPush(PragmaLoc, Info->Namespace);
   1569     return;
   1570   }
   1571 
   1572   PP.EnterTokenStream(Info->Tokens, /*DisableMacroExpansion=*/false,
   1573                       /*IsReinject=*/false);
   1574   ConsumeAnnotationToken();
   1575 
   1576   ParsedAttributes &Attrs = Info->Attributes;
   1577   Attrs.clearListOnly();
   1578 
   1579   auto SkipToEnd = [this]() {
   1580     SkipUntil(tok::eof, StopBeforeMatch);
   1581     ConsumeToken();
   1582   };
   1583 
   1584   if (Tok.is(tok::l_square) && NextToken().is(tok::l_square)) {
   1585     // Parse the CXX11 style attribute.
   1586     ParseCXX11AttributeSpecifier(Attrs);
   1587   } else if (Tok.is(tok::kw___attribute)) {
   1588     ConsumeToken();
   1589     if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
   1590                          "attribute"))
   1591       return SkipToEnd();
   1592     if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "("))
   1593       return SkipToEnd();
   1594 
   1595     if (Tok.isNot(tok::identifier)) {
   1596       Diag(Tok, diag::err_pragma_attribute_expected_attribute_name);
   1597       SkipToEnd();
   1598       return;
   1599     }
   1600     IdentifierInfo *AttrName = Tok.getIdentifierInfo();
   1601     SourceLocation AttrNameLoc = ConsumeToken();
   1602 
   1603     if (Tok.isNot(tok::l_paren))
   1604       Attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
   1605                    ParsedAttr::AS_GNU);
   1606     else
   1607       ParseGNUAttributeArgs(AttrName, AttrNameLoc, Attrs, /*EndLoc=*/nullptr,
   1608                             /*ScopeName=*/nullptr,
   1609                             /*ScopeLoc=*/SourceLocation(), ParsedAttr::AS_GNU,
   1610                             /*Declarator=*/nullptr);
   1611 
   1612     if (ExpectAndConsume(tok::r_paren))
   1613       return SkipToEnd();
   1614     if (ExpectAndConsume(tok::r_paren))
   1615       return SkipToEnd();
   1616   } else if (Tok.is(tok::kw___declspec)) {
   1617     ParseMicrosoftDeclSpecs(Attrs);
   1618   } else {
   1619     Diag(Tok, diag::err_pragma_attribute_expected_attribute_syntax);
   1620     if (Tok.getIdentifierInfo()) {
   1621       // If we suspect that this is an attribute suggest the use of
   1622       // '__attribute__'.
   1623       if (ParsedAttr::getParsedKind(
   1624               Tok.getIdentifierInfo(), /*ScopeName=*/nullptr,
   1625               ParsedAttr::AS_GNU) != ParsedAttr::UnknownAttribute) {
   1626         SourceLocation InsertStartLoc = Tok.getLocation();
   1627         ConsumeToken();
   1628         if (Tok.is(tok::l_paren)) {
   1629           ConsumeAnyToken();
   1630           SkipUntil(tok::r_paren, StopBeforeMatch);
   1631           if (Tok.isNot(tok::r_paren))
   1632             return SkipToEnd();
   1633         }
   1634         Diag(Tok, diag::note_pragma_attribute_use_attribute_kw)
   1635             << FixItHint::CreateInsertion(InsertStartLoc, "__attribute__((")
   1636             << FixItHint::CreateInsertion(Tok.getEndLoc(), "))");
   1637       }
   1638     }
   1639     SkipToEnd();
   1640     return;
   1641   }
   1642 
   1643   if (Attrs.empty() || Attrs.begin()->isInvalid()) {
   1644     SkipToEnd();
   1645     return;
   1646   }
   1647 
   1648   // Ensure that we don't have more than one attribute.
   1649   if (Attrs.size() > 1) {
   1650     SourceLocation Loc = Attrs[1].getLoc();
   1651     Diag(Loc, diag::err_pragma_attribute_multiple_attributes);
   1652     SkipToEnd();
   1653     return;
   1654   }
   1655 
   1656   ParsedAttr &Attribute = *Attrs.begin();
   1657   if (!Attribute.isSupportedByPragmaAttribute()) {
   1658     Diag(PragmaLoc, diag::err_pragma_attribute_unsupported_attribute)
   1659         << Attribute;
   1660     SkipToEnd();
   1661     return;
   1662   }
   1663 
   1664   // Parse the subject-list.
   1665   if (!TryConsumeToken(tok::comma)) {
   1666     createExpectedAttributeSubjectRulesTokenDiagnostic(
   1667         diag::err_expected, Attribute,
   1668         MissingAttributeSubjectRulesRecoveryPoint::Comma, *this)
   1669         << tok::comma;
   1670     SkipToEnd();
   1671     return;
   1672   }
   1673 
   1674   if (Tok.isNot(tok::identifier)) {
   1675     createExpectedAttributeSubjectRulesTokenDiagnostic(
   1676         diag::err_pragma_attribute_invalid_subject_set_specifier, Attribute,
   1677         MissingAttributeSubjectRulesRecoveryPoint::ApplyTo, *this);
   1678     SkipToEnd();
   1679     return;
   1680   }
   1681   const IdentifierInfo *II = Tok.getIdentifierInfo();
   1682   if (!II->isStr("apply_to")) {
   1683     createExpectedAttributeSubjectRulesTokenDiagnostic(
   1684         diag::err_pragma_attribute_invalid_subject_set_specifier, Attribute,
   1685         MissingAttributeSubjectRulesRecoveryPoint::ApplyTo, *this);
   1686     SkipToEnd();
   1687     return;
   1688   }
   1689   ConsumeToken();
   1690 
   1691   if (!TryConsumeToken(tok::equal)) {
   1692     createExpectedAttributeSubjectRulesTokenDiagnostic(
   1693         diag::err_expected, Attribute,
   1694         MissingAttributeSubjectRulesRecoveryPoint::Equals, *this)
   1695         << tok::equal;
   1696     SkipToEnd();
   1697     return;
   1698   }
   1699 
   1700   attr::ParsedSubjectMatchRuleSet SubjectMatchRules;
   1701   SourceLocation AnyLoc, LastMatchRuleEndLoc;
   1702   if (ParsePragmaAttributeSubjectMatchRuleSet(SubjectMatchRules, AnyLoc,
   1703                                               LastMatchRuleEndLoc)) {
   1704     SkipToEnd();
   1705     return;
   1706   }
   1707 
   1708   // Tokens following an ill-formed attribute will remain in the token stream
   1709   // and must be removed.
   1710   if (Tok.isNot(tok::eof)) {
   1711     Diag(Tok, diag::err_pragma_attribute_extra_tokens_after_attribute);
   1712     SkipToEnd();
   1713     return;
   1714   }
   1715 
   1716   // Consume the eof terminator token.
   1717   ConsumeToken();
   1718 
   1719   // Handle a mixed push/attribute by desurging to a push, then an attribute.
   1720   if (Info->Action == PragmaAttributeInfo::Push)
   1721     Actions.ActOnPragmaAttributeEmptyPush(PragmaLoc, Info->Namespace);
   1722 
   1723   Actions.ActOnPragmaAttributeAttribute(Attribute, PragmaLoc,
   1724                                         std::move(SubjectMatchRules));
   1725 }
   1726 
   1727 // #pragma GCC visibility comes in two variants:
   1728 //   'push' '(' [visibility] ')'
   1729 //   'pop'
   1730 void PragmaGCCVisibilityHandler::HandlePragma(Preprocessor &PP,
   1731                                               PragmaIntroducer Introducer,
   1732                                               Token &VisTok) {
   1733   SourceLocation VisLoc = VisTok.getLocation();
   1734 
   1735   Token Tok;
   1736   PP.LexUnexpandedToken(Tok);
   1737 
   1738   const IdentifierInfo *PushPop = Tok.getIdentifierInfo();
   1739 
   1740   const IdentifierInfo *VisType;
   1741   if (PushPop && PushPop->isStr("pop")) {
   1742     VisType = nullptr;
   1743   } else if (PushPop && PushPop->isStr("push")) {
   1744     PP.LexUnexpandedToken(Tok);
   1745     if (Tok.isNot(tok::l_paren)) {
   1746       PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen)
   1747         << "visibility";
   1748       return;
   1749     }
   1750     PP.LexUnexpandedToken(Tok);
   1751     VisType = Tok.getIdentifierInfo();
   1752     if (!VisType) {
   1753       PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
   1754         << "visibility";
   1755       return;
   1756     }
   1757     PP.LexUnexpandedToken(Tok);
   1758     if (Tok.isNot(tok::r_paren)) {
   1759       PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen)
   1760         << "visibility";
   1761       return;
   1762     }
   1763   } else {
   1764     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
   1765       << "visibility";
   1766     return;
   1767   }
   1768   SourceLocation EndLoc = Tok.getLocation();
   1769   PP.LexUnexpandedToken(Tok);
   1770   if (Tok.isNot(tok::eod)) {
   1771     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   1772       << "visibility";
   1773     return;
   1774   }
   1775 
   1776   auto Toks = std::make_unique<Token[]>(1);
   1777   Toks[0].startToken();
   1778   Toks[0].setKind(tok::annot_pragma_vis);
   1779   Toks[0].setLocation(VisLoc);
   1780   Toks[0].setAnnotationEndLoc(EndLoc);
   1781   Toks[0].setAnnotationValue(
   1782       const_cast<void *>(static_cast<const void *>(VisType)));
   1783   PP.EnterTokenStream(std::move(Toks), 1, /*DisableMacroExpansion=*/true,
   1784                       /*IsReinject=*/false);
   1785 }
   1786 
   1787 // #pragma pack(...) comes in the following delicious flavors:
   1788 //   pack '(' [integer] ')'
   1789 //   pack '(' 'show' ')'
   1790 //   pack '(' ('push' | 'pop') [',' identifier] [, integer] ')'
   1791 void PragmaPackHandler::HandlePragma(Preprocessor &PP,
   1792                                      PragmaIntroducer Introducer,
   1793                                      Token &PackTok) {
   1794   SourceLocation PackLoc = PackTok.getLocation();
   1795 
   1796   Token Tok;
   1797   PP.Lex(Tok);
   1798   if (Tok.isNot(tok::l_paren)) {
   1799     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "pack";
   1800     return;
   1801   }
   1802 
   1803   Sema::PragmaMsStackAction Action = Sema::PSK_Reset;
   1804   StringRef SlotLabel;
   1805   Token Alignment;
   1806   Alignment.startToken();
   1807   PP.Lex(Tok);
   1808   if (Tok.is(tok::numeric_constant)) {
   1809     Alignment = Tok;
   1810 
   1811     PP.Lex(Tok);
   1812 
   1813     // In MSVC/gcc, #pragma pack(4) sets the alignment without affecting
   1814     // the push/pop stack.
   1815     // In Apple gcc/XL, #pragma pack(4) is equivalent to #pragma pack(push, 4)
   1816     Action = (PP.getLangOpts().ApplePragmaPack || PP.getLangOpts().XLPragmaPack)
   1817                  ? Sema::PSK_Push_Set
   1818                  : Sema::PSK_Set;
   1819   } else if (Tok.is(tok::identifier)) {
   1820     const IdentifierInfo *II = Tok.getIdentifierInfo();
   1821     if (II->isStr("show")) {
   1822       Action = Sema::PSK_Show;
   1823       PP.Lex(Tok);
   1824     } else {
   1825       if (II->isStr("push")) {
   1826         Action = Sema::PSK_Push;
   1827       } else if (II->isStr("pop")) {
   1828         Action = Sema::PSK_Pop;
   1829       } else {
   1830         PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_action) << "pack";
   1831         return;
   1832       }
   1833       PP.Lex(Tok);
   1834 
   1835       if (Tok.is(tok::comma)) {
   1836         PP.Lex(Tok);
   1837 
   1838         if (Tok.is(tok::numeric_constant)) {
   1839           Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set);
   1840           Alignment = Tok;
   1841 
   1842           PP.Lex(Tok);
   1843         } else if (Tok.is(tok::identifier)) {
   1844           SlotLabel = Tok.getIdentifierInfo()->getName();
   1845           PP.Lex(Tok);
   1846 
   1847           if (Tok.is(tok::comma)) {
   1848             PP.Lex(Tok);
   1849 
   1850             if (Tok.isNot(tok::numeric_constant)) {
   1851               PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed);
   1852               return;
   1853             }
   1854 
   1855             Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set);
   1856             Alignment = Tok;
   1857 
   1858             PP.Lex(Tok);
   1859           }
   1860         } else {
   1861           PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed);
   1862           return;
   1863         }
   1864       }
   1865     }
   1866   } else if (PP.getLangOpts().ApplePragmaPack ||
   1867              PP.getLangOpts().XLPragmaPack) {
   1868     // In MSVC/gcc, #pragma pack() resets the alignment without affecting
   1869     // the push/pop stack.
   1870     // In Apple gcc and IBM XL, #pragma pack() is equivalent to #pragma
   1871     // pack(pop).
   1872     Action = Sema::PSK_Pop;
   1873   }
   1874 
   1875   if (Tok.isNot(tok::r_paren)) {
   1876     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "pack";
   1877     return;
   1878   }
   1879 
   1880   SourceLocation RParenLoc = Tok.getLocation();
   1881   PP.Lex(Tok);
   1882   if (Tok.isNot(tok::eod)) {
   1883     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "pack";
   1884     return;
   1885   }
   1886 
   1887   PragmaPackInfo *Info =
   1888       PP.getPreprocessorAllocator().Allocate<PragmaPackInfo>(1);
   1889   Info->Action = Action;
   1890   Info->SlotLabel = SlotLabel;
   1891   Info->Alignment = Alignment;
   1892 
   1893   MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
   1894                               1);
   1895   Toks[0].startToken();
   1896   Toks[0].setKind(tok::annot_pragma_pack);
   1897   Toks[0].setLocation(PackLoc);
   1898   Toks[0].setAnnotationEndLoc(RParenLoc);
   1899   Toks[0].setAnnotationValue(static_cast<void*>(Info));
   1900   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
   1901                       /*IsReinject=*/false);
   1902 }
   1903 
   1904 // #pragma ms_struct on
   1905 // #pragma ms_struct off
   1906 void PragmaMSStructHandler::HandlePragma(Preprocessor &PP,
   1907                                          PragmaIntroducer Introducer,
   1908                                          Token &MSStructTok) {
   1909   PragmaMSStructKind Kind = PMSST_OFF;
   1910 
   1911   Token Tok;
   1912   PP.Lex(Tok);
   1913   if (Tok.isNot(tok::identifier)) {
   1914     PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct);
   1915     return;
   1916   }
   1917   SourceLocation EndLoc = Tok.getLocation();
   1918   const IdentifierInfo *II = Tok.getIdentifierInfo();
   1919   if (II->isStr("on")) {
   1920     Kind = PMSST_ON;
   1921     PP.Lex(Tok);
   1922   }
   1923   else if (II->isStr("off") || II->isStr("reset"))
   1924     PP.Lex(Tok);
   1925   else {
   1926     PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct);
   1927     return;
   1928   }
   1929 
   1930   if (Tok.isNot(tok::eod)) {
   1931     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   1932       << "ms_struct";
   1933     return;
   1934   }
   1935 
   1936   MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
   1937                               1);
   1938   Toks[0].startToken();
   1939   Toks[0].setKind(tok::annot_pragma_msstruct);
   1940   Toks[0].setLocation(MSStructTok.getLocation());
   1941   Toks[0].setAnnotationEndLoc(EndLoc);
   1942   Toks[0].setAnnotationValue(reinterpret_cast<void*>(
   1943                              static_cast<uintptr_t>(Kind)));
   1944   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
   1945                       /*IsReinject=*/false);
   1946 }
   1947 
   1948 // #pragma clang section bss="abc" data="" rodata="def" text="" relro=""
   1949 void PragmaClangSectionHandler::HandlePragma(Preprocessor &PP,
   1950                                              PragmaIntroducer Introducer,
   1951                                              Token &FirstToken) {
   1952 
   1953   Token Tok;
   1954   auto SecKind = Sema::PragmaClangSectionKind::PCSK_Invalid;
   1955 
   1956   PP.Lex(Tok); // eat 'section'
   1957   while (Tok.isNot(tok::eod)) {
   1958     if (Tok.isNot(tok::identifier)) {
   1959       PP.Diag(Tok.getLocation(), diag::err_pragma_expected_clang_section_name) << "clang section";
   1960       return;
   1961     }
   1962 
   1963     const IdentifierInfo *SecType = Tok.getIdentifierInfo();
   1964     if (SecType->isStr("bss"))
   1965       SecKind = Sema::PragmaClangSectionKind::PCSK_BSS;
   1966     else if (SecType->isStr("data"))
   1967       SecKind = Sema::PragmaClangSectionKind::PCSK_Data;
   1968     else if (SecType->isStr("rodata"))
   1969       SecKind = Sema::PragmaClangSectionKind::PCSK_Rodata;
   1970     else if (SecType->isStr("relro"))
   1971       SecKind = Sema::PragmaClangSectionKind::PCSK_Relro;
   1972     else if (SecType->isStr("text"))
   1973       SecKind = Sema::PragmaClangSectionKind::PCSK_Text;
   1974     else {
   1975       PP.Diag(Tok.getLocation(), diag::err_pragma_expected_clang_section_name) << "clang section";
   1976       return;
   1977     }
   1978 
   1979     SourceLocation PragmaLocation = Tok.getLocation();
   1980     PP.Lex(Tok); // eat ['bss'|'data'|'rodata'|'text']
   1981     if (Tok.isNot(tok::equal)) {
   1982       PP.Diag(Tok.getLocation(), diag::err_pragma_clang_section_expected_equal) << SecKind;
   1983       return;
   1984     }
   1985 
   1986     std::string SecName;
   1987     if (!PP.LexStringLiteral(Tok, SecName, "pragma clang section", false))
   1988       return;
   1989 
   1990     Actions.ActOnPragmaClangSection(
   1991         PragmaLocation,
   1992         (SecName.size() ? Sema::PragmaClangSectionAction::PCSA_Set
   1993                         : Sema::PragmaClangSectionAction::PCSA_Clear),
   1994         SecKind, SecName);
   1995   }
   1996 }
   1997 
   1998 // #pragma 'align' '=' {'native','natural','mac68k','power','reset'}
   1999 // #pragma 'options 'align' '=' {'native','natural','mac68k','power','reset'}
   2000 // #pragma 'align' '(' {'native','natural','mac68k','power','reset'} ')'
   2001 static void ParseAlignPragma(Preprocessor &PP, Token &FirstTok,
   2002                              bool IsOptions) {
   2003   Token Tok;
   2004 
   2005   if (IsOptions) {
   2006     PP.Lex(Tok);
   2007     if (Tok.isNot(tok::identifier) ||
   2008         !Tok.getIdentifierInfo()->isStr("align")) {
   2009       PP.Diag(Tok.getLocation(), diag::warn_pragma_options_expected_align);
   2010       return;
   2011     }
   2012   }
   2013 
   2014   PP.Lex(Tok);
   2015   if (PP.getLangOpts().XLPragmaPack) {
   2016     if (Tok.isNot(tok::l_paren)) {
   2017       PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "align";
   2018       return;
   2019     }
   2020   } else if (Tok.isNot(tok::equal)) {
   2021     PP.Diag(Tok.getLocation(), diag::warn_pragma_align_expected_equal)
   2022       << IsOptions;
   2023     return;
   2024   }
   2025 
   2026   PP.Lex(Tok);
   2027   if (Tok.isNot(tok::identifier)) {
   2028     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
   2029       << (IsOptions ? "options" : "align");
   2030     return;
   2031   }
   2032 
   2033   Sema::PragmaOptionsAlignKind Kind = Sema::POAK_Natural;
   2034   const IdentifierInfo *II = Tok.getIdentifierInfo();
   2035   if (II->isStr("native"))
   2036     Kind = Sema::POAK_Native;
   2037   else if (II->isStr("natural"))
   2038     Kind = Sema::POAK_Natural;
   2039   else if (II->isStr("packed"))
   2040     Kind = Sema::POAK_Packed;
   2041   else if (II->isStr("power"))
   2042     Kind = Sema::POAK_Power;
   2043   else if (II->isStr("mac68k"))
   2044     Kind = Sema::POAK_Mac68k;
   2045   else if (II->isStr("reset"))
   2046     Kind = Sema::POAK_Reset;
   2047   else {
   2048     PP.Diag(Tok.getLocation(), diag::warn_pragma_align_invalid_option)
   2049       << IsOptions;
   2050     return;
   2051   }
   2052 
   2053   if (PP.getLangOpts().XLPragmaPack) {
   2054     PP.Lex(Tok);
   2055     if (Tok.isNot(tok::r_paren)) {
   2056       PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "align";
   2057       return;
   2058     }
   2059   }
   2060 
   2061   SourceLocation EndLoc = Tok.getLocation();
   2062   PP.Lex(Tok);
   2063   if (Tok.isNot(tok::eod)) {
   2064     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   2065       << (IsOptions ? "options" : "align");
   2066     return;
   2067   }
   2068 
   2069   MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
   2070                               1);
   2071   Toks[0].startToken();
   2072   Toks[0].setKind(tok::annot_pragma_align);
   2073   Toks[0].setLocation(FirstTok.getLocation());
   2074   Toks[0].setAnnotationEndLoc(EndLoc);
   2075   Toks[0].setAnnotationValue(reinterpret_cast<void*>(
   2076                              static_cast<uintptr_t>(Kind)));
   2077   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
   2078                       /*IsReinject=*/false);
   2079 }
   2080 
   2081 void PragmaAlignHandler::HandlePragma(Preprocessor &PP,
   2082                                       PragmaIntroducer Introducer,
   2083                                       Token &AlignTok) {
   2084   ParseAlignPragma(PP, AlignTok, /*IsOptions=*/false);
   2085 }
   2086 
   2087 void PragmaOptionsHandler::HandlePragma(Preprocessor &PP,
   2088                                         PragmaIntroducer Introducer,
   2089                                         Token &OptionsTok) {
   2090   ParseAlignPragma(PP, OptionsTok, /*IsOptions=*/true);
   2091 }
   2092 
   2093 // #pragma unused(identifier)
   2094 void PragmaUnusedHandler::HandlePragma(Preprocessor &PP,
   2095                                        PragmaIntroducer Introducer,
   2096                                        Token &UnusedTok) {
   2097   // FIXME: Should we be expanding macros here? My guess is no.
   2098   SourceLocation UnusedLoc = UnusedTok.getLocation();
   2099 
   2100   // Lex the left '('.
   2101   Token Tok;
   2102   PP.Lex(Tok);
   2103   if (Tok.isNot(tok::l_paren)) {
   2104     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "unused";
   2105     return;
   2106   }
   2107 
   2108   // Lex the declaration reference(s).
   2109   SmallVector<Token, 5> Identifiers;
   2110   SourceLocation RParenLoc;
   2111   bool LexID = true;
   2112 
   2113   while (true) {
   2114     PP.Lex(Tok);
   2115 
   2116     if (LexID) {
   2117       if (Tok.is(tok::identifier)) {
   2118         Identifiers.push_back(Tok);
   2119         LexID = false;
   2120         continue;
   2121       }
   2122 
   2123       // Illegal token!
   2124       PP.Diag(Tok.getLocation(), diag::warn_pragma_unused_expected_var);
   2125       return;
   2126     }
   2127 
   2128     // We are execting a ')' or a ','.
   2129     if (Tok.is(tok::comma)) {
   2130       LexID = true;
   2131       continue;
   2132     }
   2133 
   2134     if (Tok.is(tok::r_paren)) {
   2135       RParenLoc = Tok.getLocation();
   2136       break;
   2137     }
   2138 
   2139     // Illegal token!
   2140     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_punc) << "unused";
   2141     return;
   2142   }
   2143 
   2144   PP.Lex(Tok);
   2145   if (Tok.isNot(tok::eod)) {
   2146     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
   2147         "unused";
   2148     return;
   2149   }
   2150 
   2151   // Verify that we have a location for the right parenthesis.
   2152   assert(RParenLoc.isValid() && "Valid '#pragma unused' must have ')'");
   2153   assert(!Identifiers.empty() && "Valid '#pragma unused' must have arguments");
   2154 
   2155   // For each identifier token, insert into the token stream a
   2156   // annot_pragma_unused token followed by the identifier token.
   2157   // This allows us to cache a "#pragma unused" that occurs inside an inline
   2158   // C++ member function.
   2159 
   2160   MutableArrayRef<Token> Toks(
   2161       PP.getPreprocessorAllocator().Allocate<Token>(2 * Identifiers.size()),
   2162       2 * Identifiers.size());
   2163   for (unsigned i=0; i != Identifiers.size(); i++) {
   2164     Token &pragmaUnusedTok = Toks[2*i], &idTok = Toks[2*i+1];
   2165     pragmaUnusedTok.startToken();
   2166     pragmaUnusedTok.setKind(tok::annot_pragma_unused);
   2167     pragmaUnusedTok.setLocation(UnusedLoc);
   2168     idTok = Identifiers[i];
   2169   }
   2170   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
   2171                       /*IsReinject=*/false);
   2172 }
   2173 
   2174 // #pragma weak identifier
   2175 // #pragma weak identifier '=' identifier
   2176 void PragmaWeakHandler::HandlePragma(Preprocessor &PP,
   2177                                      PragmaIntroducer Introducer,
   2178                                      Token &WeakTok) {
   2179   SourceLocation WeakLoc = WeakTok.getLocation();
   2180 
   2181   Token Tok;
   2182   PP.Lex(Tok);
   2183   if (Tok.isNot(tok::identifier)) {
   2184     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "weak";
   2185     return;
   2186   }
   2187 
   2188   Token WeakName = Tok;
   2189   bool HasAlias = false;
   2190   Token AliasName;
   2191 
   2192   PP.Lex(Tok);
   2193   if (Tok.is(tok::equal)) {
   2194     HasAlias = true;
   2195     PP.Lex(Tok);
   2196     if (Tok.isNot(tok::identifier)) {
   2197       PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
   2198           << "weak";
   2199       return;
   2200     }
   2201     AliasName = Tok;
   2202     PP.Lex(Tok);
   2203   }
   2204 
   2205   if (Tok.isNot(tok::eod)) {
   2206     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "weak";
   2207     return;
   2208   }
   2209 
   2210   if (HasAlias) {
   2211     MutableArrayRef<Token> Toks(
   2212         PP.getPreprocessorAllocator().Allocate<Token>(3), 3);
   2213     Token &pragmaUnusedTok = Toks[0];
   2214     pragmaUnusedTok.startToken();
   2215     pragmaUnusedTok.setKind(tok::annot_pragma_weakalias);
   2216     pragmaUnusedTok.setLocation(WeakLoc);
   2217     pragmaUnusedTok.setAnnotationEndLoc(AliasName.getLocation());
   2218     Toks[1] = WeakName;
   2219     Toks[2] = AliasName;
   2220     PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
   2221                         /*IsReinject=*/false);
   2222   } else {
   2223     MutableArrayRef<Token> Toks(
   2224         PP.getPreprocessorAllocator().Allocate<Token>(2), 2);
   2225     Token &pragmaUnusedTok = Toks[0];
   2226     pragmaUnusedTok.startToken();
   2227     pragmaUnusedTok.setKind(tok::annot_pragma_weak);
   2228     pragmaUnusedTok.setLocation(WeakLoc);
   2229     pragmaUnusedTok.setAnnotationEndLoc(WeakLoc);
   2230     Toks[1] = WeakName;
   2231     PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
   2232                         /*IsReinject=*/false);
   2233   }
   2234 }
   2235 
   2236 // #pragma redefine_extname identifier identifier
   2237 void PragmaRedefineExtnameHandler::HandlePragma(Preprocessor &PP,
   2238                                                 PragmaIntroducer Introducer,
   2239                                                 Token &RedefToken) {
   2240   SourceLocation RedefLoc = RedefToken.getLocation();
   2241 
   2242   Token Tok;
   2243   PP.Lex(Tok);
   2244   if (Tok.isNot(tok::identifier)) {
   2245     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) <<
   2246       "redefine_extname";
   2247     return;
   2248   }
   2249 
   2250   Token RedefName = Tok;
   2251   PP.Lex(Tok);
   2252 
   2253   if (Tok.isNot(tok::identifier)) {
   2254     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
   2255         << "redefine_extname";
   2256     return;
   2257   }
   2258 
   2259   Token AliasName = Tok;
   2260   PP.Lex(Tok);
   2261 
   2262   if (Tok.isNot(tok::eod)) {
   2263     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
   2264       "redefine_extname";
   2265     return;
   2266   }
   2267 
   2268   MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(3),
   2269                               3);
   2270   Token &pragmaRedefTok = Toks[0];
   2271   pragmaRedefTok.startToken();
   2272   pragmaRedefTok.setKind(tok::annot_pragma_redefine_extname);
   2273   pragmaRedefTok.setLocation(RedefLoc);
   2274   pragmaRedefTok.setAnnotationEndLoc(AliasName.getLocation());
   2275   Toks[1] = RedefName;
   2276   Toks[2] = AliasName;
   2277   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
   2278                       /*IsReinject=*/false);
   2279 }
   2280 
   2281 void PragmaFPContractHandler::HandlePragma(Preprocessor &PP,
   2282                                            PragmaIntroducer Introducer,
   2283                                            Token &Tok) {
   2284   tok::OnOffSwitch OOS;
   2285   if (PP.LexOnOffSwitch(OOS))
   2286     return;
   2287 
   2288   MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
   2289                               1);
   2290   Toks[0].startToken();
   2291   Toks[0].setKind(tok::annot_pragma_fp_contract);
   2292   Toks[0].setLocation(Tok.getLocation());
   2293   Toks[0].setAnnotationEndLoc(Tok.getLocation());
   2294   Toks[0].setAnnotationValue(reinterpret_cast<void*>(
   2295                              static_cast<uintptr_t>(OOS)));
   2296   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
   2297                       /*IsReinject=*/false);
   2298 }
   2299 
   2300 void PragmaOpenCLExtensionHandler::HandlePragma(Preprocessor &PP,
   2301                                                 PragmaIntroducer Introducer,
   2302                                                 Token &Tok) {
   2303   PP.LexUnexpandedToken(Tok);
   2304   if (Tok.isNot(tok::identifier)) {
   2305     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) <<
   2306       "OPENCL";
   2307     return;
   2308   }
   2309   IdentifierInfo *Ext = Tok.getIdentifierInfo();
   2310   SourceLocation NameLoc = Tok.getLocation();
   2311 
   2312   PP.Lex(Tok);
   2313   if (Tok.isNot(tok::colon)) {
   2314     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_colon) << Ext;
   2315     return;
   2316   }
   2317 
   2318   PP.Lex(Tok);
   2319   if (Tok.isNot(tok::identifier)) {
   2320     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_predicate) << 0;
   2321     return;
   2322   }
   2323   IdentifierInfo *Pred = Tok.getIdentifierInfo();
   2324 
   2325   OpenCLExtState State;
   2326   if (Pred->isStr("enable")) {
   2327     State = Enable;
   2328   } else if (Pred->isStr("disable")) {
   2329     State = Disable;
   2330   } else if (Pred->isStr("begin"))
   2331     State = Begin;
   2332   else if (Pred->isStr("end"))
   2333     State = End;
   2334   else {
   2335     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_predicate)
   2336       << Ext->isStr("all");
   2337     return;
   2338   }
   2339   SourceLocation StateLoc = Tok.getLocation();
   2340 
   2341   PP.Lex(Tok);
   2342   if (Tok.isNot(tok::eod)) {
   2343     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
   2344       "OPENCL EXTENSION";
   2345     return;
   2346   }
   2347 
   2348   auto Info = PP.getPreprocessorAllocator().Allocate<OpenCLExtData>(1);
   2349   Info->first = Ext;
   2350   Info->second = State;
   2351   MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
   2352                               1);
   2353   Toks[0].startToken();
   2354   Toks[0].setKind(tok::annot_pragma_opencl_extension);
   2355   Toks[0].setLocation(NameLoc);
   2356   Toks[0].setAnnotationValue(static_cast<void*>(Info));
   2357   Toks[0].setAnnotationEndLoc(StateLoc);
   2358   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
   2359                       /*IsReinject=*/false);
   2360 
   2361   if (PP.getPPCallbacks())
   2362     PP.getPPCallbacks()->PragmaOpenCLExtension(NameLoc, Ext,
   2363                                                StateLoc, State);
   2364 }
   2365 
   2366 /// Handle '#pragma omp ...' when OpenMP is disabled.
   2367 ///
   2368 void PragmaNoOpenMPHandler::HandlePragma(Preprocessor &PP,
   2369                                          PragmaIntroducer Introducer,
   2370                                          Token &FirstTok) {
   2371   if (!PP.getDiagnostics().isIgnored(diag::warn_pragma_omp_ignored,
   2372                                      FirstTok.getLocation())) {
   2373     PP.Diag(FirstTok, diag::warn_pragma_omp_ignored);
   2374     PP.getDiagnostics().setSeverity(diag::warn_pragma_omp_ignored,
   2375                                     diag::Severity::Ignored, SourceLocation());
   2376   }
   2377   PP.DiscardUntilEndOfDirective();
   2378 }
   2379 
   2380 /// Handle '#pragma omp ...' when OpenMP is enabled.
   2381 ///
   2382 void PragmaOpenMPHandler::HandlePragma(Preprocessor &PP,
   2383                                        PragmaIntroducer Introducer,
   2384                                        Token &FirstTok) {
   2385   SmallVector<Token, 16> Pragma;
   2386   Token Tok;
   2387   Tok.startToken();
   2388   Tok.setKind(tok::annot_pragma_openmp);
   2389   Tok.setLocation(Introducer.Loc);
   2390 
   2391   while (Tok.isNot(tok::eod) && Tok.isNot(tok::eof)) {
   2392     Pragma.push_back(Tok);
   2393     PP.Lex(Tok);
   2394     if (Tok.is(tok::annot_pragma_openmp)) {
   2395       PP.Diag(Tok, diag::err_omp_unexpected_directive) << 0;
   2396       unsigned InnerPragmaCnt = 1;
   2397       while (InnerPragmaCnt != 0) {
   2398         PP.Lex(Tok);
   2399         if (Tok.is(tok::annot_pragma_openmp))
   2400           ++InnerPragmaCnt;
   2401         else if (Tok.is(tok::annot_pragma_openmp_end))
   2402           --InnerPragmaCnt;
   2403       }
   2404       PP.Lex(Tok);
   2405     }
   2406   }
   2407   SourceLocation EodLoc = Tok.getLocation();
   2408   Tok.startToken();
   2409   Tok.setKind(tok::annot_pragma_openmp_end);
   2410   Tok.setLocation(EodLoc);
   2411   Pragma.push_back(Tok);
   2412 
   2413   auto Toks = std::make_unique<Token[]>(Pragma.size());
   2414   std::copy(Pragma.begin(), Pragma.end(), Toks.get());
   2415   PP.EnterTokenStream(std::move(Toks), Pragma.size(),
   2416                       /*DisableMacroExpansion=*/false, /*IsReinject=*/false);
   2417 }
   2418 
   2419 /// Handle '#pragma pointers_to_members'
   2420 // The grammar for this pragma is as follows:
   2421 //
   2422 // <inheritance model> ::= ('single' | 'multiple' | 'virtual') '_inheritance'
   2423 //
   2424 // #pragma pointers_to_members '(' 'best_case' ')'
   2425 // #pragma pointers_to_members '(' 'full_generality' [',' inheritance-model] ')'
   2426 // #pragma pointers_to_members '(' inheritance-model ')'
   2427 void PragmaMSPointersToMembers::HandlePragma(Preprocessor &PP,
   2428                                              PragmaIntroducer Introducer,
   2429                                              Token &Tok) {
   2430   SourceLocation PointersToMembersLoc = Tok.getLocation();
   2431   PP.Lex(Tok);
   2432   if (Tok.isNot(tok::l_paren)) {
   2433     PP.Diag(PointersToMembersLoc, diag::warn_pragma_expected_lparen)
   2434       << "pointers_to_members";
   2435     return;
   2436   }
   2437   PP.Lex(Tok);
   2438   const IdentifierInfo *Arg = Tok.getIdentifierInfo();
   2439   if (!Arg) {
   2440     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
   2441       << "pointers_to_members";
   2442     return;
   2443   }
   2444   PP.Lex(Tok);
   2445 
   2446   LangOptions::PragmaMSPointersToMembersKind RepresentationMethod;
   2447   if (Arg->isStr("best_case")) {
   2448     RepresentationMethod = LangOptions::PPTMK_BestCase;
   2449   } else {
   2450     if (Arg->isStr("full_generality")) {
   2451       if (Tok.is(tok::comma)) {
   2452         PP.Lex(Tok);
   2453 
   2454         Arg = Tok.getIdentifierInfo();
   2455         if (!Arg) {
   2456           PP.Diag(Tok.getLocation(),
   2457                   diag::err_pragma_pointers_to_members_unknown_kind)
   2458               << Tok.getKind() << /*OnlyInheritanceModels*/ 0;
   2459           return;
   2460         }
   2461         PP.Lex(Tok);
   2462       } else if (Tok.is(tok::r_paren)) {
   2463         // #pragma pointers_to_members(full_generality) implicitly specifies
   2464         // virtual_inheritance.
   2465         Arg = nullptr;
   2466         RepresentationMethod = LangOptions::PPTMK_FullGeneralityVirtualInheritance;
   2467       } else {
   2468         PP.Diag(Tok.getLocation(), diag::err_expected_punc)
   2469             << "full_generality";
   2470         return;
   2471       }
   2472     }
   2473 
   2474     if (Arg) {
   2475       if (Arg->isStr("single_inheritance")) {
   2476         RepresentationMethod =
   2477             LangOptions::PPTMK_FullGeneralitySingleInheritance;
   2478       } else if (Arg->isStr("multiple_inheritance")) {
   2479         RepresentationMethod =
   2480             LangOptions::PPTMK_FullGeneralityMultipleInheritance;
   2481       } else if (Arg->isStr("virtual_inheritance")) {
   2482         RepresentationMethod =
   2483             LangOptions::PPTMK_FullGeneralityVirtualInheritance;
   2484       } else {
   2485         PP.Diag(Tok.getLocation(),
   2486                 diag::err_pragma_pointers_to_members_unknown_kind)
   2487             << Arg << /*HasPointerDeclaration*/ 1;
   2488         return;
   2489       }
   2490     }
   2491   }
   2492 
   2493   if (Tok.isNot(tok::r_paren)) {
   2494     PP.Diag(Tok.getLocation(), diag::err_expected_rparen_after)
   2495         << (Arg ? Arg->getName() : "full_generality");
   2496     return;
   2497   }
   2498 
   2499   SourceLocation EndLoc = Tok.getLocation();
   2500   PP.Lex(Tok);
   2501   if (Tok.isNot(tok::eod)) {
   2502     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   2503       << "pointers_to_members";
   2504     return;
   2505   }
   2506 
   2507   Token AnnotTok;
   2508   AnnotTok.startToken();
   2509   AnnotTok.setKind(tok::annot_pragma_ms_pointers_to_members);
   2510   AnnotTok.setLocation(PointersToMembersLoc);
   2511   AnnotTok.setAnnotationEndLoc(EndLoc);
   2512   AnnotTok.setAnnotationValue(
   2513       reinterpret_cast<void *>(static_cast<uintptr_t>(RepresentationMethod)));
   2514   PP.EnterToken(AnnotTok, /*IsReinject=*/true);
   2515 }
   2516 
   2517 /// Handle '#pragma vtordisp'
   2518 // The grammar for this pragma is as follows:
   2519 //
   2520 // <vtordisp-mode> ::= ('off' | 'on' | '0' | '1' | '2' )
   2521 //
   2522 // #pragma vtordisp '(' ['push' ','] vtordisp-mode ')'
   2523 // #pragma vtordisp '(' 'pop' ')'
   2524 // #pragma vtordisp '(' ')'
   2525 void PragmaMSVtorDisp::HandlePragma(Preprocessor &PP,
   2526                                     PragmaIntroducer Introducer, Token &Tok) {
   2527   SourceLocation VtorDispLoc = Tok.getLocation();
   2528   PP.Lex(Tok);
   2529   if (Tok.isNot(tok::l_paren)) {
   2530     PP.Diag(VtorDispLoc, diag::warn_pragma_expected_lparen) << "vtordisp";
   2531     return;
   2532   }
   2533   PP.Lex(Tok);
   2534 
   2535   Sema::PragmaMsStackAction Action = Sema::PSK_Set;
   2536   const IdentifierInfo *II = Tok.getIdentifierInfo();
   2537   if (II) {
   2538     if (II->isStr("push")) {
   2539       // #pragma vtordisp(push, mode)
   2540       PP.Lex(Tok);
   2541       if (Tok.isNot(tok::comma)) {
   2542         PP.Diag(VtorDispLoc, diag::warn_pragma_expected_punc) << "vtordisp";
   2543         return;
   2544       }
   2545       PP.Lex(Tok);
   2546       Action = Sema::PSK_Push_Set;
   2547       // not push, could be on/off
   2548     } else if (II->isStr("pop")) {
   2549       // #pragma vtordisp(pop)
   2550       PP.Lex(Tok);
   2551       Action = Sema::PSK_Pop;
   2552     }
   2553     // not push or pop, could be on/off
   2554   } else {
   2555     if (Tok.is(tok::r_paren)) {
   2556       // #pragma vtordisp()
   2557       Action = Sema::PSK_Reset;
   2558     }
   2559   }
   2560 
   2561 
   2562   uint64_t Value = 0;
   2563   if (Action & Sema::PSK_Push || Action & Sema::PSK_Set) {
   2564     const IdentifierInfo *II = Tok.getIdentifierInfo();
   2565     if (II && II->isStr("off")) {
   2566       PP.Lex(Tok);
   2567       Value = 0;
   2568     } else if (II && II->isStr("on")) {
   2569       PP.Lex(Tok);
   2570       Value = 1;
   2571     } else if (Tok.is(tok::numeric_constant) &&
   2572                PP.parseSimpleIntegerLiteral(Tok, Value)) {
   2573       if (Value > 2) {
   2574         PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_integer)
   2575             << 0 << 2 << "vtordisp";
   2576         return;
   2577       }
   2578     } else {
   2579       PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_action)
   2580           << "vtordisp";
   2581       return;
   2582     }
   2583   }
   2584 
   2585   // Finish the pragma: ')' $
   2586   if (Tok.isNot(tok::r_paren)) {
   2587     PP.Diag(VtorDispLoc, diag::warn_pragma_expected_rparen) << "vtordisp";
   2588     return;
   2589   }
   2590   SourceLocation EndLoc = Tok.getLocation();
   2591   PP.Lex(Tok);
   2592   if (Tok.isNot(tok::eod)) {
   2593     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   2594         << "vtordisp";
   2595     return;
   2596   }
   2597 
   2598   // Enter the annotation.
   2599   Token AnnotTok;
   2600   AnnotTok.startToken();
   2601   AnnotTok.setKind(tok::annot_pragma_ms_vtordisp);
   2602   AnnotTok.setLocation(VtorDispLoc);
   2603   AnnotTok.setAnnotationEndLoc(EndLoc);
   2604   AnnotTok.setAnnotationValue(reinterpret_cast<void *>(
   2605       static_cast<uintptr_t>((Action << 16) | (Value & 0xFFFF))));
   2606   PP.EnterToken(AnnotTok, /*IsReinject=*/false);
   2607 }
   2608 
   2609 /// Handle all MS pragmas.  Simply forwards the tokens after inserting
   2610 /// an annotation token.
   2611 void PragmaMSPragma::HandlePragma(Preprocessor &PP,
   2612                                   PragmaIntroducer Introducer, Token &Tok) {
   2613   Token EoF, AnnotTok;
   2614   EoF.startToken();
   2615   EoF.setKind(tok::eof);
   2616   AnnotTok.startToken();
   2617   AnnotTok.setKind(tok::annot_pragma_ms_pragma);
   2618   AnnotTok.setLocation(Tok.getLocation());
   2619   AnnotTok.setAnnotationEndLoc(Tok.getLocation());
   2620   SmallVector<Token, 8> TokenVector;
   2621   // Suck up all of the tokens before the eod.
   2622   for (; Tok.isNot(tok::eod); PP.Lex(Tok)) {
   2623     TokenVector.push_back(Tok);
   2624     AnnotTok.setAnnotationEndLoc(Tok.getLocation());
   2625   }
   2626   // Add a sentinel EoF token to the end of the list.
   2627   TokenVector.push_back(EoF);
   2628   // We must allocate this array with new because EnterTokenStream is going to
   2629   // delete it later.
   2630   markAsReinjectedForRelexing(TokenVector);
   2631   auto TokenArray = std::make_unique<Token[]>(TokenVector.size());
   2632   std::copy(TokenVector.begin(), TokenVector.end(), TokenArray.get());
   2633   auto Value = new (PP.getPreprocessorAllocator())
   2634       std::pair<std::unique_ptr<Token[]>, size_t>(std::move(TokenArray),
   2635                                                   TokenVector.size());
   2636   AnnotTok.setAnnotationValue(Value);
   2637   PP.EnterToken(AnnotTok, /*IsReinject*/ false);
   2638 }
   2639 
   2640 /// Handle the \#pragma float_control extension.
   2641 ///
   2642 /// The syntax is:
   2643 /// \code
   2644 ///   #pragma float_control(keyword[, setting] [,push])
   2645 /// \endcode
   2646 /// Where 'keyword' and 'setting' are identifiers.
   2647 // 'keyword' can be: precise, except, push, pop
   2648 // 'setting' can be: on, off
   2649 /// The optional arguments 'setting' and 'push' are supported only
   2650 /// when the keyword is 'precise' or 'except'.
   2651 void PragmaFloatControlHandler::HandlePragma(Preprocessor &PP,
   2652                                              PragmaIntroducer Introducer,
   2653                                              Token &Tok) {
   2654   Sema::PragmaMsStackAction Action = Sema::PSK_Set;
   2655   SourceLocation FloatControlLoc = Tok.getLocation();
   2656   Token PragmaName = Tok;
   2657   if (!PP.getTargetInfo().hasStrictFP() && !PP.getLangOpts().ExpStrictFP) {
   2658     PP.Diag(Tok.getLocation(), diag::warn_pragma_fp_ignored)
   2659         << PragmaName.getIdentifierInfo()->getName();
   2660     return;
   2661   }
   2662   PP.Lex(Tok);
   2663   if (Tok.isNot(tok::l_paren)) {
   2664     PP.Diag(FloatControlLoc, diag::err_expected) << tok::l_paren;
   2665     return;
   2666   }
   2667 
   2668   // Read the identifier.
   2669   PP.Lex(Tok);
   2670   if (Tok.isNot(tok::identifier)) {
   2671     PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);
   2672     return;
   2673   }
   2674 
   2675   // Verify that this is one of the float control options.
   2676   IdentifierInfo *II = Tok.getIdentifierInfo();
   2677   PragmaFloatControlKind Kind =
   2678       llvm::StringSwitch<PragmaFloatControlKind>(II->getName())
   2679           .Case("precise", PFC_Precise)
   2680           .Case("except", PFC_Except)
   2681           .Case("push", PFC_Push)
   2682           .Case("pop", PFC_Pop)
   2683           .Default(PFC_Unknown);
   2684   PP.Lex(Tok); // the identifier
   2685   if (Kind == PFC_Unknown) {
   2686     PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);
   2687     return;
   2688   } else if (Kind == PFC_Push || Kind == PFC_Pop) {
   2689     if (Tok.isNot(tok::r_paren)) {
   2690       PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);
   2691       return;
   2692     }
   2693     PP.Lex(Tok); // Eat the r_paren
   2694     Action = (Kind == PFC_Pop) ? Sema::PSK_Pop : Sema::PSK_Push;
   2695   } else {
   2696     if (Tok.is(tok::r_paren))
   2697       // Selecting Precise or Except
   2698       PP.Lex(Tok); // the r_paren
   2699     else if (Tok.isNot(tok::comma)) {
   2700       PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);
   2701       return;
   2702     } else {
   2703       PP.Lex(Tok); // ,
   2704       if (!Tok.isAnyIdentifier()) {
   2705         PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);
   2706         return;
   2707       }
   2708       StringRef PushOnOff = Tok.getIdentifierInfo()->getName();
   2709       if (PushOnOff == "on")
   2710         // Kind is set correctly
   2711         ;
   2712       else if (PushOnOff == "off") {
   2713         if (Kind == PFC_Precise)
   2714           Kind = PFC_NoPrecise;
   2715         if (Kind == PFC_Except)
   2716           Kind = PFC_NoExcept;
   2717       } else if (PushOnOff == "push") {
   2718         Action = Sema::PSK_Push_Set;
   2719       } else {
   2720         PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);
   2721         return;
   2722       }
   2723       PP.Lex(Tok); // the identifier
   2724       if (Tok.is(tok::comma)) {
   2725         PP.Lex(Tok); // ,
   2726         if (!Tok.isAnyIdentifier()) {
   2727           PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);
   2728           return;
   2729         }
   2730         StringRef ExpectedPush = Tok.getIdentifierInfo()->getName();
   2731         if (ExpectedPush == "push") {
   2732           Action = Sema::PSK_Push_Set;
   2733         } else {
   2734           PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);
   2735           return;
   2736         }
   2737         PP.Lex(Tok); // the push identifier
   2738       }
   2739       if (Tok.isNot(tok::r_paren)) {
   2740         PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);
   2741         return;
   2742       }
   2743       PP.Lex(Tok); // the r_paren
   2744     }
   2745   }
   2746   SourceLocation EndLoc = Tok.getLocation();
   2747   if (Tok.isNot(tok::eod)) {
   2748     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   2749         << "float_control";
   2750     return;
   2751   }
   2752 
   2753   // Note: there is no accomodation for PP callback for this pragma.
   2754 
   2755   // Enter the annotation.
   2756   auto TokenArray = std::make_unique<Token[]>(1);
   2757   TokenArray[0].startToken();
   2758   TokenArray[0].setKind(tok::annot_pragma_float_control);
   2759   TokenArray[0].setLocation(FloatControlLoc);
   2760   TokenArray[0].setAnnotationEndLoc(EndLoc);
   2761   // Create an encoding of Action and Value by shifting the Action into
   2762   // the high 16 bits then union with the Kind.
   2763   TokenArray[0].setAnnotationValue(reinterpret_cast<void *>(
   2764       static_cast<uintptr_t>((Action << 16) | (Kind & 0xFFFF))));
   2765   PP.EnterTokenStream(std::move(TokenArray), 1,
   2766                       /*DisableMacroExpansion=*/false, /*IsReinject=*/false);
   2767 }
   2768 
   2769 /// Handle the Microsoft \#pragma detect_mismatch extension.
   2770 ///
   2771 /// The syntax is:
   2772 /// \code
   2773 ///   #pragma detect_mismatch("name", "value")
   2774 /// \endcode
   2775 /// Where 'name' and 'value' are quoted strings.  The values are embedded in
   2776 /// the object file and passed along to the linker.  If the linker detects a
   2777 /// mismatch in the object file's values for the given name, a LNK2038 error
   2778 /// is emitted.  See MSDN for more details.
   2779 void PragmaDetectMismatchHandler::HandlePragma(Preprocessor &PP,
   2780                                                PragmaIntroducer Introducer,
   2781                                                Token &Tok) {
   2782   SourceLocation DetectMismatchLoc = Tok.getLocation();
   2783   PP.Lex(Tok);
   2784   if (Tok.isNot(tok::l_paren)) {
   2785     PP.Diag(DetectMismatchLoc, diag::err_expected) << tok::l_paren;
   2786     return;
   2787   }
   2788 
   2789   // Read the name to embed, which must be a string literal.
   2790   std::string NameString;
   2791   if (!PP.LexStringLiteral(Tok, NameString,
   2792                            "pragma detect_mismatch",
   2793                            /*AllowMacroExpansion=*/true))
   2794     return;
   2795 
   2796   // Read the comma followed by a second string literal.
   2797   std::string ValueString;
   2798   if (Tok.isNot(tok::comma)) {
   2799     PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed);
   2800     return;
   2801   }
   2802 
   2803   if (!PP.LexStringLiteral(Tok, ValueString, "pragma detect_mismatch",
   2804                            /*AllowMacroExpansion=*/true))
   2805     return;
   2806 
   2807   if (Tok.isNot(tok::r_paren)) {
   2808     PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
   2809     return;
   2810   }
   2811   PP.Lex(Tok);  // Eat the r_paren.
   2812 
   2813   if (Tok.isNot(tok::eod)) {
   2814     PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed);
   2815     return;
   2816   }
   2817 
   2818   // If the pragma is lexically sound, notify any interested PPCallbacks.
   2819   if (PP.getPPCallbacks())
   2820     PP.getPPCallbacks()->PragmaDetectMismatch(DetectMismatchLoc, NameString,
   2821                                               ValueString);
   2822 
   2823   Actions.ActOnPragmaDetectMismatch(DetectMismatchLoc, NameString, ValueString);
   2824 }
   2825 
   2826 /// Handle the microsoft \#pragma comment extension.
   2827 ///
   2828 /// The syntax is:
   2829 /// \code
   2830 ///   #pragma comment(linker, "foo")
   2831 /// \endcode
   2832 /// 'linker' is one of five identifiers: compiler, exestr, lib, linker, user.
   2833 /// "foo" is a string, which is fully macro expanded, and permits string
   2834 /// concatenation, embedded escape characters etc.  See MSDN for more details.
   2835 void PragmaCommentHandler::HandlePragma(Preprocessor &PP,
   2836                                         PragmaIntroducer Introducer,
   2837                                         Token &Tok) {
   2838   SourceLocation CommentLoc = Tok.getLocation();
   2839   PP.Lex(Tok);
   2840   if (Tok.isNot(tok::l_paren)) {
   2841     PP.Diag(CommentLoc, diag::err_pragma_comment_malformed);
   2842     return;
   2843   }
   2844 
   2845   // Read the identifier.
   2846   PP.Lex(Tok);
   2847   if (Tok.isNot(tok::identifier)) {
   2848     PP.Diag(CommentLoc, diag::err_pragma_comment_malformed);
   2849     return;
   2850   }
   2851 
   2852   // Verify that this is one of the 5 explicitly listed options.
   2853   IdentifierInfo *II = Tok.getIdentifierInfo();
   2854   PragmaMSCommentKind Kind =
   2855     llvm::StringSwitch<PragmaMSCommentKind>(II->getName())
   2856     .Case("linker",   PCK_Linker)
   2857     .Case("lib",      PCK_Lib)
   2858     .Case("compiler", PCK_Compiler)
   2859     .Case("exestr",   PCK_ExeStr)
   2860     .Case("user",     PCK_User)
   2861     .Default(PCK_Unknown);
   2862   if (Kind == PCK_Unknown) {
   2863     PP.Diag(Tok.getLocation(), diag::err_pragma_comment_unknown_kind);
   2864     return;
   2865   }
   2866 
   2867   if (PP.getTargetInfo().getTriple().isOSBinFormatELF() && Kind != PCK_Lib) {
   2868     PP.Diag(Tok.getLocation(), diag::warn_pragma_comment_ignored)
   2869         << II->getName();
   2870     return;
   2871   }
   2872 
   2873   // On PS4, issue a warning about any pragma comments other than
   2874   // #pragma comment lib.
   2875   if (PP.getTargetInfo().getTriple().isPS4() && Kind != PCK_Lib) {
   2876     PP.Diag(Tok.getLocation(), diag::warn_pragma_comment_ignored)
   2877       << II->getName();
   2878     return;
   2879   }
   2880 
   2881   // Read the optional string if present.
   2882   PP.Lex(Tok);
   2883   std::string ArgumentString;
   2884   if (Tok.is(tok::comma) && !PP.LexStringLiteral(Tok, ArgumentString,
   2885                                                  "pragma comment",
   2886                                                  /*AllowMacroExpansion=*/true))
   2887     return;
   2888 
   2889   // FIXME: warn that 'exestr' is deprecated.
   2890   // FIXME: If the kind is "compiler" warn if the string is present (it is
   2891   // ignored).
   2892   // The MSDN docs say that "lib" and "linker" require a string and have a short
   2893   // list of linker options they support, but in practice MSVC doesn't
   2894   // issue a diagnostic.  Therefore neither does clang.
   2895 
   2896   if (Tok.isNot(tok::r_paren)) {
   2897     PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed);
   2898     return;
   2899   }
   2900   PP.Lex(Tok);  // eat the r_paren.
   2901 
   2902   if (Tok.isNot(tok::eod)) {
   2903     PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed);
   2904     return;
   2905   }
   2906 
   2907   // If the pragma is lexically sound, notify any interested PPCallbacks.
   2908   if (PP.getPPCallbacks())
   2909     PP.getPPCallbacks()->PragmaComment(CommentLoc, II, ArgumentString);
   2910 
   2911   Actions.ActOnPragmaMSComment(CommentLoc, Kind, ArgumentString);
   2912 }
   2913 
   2914 // #pragma clang optimize off
   2915 // #pragma clang optimize on
   2916 void PragmaOptimizeHandler::HandlePragma(Preprocessor &PP,
   2917                                          PragmaIntroducer Introducer,
   2918                                          Token &FirstToken) {
   2919   Token Tok;
   2920   PP.Lex(Tok);
   2921   if (Tok.is(tok::eod)) {
   2922     PP.Diag(Tok.getLocation(), diag::err_pragma_missing_argument)
   2923         << "clang optimize" << /*Expected=*/true << "'on' or 'off'";
   2924     return;
   2925   }
   2926   if (Tok.isNot(tok::identifier)) {
   2927     PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_invalid_argument)
   2928       << PP.getSpelling(Tok);
   2929     return;
   2930   }
   2931   const IdentifierInfo *II = Tok.getIdentifierInfo();
   2932   // The only accepted values are 'on' or 'off'.
   2933   bool IsOn = false;
   2934   if (II->isStr("on")) {
   2935     IsOn = true;
   2936   } else if (!II->isStr("off")) {
   2937     PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_invalid_argument)
   2938       << PP.getSpelling(Tok);
   2939     return;
   2940   }
   2941   PP.Lex(Tok);
   2942 
   2943   if (Tok.isNot(tok::eod)) {
   2944     PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_extra_argument)
   2945       << PP.getSpelling(Tok);
   2946     return;
   2947   }
   2948 
   2949   Actions.ActOnPragmaOptimize(IsOn, FirstToken.getLocation());
   2950 }
   2951 
   2952 namespace {
   2953 /// Used as the annotation value for tok::annot_pragma_fp.
   2954 struct TokFPAnnotValue {
   2955   enum FlagKinds { Contract, Reassociate, Exceptions };
   2956   enum FlagValues { On, Off, Fast };
   2957 
   2958   llvm::Optional<LangOptions::FPModeKind> ContractValue;
   2959   llvm::Optional<LangOptions::FPModeKind> ReassociateValue;
   2960   llvm::Optional<LangOptions::FPExceptionModeKind> ExceptionsValue;
   2961 };
   2962 } // end anonymous namespace
   2963 
   2964 void PragmaFPHandler::HandlePragma(Preprocessor &PP,
   2965                                    PragmaIntroducer Introducer, Token &Tok) {
   2966   // fp
   2967   Token PragmaName = Tok;
   2968   SmallVector<Token, 1> TokenList;
   2969 
   2970   PP.Lex(Tok);
   2971   if (Tok.isNot(tok::identifier)) {
   2972     PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_option)
   2973         << /*MissingOption=*/true << "";
   2974     return;
   2975   }
   2976 
   2977   auto *AnnotValue = new (PP.getPreprocessorAllocator()) TokFPAnnotValue;
   2978   while (Tok.is(tok::identifier)) {
   2979     IdentifierInfo *OptionInfo = Tok.getIdentifierInfo();
   2980 
   2981     auto FlagKind =
   2982         llvm::StringSwitch<llvm::Optional<TokFPAnnotValue::FlagKinds>>(
   2983             OptionInfo->getName())
   2984             .Case("contract", TokFPAnnotValue::Contract)
   2985             .Case("reassociate", TokFPAnnotValue::Reassociate)
   2986             .Case("exceptions", TokFPAnnotValue::Exceptions)
   2987             .Default(None);
   2988     if (!FlagKind) {
   2989       PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_option)
   2990           << /*MissingOption=*/false << OptionInfo;
   2991       return;
   2992     }
   2993     PP.Lex(Tok);
   2994 
   2995     // Read '('
   2996     if (Tok.isNot(tok::l_paren)) {
   2997       PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren;
   2998       return;
   2999     }
   3000     PP.Lex(Tok);
   3001 
   3002     if (Tok.isNot(tok::identifier)) {
   3003       PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument)
   3004           << PP.getSpelling(Tok) << OptionInfo->getName()
   3005           << static_cast<int>(*FlagKind);
   3006       return;
   3007     }
   3008     const IdentifierInfo *II = Tok.getIdentifierInfo();
   3009 
   3010     if (FlagKind == TokFPAnnotValue::Contract) {
   3011       AnnotValue->ContractValue =
   3012           llvm::StringSwitch<llvm::Optional<LangOptions::FPModeKind>>(
   3013               II->getName())
   3014               .Case("on", LangOptions::FPModeKind::FPM_On)
   3015               .Case("off", LangOptions::FPModeKind::FPM_Off)
   3016               .Case("fast", LangOptions::FPModeKind::FPM_Fast)
   3017               .Default(llvm::None);
   3018       if (!AnnotValue->ContractValue) {
   3019         PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument)
   3020             << PP.getSpelling(Tok) << OptionInfo->getName() << *FlagKind;
   3021         return;
   3022       }
   3023     } else if (FlagKind == TokFPAnnotValue::Reassociate) {
   3024       AnnotValue->ReassociateValue =
   3025           llvm::StringSwitch<llvm::Optional<LangOptions::FPModeKind>>(
   3026               II->getName())
   3027               .Case("on", LangOptions::FPModeKind::FPM_On)
   3028               .Case("off", LangOptions::FPModeKind::FPM_Off)
   3029               .Default(llvm::None);
   3030       if (!AnnotValue->ReassociateValue) {
   3031         PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument)
   3032             << PP.getSpelling(Tok) << OptionInfo->getName() << *FlagKind;
   3033         return;
   3034       }
   3035     } else if (FlagKind == TokFPAnnotValue::Exceptions) {
   3036       AnnotValue->ExceptionsValue =
   3037           llvm::StringSwitch<llvm::Optional<LangOptions::FPExceptionModeKind>>(
   3038               II->getName())
   3039               .Case("ignore", LangOptions::FPE_Ignore)
   3040               .Case("maytrap", LangOptions::FPE_MayTrap)
   3041               .Case("strict", LangOptions::FPE_Strict)
   3042               .Default(llvm::None);
   3043       if (!AnnotValue->ExceptionsValue) {
   3044         PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument)
   3045             << PP.getSpelling(Tok) << OptionInfo->getName() << *FlagKind;
   3046         return;
   3047       }
   3048     }
   3049     PP.Lex(Tok);
   3050 
   3051     // Read ')'
   3052     if (Tok.isNot(tok::r_paren)) {
   3053       PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
   3054       return;
   3055     }
   3056     PP.Lex(Tok);
   3057   }
   3058 
   3059   if (Tok.isNot(tok::eod)) {
   3060     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   3061         << "clang fp";
   3062     return;
   3063   }
   3064 
   3065   Token FPTok;
   3066   FPTok.startToken();
   3067   FPTok.setKind(tok::annot_pragma_fp);
   3068   FPTok.setLocation(PragmaName.getLocation());
   3069   FPTok.setAnnotationEndLoc(PragmaName.getLocation());
   3070   FPTok.setAnnotationValue(reinterpret_cast<void *>(AnnotValue));
   3071   TokenList.push_back(FPTok);
   3072 
   3073   auto TokenArray = std::make_unique<Token[]>(TokenList.size());
   3074   std::copy(TokenList.begin(), TokenList.end(), TokenArray.get());
   3075 
   3076   PP.EnterTokenStream(std::move(TokenArray), TokenList.size(),
   3077                       /*DisableMacroExpansion=*/false, /*IsReinject=*/false);
   3078 }
   3079 
   3080 void PragmaSTDC_FENV_ROUNDHandler::HandlePragma(Preprocessor &PP,
   3081                                                 PragmaIntroducer Introducer,
   3082                                                 Token &Tok) {
   3083   Token PragmaName = Tok;
   3084   SmallVector<Token, 1> TokenList;
   3085   if (!PP.getTargetInfo().hasStrictFP() && !PP.getLangOpts().ExpStrictFP) {
   3086     PP.Diag(Tok.getLocation(), diag::warn_pragma_fp_ignored)
   3087         << PragmaName.getIdentifierInfo()->getName();
   3088     return;
   3089   }
   3090 
   3091   PP.Lex(Tok);
   3092   if (Tok.isNot(tok::identifier)) {
   3093     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
   3094         << PragmaName.getIdentifierInfo()->getName();
   3095     return;
   3096   }
   3097   IdentifierInfo *II = Tok.getIdentifierInfo();
   3098 
   3099   auto RM =
   3100       llvm::StringSwitch<llvm::RoundingMode>(II->getName())
   3101           .Case("FE_TOWARDZERO", llvm::RoundingMode::TowardZero)
   3102           .Case("FE_TONEAREST", llvm::RoundingMode::NearestTiesToEven)
   3103           .Case("FE_UPWARD", llvm::RoundingMode::TowardPositive)
   3104           .Case("FE_DOWNWARD", llvm::RoundingMode::TowardNegative)
   3105           .Case("FE_TONEARESTFROMZERO", llvm::RoundingMode::NearestTiesToAway)
   3106           .Case("FE_DYNAMIC", llvm::RoundingMode::Dynamic)
   3107           .Default(llvm::RoundingMode::Invalid);
   3108   if (RM == llvm::RoundingMode::Invalid) {
   3109     PP.Diag(Tok.getLocation(), diag::warn_stdc_unknown_rounding_mode);
   3110     return;
   3111   }
   3112   PP.Lex(Tok);
   3113 
   3114   if (Tok.isNot(tok::eod)) {
   3115     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   3116         << "STDC FENV_ROUND";
   3117     return;
   3118   }
   3119 
   3120   // Until the pragma is fully implemented, issue a warning.
   3121   PP.Diag(Tok.getLocation(), diag::warn_stdc_fenv_round_not_supported);
   3122 
   3123   MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
   3124                               1);
   3125   Toks[0].startToken();
   3126   Toks[0].setKind(tok::annot_pragma_fenv_round);
   3127   Toks[0].setLocation(Tok.getLocation());
   3128   Toks[0].setAnnotationEndLoc(Tok.getLocation());
   3129   Toks[0].setAnnotationValue(
   3130       reinterpret_cast<void *>(static_cast<uintptr_t>(RM)));
   3131   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
   3132                       /*IsReinject=*/false);
   3133 }
   3134 
   3135 void Parser::HandlePragmaFP() {
   3136   assert(Tok.is(tok::annot_pragma_fp));
   3137   auto *AnnotValue =
   3138       reinterpret_cast<TokFPAnnotValue *>(Tok.getAnnotationValue());
   3139 
   3140   if (AnnotValue->ReassociateValue)
   3141     Actions.ActOnPragmaFPReassociate(Tok.getLocation(),
   3142                                      *AnnotValue->ReassociateValue ==
   3143                                          LangOptions::FPModeKind::FPM_On);
   3144   if (AnnotValue->ContractValue)
   3145     Actions.ActOnPragmaFPContract(Tok.getLocation(),
   3146                                   *AnnotValue->ContractValue);
   3147   if (AnnotValue->ExceptionsValue)
   3148     Actions.ActOnPragmaFPExceptions(Tok.getLocation(),
   3149                                     *AnnotValue->ExceptionsValue);
   3150   ConsumeAnnotationToken();
   3151 }
   3152 
   3153 /// Parses loop or unroll pragma hint value and fills in Info.
   3154 static bool ParseLoopHintValue(Preprocessor &PP, Token &Tok, Token PragmaName,
   3155                                Token Option, bool ValueInParens,
   3156                                PragmaLoopHintInfo &Info) {
   3157   SmallVector<Token, 1> ValueList;
   3158   int OpenParens = ValueInParens ? 1 : 0;
   3159   // Read constant expression.
   3160   while (Tok.isNot(tok::eod)) {
   3161     if (Tok.is(tok::l_paren))
   3162       OpenParens++;
   3163     else if (Tok.is(tok::r_paren)) {
   3164       OpenParens--;
   3165       if (OpenParens == 0 && ValueInParens)
   3166         break;
   3167     }
   3168 
   3169     ValueList.push_back(Tok);
   3170     PP.Lex(Tok);
   3171   }
   3172 
   3173   if (ValueInParens) {
   3174     // Read ')'
   3175     if (Tok.isNot(tok::r_paren)) {
   3176       PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
   3177       return true;
   3178     }
   3179     PP.Lex(Tok);
   3180   }
   3181 
   3182   Token EOFTok;
   3183   EOFTok.startToken();
   3184   EOFTok.setKind(tok::eof);
   3185   EOFTok.setLocation(Tok.getLocation());
   3186   ValueList.push_back(EOFTok); // Terminates expression for parsing.
   3187 
   3188   markAsReinjectedForRelexing(ValueList);
   3189   Info.Toks = llvm::makeArrayRef(ValueList).copy(PP.getPreprocessorAllocator());
   3190 
   3191   Info.PragmaName = PragmaName;
   3192   Info.Option = Option;
   3193   return false;
   3194 }
   3195 
   3196 /// Handle the \#pragma clang loop directive.
   3197 ///  #pragma clang 'loop' loop-hints
   3198 ///
   3199 ///  loop-hints:
   3200 ///    loop-hint loop-hints[opt]
   3201 ///
   3202 ///  loop-hint:
   3203 ///    'vectorize' '(' loop-hint-keyword ')'
   3204 ///    'interleave' '(' loop-hint-keyword ')'
   3205 ///    'unroll' '(' unroll-hint-keyword ')'
   3206 ///    'vectorize_predicate' '(' loop-hint-keyword ')'
   3207 ///    'vectorize_width' '(' loop-hint-value ')'
   3208 ///    'interleave_count' '(' loop-hint-value ')'
   3209 ///    'unroll_count' '(' loop-hint-value ')'
   3210 ///    'pipeline' '(' disable ')'
   3211 ///    'pipeline_initiation_interval' '(' loop-hint-value ')'
   3212 ///
   3213 ///  loop-hint-keyword:
   3214 ///    'enable'
   3215 ///    'disable'
   3216 ///    'assume_safety'
   3217 ///
   3218 ///  unroll-hint-keyword:
   3219 ///    'enable'
   3220 ///    'disable'
   3221 ///    'full'
   3222 ///
   3223 ///  loop-hint-value:
   3224 ///    constant-expression
   3225 ///
   3226 /// Specifying vectorize(enable) or vectorize_width(_value_) instructs llvm to
   3227 /// try vectorizing the instructions of the loop it precedes. Specifying
   3228 /// interleave(enable) or interleave_count(_value_) instructs llvm to try
   3229 /// interleaving multiple iterations of the loop it precedes. The width of the
   3230 /// vector instructions is specified by vectorize_width() and the number of
   3231 /// interleaved loop iterations is specified by interleave_count(). Specifying a
   3232 /// value of 1 effectively disables vectorization/interleaving, even if it is
   3233 /// possible and profitable, and 0 is invalid. The loop vectorizer currently
   3234 /// only works on inner loops.
   3235 ///
   3236 /// The unroll and unroll_count directives control the concatenation
   3237 /// unroller. Specifying unroll(enable) instructs llvm to unroll the loop
   3238 /// completely if the trip count is known at compile time and unroll partially
   3239 /// if the trip count is not known.  Specifying unroll(full) is similar to
   3240 /// unroll(enable) but will unroll the loop only if the trip count is known at
   3241 /// compile time.  Specifying unroll(disable) disables unrolling for the
   3242 /// loop. Specifying unroll_count(_value_) instructs llvm to try to unroll the
   3243 /// loop the number of times indicated by the value.
   3244 void PragmaLoopHintHandler::HandlePragma(Preprocessor &PP,
   3245                                          PragmaIntroducer Introducer,
   3246                                          Token &Tok) {
   3247   // Incoming token is "loop" from "#pragma clang loop".
   3248   Token PragmaName = Tok;
   3249   SmallVector<Token, 1> TokenList;
   3250 
   3251   // Lex the optimization option and verify it is an identifier.
   3252   PP.Lex(Tok);
   3253   if (Tok.isNot(tok::identifier)) {
   3254     PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option)
   3255         << /*MissingOption=*/true << "";
   3256     return;
   3257   }
   3258 
   3259   while (Tok.is(tok::identifier)) {
   3260     Token Option = Tok;
   3261     IdentifierInfo *OptionInfo = Tok.getIdentifierInfo();
   3262 
   3263     bool OptionValid = llvm::StringSwitch<bool>(OptionInfo->getName())
   3264                            .Case("vectorize", true)
   3265                            .Case("interleave", true)
   3266                            .Case("unroll", true)
   3267                            .Case("distribute", true)
   3268                            .Case("vectorize_predicate", true)
   3269                            .Case("vectorize_width", true)
   3270                            .Case("interleave_count", true)
   3271                            .Case("unroll_count", true)
   3272                            .Case("pipeline", true)
   3273                            .Case("pipeline_initiation_interval", true)
   3274                            .Default(false);
   3275     if (!OptionValid) {
   3276       PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option)
   3277           << /*MissingOption=*/false << OptionInfo;
   3278       return;
   3279     }
   3280     PP.Lex(Tok);
   3281 
   3282     // Read '('
   3283     if (Tok.isNot(tok::l_paren)) {
   3284       PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren;
   3285       return;
   3286     }
   3287     PP.Lex(Tok);
   3288 
   3289     auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo;
   3290     if (ParseLoopHintValue(PP, Tok, PragmaName, Option, /*ValueInParens=*/true,
   3291                            *Info))
   3292       return;
   3293 
   3294     // Generate the loop hint token.
   3295     Token LoopHintTok;
   3296     LoopHintTok.startToken();
   3297     LoopHintTok.setKind(tok::annot_pragma_loop_hint);
   3298     LoopHintTok.setLocation(Introducer.Loc);
   3299     LoopHintTok.setAnnotationEndLoc(PragmaName.getLocation());
   3300     LoopHintTok.setAnnotationValue(static_cast<void *>(Info));
   3301     TokenList.push_back(LoopHintTok);
   3302   }
   3303 
   3304   if (Tok.isNot(tok::eod)) {
   3305     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   3306         << "clang loop";
   3307     return;
   3308   }
   3309 
   3310   auto TokenArray = std::make_unique<Token[]>(TokenList.size());
   3311   std::copy(TokenList.begin(), TokenList.end(), TokenArray.get());
   3312 
   3313   PP.EnterTokenStream(std::move(TokenArray), TokenList.size(),
   3314                       /*DisableMacroExpansion=*/false, /*IsReinject=*/false);
   3315 }
   3316 
   3317 /// Handle the loop unroll optimization pragmas.
   3318 ///  #pragma unroll
   3319 ///  #pragma unroll unroll-hint-value
   3320 ///  #pragma unroll '(' unroll-hint-value ')'
   3321 ///  #pragma nounroll
   3322 ///  #pragma unroll_and_jam
   3323 ///  #pragma unroll_and_jam unroll-hint-value
   3324 ///  #pragma unroll_and_jam '(' unroll-hint-value ')'
   3325 ///  #pragma nounroll_and_jam
   3326 ///
   3327 ///  unroll-hint-value:
   3328 ///    constant-expression
   3329 ///
   3330 /// Loop unrolling hints can be specified with '#pragma unroll' or
   3331 /// '#pragma nounroll'. '#pragma unroll' can take a numeric argument optionally
   3332 /// contained in parentheses. With no argument the directive instructs llvm to
   3333 /// try to unroll the loop completely. A positive integer argument can be
   3334 /// specified to indicate the number of times the loop should be unrolled.  To
   3335 /// maximize compatibility with other compilers the unroll count argument can be
   3336 /// specified with or without parentheses.  Specifying, '#pragma nounroll'
   3337 /// disables unrolling of the loop.
   3338 void PragmaUnrollHintHandler::HandlePragma(Preprocessor &PP,
   3339                                            PragmaIntroducer Introducer,
   3340                                            Token &Tok) {
   3341   // Incoming token is "unroll" for "#pragma unroll", or "nounroll" for
   3342   // "#pragma nounroll".
   3343   Token PragmaName = Tok;
   3344   PP.Lex(Tok);
   3345   auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo;
   3346   if (Tok.is(tok::eod)) {
   3347     // nounroll or unroll pragma without an argument.
   3348     Info->PragmaName = PragmaName;
   3349     Info->Option.startToken();
   3350   } else if (PragmaName.getIdentifierInfo()->getName() == "nounroll" ||
   3351              PragmaName.getIdentifierInfo()->getName() == "nounroll_and_jam") {
   3352     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   3353         << PragmaName.getIdentifierInfo()->getName();
   3354     return;
   3355   } else {
   3356     // Unroll pragma with an argument: "#pragma unroll N" or
   3357     // "#pragma unroll(N)".
   3358     // Read '(' if it exists.
   3359     bool ValueInParens = Tok.is(tok::l_paren);
   3360     if (ValueInParens)
   3361       PP.Lex(Tok);
   3362 
   3363     Token Option;
   3364     Option.startToken();
   3365     if (ParseLoopHintValue(PP, Tok, PragmaName, Option, ValueInParens, *Info))
   3366       return;
   3367 
   3368     // In CUDA, the argument to '#pragma unroll' should not be contained in
   3369     // parentheses.
   3370     if (PP.getLangOpts().CUDA && ValueInParens)
   3371       PP.Diag(Info->Toks[0].getLocation(),
   3372               diag::warn_pragma_unroll_cuda_value_in_parens);
   3373 
   3374     if (Tok.isNot(tok::eod)) {
   3375       PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   3376           << "unroll";
   3377       return;
   3378     }
   3379   }
   3380 
   3381   // Generate the hint token.
   3382   auto TokenArray = std::make_unique<Token[]>(1);
   3383   TokenArray[0].startToken();
   3384   TokenArray[0].setKind(tok::annot_pragma_loop_hint);
   3385   TokenArray[0].setLocation(Introducer.Loc);
   3386   TokenArray[0].setAnnotationEndLoc(PragmaName.getLocation());
   3387   TokenArray[0].setAnnotationValue(static_cast<void *>(Info));
   3388   PP.EnterTokenStream(std::move(TokenArray), 1,
   3389                       /*DisableMacroExpansion=*/false, /*IsReinject=*/false);
   3390 }
   3391 
   3392 /// Handle the Microsoft \#pragma intrinsic extension.
   3393 ///
   3394 /// The syntax is:
   3395 /// \code
   3396 ///  #pragma intrinsic(memset)
   3397 ///  #pragma intrinsic(strlen, memcpy)
   3398 /// \endcode
   3399 ///
   3400 /// Pragma intrisic tells the compiler to use a builtin version of the
   3401 /// function. Clang does it anyway, so the pragma doesn't really do anything.
   3402 /// Anyway, we emit a warning if the function specified in \#pragma intrinsic
   3403 /// isn't an intrinsic in clang and suggest to include intrin.h.
   3404 void PragmaMSIntrinsicHandler::HandlePragma(Preprocessor &PP,
   3405                                             PragmaIntroducer Introducer,
   3406                                             Token &Tok) {
   3407   PP.Lex(Tok);
   3408 
   3409   if (Tok.isNot(tok::l_paren)) {
   3410     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen)
   3411         << "intrinsic";
   3412     return;
   3413   }
   3414   PP.Lex(Tok);
   3415 
   3416   bool SuggestIntrinH = !PP.isMacroDefined("__INTRIN_H");
   3417 
   3418   while (Tok.is(tok::identifier)) {
   3419     IdentifierInfo *II = Tok.getIdentifierInfo();
   3420     if (!II->getBuiltinID())
   3421       PP.Diag(Tok.getLocation(), diag::warn_pragma_intrinsic_builtin)
   3422           << II << SuggestIntrinH;
   3423 
   3424     PP.Lex(Tok);
   3425     if (Tok.isNot(tok::comma))
   3426       break;
   3427     PP.Lex(Tok);
   3428   }
   3429 
   3430   if (Tok.isNot(tok::r_paren)) {
   3431     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen)
   3432         << "intrinsic";
   3433     return;
   3434   }
   3435   PP.Lex(Tok);
   3436 
   3437   if (Tok.isNot(tok::eod))
   3438     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   3439         << "intrinsic";
   3440 }
   3441 
   3442 // #pragma optimize("gsty", on|off)
   3443 void PragmaMSOptimizeHandler::HandlePragma(Preprocessor &PP,
   3444                                            PragmaIntroducer Introducer,
   3445                                            Token &Tok) {
   3446   SourceLocation StartLoc = Tok.getLocation();
   3447   PP.Lex(Tok);
   3448 
   3449   if (Tok.isNot(tok::l_paren)) {
   3450     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "optimize";
   3451     return;
   3452   }
   3453   PP.Lex(Tok);
   3454 
   3455   if (Tok.isNot(tok::string_literal)) {
   3456     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_string) << "optimize";
   3457     return;
   3458   }
   3459   // We could syntax check the string but it's probably not worth the effort.
   3460   PP.Lex(Tok);
   3461 
   3462   if (Tok.isNot(tok::comma)) {
   3463     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_comma) << "optimize";
   3464     return;
   3465   }
   3466   PP.Lex(Tok);
   3467 
   3468   if (Tok.is(tok::eod) || Tok.is(tok::r_paren)) {
   3469     PP.Diag(Tok.getLocation(), diag::warn_pragma_missing_argument)
   3470         << "optimize" << /*Expected=*/true << "'on' or 'off'";
   3471     return;
   3472   }
   3473   IdentifierInfo *II = Tok.getIdentifierInfo();
   3474   if (!II || (!II->isStr("on") && !II->isStr("off"))) {
   3475     PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_argument)
   3476         << PP.getSpelling(Tok) << "optimize" << /*Expected=*/true
   3477         << "'on' or 'off'";
   3478     return;
   3479   }
   3480   PP.Lex(Tok);
   3481 
   3482   if (Tok.isNot(tok::r_paren)) {
   3483     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "optimize";
   3484     return;
   3485   }
   3486   PP.Lex(Tok);
   3487 
   3488   if (Tok.isNot(tok::eod)) {
   3489     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   3490         << "optimize";
   3491     return;
   3492   }
   3493   PP.Diag(StartLoc, diag::warn_pragma_optimize);
   3494 }
   3495 
   3496 void PragmaForceCUDAHostDeviceHandler::HandlePragma(
   3497     Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {
   3498   Token FirstTok = Tok;
   3499 
   3500   PP.Lex(Tok);
   3501   IdentifierInfo *Info = Tok.getIdentifierInfo();
   3502   if (!Info || (!Info->isStr("begin") && !Info->isStr("end"))) {
   3503     PP.Diag(FirstTok.getLocation(),
   3504             diag::warn_pragma_force_cuda_host_device_bad_arg);
   3505     return;
   3506   }
   3507 
   3508   if (Info->isStr("begin"))
   3509     Actions.PushForceCUDAHostDevice();
   3510   else if (!Actions.PopForceCUDAHostDevice())
   3511     PP.Diag(FirstTok.getLocation(),
   3512             diag::err_pragma_cannot_end_force_cuda_host_device);
   3513 
   3514   PP.Lex(Tok);
   3515   if (!Tok.is(tok::eod))
   3516     PP.Diag(FirstTok.getLocation(),
   3517             diag::warn_pragma_force_cuda_host_device_bad_arg);
   3518 }
   3519 
   3520 /// Handle the #pragma clang attribute directive.
   3521 ///
   3522 /// The syntax is:
   3523 /// \code
   3524 ///  #pragma clang attribute push (attribute, subject-set)
   3525 ///  #pragma clang attribute push
   3526 ///  #pragma clang attribute (attribute, subject-set)
   3527 ///  #pragma clang attribute pop
   3528 /// \endcode
   3529 ///
   3530 /// There are also 'namespace' variants of push and pop directives. The bare
   3531 /// '#pragma clang attribute (attribute, subject-set)' version doesn't require a
   3532 /// namespace, since it always applies attributes to the most recently pushed
   3533 /// group, regardless of namespace.
   3534 /// \code
   3535 ///  #pragma clang attribute namespace.push (attribute, subject-set)
   3536 ///  #pragma clang attribute namespace.push
   3537 ///  #pragma clang attribute namespace.pop
   3538 /// \endcode
   3539 ///
   3540 /// The subject-set clause defines the set of declarations which receive the
   3541 /// attribute. Its exact syntax is described in the LanguageExtensions document
   3542 /// in Clang's documentation.
   3543 ///
   3544 /// This directive instructs the compiler to begin/finish applying the specified
   3545 /// attribute to the set of attribute-specific declarations in the active range
   3546 /// of the pragma.
   3547 void PragmaAttributeHandler::HandlePragma(Preprocessor &PP,
   3548                                           PragmaIntroducer Introducer,
   3549                                           Token &FirstToken) {
   3550   Token Tok;
   3551   PP.Lex(Tok);
   3552   auto *Info = new (PP.getPreprocessorAllocator())
   3553       PragmaAttributeInfo(AttributesForPragmaAttribute);
   3554 
   3555   // Parse the optional namespace followed by a period.
   3556   if (Tok.is(tok::identifier)) {
   3557     IdentifierInfo *II = Tok.getIdentifierInfo();
   3558     if (!II->isStr("push") && !II->isStr("pop")) {
   3559       Info->Namespace = II;
   3560       PP.Lex(Tok);
   3561 
   3562       if (!Tok.is(tok::period)) {
   3563         PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_expected_period)
   3564             << II;
   3565         return;
   3566       }
   3567       PP.Lex(Tok);
   3568     }
   3569   }
   3570 
   3571   if (!Tok.isOneOf(tok::identifier, tok::l_paren)) {
   3572     PP.Diag(Tok.getLocation(),
   3573             diag::err_pragma_attribute_expected_push_pop_paren);
   3574     return;
   3575   }
   3576 
   3577   // Determine what action this pragma clang attribute represents.
   3578   if (Tok.is(tok::l_paren)) {
   3579     if (Info->Namespace) {
   3580       PP.Diag(Tok.getLocation(),
   3581               diag::err_pragma_attribute_namespace_on_attribute);
   3582       PP.Diag(Tok.getLocation(),
   3583               diag::note_pragma_attribute_namespace_on_attribute);
   3584       return;
   3585     }
   3586     Info->Action = PragmaAttributeInfo::Attribute;
   3587   } else {
   3588     const IdentifierInfo *II = Tok.getIdentifierInfo();
   3589     if (II->isStr("push"))
   3590       Info->Action = PragmaAttributeInfo::Push;
   3591     else if (II->isStr("pop"))
   3592       Info->Action = PragmaAttributeInfo::Pop;
   3593     else {
   3594       PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_invalid_argument)
   3595           << PP.getSpelling(Tok);
   3596       return;
   3597     }
   3598 
   3599     PP.Lex(Tok);
   3600   }
   3601 
   3602   // Parse the actual attribute.
   3603   if ((Info->Action == PragmaAttributeInfo::Push && Tok.isNot(tok::eod)) ||
   3604       Info->Action == PragmaAttributeInfo::Attribute) {
   3605     if (Tok.isNot(tok::l_paren)) {
   3606       PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren;
   3607       return;
   3608     }
   3609     PP.Lex(Tok);
   3610 
   3611     // Lex the attribute tokens.
   3612     SmallVector<Token, 16> AttributeTokens;
   3613     int OpenParens = 1;
   3614     while (Tok.isNot(tok::eod)) {
   3615       if (Tok.is(tok::l_paren))
   3616         OpenParens++;
   3617       else if (Tok.is(tok::r_paren)) {
   3618         OpenParens--;
   3619         if (OpenParens == 0)
   3620           break;
   3621       }
   3622 
   3623       AttributeTokens.push_back(Tok);
   3624       PP.Lex(Tok);
   3625     }
   3626 
   3627     if (AttributeTokens.empty()) {
   3628       PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_expected_attribute);
   3629       return;
   3630     }
   3631     if (Tok.isNot(tok::r_paren)) {
   3632       PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
   3633       return;
   3634     }
   3635     SourceLocation EndLoc = Tok.getLocation();
   3636     PP.Lex(Tok);
   3637 
   3638     // Terminate the attribute for parsing.
   3639     Token EOFTok;
   3640     EOFTok.startToken();
   3641     EOFTok.setKind(tok::eof);
   3642     EOFTok.setLocation(EndLoc);
   3643     AttributeTokens.push_back(EOFTok);
   3644 
   3645     markAsReinjectedForRelexing(AttributeTokens);
   3646     Info->Tokens =
   3647         llvm::makeArrayRef(AttributeTokens).copy(PP.getPreprocessorAllocator());
   3648   }
   3649 
   3650   if (Tok.isNot(tok::eod))
   3651     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   3652         << "clang attribute";
   3653 
   3654   // Generate the annotated pragma token.
   3655   auto TokenArray = std::make_unique<Token[]>(1);
   3656   TokenArray[0].startToken();
   3657   TokenArray[0].setKind(tok::annot_pragma_attribute);
   3658   TokenArray[0].setLocation(FirstToken.getLocation());
   3659   TokenArray[0].setAnnotationEndLoc(FirstToken.getLocation());
   3660   TokenArray[0].setAnnotationValue(static_cast<void *>(Info));
   3661   PP.EnterTokenStream(std::move(TokenArray), 1,
   3662                       /*DisableMacroExpansion=*/false, /*IsReinject=*/false);
   3663 }
   3664 
   3665 // Handle '#pragma clang max_tokens 12345'.
   3666 void PragmaMaxTokensHereHandler::HandlePragma(Preprocessor &PP,
   3667                                               PragmaIntroducer Introducer,
   3668                                               Token &Tok) {
   3669   PP.Lex(Tok);
   3670   if (Tok.is(tok::eod)) {
   3671     PP.Diag(Tok.getLocation(), diag::err_pragma_missing_argument)
   3672         << "clang max_tokens_here" << /*Expected=*/true << "integer";
   3673     return;
   3674   }
   3675 
   3676   SourceLocation Loc = Tok.getLocation();
   3677   uint64_t MaxTokens;
   3678   if (Tok.isNot(tok::numeric_constant) ||
   3679       !PP.parseSimpleIntegerLiteral(Tok, MaxTokens)) {
   3680     PP.Diag(Tok.getLocation(), diag::err_pragma_expected_integer)
   3681         << "clang max_tokens_here";
   3682     return;
   3683   }
   3684 
   3685   if (Tok.isNot(tok::eod)) {
   3686     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   3687         << "clang max_tokens_here";
   3688     return;
   3689   }
   3690 
   3691   if (PP.getTokenCount() > MaxTokens) {
   3692     PP.Diag(Loc, diag::warn_max_tokens)
   3693         << PP.getTokenCount() << (unsigned)MaxTokens;
   3694   }
   3695 }
   3696 
   3697 // Handle '#pragma clang max_tokens_total 12345'.
   3698 void PragmaMaxTokensTotalHandler::HandlePragma(Preprocessor &PP,
   3699                                                PragmaIntroducer Introducer,
   3700                                                Token &Tok) {
   3701   PP.Lex(Tok);
   3702   if (Tok.is(tok::eod)) {
   3703     PP.Diag(Tok.getLocation(), diag::err_pragma_missing_argument)
   3704         << "clang max_tokens_total" << /*Expected=*/true << "integer";
   3705     return;
   3706   }
   3707 
   3708   SourceLocation Loc = Tok.getLocation();
   3709   uint64_t MaxTokens;
   3710   if (Tok.isNot(tok::numeric_constant) ||
   3711       !PP.parseSimpleIntegerLiteral(Tok, MaxTokens)) {
   3712     PP.Diag(Tok.getLocation(), diag::err_pragma_expected_integer)
   3713         << "clang max_tokens_total";
   3714     return;
   3715   }
   3716 
   3717   if (Tok.isNot(tok::eod)) {
   3718     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   3719         << "clang max_tokens_total";
   3720     return;
   3721   }
   3722 
   3723   PP.overrideMaxTokens(MaxTokens, Loc);
   3724 }
   3725