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