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