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