Home | History | Annotate | Download | only in Parse 
      1 //===--- ParsePragma.cpp - Language specific pragma parsing ---------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This file implements the language specific #pragma handlers.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "RAIIObjectsForParser.h"
     15 #include "clang/AST/ASTContext.h"
     16 #include "clang/Basic/PragmaKinds.h"
     17 #include "clang/Basic/TargetInfo.h"
     18 #include "clang/Lex/Preprocessor.h"
     19 #include "clang/Parse/ParseDiagnostic.h"
     20 #include "clang/Parse/Parser.h"
     21 #include "clang/Sema/LoopHint.h"
     22 #include "clang/Sema/Scope.h"
     23 #include "llvm/ADT/StringSwitch.h"
     24 using namespace clang;
     25 
     26 namespace {
     27 
     28 struct PragmaAlignHandler : public PragmaHandler {
     29   explicit PragmaAlignHandler() : PragmaHandler("align") {}
     30   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
     31                     Token &FirstToken) override;
     32 };
     33 
     34 struct PragmaGCCVisibilityHandler : public PragmaHandler {
     35   explicit PragmaGCCVisibilityHandler() : PragmaHandler("visibility") {}
     36   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
     37                     Token &FirstToken) override;
     38 };
     39 
     40 struct PragmaOptionsHandler : public PragmaHandler {
     41   explicit PragmaOptionsHandler() : PragmaHandler("options") {}
     42   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
     43                     Token &FirstToken) override;
     44 };
     45 
     46 struct PragmaPackHandler : public PragmaHandler {
     47   explicit PragmaPackHandler() : PragmaHandler("pack") {}
     48   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
     49                     Token &FirstToken) override;
     50 };
     51 
     52 struct PragmaMSStructHandler : public PragmaHandler {
     53   explicit PragmaMSStructHandler() : PragmaHandler("ms_struct") {}
     54   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
     55                     Token &FirstToken) override;
     56 };
     57 
     58 struct PragmaUnusedHandler : public PragmaHandler {
     59   PragmaUnusedHandler() : PragmaHandler("unused") {}
     60   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
     61                     Token &FirstToken) override;
     62 };
     63 
     64 struct PragmaWeakHandler : public PragmaHandler {
     65   explicit PragmaWeakHandler() : PragmaHandler("weak") {}
     66   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
     67                     Token &FirstToken) override;
     68 };
     69 
     70 struct PragmaRedefineExtnameHandler : public PragmaHandler {
     71   explicit PragmaRedefineExtnameHandler() : PragmaHandler("redefine_extname") {}
     72   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
     73                     Token &FirstToken) override;
     74 };
     75 
     76 struct PragmaOpenCLExtensionHandler : public PragmaHandler {
     77   PragmaOpenCLExtensionHandler() : PragmaHandler("EXTENSION") {}
     78   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
     79                     Token &FirstToken) override;
     80 };
     81 
     82 
     83 struct PragmaFPContractHandler : public PragmaHandler {
     84   PragmaFPContractHandler() : PragmaHandler("FP_CONTRACT") {}
     85   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
     86                     Token &FirstToken) override;
     87 };
     88 
     89 struct PragmaNoOpenMPHandler : public PragmaHandler {
     90   PragmaNoOpenMPHandler() : PragmaHandler("omp") { }
     91   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
     92                     Token &FirstToken) override;
     93 };
     94 
     95 struct PragmaOpenMPHandler : public PragmaHandler {
     96   PragmaOpenMPHandler() : PragmaHandler("omp") { }
     97   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
     98                     Token &FirstToken) override;
     99 };
    100 
    101 /// PragmaCommentHandler - "\#pragma comment ...".
    102 struct PragmaCommentHandler : public PragmaHandler {
    103   PragmaCommentHandler(Sema &Actions)
    104     : PragmaHandler("comment"), Actions(Actions) {}
    105   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
    106                     Token &FirstToken) override;
    107 private:
    108   Sema &Actions;
    109 };
    110 
    111 struct PragmaDetectMismatchHandler : public PragmaHandler {
    112   PragmaDetectMismatchHandler(Sema &Actions)
    113     : PragmaHandler("detect_mismatch"), Actions(Actions) {}
    114   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
    115                     Token &FirstToken) override;
    116 private:
    117   Sema &Actions;
    118 };
    119 
    120 struct PragmaMSPointersToMembers : public PragmaHandler {
    121   explicit PragmaMSPointersToMembers() : PragmaHandler("pointers_to_members") {}
    122   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
    123                     Token &FirstToken) override;
    124 };
    125 
    126 struct PragmaMSVtorDisp : public PragmaHandler {
    127   explicit PragmaMSVtorDisp() : PragmaHandler("vtordisp") {}
    128   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
    129                     Token &FirstToken) override;
    130 };
    131 
    132 struct PragmaMSPragma : public PragmaHandler {
    133   explicit PragmaMSPragma(const char *name) : PragmaHandler(name) {}
    134   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
    135                     Token &FirstToken) override;
    136 };
    137 
    138 /// PragmaOptimizeHandler - "\#pragma clang optimize on/off".
    139 struct PragmaOptimizeHandler : public PragmaHandler {
    140   PragmaOptimizeHandler(Sema &S)
    141     : PragmaHandler("optimize"), Actions(S) {}
    142   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
    143                     Token &FirstToken) override;
    144 private:
    145   Sema &Actions;
    146 };
    147 
    148 struct PragmaLoopHintHandler : public PragmaHandler {
    149   PragmaLoopHintHandler() : PragmaHandler("loop") {}
    150   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
    151                     Token &FirstToken) override;
    152 };
    153 
    154 struct PragmaUnrollHintHandler : public PragmaHandler {
    155   PragmaUnrollHintHandler(const char *name) : PragmaHandler(name) {}
    156   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
    157                     Token &FirstToken) override;
    158 };
    159 
    160 struct PragmaMSRuntimeChecksHandler : public EmptyPragmaHandler {
    161   PragmaMSRuntimeChecksHandler() : EmptyPragmaHandler("runtime_checks") {}
    162 };
    163 
    164 }  // end namespace
    165 
    166 void Parser::initializePragmaHandlers() {
    167   AlignHandler.reset(new PragmaAlignHandler());
    168   PP.AddPragmaHandler(AlignHandler.get());
    169 
    170   GCCVisibilityHandler.reset(new PragmaGCCVisibilityHandler());
    171   PP.AddPragmaHandler("GCC", GCCVisibilityHandler.get());
    172 
    173   OptionsHandler.reset(new PragmaOptionsHandler());
    174   PP.AddPragmaHandler(OptionsHandler.get());
    175 
    176   PackHandler.reset(new PragmaPackHandler());
    177   PP.AddPragmaHandler(PackHandler.get());
    178 
    179   MSStructHandler.reset(new PragmaMSStructHandler());
    180   PP.AddPragmaHandler(MSStructHandler.get());
    181 
    182   UnusedHandler.reset(new PragmaUnusedHandler());
    183   PP.AddPragmaHandler(UnusedHandler.get());
    184 
    185   WeakHandler.reset(new PragmaWeakHandler());
    186   PP.AddPragmaHandler(WeakHandler.get());
    187 
    188   RedefineExtnameHandler.reset(new PragmaRedefineExtnameHandler());
    189   PP.AddPragmaHandler(RedefineExtnameHandler.get());
    190 
    191   FPContractHandler.reset(new PragmaFPContractHandler());
    192   PP.AddPragmaHandler("STDC", FPContractHandler.get());
    193 
    194   if (getLangOpts().OpenCL) {
    195     OpenCLExtensionHandler.reset(new PragmaOpenCLExtensionHandler());
    196     PP.AddPragmaHandler("OPENCL", OpenCLExtensionHandler.get());
    197 
    198     PP.AddPragmaHandler("OPENCL", FPContractHandler.get());
    199   }
    200   if (getLangOpts().OpenMP)
    201     OpenMPHandler.reset(new PragmaOpenMPHandler());
    202   else
    203     OpenMPHandler.reset(new PragmaNoOpenMPHandler());
    204   PP.AddPragmaHandler(OpenMPHandler.get());
    205 
    206   if (getLangOpts().MicrosoftExt || getTargetInfo().getTriple().isPS4()) {
    207     MSCommentHandler.reset(new PragmaCommentHandler(Actions));
    208     PP.AddPragmaHandler(MSCommentHandler.get());
    209   }
    210 
    211   if (getLangOpts().MicrosoftExt) {
    212     MSDetectMismatchHandler.reset(new PragmaDetectMismatchHandler(Actions));
    213     PP.AddPragmaHandler(MSDetectMismatchHandler.get());
    214     MSPointersToMembers.reset(new PragmaMSPointersToMembers());
    215     PP.AddPragmaHandler(MSPointersToMembers.get());
    216     MSVtorDisp.reset(new PragmaMSVtorDisp());
    217     PP.AddPragmaHandler(MSVtorDisp.get());
    218     MSInitSeg.reset(new PragmaMSPragma("init_seg"));
    219     PP.AddPragmaHandler(MSInitSeg.get());
    220     MSDataSeg.reset(new PragmaMSPragma("data_seg"));
    221     PP.AddPragmaHandler(MSDataSeg.get());
    222     MSBSSSeg.reset(new PragmaMSPragma("bss_seg"));
    223     PP.AddPragmaHandler(MSBSSSeg.get());
    224     MSConstSeg.reset(new PragmaMSPragma("const_seg"));
    225     PP.AddPragmaHandler(MSConstSeg.get());
    226     MSCodeSeg.reset(new PragmaMSPragma("code_seg"));
    227     PP.AddPragmaHandler(MSCodeSeg.get());
    228     MSSection.reset(new PragmaMSPragma("section"));
    229     PP.AddPragmaHandler(MSSection.get());
    230     MSRuntimeChecks.reset(new PragmaMSRuntimeChecksHandler());
    231     PP.AddPragmaHandler(MSRuntimeChecks.get());
    232   }
    233 
    234   OptimizeHandler.reset(new PragmaOptimizeHandler(Actions));
    235   PP.AddPragmaHandler("clang", OptimizeHandler.get());
    236 
    237   LoopHintHandler.reset(new PragmaLoopHintHandler());
    238   PP.AddPragmaHandler("clang", LoopHintHandler.get());
    239 
    240   UnrollHintHandler.reset(new PragmaUnrollHintHandler("unroll"));
    241   PP.AddPragmaHandler(UnrollHintHandler.get());
    242 
    243   NoUnrollHintHandler.reset(new PragmaUnrollHintHandler("nounroll"));
    244   PP.AddPragmaHandler(NoUnrollHintHandler.get());
    245 }
    246 
    247 void Parser::resetPragmaHandlers() {
    248   // Remove the pragma handlers we installed.
    249   PP.RemovePragmaHandler(AlignHandler.get());
    250   AlignHandler.reset();
    251   PP.RemovePragmaHandler("GCC", GCCVisibilityHandler.get());
    252   GCCVisibilityHandler.reset();
    253   PP.RemovePragmaHandler(OptionsHandler.get());
    254   OptionsHandler.reset();
    255   PP.RemovePragmaHandler(PackHandler.get());
    256   PackHandler.reset();
    257   PP.RemovePragmaHandler(MSStructHandler.get());
    258   MSStructHandler.reset();
    259   PP.RemovePragmaHandler(UnusedHandler.get());
    260   UnusedHandler.reset();
    261   PP.RemovePragmaHandler(WeakHandler.get());
    262   WeakHandler.reset();
    263   PP.RemovePragmaHandler(RedefineExtnameHandler.get());
    264   RedefineExtnameHandler.reset();
    265 
    266   if (getLangOpts().OpenCL) {
    267     PP.RemovePragmaHandler("OPENCL", OpenCLExtensionHandler.get());
    268     OpenCLExtensionHandler.reset();
    269     PP.RemovePragmaHandler("OPENCL", FPContractHandler.get());
    270   }
    271   PP.RemovePragmaHandler(OpenMPHandler.get());
    272   OpenMPHandler.reset();
    273 
    274   if (getLangOpts().MicrosoftExt || getTargetInfo().getTriple().isPS4()) {
    275     PP.RemovePragmaHandler(MSCommentHandler.get());
    276     MSCommentHandler.reset();
    277   }
    278 
    279   if (getLangOpts().MicrosoftExt) {
    280     PP.RemovePragmaHandler(MSDetectMismatchHandler.get());
    281     MSDetectMismatchHandler.reset();
    282     PP.RemovePragmaHandler(MSPointersToMembers.get());
    283     MSPointersToMembers.reset();
    284     PP.RemovePragmaHandler(MSVtorDisp.get());
    285     MSVtorDisp.reset();
    286     PP.RemovePragmaHandler(MSInitSeg.get());
    287     MSInitSeg.reset();
    288     PP.RemovePragmaHandler(MSDataSeg.get());
    289     MSDataSeg.reset();
    290     PP.RemovePragmaHandler(MSBSSSeg.get());
    291     MSBSSSeg.reset();
    292     PP.RemovePragmaHandler(MSConstSeg.get());
    293     MSConstSeg.reset();
    294     PP.RemovePragmaHandler(MSCodeSeg.get());
    295     MSCodeSeg.reset();
    296     PP.RemovePragmaHandler(MSSection.get());
    297     MSSection.reset();
    298     PP.RemovePragmaHandler(MSRuntimeChecks.get());
    299     MSRuntimeChecks.reset();
    300   }
    301 
    302   PP.RemovePragmaHandler("STDC", FPContractHandler.get());
    303   FPContractHandler.reset();
    304 
    305   PP.RemovePragmaHandler("clang", OptimizeHandler.get());
    306   OptimizeHandler.reset();
    307 
    308   PP.RemovePragmaHandler("clang", LoopHintHandler.get());
    309   LoopHintHandler.reset();
    310 
    311   PP.RemovePragmaHandler(UnrollHintHandler.get());
    312   UnrollHintHandler.reset();
    313 
    314   PP.RemovePragmaHandler(NoUnrollHintHandler.get());
    315   NoUnrollHintHandler.reset();
    316 }
    317 
    318 /// \brief Handle the annotation token produced for #pragma unused(...)
    319 ///
    320 /// Each annot_pragma_unused is followed by the argument token so e.g.
    321 /// "#pragma unused(x,y)" becomes:
    322 /// annot_pragma_unused 'x' annot_pragma_unused 'y'
    323 void Parser::HandlePragmaUnused() {
    324   assert(Tok.is(tok::annot_pragma_unused));
    325   SourceLocation UnusedLoc = ConsumeToken();
    326   Actions.ActOnPragmaUnused(Tok, getCurScope(), UnusedLoc);
    327   ConsumeToken(); // The argument token.
    328 }
    329 
    330 void Parser::HandlePragmaVisibility() {
    331   assert(Tok.is(tok::annot_pragma_vis));
    332   const IdentifierInfo *VisType =
    333     static_cast<IdentifierInfo *>(Tok.getAnnotationValue());
    334   SourceLocation VisLoc = ConsumeToken();
    335   Actions.ActOnPragmaVisibility(VisType, VisLoc);
    336 }
    337 
    338 namespace {
    339 struct PragmaPackInfo {
    340   Sema::PragmaMsStackAction Action;
    341   StringRef SlotLabel;
    342   Token Alignment;
    343 };
    344 } // end anonymous namespace
    345 
    346 void Parser::HandlePragmaPack() {
    347   assert(Tok.is(tok::annot_pragma_pack));
    348   PragmaPackInfo *Info =
    349     static_cast<PragmaPackInfo *>(Tok.getAnnotationValue());
    350   SourceLocation PragmaLoc = ConsumeToken();
    351   ExprResult Alignment;
    352   if (Info->Alignment.is(tok::numeric_constant)) {
    353     Alignment = Actions.ActOnNumericConstant(Info->Alignment);
    354     if (Alignment.isInvalid())
    355       return;
    356   }
    357   Actions.ActOnPragmaPack(PragmaLoc, Info->Action, Info->SlotLabel,
    358                           Alignment.get());
    359 }
    360 
    361 void Parser::HandlePragmaMSStruct() {
    362   assert(Tok.is(tok::annot_pragma_msstruct));
    363   PragmaMSStructKind Kind = static_cast<PragmaMSStructKind>(
    364       reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
    365   Actions.ActOnPragmaMSStruct(Kind);
    366   ConsumeToken(); // The annotation token.
    367 }
    368 
    369 void Parser::HandlePragmaAlign() {
    370   assert(Tok.is(tok::annot_pragma_align));
    371   Sema::PragmaOptionsAlignKind Kind =
    372     static_cast<Sema::PragmaOptionsAlignKind>(
    373     reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
    374   SourceLocation PragmaLoc = ConsumeToken();
    375   Actions.ActOnPragmaOptionsAlign(Kind, PragmaLoc);
    376 }
    377 
    378 void Parser::HandlePragmaDump() {
    379   assert(Tok.is(tok::annot_pragma_dump));
    380   IdentifierInfo *II =
    381       reinterpret_cast<IdentifierInfo *>(Tok.getAnnotationValue());
    382   Actions.ActOnPragmaDump(getCurScope(), Tok.getLocation(), II);
    383   ConsumeToken();
    384 }
    385 
    386 void Parser::HandlePragmaWeak() {
    387   assert(Tok.is(tok::annot_pragma_weak));
    388   SourceLocation PragmaLoc = ConsumeToken();
    389   Actions.ActOnPragmaWeakID(Tok.getIdentifierInfo(), PragmaLoc,
    390                             Tok.getLocation());
    391   ConsumeToken(); // The weak name.
    392 }
    393 
    394 void Parser::HandlePragmaWeakAlias() {
    395   assert(Tok.is(tok::annot_pragma_weakalias));
    396   SourceLocation PragmaLoc = ConsumeToken();
    397   IdentifierInfo *WeakName = Tok.getIdentifierInfo();
    398   SourceLocation WeakNameLoc = Tok.getLocation();
    399   ConsumeToken();
    400   IdentifierInfo *AliasName = Tok.getIdentifierInfo();
    401   SourceLocation AliasNameLoc = Tok.getLocation();
    402   ConsumeToken();
    403   Actions.ActOnPragmaWeakAlias(WeakName, AliasName, PragmaLoc,
    404                                WeakNameLoc, AliasNameLoc);
    405 
    406 }
    407 
    408 void Parser::HandlePragmaRedefineExtname() {
    409   assert(Tok.is(tok::annot_pragma_redefine_extname));
    410   SourceLocation RedefLoc = ConsumeToken();
    411   IdentifierInfo *RedefName = Tok.getIdentifierInfo();
    412   SourceLocation RedefNameLoc = Tok.getLocation();
    413   ConsumeToken();
    414   IdentifierInfo *AliasName = Tok.getIdentifierInfo();
    415   SourceLocation AliasNameLoc = Tok.getLocation();
    416   ConsumeToken();
    417   Actions.ActOnPragmaRedefineExtname(RedefName, AliasName, RedefLoc,
    418                                      RedefNameLoc, AliasNameLoc);
    419 }
    420 
    421 void Parser::HandlePragmaFPContract() {
    422   assert(Tok.is(tok::annot_pragma_fp_contract));
    423   tok::OnOffSwitch OOS =
    424     static_cast<tok::OnOffSwitch>(
    425     reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
    426   Actions.ActOnPragmaFPContract(OOS);
    427   ConsumeToken(); // The annotation token.
    428 }
    429 
    430 StmtResult Parser::HandlePragmaCaptured()
    431 {
    432   assert(Tok.is(tok::annot_pragma_captured));
    433   ConsumeToken();
    434 
    435   if (Tok.isNot(tok::l_brace)) {
    436     PP.Diag(Tok, diag::err_expected) << tok::l_brace;
    437     return StmtError();
    438   }
    439 
    440   SourceLocation Loc = Tok.getLocation();
    441 
    442   ParseScope CapturedRegionScope(this, Scope::FnScope | Scope::DeclScope);
    443   Actions.ActOnCapturedRegionStart(Loc, getCurScope(), CR_Default,
    444                                    /*NumParams=*/1);
    445 
    446   StmtResult R = ParseCompoundStatement();
    447   CapturedRegionScope.Exit();
    448 
    449   if (R.isInvalid()) {
    450     Actions.ActOnCapturedRegionError();
    451     return StmtError();
    452   }
    453 
    454   return Actions.ActOnCapturedRegionEnd(R.get());
    455 }
    456 
    457 namespace {
    458   typedef llvm::PointerIntPair<IdentifierInfo *, 1, bool> OpenCLExtData;
    459 }
    460 
    461 void Parser::HandlePragmaOpenCLExtension() {
    462   assert(Tok.is(tok::annot_pragma_opencl_extension));
    463   OpenCLExtData data =
    464       OpenCLExtData::getFromOpaqueValue(Tok.getAnnotationValue());
    465   unsigned state = data.getInt();
    466   IdentifierInfo *ename = data.getPointer();
    467   SourceLocation NameLoc = Tok.getLocation();
    468   ConsumeToken(); // The annotation token.
    469 
    470   OpenCLOptions &f = Actions.getOpenCLOptions();
    471   auto CLVer = getLangOpts().OpenCLVersion;
    472   auto &Supp = getTargetInfo().getSupportedOpenCLOpts();
    473   // OpenCL 1.1 9.1: "The all variant sets the behavior for all extensions,
    474   // overriding all previously issued extension directives, but only if the
    475   // behavior is set to disable."
    476   if (state == 0 && ename->isStr("all")) {
    477 #define OPENCLEXT(nm) \
    478     if (Supp.is_##nm##_supported_extension(CLVer)) \
    479       f.nm = 0;
    480 #include "clang/Basic/OpenCLExtensions.def"
    481   }
    482 #define OPENCLEXT(nm) else if (ename->isStr(#nm)) \
    483    if (Supp.is_##nm##_supported_extension(CLVer)) \
    484      f.nm = state; \
    485    else if (Supp.is_##nm##_supported_core(CLVer)) \
    486      PP.Diag(NameLoc, diag::warn_pragma_extension_is_core) << ename; \
    487    else \
    488      PP.Diag(NameLoc, diag::warn_pragma_unsupported_extension) << ename;
    489 #include "clang/Basic/OpenCLExtensions.def"
    490   else {
    491     PP.Diag(NameLoc, diag::warn_pragma_unknown_extension) << ename;
    492     return;
    493   }
    494 }
    495 
    496 void Parser::HandlePragmaMSPointersToMembers() {
    497   assert(Tok.is(tok::annot_pragma_ms_pointers_to_members));
    498   LangOptions::PragmaMSPointersToMembersKind RepresentationMethod =
    499       static_cast<LangOptions::PragmaMSPointersToMembersKind>(
    500           reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
    501   SourceLocation PragmaLoc = ConsumeToken(); // The annotation token.
    502   Actions.ActOnPragmaMSPointersToMembers(RepresentationMethod, PragmaLoc);
    503 }
    504 
    505 void Parser::HandlePragmaMSVtorDisp() {
    506   assert(Tok.is(tok::annot_pragma_ms_vtordisp));
    507   uintptr_t Value = reinterpret_cast<uintptr_t>(Tok.getAnnotationValue());
    508   Sema::PragmaMsStackAction Action =
    509       static_cast<Sema::PragmaMsStackAction>((Value >> 16) & 0xFFFF);
    510   MSVtorDispAttr::Mode Mode = MSVtorDispAttr::Mode(Value & 0xFFFF);
    511   SourceLocation PragmaLoc = ConsumeToken(); // The annotation token.
    512   Actions.ActOnPragmaMSVtorDisp(Action, PragmaLoc, Mode);
    513 }
    514 
    515 void Parser::HandlePragmaMSPragma() {
    516   assert(Tok.is(tok::annot_pragma_ms_pragma));
    517   // Grab the tokens out of the annotation and enter them into the stream.
    518   auto TheTokens =
    519       (std::pair<std::unique_ptr<Token[]>, size_t> *)Tok.getAnnotationValue();
    520   PP.EnterTokenStream(std::move(TheTokens->first), TheTokens->second, true);
    521   SourceLocation PragmaLocation = ConsumeToken(); // The annotation token.
    522   assert(Tok.isAnyIdentifier());
    523   StringRef PragmaName = Tok.getIdentifierInfo()->getName();
    524   PP.Lex(Tok); // pragma kind
    525 
    526   // Figure out which #pragma we're dealing with.  The switch has no default
    527   // because lex shouldn't emit the annotation token for unrecognized pragmas.
    528   typedef bool (Parser::*PragmaHandler)(StringRef, SourceLocation);
    529   PragmaHandler Handler = llvm::StringSwitch<PragmaHandler>(PragmaName)
    530     .Case("data_seg", &Parser::HandlePragmaMSSegment)
    531     .Case("bss_seg", &Parser::HandlePragmaMSSegment)
    532     .Case("const_seg", &Parser::HandlePragmaMSSegment)
    533     .Case("code_seg", &Parser::HandlePragmaMSSegment)
    534     .Case("section", &Parser::HandlePragmaMSSection)
    535     .Case("init_seg", &Parser::HandlePragmaMSInitSeg);
    536 
    537   if (!(this->*Handler)(PragmaName, PragmaLocation)) {
    538     // Pragma handling failed, and has been diagnosed.  Slurp up the tokens
    539     // until eof (really end of line) to prevent follow-on errors.
    540     while (Tok.isNot(tok::eof))
    541       PP.Lex(Tok);
    542     PP.Lex(Tok);
    543   }
    544 }
    545 
    546 bool Parser::HandlePragmaMSSection(StringRef PragmaName,
    547                                    SourceLocation PragmaLocation) {
    548   if (Tok.isNot(tok::l_paren)) {
    549     PP.Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName;
    550     return false;
    551   }
    552   PP.Lex(Tok); // (
    553   // Parsing code for pragma section
    554   if (Tok.isNot(tok::string_literal)) {
    555     PP.Diag(PragmaLocation, diag::warn_pragma_expected_section_name)
    556         << PragmaName;
    557     return false;
    558   }
    559   ExprResult StringResult = ParseStringLiteralExpression();
    560   if (StringResult.isInvalid())
    561     return false; // Already diagnosed.
    562   StringLiteral *SegmentName = cast<StringLiteral>(StringResult.get());
    563   if (SegmentName->getCharByteWidth() != 1) {
    564     PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
    565         << PragmaName;
    566     return false;
    567   }
    568   int SectionFlags = ASTContext::PSF_Read;
    569   bool SectionFlagsAreDefault = true;
    570   while (Tok.is(tok::comma)) {
    571     PP.Lex(Tok); // ,
    572     // Ignore "long" and "short".
    573     // They are undocumented, but widely used, section attributes which appear
    574     // to do nothing.
    575     if (Tok.is(tok::kw_long) || Tok.is(tok::kw_short)) {
    576       PP.Lex(Tok); // long/short
    577       continue;
    578     }
    579 
    580     if (!Tok.isAnyIdentifier()) {
    581       PP.Diag(PragmaLocation, diag::warn_pragma_expected_action_or_r_paren)
    582           << PragmaName;
    583       return false;
    584     }
    585     ASTContext::PragmaSectionFlag Flag =
    586       llvm::StringSwitch<ASTContext::PragmaSectionFlag>(
    587       Tok.getIdentifierInfo()->getName())
    588       .Case("read", ASTContext::PSF_Read)
    589       .Case("write", ASTContext::PSF_Write)
    590       .Case("execute", ASTContext::PSF_Execute)
    591       .Case("shared", ASTContext::PSF_Invalid)
    592       .Case("nopage", ASTContext::PSF_Invalid)
    593       .Case("nocache", ASTContext::PSF_Invalid)
    594       .Case("discard", ASTContext::PSF_Invalid)
    595       .Case("remove", ASTContext::PSF_Invalid)
    596       .Default(ASTContext::PSF_None);
    597     if (Flag == ASTContext::PSF_None || Flag == ASTContext::PSF_Invalid) {
    598       PP.Diag(PragmaLocation, Flag == ASTContext::PSF_None
    599                                   ? diag::warn_pragma_invalid_specific_action
    600                                   : diag::warn_pragma_unsupported_action)
    601           << PragmaName << Tok.getIdentifierInfo()->getName();
    602       return false;
    603     }
    604     SectionFlags |= Flag;
    605     SectionFlagsAreDefault = false;
    606     PP.Lex(Tok); // Identifier
    607   }
    608   // If no section attributes are specified, the section will be marked as
    609   // read/write.
    610   if (SectionFlagsAreDefault)
    611     SectionFlags |= ASTContext::PSF_Write;
    612   if (Tok.isNot(tok::r_paren)) {
    613     PP.Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName;
    614     return false;
    615   }
    616   PP.Lex(Tok); // )
    617   if (Tok.isNot(tok::eof)) {
    618     PP.Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol)
    619         << PragmaName;
    620     return false;
    621   }
    622   PP.Lex(Tok); // eof
    623   Actions.ActOnPragmaMSSection(PragmaLocation, SectionFlags, SegmentName);
    624   return true;
    625 }
    626 
    627 bool Parser::HandlePragmaMSSegment(StringRef PragmaName,
    628                                    SourceLocation PragmaLocation) {
    629   if (Tok.isNot(tok::l_paren)) {
    630     PP.Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName;
    631     return false;
    632   }
    633   PP.Lex(Tok); // (
    634   Sema::PragmaMsStackAction Action = Sema::PSK_Reset;
    635   StringRef SlotLabel;
    636   if (Tok.isAnyIdentifier()) {
    637     StringRef PushPop = Tok.getIdentifierInfo()->getName();
    638     if (PushPop == "push")
    639       Action = Sema::PSK_Push;
    640     else if (PushPop == "pop")
    641       Action = Sema::PSK_Pop;
    642     else {
    643       PP.Diag(PragmaLocation,
    644               diag::warn_pragma_expected_section_push_pop_or_name)
    645           << PragmaName;
    646       return false;
    647     }
    648     if (Action != Sema::PSK_Reset) {
    649       PP.Lex(Tok); // push | pop
    650       if (Tok.is(tok::comma)) {
    651         PP.Lex(Tok); // ,
    652         // If we've got a comma, we either need a label or a string.
    653         if (Tok.isAnyIdentifier()) {
    654           SlotLabel = Tok.getIdentifierInfo()->getName();
    655           PP.Lex(Tok); // identifier
    656           if (Tok.is(tok::comma))
    657             PP.Lex(Tok);
    658           else if (Tok.isNot(tok::r_paren)) {
    659             PP.Diag(PragmaLocation, diag::warn_pragma_expected_punc)
    660                 << PragmaName;
    661             return false;
    662           }
    663         }
    664       } else if (Tok.isNot(tok::r_paren)) {
    665         PP.Diag(PragmaLocation, diag::warn_pragma_expected_punc) << PragmaName;
    666         return false;
    667       }
    668     }
    669   }
    670   // Grab the string literal for our section name.
    671   StringLiteral *SegmentName = nullptr;
    672   if (Tok.isNot(tok::r_paren)) {
    673     if (Tok.isNot(tok::string_literal)) {
    674       unsigned DiagID = Action != Sema::PSK_Reset ? !SlotLabel.empty() ?
    675           diag::warn_pragma_expected_section_name :
    676           diag::warn_pragma_expected_section_label_or_name :
    677           diag::warn_pragma_expected_section_push_pop_or_name;
    678       PP.Diag(PragmaLocation, DiagID) << PragmaName;
    679       return false;
    680     }
    681     ExprResult StringResult = ParseStringLiteralExpression();
    682     if (StringResult.isInvalid())
    683       return false; // Already diagnosed.
    684     SegmentName = cast<StringLiteral>(StringResult.get());
    685     if (SegmentName->getCharByteWidth() != 1) {
    686       PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
    687           << PragmaName;
    688       return false;
    689     }
    690     // Setting section "" has no effect
    691     if (SegmentName->getLength())
    692       Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set);
    693   }
    694   if (Tok.isNot(tok::r_paren)) {
    695     PP.Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName;
    696     return false;
    697   }
    698   PP.Lex(Tok); // )
    699   if (Tok.isNot(tok::eof)) {
    700     PP.Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol)
    701         << PragmaName;
    702     return false;
    703   }
    704   PP.Lex(Tok); // eof
    705   Actions.ActOnPragmaMSSeg(PragmaLocation, Action, SlotLabel,
    706                            SegmentName, PragmaName);
    707   return true;
    708 }
    709 
    710 // #pragma init_seg({ compiler | lib | user | "section-name" [, func-name]} )
    711 bool Parser::HandlePragmaMSInitSeg(StringRef PragmaName,
    712                                    SourceLocation PragmaLocation) {
    713   if (getTargetInfo().getTriple().getEnvironment() != llvm::Triple::MSVC) {
    714     PP.Diag(PragmaLocation, diag::warn_pragma_init_seg_unsupported_target);
    715     return false;
    716   }
    717 
    718   if (ExpectAndConsume(tok::l_paren, diag::warn_pragma_expected_lparen,
    719                        PragmaName))
    720     return false;
    721 
    722   // Parse either the known section names or the string section name.
    723   StringLiteral *SegmentName = nullptr;
    724   if (Tok.isAnyIdentifier()) {
    725     auto *II = Tok.getIdentifierInfo();
    726     StringRef Section = llvm::StringSwitch<StringRef>(II->getName())
    727                             .Case("compiler", "\".CRT$XCC\"")
    728                             .Case("lib", "\".CRT$XCL\"")
    729                             .Case("user", "\".CRT$XCU\"")
    730                             .Default("");
    731 
    732     if (!Section.empty()) {
    733       // Pretend the user wrote the appropriate string literal here.
    734       Token Toks[1];
    735       Toks[0].startToken();
    736       Toks[0].setKind(tok::string_literal);
    737       Toks[0].setLocation(Tok.getLocation());
    738       Toks[0].setLiteralData(Section.data());
    739       Toks[0].setLength(Section.size());
    740       SegmentName =
    741           cast<StringLiteral>(Actions.ActOnStringLiteral(Toks, nullptr).get());
    742       PP.Lex(Tok);
    743     }
    744   } else if (Tok.is(tok::string_literal)) {
    745     ExprResult StringResult = ParseStringLiteralExpression();
    746     if (StringResult.isInvalid())
    747       return false;
    748     SegmentName = cast<StringLiteral>(StringResult.get());
    749     if (SegmentName->getCharByteWidth() != 1) {
    750       PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
    751           << PragmaName;
    752       return false;
    753     }
    754     // FIXME: Add support for the '[, func-name]' part of the pragma.
    755   }
    756 
    757   if (!SegmentName) {
    758     PP.Diag(PragmaLocation, diag::warn_pragma_expected_init_seg) << PragmaName;
    759     return false;
    760   }
    761 
    762   if (ExpectAndConsume(tok::r_paren, diag::warn_pragma_expected_rparen,
    763                        PragmaName) ||
    764       ExpectAndConsume(tok::eof, diag::warn_pragma_extra_tokens_at_eol,
    765                        PragmaName))
    766     return false;
    767 
    768   Actions.ActOnPragmaMSInitSeg(PragmaLocation, SegmentName);
    769   return true;
    770 }
    771 
    772 namespace {
    773 struct PragmaLoopHintInfo {
    774   Token PragmaName;
    775   Token Option;
    776   ArrayRef<Token> Toks;
    777 };
    778 } // end anonymous namespace
    779 
    780 static std::string PragmaLoopHintString(Token PragmaName, Token Option) {
    781   std::string PragmaString;
    782   if (PragmaName.getIdentifierInfo()->getName() == "loop") {
    783     PragmaString = "clang loop ";
    784     PragmaString += Option.getIdentifierInfo()->getName();
    785   } else {
    786     assert(PragmaName.getIdentifierInfo()->getName() == "unroll" &&
    787            "Unexpected pragma name");
    788     PragmaString = "unroll";
    789   }
    790   return PragmaString;
    791 }
    792 
    793 bool Parser::HandlePragmaLoopHint(LoopHint &Hint) {
    794   assert(Tok.is(tok::annot_pragma_loop_hint));
    795   PragmaLoopHintInfo *Info =
    796       static_cast<PragmaLoopHintInfo *>(Tok.getAnnotationValue());
    797 
    798   IdentifierInfo *PragmaNameInfo = Info->PragmaName.getIdentifierInfo();
    799   Hint.PragmaNameLoc = IdentifierLoc::create(
    800       Actions.Context, Info->PragmaName.getLocation(), PragmaNameInfo);
    801 
    802   // It is possible that the loop hint has no option identifier, such as
    803   // #pragma unroll(4).
    804   IdentifierInfo *OptionInfo = Info->Option.is(tok::identifier)
    805                                    ? Info->Option.getIdentifierInfo()
    806                                    : nullptr;
    807   Hint.OptionLoc = IdentifierLoc::create(
    808       Actions.Context, Info->Option.getLocation(), OptionInfo);
    809 
    810   llvm::ArrayRef<Token> Toks = Info->Toks;
    811 
    812   // Return a valid hint if pragma unroll or nounroll were specified
    813   // without an argument.
    814   bool PragmaUnroll = PragmaNameInfo->getName() == "unroll";
    815   bool PragmaNoUnroll = PragmaNameInfo->getName() == "nounroll";
    816   if (Toks.empty() && (PragmaUnroll || PragmaNoUnroll)) {
    817     ConsumeToken(); // The annotation token.
    818     Hint.Range = Info->PragmaName.getLocation();
    819     return true;
    820   }
    821 
    822   // The constant expression is always followed by an eof token, which increases
    823   // the TokSize by 1.
    824   assert(!Toks.empty() &&
    825          "PragmaLoopHintInfo::Toks must contain at least one token.");
    826 
    827   // If no option is specified the argument is assumed to be a constant expr.
    828   bool OptionUnroll = false;
    829   bool OptionDistribute = false;
    830   bool StateOption = false;
    831   if (OptionInfo) { // Pragma Unroll does not specify an option.
    832     OptionUnroll = OptionInfo->isStr("unroll");
    833     OptionDistribute = OptionInfo->isStr("distribute");
    834     StateOption = llvm::StringSwitch<bool>(OptionInfo->getName())
    835                       .Case("vectorize", true)
    836                       .Case("interleave", true)
    837                       .Default(false) ||
    838                   OptionUnroll || OptionDistribute;
    839   }
    840 
    841   bool AssumeSafetyArg = !OptionUnroll && !OptionDistribute;
    842   // Verify loop hint has an argument.
    843   if (Toks[0].is(tok::eof)) {
    844     ConsumeToken(); // The annotation token.
    845     Diag(Toks[0].getLocation(), diag::err_pragma_loop_missing_argument)
    846         << /*StateArgument=*/StateOption << /*FullKeyword=*/OptionUnroll
    847         << /*AssumeSafetyKeyword=*/AssumeSafetyArg;
    848     return false;
    849   }
    850 
    851   // Validate the argument.
    852   if (StateOption) {
    853     ConsumeToken(); // The annotation token.
    854     SourceLocation StateLoc = Toks[0].getLocation();
    855     IdentifierInfo *StateInfo = Toks[0].getIdentifierInfo();
    856 
    857     bool Valid = StateInfo &&
    858                  llvm::StringSwitch<bool>(StateInfo->getName())
    859                      .Cases("enable", "disable", true)
    860                      .Case("full", OptionUnroll)
    861                      .Case("assume_safety", AssumeSafetyArg)
    862                      .Default(false);
    863     if (!Valid) {
    864       Diag(Toks[0].getLocation(), diag::err_pragma_invalid_keyword)
    865           << /*FullKeyword=*/OptionUnroll
    866           << /*AssumeSafetyKeyword=*/AssumeSafetyArg;
    867       return false;
    868     }
    869     if (Toks.size() > 2)
    870       Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
    871           << PragmaLoopHintString(Info->PragmaName, Info->Option);
    872     Hint.StateLoc = IdentifierLoc::create(Actions.Context, StateLoc, StateInfo);
    873   } else {
    874     // Enter constant expression including eof terminator into token stream.
    875     PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/false);
    876     ConsumeToken(); // The annotation token.
    877 
    878     ExprResult R = ParseConstantExpression();
    879 
    880     // Tokens following an error in an ill-formed constant expression will
    881     // remain in the token stream and must be removed.
    882     if (Tok.isNot(tok::eof)) {
    883       Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
    884           << PragmaLoopHintString(Info->PragmaName, Info->Option);
    885       while (Tok.isNot(tok::eof))
    886         ConsumeAnyToken();
    887     }
    888 
    889     ConsumeToken(); // Consume the constant expression eof terminator.
    890 
    891     if (R.isInvalid() ||
    892         Actions.CheckLoopHintExpr(R.get(), Toks[0].getLocation()))
    893       return false;
    894 
    895     // Argument is a constant expression with an integer type.
    896     Hint.ValueExpr = R.get();
    897   }
    898 
    899   Hint.Range = SourceRange(Info->PragmaName.getLocation(),
    900                            Info->Toks.back().getLocation());
    901   return true;
    902 }
    903 
    904 // #pragma GCC visibility comes in two variants:
    905 //   'push' '(' [visibility] ')'
    906 //   'pop'
    907 void PragmaGCCVisibilityHandler::HandlePragma(Preprocessor &PP,
    908                                               PragmaIntroducerKind Introducer,
    909                                               Token &VisTok) {
    910   SourceLocation VisLoc = VisTok.getLocation();
    911 
    912   Token Tok;
    913   PP.LexUnexpandedToken(Tok);
    914 
    915   const IdentifierInfo *PushPop = Tok.getIdentifierInfo();
    916 
    917   const IdentifierInfo *VisType;
    918   if (PushPop && PushPop->isStr("pop")) {
    919     VisType = nullptr;
    920   } else if (PushPop && PushPop->isStr("push")) {
    921     PP.LexUnexpandedToken(Tok);
    922     if (Tok.isNot(tok::l_paren)) {
    923       PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen)
    924         << "visibility";
    925       return;
    926     }
    927     PP.LexUnexpandedToken(Tok);
    928     VisType = Tok.getIdentifierInfo();
    929     if (!VisType) {
    930       PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
    931         << "visibility";
    932       return;
    933     }
    934     PP.LexUnexpandedToken(Tok);
    935     if (Tok.isNot(tok::r_paren)) {
    936       PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen)
    937         << "visibility";
    938       return;
    939     }
    940   } else {
    941     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
    942       << "visibility";
    943     return;
    944   }
    945   SourceLocation EndLoc = Tok.getLocation();
    946   PP.LexUnexpandedToken(Tok);
    947   if (Tok.isNot(tok::eod)) {
    948     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
    949       << "visibility";
    950     return;
    951   }
    952 
    953   auto Toks = llvm::make_unique<Token[]>(1);
    954   Toks[0].startToken();
    955   Toks[0].setKind(tok::annot_pragma_vis);
    956   Toks[0].setLocation(VisLoc);
    957   Toks[0].setAnnotationEndLoc(EndLoc);
    958   Toks[0].setAnnotationValue(
    959                           const_cast<void*>(static_cast<const void*>(VisType)));
    960   PP.EnterTokenStream(std::move(Toks), 1, /*DisableMacroExpansion=*/true);
    961 }
    962 
    963 // #pragma pack(...) comes in the following delicious flavors:
    964 //   pack '(' [integer] ')'
    965 //   pack '(' 'show' ')'
    966 //   pack '(' ('push' | 'pop') [',' identifier] [, integer] ')'
    967 void PragmaPackHandler::HandlePragma(Preprocessor &PP,
    968                                      PragmaIntroducerKind Introducer,
    969                                      Token &PackTok) {
    970   SourceLocation PackLoc = PackTok.getLocation();
    971 
    972   Token Tok;
    973   PP.Lex(Tok);
    974   if (Tok.isNot(tok::l_paren)) {
    975     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "pack";
    976     return;
    977   }
    978 
    979   Sema::PragmaMsStackAction Action = Sema::PSK_Reset;
    980   StringRef SlotLabel;
    981   Token Alignment;
    982   Alignment.startToken();
    983   PP.Lex(Tok);
    984   if (Tok.is(tok::numeric_constant)) {
    985     Alignment = Tok;
    986 
    987     PP.Lex(Tok);
    988 
    989     // In MSVC/gcc, #pragma pack(4) sets the alignment without affecting
    990     // the push/pop stack.
    991     // In Apple gcc, #pragma pack(4) is equivalent to #pragma pack(push, 4)
    992     Action =
    993         PP.getLangOpts().ApplePragmaPack ? Sema::PSK_Push_Set : Sema::PSK_Set;
    994   } else if (Tok.is(tok::identifier)) {
    995     const IdentifierInfo *II = Tok.getIdentifierInfo();
    996     if (II->isStr("show")) {
    997       Action = Sema::PSK_Show;
    998       PP.Lex(Tok);
    999     } else {
   1000       if (II->isStr("push")) {
   1001         Action = Sema::PSK_Push;
   1002       } else if (II->isStr("pop")) {
   1003         Action = Sema::PSK_Pop;
   1004       } else {
   1005         PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_action) << "pack";
   1006         return;
   1007       }
   1008       PP.Lex(Tok);
   1009 
   1010       if (Tok.is(tok::comma)) {
   1011         PP.Lex(Tok);
   1012 
   1013         if (Tok.is(tok::numeric_constant)) {
   1014           Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set);
   1015           Alignment = Tok;
   1016 
   1017           PP.Lex(Tok);
   1018         } else if (Tok.is(tok::identifier)) {
   1019           SlotLabel = Tok.getIdentifierInfo()->getName();
   1020           PP.Lex(Tok);
   1021 
   1022           if (Tok.is(tok::comma)) {
   1023             PP.Lex(Tok);
   1024 
   1025             if (Tok.isNot(tok::numeric_constant)) {
   1026               PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed);
   1027               return;
   1028             }
   1029 
   1030             Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set);
   1031             Alignment = Tok;
   1032 
   1033             PP.Lex(Tok);
   1034           }
   1035         } else {
   1036           PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed);
   1037           return;
   1038         }
   1039       }
   1040     }
   1041   } else if (PP.getLangOpts().ApplePragmaPack) {
   1042     // In MSVC/gcc, #pragma pack() resets the alignment without affecting
   1043     // the push/pop stack.
   1044     // In Apple gcc #pragma pack() is equivalent to #pragma pack(pop).
   1045     Action = Sema::PSK_Pop;
   1046   }
   1047 
   1048   if (Tok.isNot(tok::r_paren)) {
   1049     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "pack";
   1050     return;
   1051   }
   1052 
   1053   SourceLocation RParenLoc = Tok.getLocation();
   1054   PP.Lex(Tok);
   1055   if (Tok.isNot(tok::eod)) {
   1056     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "pack";
   1057     return;
   1058   }
   1059 
   1060   PragmaPackInfo *Info =
   1061       PP.getPreprocessorAllocator().Allocate<PragmaPackInfo>(1);
   1062   Info->Action = Action;
   1063   Info->SlotLabel = SlotLabel;
   1064   Info->Alignment = Alignment;
   1065 
   1066   MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
   1067                               1);
   1068   Toks[0].startToken();
   1069   Toks[0].setKind(tok::annot_pragma_pack);
   1070   Toks[0].setLocation(PackLoc);
   1071   Toks[0].setAnnotationEndLoc(RParenLoc);
   1072   Toks[0].setAnnotationValue(static_cast<void*>(Info));
   1073   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
   1074 }
   1075 
   1076 // #pragma ms_struct on
   1077 // #pragma ms_struct off
   1078 void PragmaMSStructHandler::HandlePragma(Preprocessor &PP,
   1079                                          PragmaIntroducerKind Introducer,
   1080                                          Token &MSStructTok) {
   1081   PragmaMSStructKind Kind = PMSST_OFF;
   1082 
   1083   Token Tok;
   1084   PP.Lex(Tok);
   1085   if (Tok.isNot(tok::identifier)) {
   1086     PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct);
   1087     return;
   1088   }
   1089   SourceLocation EndLoc = Tok.getLocation();
   1090   const IdentifierInfo *II = Tok.getIdentifierInfo();
   1091   if (II->isStr("on")) {
   1092     Kind = PMSST_ON;
   1093     PP.Lex(Tok);
   1094   }
   1095   else if (II->isStr("off") || II->isStr("reset"))
   1096     PP.Lex(Tok);
   1097   else {
   1098     PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct);
   1099     return;
   1100   }
   1101 
   1102   if (Tok.isNot(tok::eod)) {
   1103     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   1104       << "ms_struct";
   1105     return;
   1106   }
   1107 
   1108   MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
   1109                               1);
   1110   Toks[0].startToken();
   1111   Toks[0].setKind(tok::annot_pragma_msstruct);
   1112   Toks[0].setLocation(MSStructTok.getLocation());
   1113   Toks[0].setAnnotationEndLoc(EndLoc);
   1114   Toks[0].setAnnotationValue(reinterpret_cast<void*>(
   1115                              static_cast<uintptr_t>(Kind)));
   1116   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
   1117 }
   1118 
   1119 // #pragma 'align' '=' {'native','natural','mac68k','power','reset'}
   1120 // #pragma 'options 'align' '=' {'native','natural','mac68k','power','reset'}
   1121 static void ParseAlignPragma(Preprocessor &PP, Token &FirstTok,
   1122                              bool IsOptions) {
   1123   Token Tok;
   1124 
   1125   if (IsOptions) {
   1126     PP.Lex(Tok);
   1127     if (Tok.isNot(tok::identifier) ||
   1128         !Tok.getIdentifierInfo()->isStr("align")) {
   1129       PP.Diag(Tok.getLocation(), diag::warn_pragma_options_expected_align);
   1130       return;
   1131     }
   1132   }
   1133 
   1134   PP.Lex(Tok);
   1135   if (Tok.isNot(tok::equal)) {
   1136     PP.Diag(Tok.getLocation(), diag::warn_pragma_align_expected_equal)
   1137       << IsOptions;
   1138     return;
   1139   }
   1140 
   1141   PP.Lex(Tok);
   1142   if (Tok.isNot(tok::identifier)) {
   1143     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
   1144       << (IsOptions ? "options" : "align");
   1145     return;
   1146   }
   1147 
   1148   Sema::PragmaOptionsAlignKind Kind = Sema::POAK_Natural;
   1149   const IdentifierInfo *II = Tok.getIdentifierInfo();
   1150   if (II->isStr("native"))
   1151     Kind = Sema::POAK_Native;
   1152   else if (II->isStr("natural"))
   1153     Kind = Sema::POAK_Natural;
   1154   else if (II->isStr("packed"))
   1155     Kind = Sema::POAK_Packed;
   1156   else if (II->isStr("power"))
   1157     Kind = Sema::POAK_Power;
   1158   else if (II->isStr("mac68k"))
   1159     Kind = Sema::POAK_Mac68k;
   1160   else if (II->isStr("reset"))
   1161     Kind = Sema::POAK_Reset;
   1162   else {
   1163     PP.Diag(Tok.getLocation(), diag::warn_pragma_align_invalid_option)
   1164       << IsOptions;
   1165     return;
   1166   }
   1167 
   1168   SourceLocation EndLoc = Tok.getLocation();
   1169   PP.Lex(Tok);
   1170   if (Tok.isNot(tok::eod)) {
   1171     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   1172       << (IsOptions ? "options" : "align");
   1173     return;
   1174   }
   1175 
   1176   MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
   1177                               1);
   1178   Toks[0].startToken();
   1179   Toks[0].setKind(tok::annot_pragma_align);
   1180   Toks[0].setLocation(FirstTok.getLocation());
   1181   Toks[0].setAnnotationEndLoc(EndLoc);
   1182   Toks[0].setAnnotationValue(reinterpret_cast<void*>(
   1183                              static_cast<uintptr_t>(Kind)));
   1184   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
   1185 }
   1186 
   1187 void PragmaAlignHandler::HandlePragma(Preprocessor &PP,
   1188                                       PragmaIntroducerKind Introducer,
   1189                                       Token &AlignTok) {
   1190   ParseAlignPragma(PP, AlignTok, /*IsOptions=*/false);
   1191 }
   1192 
   1193 void PragmaOptionsHandler::HandlePragma(Preprocessor &PP,
   1194                                         PragmaIntroducerKind Introducer,
   1195                                         Token &OptionsTok) {
   1196   ParseAlignPragma(PP, OptionsTok, /*IsOptions=*/true);
   1197 }
   1198 
   1199 // #pragma unused(identifier)
   1200 void PragmaUnusedHandler::HandlePragma(Preprocessor &PP,
   1201                                        PragmaIntroducerKind Introducer,
   1202                                        Token &UnusedTok) {
   1203   // FIXME: Should we be expanding macros here? My guess is no.
   1204   SourceLocation UnusedLoc = UnusedTok.getLocation();
   1205 
   1206   // Lex the left '('.
   1207   Token Tok;
   1208   PP.Lex(Tok);
   1209   if (Tok.isNot(tok::l_paren)) {
   1210     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "unused";
   1211     return;
   1212   }
   1213 
   1214   // Lex the declaration reference(s).
   1215   SmallVector<Token, 5> Identifiers;
   1216   SourceLocation RParenLoc;
   1217   bool LexID = true;
   1218 
   1219   while (true) {
   1220     PP.Lex(Tok);
   1221 
   1222     if (LexID) {
   1223       if (Tok.is(tok::identifier)) {
   1224         Identifiers.push_back(Tok);
   1225         LexID = false;
   1226         continue;
   1227       }
   1228 
   1229       // Illegal token!
   1230       PP.Diag(Tok.getLocation(), diag::warn_pragma_unused_expected_var);
   1231       return;
   1232     }
   1233 
   1234     // We are execting a ')' or a ','.
   1235     if (Tok.is(tok::comma)) {
   1236       LexID = true;
   1237       continue;
   1238     }
   1239 
   1240     if (Tok.is(tok::r_paren)) {
   1241       RParenLoc = Tok.getLocation();
   1242       break;
   1243     }
   1244 
   1245     // Illegal token!
   1246     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_punc) << "unused";
   1247     return;
   1248   }
   1249 
   1250   PP.Lex(Tok);
   1251   if (Tok.isNot(tok::eod)) {
   1252     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
   1253         "unused";
   1254     return;
   1255   }
   1256 
   1257   // Verify that we have a location for the right parenthesis.
   1258   assert(RParenLoc.isValid() && "Valid '#pragma unused' must have ')'");
   1259   assert(!Identifiers.empty() && "Valid '#pragma unused' must have arguments");
   1260 
   1261   // For each identifier token, insert into the token stream a
   1262   // annot_pragma_unused token followed by the identifier token.
   1263   // This allows us to cache a "#pragma unused" that occurs inside an inline
   1264   // C++ member function.
   1265 
   1266   MutableArrayRef<Token> Toks(
   1267       PP.getPreprocessorAllocator().Allocate<Token>(2 * Identifiers.size()),
   1268       2 * Identifiers.size());
   1269   for (unsigned i=0; i != Identifiers.size(); i++) {
   1270     Token &pragmaUnusedTok = Toks[2*i], &idTok = Toks[2*i+1];
   1271     pragmaUnusedTok.startToken();
   1272     pragmaUnusedTok.setKind(tok::annot_pragma_unused);
   1273     pragmaUnusedTok.setLocation(UnusedLoc);
   1274     idTok = Identifiers[i];
   1275   }
   1276   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
   1277 }
   1278 
   1279 // #pragma weak identifier
   1280 // #pragma weak identifier '=' identifier
   1281 void PragmaWeakHandler::HandlePragma(Preprocessor &PP,
   1282                                      PragmaIntroducerKind Introducer,
   1283                                      Token &WeakTok) {
   1284   SourceLocation WeakLoc = WeakTok.getLocation();
   1285 
   1286   Token Tok;
   1287   PP.Lex(Tok);
   1288   if (Tok.isNot(tok::identifier)) {
   1289     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "weak";
   1290     return;
   1291   }
   1292 
   1293   Token WeakName = Tok;
   1294   bool HasAlias = false;
   1295   Token AliasName;
   1296 
   1297   PP.Lex(Tok);
   1298   if (Tok.is(tok::equal)) {
   1299     HasAlias = true;
   1300     PP.Lex(Tok);
   1301     if (Tok.isNot(tok::identifier)) {
   1302       PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
   1303           << "weak";
   1304       return;
   1305     }
   1306     AliasName = Tok;
   1307     PP.Lex(Tok);
   1308   }
   1309 
   1310   if (Tok.isNot(tok::eod)) {
   1311     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "weak";
   1312     return;
   1313   }
   1314 
   1315   if (HasAlias) {
   1316     MutableArrayRef<Token> Toks(
   1317         PP.getPreprocessorAllocator().Allocate<Token>(3), 3);
   1318     Token &pragmaUnusedTok = Toks[0];
   1319     pragmaUnusedTok.startToken();
   1320     pragmaUnusedTok.setKind(tok::annot_pragma_weakalias);
   1321     pragmaUnusedTok.setLocation(WeakLoc);
   1322     pragmaUnusedTok.setAnnotationEndLoc(AliasName.getLocation());
   1323     Toks[1] = WeakName;
   1324     Toks[2] = AliasName;
   1325     PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
   1326   } else {
   1327     MutableArrayRef<Token> Toks(
   1328         PP.getPreprocessorAllocator().Allocate<Token>(2), 2);
   1329     Token &pragmaUnusedTok = Toks[0];
   1330     pragmaUnusedTok.startToken();
   1331     pragmaUnusedTok.setKind(tok::annot_pragma_weak);
   1332     pragmaUnusedTok.setLocation(WeakLoc);
   1333     pragmaUnusedTok.setAnnotationEndLoc(WeakLoc);
   1334     Toks[1] = WeakName;
   1335     PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
   1336   }
   1337 }
   1338 
   1339 // #pragma redefine_extname identifier identifier
   1340 void PragmaRedefineExtnameHandler::HandlePragma(Preprocessor &PP,
   1341                                                PragmaIntroducerKind Introducer,
   1342                                                 Token &RedefToken) {
   1343   SourceLocation RedefLoc = RedefToken.getLocation();
   1344 
   1345   Token Tok;
   1346   PP.Lex(Tok);
   1347   if (Tok.isNot(tok::identifier)) {
   1348     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) <<
   1349       "redefine_extname";
   1350     return;
   1351   }
   1352 
   1353   Token RedefName = Tok;
   1354   PP.Lex(Tok);
   1355 
   1356   if (Tok.isNot(tok::identifier)) {
   1357     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
   1358         << "redefine_extname";
   1359     return;
   1360   }
   1361 
   1362   Token AliasName = Tok;
   1363   PP.Lex(Tok);
   1364 
   1365   if (Tok.isNot(tok::eod)) {
   1366     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
   1367       "redefine_extname";
   1368     return;
   1369   }
   1370 
   1371   MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(3),
   1372                               3);
   1373   Token &pragmaRedefTok = Toks[0];
   1374   pragmaRedefTok.startToken();
   1375   pragmaRedefTok.setKind(tok::annot_pragma_redefine_extname);
   1376   pragmaRedefTok.setLocation(RedefLoc);
   1377   pragmaRedefTok.setAnnotationEndLoc(AliasName.getLocation());
   1378   Toks[1] = RedefName;
   1379   Toks[2] = AliasName;
   1380   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
   1381 }
   1382 
   1383 
   1384 void
   1385 PragmaFPContractHandler::HandlePragma(Preprocessor &PP,
   1386                                       PragmaIntroducerKind Introducer,
   1387                                       Token &Tok) {
   1388   tok::OnOffSwitch OOS;
   1389   if (PP.LexOnOffSwitch(OOS))
   1390     return;
   1391 
   1392   MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
   1393                               1);
   1394   Toks[0].startToken();
   1395   Toks[0].setKind(tok::annot_pragma_fp_contract);
   1396   Toks[0].setLocation(Tok.getLocation());
   1397   Toks[0].setAnnotationEndLoc(Tok.getLocation());
   1398   Toks[0].setAnnotationValue(reinterpret_cast<void*>(
   1399                              static_cast<uintptr_t>(OOS)));
   1400   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
   1401 }
   1402 
   1403 void
   1404 PragmaOpenCLExtensionHandler::HandlePragma(Preprocessor &PP,
   1405                                            PragmaIntroducerKind Introducer,
   1406                                            Token &Tok) {
   1407   PP.LexUnexpandedToken(Tok);
   1408   if (Tok.isNot(tok::identifier)) {
   1409     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) <<
   1410       "OPENCL";
   1411     return;
   1412   }
   1413   IdentifierInfo *ename = Tok.getIdentifierInfo();
   1414   SourceLocation NameLoc = Tok.getLocation();
   1415 
   1416   PP.Lex(Tok);
   1417   if (Tok.isNot(tok::colon)) {
   1418     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_colon) << ename;
   1419     return;
   1420   }
   1421 
   1422   PP.Lex(Tok);
   1423   if (Tok.isNot(tok::identifier)) {
   1424     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable);
   1425     return;
   1426   }
   1427   IdentifierInfo *op = Tok.getIdentifierInfo();
   1428 
   1429   unsigned state;
   1430   if (op->isStr("enable")) {
   1431     state = 1;
   1432   } else if (op->isStr("disable")) {
   1433     state = 0;
   1434   } else {
   1435     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable);
   1436     return;
   1437   }
   1438   SourceLocation StateLoc = Tok.getLocation();
   1439 
   1440   PP.Lex(Tok);
   1441   if (Tok.isNot(tok::eod)) {
   1442     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
   1443       "OPENCL EXTENSION";
   1444     return;
   1445   }
   1446 
   1447   OpenCLExtData data(ename, state);
   1448   MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
   1449                               1);
   1450   Toks[0].startToken();
   1451   Toks[0].setKind(tok::annot_pragma_opencl_extension);
   1452   Toks[0].setLocation(NameLoc);
   1453   Toks[0].setAnnotationValue(data.getOpaqueValue());
   1454   Toks[0].setAnnotationEndLoc(StateLoc);
   1455   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
   1456 
   1457   if (PP.getPPCallbacks())
   1458     PP.getPPCallbacks()->PragmaOpenCLExtension(NameLoc, ename,
   1459                                                StateLoc, state);
   1460 }
   1461 
   1462 /// \brief Handle '#pragma omp ...' when OpenMP is disabled.
   1463 ///
   1464 void
   1465 PragmaNoOpenMPHandler::HandlePragma(Preprocessor &PP,
   1466                                     PragmaIntroducerKind Introducer,
   1467                                     Token &FirstTok) {
   1468   if (!PP.getDiagnostics().isIgnored(diag::warn_pragma_omp_ignored,
   1469                                      FirstTok.getLocation())) {
   1470     PP.Diag(FirstTok, diag::warn_pragma_omp_ignored);
   1471     PP.getDiagnostics().setSeverity(diag::warn_pragma_omp_ignored,
   1472                                     diag::Severity::Ignored, SourceLocation());
   1473   }
   1474   PP.DiscardUntilEndOfDirective();
   1475 }
   1476 
   1477 /// \brief Handle '#pragma omp ...' when OpenMP is enabled.
   1478 ///
   1479 void
   1480 PragmaOpenMPHandler::HandlePragma(Preprocessor &PP,
   1481                                   PragmaIntroducerKind Introducer,
   1482                                   Token &FirstTok) {
   1483   SmallVector<Token, 16> Pragma;
   1484   Token Tok;
   1485   Tok.startToken();
   1486   Tok.setKind(tok::annot_pragma_openmp);
   1487   Tok.setLocation(FirstTok.getLocation());
   1488 
   1489   while (Tok.isNot(tok::eod)) {
   1490     Pragma.push_back(Tok);
   1491     PP.Lex(Tok);
   1492   }
   1493   SourceLocation EodLoc = Tok.getLocation();
   1494   Tok.startToken();
   1495   Tok.setKind(tok::annot_pragma_openmp_end);
   1496   Tok.setLocation(EodLoc);
   1497   Pragma.push_back(Tok);
   1498 
   1499   auto Toks = llvm::make_unique<Token[]>(Pragma.size());
   1500   std::copy(Pragma.begin(), Pragma.end(), Toks.get());
   1501   PP.EnterTokenStream(std::move(Toks), Pragma.size(),
   1502                       /*DisableMacroExpansion=*/false);
   1503 }
   1504 
   1505 /// \brief Handle '#pragma pointers_to_members'
   1506 // The grammar for this pragma is as follows:
   1507 //
   1508 // <inheritance model> ::= ('single' | 'multiple' | 'virtual') '_inheritance'
   1509 //
   1510 // #pragma pointers_to_members '(' 'best_case' ')'
   1511 // #pragma pointers_to_members '(' 'full_generality' [',' inheritance-model] ')'
   1512 // #pragma pointers_to_members '(' inheritance-model ')'
   1513 void PragmaMSPointersToMembers::HandlePragma(Preprocessor &PP,
   1514                                              PragmaIntroducerKind Introducer,
   1515                                              Token &Tok) {
   1516   SourceLocation PointersToMembersLoc = Tok.getLocation();
   1517   PP.Lex(Tok);
   1518   if (Tok.isNot(tok::l_paren)) {
   1519     PP.Diag(PointersToMembersLoc, diag::warn_pragma_expected_lparen)
   1520       << "pointers_to_members";
   1521     return;
   1522   }
   1523   PP.Lex(Tok);
   1524   const IdentifierInfo *Arg = Tok.getIdentifierInfo();
   1525   if (!Arg) {
   1526     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
   1527       << "pointers_to_members";
   1528     return;
   1529   }
   1530   PP.Lex(Tok);
   1531 
   1532   LangOptions::PragmaMSPointersToMembersKind RepresentationMethod;
   1533   if (Arg->isStr("best_case")) {
   1534     RepresentationMethod = LangOptions::PPTMK_BestCase;
   1535   } else {
   1536     if (Arg->isStr("full_generality")) {
   1537       if (Tok.is(tok::comma)) {
   1538         PP.Lex(Tok);
   1539 
   1540         Arg = Tok.getIdentifierInfo();
   1541         if (!Arg) {
   1542           PP.Diag(Tok.getLocation(),
   1543                   diag::err_pragma_pointers_to_members_unknown_kind)
   1544               << Tok.getKind() << /*OnlyInheritanceModels*/ 0;
   1545           return;
   1546         }
   1547         PP.Lex(Tok);
   1548       } else if (Tok.is(tok::r_paren)) {
   1549         // #pragma pointers_to_members(full_generality) implicitly specifies
   1550         // virtual_inheritance.
   1551         Arg = nullptr;
   1552         RepresentationMethod = LangOptions::PPTMK_FullGeneralityVirtualInheritance;
   1553       } else {
   1554         PP.Diag(Tok.getLocation(), diag::err_expected_punc)
   1555             << "full_generality";
   1556         return;
   1557       }
   1558     }
   1559 
   1560     if (Arg) {
   1561       if (Arg->isStr("single_inheritance")) {
   1562         RepresentationMethod =
   1563             LangOptions::PPTMK_FullGeneralitySingleInheritance;
   1564       } else if (Arg->isStr("multiple_inheritance")) {
   1565         RepresentationMethod =
   1566             LangOptions::PPTMK_FullGeneralityMultipleInheritance;
   1567       } else if (Arg->isStr("virtual_inheritance")) {
   1568         RepresentationMethod =
   1569             LangOptions::PPTMK_FullGeneralityVirtualInheritance;
   1570       } else {
   1571         PP.Diag(Tok.getLocation(),
   1572                 diag::err_pragma_pointers_to_members_unknown_kind)
   1573             << Arg << /*HasPointerDeclaration*/ 1;
   1574         return;
   1575       }
   1576     }
   1577   }
   1578 
   1579   if (Tok.isNot(tok::r_paren)) {
   1580     PP.Diag(Tok.getLocation(), diag::err_expected_rparen_after)
   1581         << (Arg ? Arg->getName() : "full_generality");
   1582     return;
   1583   }
   1584 
   1585   SourceLocation EndLoc = Tok.getLocation();
   1586   PP.Lex(Tok);
   1587   if (Tok.isNot(tok::eod)) {
   1588     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   1589       << "pointers_to_members";
   1590     return;
   1591   }
   1592 
   1593   Token AnnotTok;
   1594   AnnotTok.startToken();
   1595   AnnotTok.setKind(tok::annot_pragma_ms_pointers_to_members);
   1596   AnnotTok.setLocation(PointersToMembersLoc);
   1597   AnnotTok.setAnnotationEndLoc(EndLoc);
   1598   AnnotTok.setAnnotationValue(
   1599       reinterpret_cast<void *>(static_cast<uintptr_t>(RepresentationMethod)));
   1600   PP.EnterToken(AnnotTok);
   1601 }
   1602 
   1603 /// \brief Handle '#pragma vtordisp'
   1604 // The grammar for this pragma is as follows:
   1605 //
   1606 // <vtordisp-mode> ::= ('off' | 'on' | '0' | '1' | '2' )
   1607 //
   1608 // #pragma vtordisp '(' ['push' ','] vtordisp-mode ')'
   1609 // #pragma vtordisp '(' 'pop' ')'
   1610 // #pragma vtordisp '(' ')'
   1611 void PragmaMSVtorDisp::HandlePragma(Preprocessor &PP,
   1612                                     PragmaIntroducerKind Introducer,
   1613                                     Token &Tok) {
   1614   SourceLocation VtorDispLoc = Tok.getLocation();
   1615   PP.Lex(Tok);
   1616   if (Tok.isNot(tok::l_paren)) {
   1617     PP.Diag(VtorDispLoc, diag::warn_pragma_expected_lparen) << "vtordisp";
   1618     return;
   1619   }
   1620   PP.Lex(Tok);
   1621 
   1622   Sema::PragmaMsStackAction Action = Sema::PSK_Set;
   1623   const IdentifierInfo *II = Tok.getIdentifierInfo();
   1624   if (II) {
   1625     if (II->isStr("push")) {
   1626       // #pragma vtordisp(push, mode)
   1627       PP.Lex(Tok);
   1628       if (Tok.isNot(tok::comma)) {
   1629         PP.Diag(VtorDispLoc, diag::warn_pragma_expected_punc) << "vtordisp";
   1630         return;
   1631       }
   1632       PP.Lex(Tok);
   1633       Action = Sema::PSK_Push_Set;
   1634       // not push, could be on/off
   1635     } else if (II->isStr("pop")) {
   1636       // #pragma vtordisp(pop)
   1637       PP.Lex(Tok);
   1638       Action = Sema::PSK_Pop;
   1639     }
   1640     // not push or pop, could be on/off
   1641   } else {
   1642     if (Tok.is(tok::r_paren)) {
   1643       // #pragma vtordisp()
   1644       Action = Sema::PSK_Reset;
   1645     }
   1646   }
   1647 
   1648 
   1649   uint64_t Value = 0;
   1650   if (Action & Sema::PSK_Push || Action & Sema::PSK_Set) {
   1651     const IdentifierInfo *II = Tok.getIdentifierInfo();
   1652     if (II && II->isStr("off")) {
   1653       PP.Lex(Tok);
   1654       Value = 0;
   1655     } else if (II && II->isStr("on")) {
   1656       PP.Lex(Tok);
   1657       Value = 1;
   1658     } else if (Tok.is(tok::numeric_constant) &&
   1659                PP.parseSimpleIntegerLiteral(Tok, Value)) {
   1660       if (Value > 2) {
   1661         PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_integer)
   1662             << 0 << 2 << "vtordisp";
   1663         return;
   1664       }
   1665     } else {
   1666       PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_action)
   1667           << "vtordisp";
   1668       return;
   1669     }
   1670   }
   1671 
   1672   // Finish the pragma: ')' $
   1673   if (Tok.isNot(tok::r_paren)) {
   1674     PP.Diag(VtorDispLoc, diag::warn_pragma_expected_rparen) << "vtordisp";
   1675     return;
   1676   }
   1677   SourceLocation EndLoc = Tok.getLocation();
   1678   PP.Lex(Tok);
   1679   if (Tok.isNot(tok::eod)) {
   1680     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   1681         << "vtordisp";
   1682     return;
   1683   }
   1684 
   1685   // Enter the annotation.
   1686   Token AnnotTok;
   1687   AnnotTok.startToken();
   1688   AnnotTok.setKind(tok::annot_pragma_ms_vtordisp);
   1689   AnnotTok.setLocation(VtorDispLoc);
   1690   AnnotTok.setAnnotationEndLoc(EndLoc);
   1691   AnnotTok.setAnnotationValue(reinterpret_cast<void *>(
   1692       static_cast<uintptr_t>((Action << 16) | (Value & 0xFFFF))));
   1693   PP.EnterToken(AnnotTok);
   1694 }
   1695 
   1696 /// \brief Handle all MS pragmas.  Simply forwards the tokens after inserting
   1697 /// an annotation token.
   1698 void PragmaMSPragma::HandlePragma(Preprocessor &PP,
   1699                                   PragmaIntroducerKind Introducer,
   1700                                   Token &Tok) {
   1701   Token EoF, AnnotTok;
   1702   EoF.startToken();
   1703   EoF.setKind(tok::eof);
   1704   AnnotTok.startToken();
   1705   AnnotTok.setKind(tok::annot_pragma_ms_pragma);
   1706   AnnotTok.setLocation(Tok.getLocation());
   1707   AnnotTok.setAnnotationEndLoc(Tok.getLocation());
   1708   SmallVector<Token, 8> TokenVector;
   1709   // Suck up all of the tokens before the eod.
   1710   for (; Tok.isNot(tok::eod); PP.Lex(Tok)) {
   1711     TokenVector.push_back(Tok);
   1712     AnnotTok.setAnnotationEndLoc(Tok.getLocation());
   1713   }
   1714   // Add a sentinal EoF token to the end of the list.
   1715   TokenVector.push_back(EoF);
   1716   // We must allocate this array with new because EnterTokenStream is going to
   1717   // delete it later.
   1718   auto TokenArray = llvm::make_unique<Token[]>(TokenVector.size());
   1719   std::copy(TokenVector.begin(), TokenVector.end(), TokenArray.get());
   1720   auto Value = new (PP.getPreprocessorAllocator())
   1721       std::pair<std::unique_ptr<Token[]>, size_t>(std::move(TokenArray),
   1722                                                   TokenVector.size());
   1723   AnnotTok.setAnnotationValue(Value);
   1724   PP.EnterToken(AnnotTok);
   1725 }
   1726 
   1727 /// \brief Handle the Microsoft \#pragma detect_mismatch extension.
   1728 ///
   1729 /// The syntax is:
   1730 /// \code
   1731 ///   #pragma detect_mismatch("name", "value")
   1732 /// \endcode
   1733 /// Where 'name' and 'value' are quoted strings.  The values are embedded in
   1734 /// the object file and passed along to the linker.  If the linker detects a
   1735 /// mismatch in the object file's values for the given name, a LNK2038 error
   1736 /// is emitted.  See MSDN for more details.
   1737 void PragmaDetectMismatchHandler::HandlePragma(Preprocessor &PP,
   1738                                                PragmaIntroducerKind Introducer,
   1739                                                Token &Tok) {
   1740   SourceLocation DetectMismatchLoc = Tok.getLocation();
   1741   PP.Lex(Tok);
   1742   if (Tok.isNot(tok::l_paren)) {
   1743     PP.Diag(DetectMismatchLoc, diag::err_expected) << tok::l_paren;
   1744     return;
   1745   }
   1746 
   1747   // Read the name to embed, which must be a string literal.
   1748   std::string NameString;
   1749   if (!PP.LexStringLiteral(Tok, NameString,
   1750                            "pragma detect_mismatch",
   1751                            /*MacroExpansion=*/true))
   1752     return;
   1753 
   1754   // Read the comma followed by a second string literal.
   1755   std::string ValueString;
   1756   if (Tok.isNot(tok::comma)) {
   1757     PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed);
   1758     return;
   1759   }
   1760 
   1761   if (!PP.LexStringLiteral(Tok, ValueString, "pragma detect_mismatch",
   1762                            /*MacroExpansion=*/true))
   1763     return;
   1764 
   1765   if (Tok.isNot(tok::r_paren)) {
   1766     PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
   1767     return;
   1768   }
   1769   PP.Lex(Tok);  // Eat the r_paren.
   1770 
   1771   if (Tok.isNot(tok::eod)) {
   1772     PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed);
   1773     return;
   1774   }
   1775 
   1776   // If the pragma is lexically sound, notify any interested PPCallbacks.
   1777   if (PP.getPPCallbacks())
   1778     PP.getPPCallbacks()->PragmaDetectMismatch(DetectMismatchLoc, NameString,
   1779                                               ValueString);
   1780 
   1781   Actions.ActOnPragmaDetectMismatch(DetectMismatchLoc, NameString, ValueString);
   1782 }
   1783 
   1784 /// \brief Handle the microsoft \#pragma comment extension.
   1785 ///
   1786 /// The syntax is:
   1787 /// \code
   1788 ///   #pragma comment(linker, "foo")
   1789 /// \endcode
   1790 /// 'linker' is one of five identifiers: compiler, exestr, lib, linker, user.
   1791 /// "foo" is a string, which is fully macro expanded, and permits string
   1792 /// concatenation, embedded escape characters etc.  See MSDN for more details.
   1793 void PragmaCommentHandler::HandlePragma(Preprocessor &PP,
   1794                                         PragmaIntroducerKind Introducer,
   1795                                         Token &Tok) {
   1796   SourceLocation CommentLoc = Tok.getLocation();
   1797   PP.Lex(Tok);
   1798   if (Tok.isNot(tok::l_paren)) {
   1799     PP.Diag(CommentLoc, diag::err_pragma_comment_malformed);
   1800     return;
   1801   }
   1802 
   1803   // Read the identifier.
   1804   PP.Lex(Tok);
   1805   if (Tok.isNot(tok::identifier)) {
   1806     PP.Diag(CommentLoc, diag::err_pragma_comment_malformed);
   1807     return;
   1808   }
   1809 
   1810   // Verify that this is one of the 5 whitelisted options.
   1811   IdentifierInfo *II = Tok.getIdentifierInfo();
   1812   PragmaMSCommentKind Kind =
   1813     llvm::StringSwitch<PragmaMSCommentKind>(II->getName())
   1814     .Case("linker",   PCK_Linker)
   1815     .Case("lib",      PCK_Lib)
   1816     .Case("compiler", PCK_Compiler)
   1817     .Case("exestr",   PCK_ExeStr)
   1818     .Case("user",     PCK_User)
   1819     .Default(PCK_Unknown);
   1820   if (Kind == PCK_Unknown) {
   1821     PP.Diag(Tok.getLocation(), diag::err_pragma_comment_unknown_kind);
   1822     return;
   1823   }
   1824 
   1825   // On PS4, issue a warning about any pragma comments other than
   1826   // #pragma comment lib.
   1827   if (PP.getTargetInfo().getTriple().isPS4() && Kind != PCK_Lib) {
   1828     PP.Diag(Tok.getLocation(), diag::warn_pragma_comment_ignored)
   1829       << II->getName();
   1830     return;
   1831   }
   1832 
   1833   // Read the optional string if present.
   1834   PP.Lex(Tok);
   1835   std::string ArgumentString;
   1836   if (Tok.is(tok::comma) && !PP.LexStringLiteral(Tok, ArgumentString,
   1837                                                  "pragma comment",
   1838                                                  /*MacroExpansion=*/true))
   1839     return;
   1840 
   1841   // FIXME: warn that 'exestr' is deprecated.
   1842   // FIXME: If the kind is "compiler" warn if the string is present (it is
   1843   // ignored).
   1844   // The MSDN docs say that "lib" and "linker" require a string and have a short
   1845   // whitelist of linker options they support, but in practice MSVC doesn't
   1846   // issue a diagnostic.  Therefore neither does clang.
   1847 
   1848   if (Tok.isNot(tok::r_paren)) {
   1849     PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed);
   1850     return;
   1851   }
   1852   PP.Lex(Tok);  // eat the r_paren.
   1853 
   1854   if (Tok.isNot(tok::eod)) {
   1855     PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed);
   1856     return;
   1857   }
   1858 
   1859   // If the pragma is lexically sound, notify any interested PPCallbacks.
   1860   if (PP.getPPCallbacks())
   1861     PP.getPPCallbacks()->PragmaComment(CommentLoc, II, ArgumentString);
   1862 
   1863   Actions.ActOnPragmaMSComment(CommentLoc, Kind, ArgumentString);
   1864 }
   1865 
   1866 // #pragma clang optimize off
   1867 // #pragma clang optimize on
   1868 void PragmaOptimizeHandler::HandlePragma(Preprocessor &PP,
   1869                                         PragmaIntroducerKind Introducer,
   1870                                         Token &FirstToken) {
   1871   Token Tok;
   1872   PP.Lex(Tok);
   1873   if (Tok.is(tok::eod)) {
   1874     PP.Diag(Tok.getLocation(), diag::err_pragma_missing_argument)
   1875         << "clang optimize" << /*Expected=*/true << "'on' or 'off'";
   1876     return;
   1877   }
   1878   if (Tok.isNot(tok::identifier)) {
   1879     PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_invalid_argument)
   1880       << PP.getSpelling(Tok);
   1881     return;
   1882   }
   1883   const IdentifierInfo *II = Tok.getIdentifierInfo();
   1884   // The only accepted values are 'on' or 'off'.
   1885   bool IsOn = false;
   1886   if (II->isStr("on")) {
   1887     IsOn = true;
   1888   } else if (!II->isStr("off")) {
   1889     PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_invalid_argument)
   1890       << PP.getSpelling(Tok);
   1891     return;
   1892   }
   1893   PP.Lex(Tok);
   1894 
   1895   if (Tok.isNot(tok::eod)) {
   1896     PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_extra_argument)
   1897       << PP.getSpelling(Tok);
   1898     return;
   1899   }
   1900 
   1901   Actions.ActOnPragmaOptimize(IsOn, FirstToken.getLocation());
   1902 }
   1903 
   1904 /// \brief Parses loop or unroll pragma hint value and fills in Info.
   1905 static bool ParseLoopHintValue(Preprocessor &PP, Token &Tok, Token PragmaName,
   1906                                Token Option, bool ValueInParens,
   1907                                PragmaLoopHintInfo &Info) {
   1908   SmallVector<Token, 1> ValueList;
   1909   int OpenParens = ValueInParens ? 1 : 0;
   1910   // Read constant expression.
   1911   while (Tok.isNot(tok::eod)) {
   1912     if (Tok.is(tok::l_paren))
   1913       OpenParens++;
   1914     else if (Tok.is(tok::r_paren)) {
   1915       OpenParens--;
   1916       if (OpenParens == 0 && ValueInParens)
   1917         break;
   1918     }
   1919 
   1920     ValueList.push_back(Tok);
   1921     PP.Lex(Tok);
   1922   }
   1923 
   1924   if (ValueInParens) {
   1925     // Read ')'
   1926     if (Tok.isNot(tok::r_paren)) {
   1927       PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
   1928       return true;
   1929     }
   1930     PP.Lex(Tok);
   1931   }
   1932 
   1933   Token EOFTok;
   1934   EOFTok.startToken();
   1935   EOFTok.setKind(tok::eof);
   1936   EOFTok.setLocation(Tok.getLocation());
   1937   ValueList.push_back(EOFTok); // Terminates expression for parsing.
   1938 
   1939   Info.Toks = llvm::makeArrayRef(ValueList).copy(PP.getPreprocessorAllocator());
   1940 
   1941   Info.PragmaName = PragmaName;
   1942   Info.Option = Option;
   1943   return false;
   1944 }
   1945 
   1946 /// \brief Handle the \#pragma clang loop directive.
   1947 ///  #pragma clang 'loop' loop-hints
   1948 ///
   1949 ///  loop-hints:
   1950 ///    loop-hint loop-hints[opt]
   1951 ///
   1952 ///  loop-hint:
   1953 ///    'vectorize' '(' loop-hint-keyword ')'
   1954 ///    'interleave' '(' loop-hint-keyword ')'
   1955 ///    'unroll' '(' unroll-hint-keyword ')'
   1956 ///    'vectorize_width' '(' loop-hint-value ')'
   1957 ///    'interleave_count' '(' loop-hint-value ')'
   1958 ///    'unroll_count' '(' loop-hint-value ')'
   1959 ///
   1960 ///  loop-hint-keyword:
   1961 ///    'enable'
   1962 ///    'disable'
   1963 ///    'assume_safety'
   1964 ///
   1965 ///  unroll-hint-keyword:
   1966 ///    'enable'
   1967 ///    'disable'
   1968 ///    'full'
   1969 ///
   1970 ///  loop-hint-value:
   1971 ///    constant-expression
   1972 ///
   1973 /// Specifying vectorize(enable) or vectorize_width(_value_) instructs llvm to
   1974 /// try vectorizing the instructions of the loop it precedes. Specifying
   1975 /// interleave(enable) or interleave_count(_value_) instructs llvm to try
   1976 /// interleaving multiple iterations of the loop it precedes. The width of the
   1977 /// vector instructions is specified by vectorize_width() and the number of
   1978 /// interleaved loop iterations is specified by interleave_count(). Specifying a
   1979 /// value of 1 effectively disables vectorization/interleaving, even if it is
   1980 /// possible and profitable, and 0 is invalid. The loop vectorizer currently
   1981 /// only works on inner loops.
   1982 ///
   1983 /// The unroll and unroll_count directives control the concatenation
   1984 /// unroller. Specifying unroll(enable) instructs llvm to unroll the loop
   1985 /// completely if the trip count is known at compile time and unroll partially
   1986 /// if the trip count is not known.  Specifying unroll(full) is similar to
   1987 /// unroll(enable) but will unroll the loop only if the trip count is known at
   1988 /// compile time.  Specifying unroll(disable) disables unrolling for the
   1989 /// loop. Specifying unroll_count(_value_) instructs llvm to try to unroll the
   1990 /// loop the number of times indicated by the value.
   1991 void PragmaLoopHintHandler::HandlePragma(Preprocessor &PP,
   1992                                          PragmaIntroducerKind Introducer,
   1993                                          Token &Tok) {
   1994   // Incoming token is "loop" from "#pragma clang loop".
   1995   Token PragmaName = Tok;
   1996   SmallVector<Token, 1> TokenList;
   1997 
   1998   // Lex the optimization option and verify it is an identifier.
   1999   PP.Lex(Tok);
   2000   if (Tok.isNot(tok::identifier)) {
   2001     PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option)
   2002         << /*MissingOption=*/true << "";
   2003     return;
   2004   }
   2005 
   2006   while (Tok.is(tok::identifier)) {
   2007     Token Option = Tok;
   2008     IdentifierInfo *OptionInfo = Tok.getIdentifierInfo();
   2009 
   2010     bool OptionValid = llvm::StringSwitch<bool>(OptionInfo->getName())
   2011                            .Case("vectorize", true)
   2012                            .Case("interleave", true)
   2013                            .Case("unroll", true)
   2014                            .Case("distribute", true)
   2015                            .Case("vectorize_width", true)
   2016                            .Case("interleave_count", true)
   2017                            .Case("unroll_count", true)
   2018                            .Default(false);
   2019     if (!OptionValid) {
   2020       PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option)
   2021           << /*MissingOption=*/false << OptionInfo;
   2022       return;
   2023     }
   2024     PP.Lex(Tok);
   2025 
   2026     // Read '('
   2027     if (Tok.isNot(tok::l_paren)) {
   2028       PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren;
   2029       return;
   2030     }
   2031     PP.Lex(Tok);
   2032 
   2033     auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo;
   2034     if (ParseLoopHintValue(PP, Tok, PragmaName, Option, /*ValueInParens=*/true,
   2035                            *Info))
   2036       return;
   2037 
   2038     // Generate the loop hint token.
   2039     Token LoopHintTok;
   2040     LoopHintTok.startToken();
   2041     LoopHintTok.setKind(tok::annot_pragma_loop_hint);
   2042     LoopHintTok.setLocation(PragmaName.getLocation());
   2043     LoopHintTok.setAnnotationEndLoc(PragmaName.getLocation());
   2044     LoopHintTok.setAnnotationValue(static_cast<void *>(Info));
   2045     TokenList.push_back(LoopHintTok);
   2046   }
   2047 
   2048   if (Tok.isNot(tok::eod)) {
   2049     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   2050         << "clang loop";
   2051     return;
   2052   }
   2053 
   2054   auto TokenArray = llvm::make_unique<Token[]>(TokenList.size());
   2055   std::copy(TokenList.begin(), TokenList.end(), TokenArray.get());
   2056 
   2057   PP.EnterTokenStream(std::move(TokenArray), TokenList.size(),
   2058                       /*DisableMacroExpansion=*/false);
   2059 }
   2060 
   2061 /// \brief Handle the loop unroll optimization pragmas.
   2062 ///  #pragma unroll
   2063 ///  #pragma unroll unroll-hint-value
   2064 ///  #pragma unroll '(' unroll-hint-value ')'
   2065 ///  #pragma nounroll
   2066 ///
   2067 ///  unroll-hint-value:
   2068 ///    constant-expression
   2069 ///
   2070 /// Loop unrolling hints can be specified with '#pragma unroll' or
   2071 /// '#pragma nounroll'. '#pragma unroll' can take a numeric argument optionally
   2072 /// contained in parentheses. With no argument the directive instructs llvm to
   2073 /// try to unroll the loop completely. A positive integer argument can be
   2074 /// specified to indicate the number of times the loop should be unrolled.  To
   2075 /// maximize compatibility with other compilers the unroll count argument can be
   2076 /// specified with or without parentheses.  Specifying, '#pragma nounroll'
   2077 /// disables unrolling of the loop.
   2078 void PragmaUnrollHintHandler::HandlePragma(Preprocessor &PP,
   2079                                            PragmaIntroducerKind Introducer,
   2080                                            Token &Tok) {
   2081   // Incoming token is "unroll" for "#pragma unroll", or "nounroll" for
   2082   // "#pragma nounroll".
   2083   Token PragmaName = Tok;
   2084   PP.Lex(Tok);
   2085   auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo;
   2086   if (Tok.is(tok::eod)) {
   2087     // nounroll or unroll pragma without an argument.
   2088     Info->PragmaName = PragmaName;
   2089     Info->Option.startToken();
   2090   } else if (PragmaName.getIdentifierInfo()->getName() == "nounroll") {
   2091     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   2092         << "nounroll";
   2093     return;
   2094   } else {
   2095     // Unroll pragma with an argument: "#pragma unroll N" or
   2096     // "#pragma unroll(N)".
   2097     // Read '(' if it exists.
   2098     bool ValueInParens = Tok.is(tok::l_paren);
   2099     if (ValueInParens)
   2100       PP.Lex(Tok);
   2101 
   2102     Token Option;
   2103     Option.startToken();
   2104     if (ParseLoopHintValue(PP, Tok, PragmaName, Option, ValueInParens, *Info))
   2105       return;
   2106 
   2107     // In CUDA, the argument to '#pragma unroll' should not be contained in
   2108     // parentheses.
   2109     if (PP.getLangOpts().CUDA && ValueInParens)
   2110       PP.Diag(Info->Toks[0].getLocation(),
   2111               diag::warn_pragma_unroll_cuda_value_in_parens);
   2112 
   2113     if (Tok.isNot(tok::eod)) {
   2114       PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
   2115           << "unroll";
   2116       return;
   2117     }
   2118   }
   2119 
   2120   // Generate the hint token.
   2121   auto TokenArray = llvm::make_unique<Token[]>(1);
   2122   TokenArray[0].startToken();
   2123   TokenArray[0].setKind(tok::annot_pragma_loop_hint);
   2124   TokenArray[0].setLocation(PragmaName.getLocation());
   2125   TokenArray[0].setAnnotationEndLoc(PragmaName.getLocation());
   2126   TokenArray[0].setAnnotationValue(static_cast<void *>(Info));
   2127   PP.EnterTokenStream(std::move(TokenArray), 1,
   2128                       /*DisableMacroExpansion=*/false);
   2129 }
   2130