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