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__'.
1472  Tok.getIdentifierInfo(), /*ScopeName=*/nullptr,
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;
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="" relro=""
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("relro"))
1816  SecKind = Sema::PragmaClangSectionKind::PCSK_Relro;
1817  else if (SecType->isStr("text"))
1818  SecKind = Sema::PragmaClangSectionKind::PCSK_Text;
1819  else {
1820  PP.Diag(Tok.getLocation(), diag::err_pragma_expected_clang_section_name) << "clang section";
1821  return;
1822  }
1823 
1824  PP.Lex(Tok); // eat ['bss'|'data'|'rodata'|'text']
1825  if (Tok.isNot(tok::equal)) {
1826  PP.Diag(Tok.getLocation(), diag::err_pragma_clang_section_expected_equal) << SecKind;
1827  return;
1828  }
1829 
1830  std::string SecName;
1831  if (!PP.LexStringLiteral(Tok, SecName, "pragma clang section", false))
1832  return;
1833 
1834  Actions.ActOnPragmaClangSection(Tok.getLocation(),
1835  (SecName.size()? Sema::PragmaClangSectionAction::PCSA_Set :
1836  Sema::PragmaClangSectionAction::PCSA_Clear),
1837  SecKind, SecName);
1838  }
1839 }
1840 
1841 // #pragma 'align' '=' {'native','natural','mac68k','power','reset'}
1842 // #pragma 'options 'align' '=' {'native','natural','mac68k','power','reset'}
1843 static void ParseAlignPragma(Preprocessor &PP, Token &FirstTok,
1844  bool IsOptions) {
1845  Token Tok;
1846 
1847  if (IsOptions) {
1848  PP.Lex(Tok);
1849  if (Tok.isNot(tok::identifier) ||
1850  !Tok.getIdentifierInfo()->isStr("align")) {
1851  PP.Diag(Tok.getLocation(), diag::warn_pragma_options_expected_align);
1852  return;
1853  }
1854  }
1855 
1856  PP.Lex(Tok);
1857  if (Tok.isNot(tok::equal)) {
1858  PP.Diag(Tok.getLocation(), diag::warn_pragma_align_expected_equal)
1859  << IsOptions;
1860  return;
1861  }
1862 
1863  PP.Lex(Tok);
1864  if (Tok.isNot(tok::identifier)) {
1865  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
1866  << (IsOptions ? "options" : "align");
1867  return;
1868  }
1869 
1871  const IdentifierInfo *II = Tok.getIdentifierInfo();
1872  if (II->isStr("native"))
1873  Kind = Sema::POAK_Native;
1874  else if (II->isStr("natural"))
1875  Kind = Sema::POAK_Natural;
1876  else if (II->isStr("packed"))
1877  Kind = Sema::POAK_Packed;
1878  else if (II->isStr("power"))
1879  Kind = Sema::POAK_Power;
1880  else if (II->isStr("mac68k"))
1881  Kind = Sema::POAK_Mac68k;
1882  else if (II->isStr("reset"))
1883  Kind = Sema::POAK_Reset;
1884  else {
1885  PP.Diag(Tok.getLocation(), diag::warn_pragma_align_invalid_option)
1886  << IsOptions;
1887  return;
1888  }
1889 
1890  SourceLocation EndLoc = Tok.getLocation();
1891  PP.Lex(Tok);
1892  if (Tok.isNot(tok::eod)) {
1893  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
1894  << (IsOptions ? "options" : "align");
1895  return;
1896  }
1897 
1898  MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
1899  1);
1900  Toks[0].startToken();
1901  Toks[0].setKind(tok::annot_pragma_align);
1902  Toks[0].setLocation(FirstTok.getLocation());
1903  Toks[0].setAnnotationEndLoc(EndLoc);
1904  Toks[0].setAnnotationValue(reinterpret_cast<void*>(
1905  static_cast<uintptr_t>(Kind)));
1906  PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
1907  /*IsReinject=*/false);
1908 }
1909 
1910 void PragmaAlignHandler::HandlePragma(Preprocessor &PP,
1911  PragmaIntroducer Introducer,
1912  Token &AlignTok) {
1913  ParseAlignPragma(PP, AlignTok, /*IsOptions=*/false);
1914 }
1915 
1916 void PragmaOptionsHandler::HandlePragma(Preprocessor &PP,
1917  PragmaIntroducer Introducer,
1918  Token &OptionsTok) {
1919  ParseAlignPragma(PP, OptionsTok, /*IsOptions=*/true);
1920 }
1921 
1922 // #pragma unused(identifier)
1923 void PragmaUnusedHandler::HandlePragma(Preprocessor &PP,
1924  PragmaIntroducer Introducer,
1925  Token &UnusedTok) {
1926  // FIXME: Should we be expanding macros here? My guess is no.
1927  SourceLocation UnusedLoc = UnusedTok.getLocation();
1928 
1929  // Lex the left '('.
1930  Token Tok;
1931  PP.Lex(Tok);
1932  if (Tok.isNot(tok::l_paren)) {
1933  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "unused";
1934  return;
1935  }
1936 
1937  // Lex the declaration reference(s).
1938  SmallVector<Token, 5> Identifiers;
1939  SourceLocation RParenLoc;
1940  bool LexID = true;
1941 
1942  while (true) {
1943  PP.Lex(Tok);
1944 
1945  if (LexID) {
1946  if (Tok.is(tok::identifier)) {
1947  Identifiers.push_back(Tok);
1948  LexID = false;
1949  continue;
1950  }
1951 
1952  // Illegal token!
1953  PP.Diag(Tok.getLocation(), diag::warn_pragma_unused_expected_var);
1954  return;
1955  }
1956 
1957  // We are execting a ')' or a ','.
1958  if (Tok.is(tok::comma)) {
1959  LexID = true;
1960  continue;
1961  }
1962 
1963  if (Tok.is(tok::r_paren)) {
1964  RParenLoc = Tok.getLocation();
1965  break;
1966  }
1967 
1968  // Illegal token!
1969  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_punc) << "unused";
1970  return;
1971  }
1972 
1973  PP.Lex(Tok);
1974  if (Tok.isNot(tok::eod)) {
1975  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
1976  "unused";
1977  return;
1978  }
1979 
1980  // Verify that we have a location for the right parenthesis.
1981  assert(RParenLoc.isValid() && "Valid '#pragma unused' must have ')'");
1982  assert(!Identifiers.empty() && "Valid '#pragma unused' must have arguments");
1983 
1984  // For each identifier token, insert into the token stream a
1985  // annot_pragma_unused token followed by the identifier token.
1986  // This allows us to cache a "#pragma unused" that occurs inside an inline
1987  // C++ member function.
1988 
1990  PP.getPreprocessorAllocator().Allocate<Token>(2 * Identifiers.size()),
1991  2 * Identifiers.size());
1992  for (unsigned i=0; i != Identifiers.size(); i++) {
1993  Token &pragmaUnusedTok = Toks[2*i], &idTok = Toks[2*i+1];
1994  pragmaUnusedTok.startToken();
1995  pragmaUnusedTok.setKind(tok::annot_pragma_unused);
1996  pragmaUnusedTok.setLocation(UnusedLoc);
1997  idTok = Identifiers[i];
1998  }
1999  PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
2000  /*IsReinject=*/false);
2001 }
2002 
2003 // #pragma weak identifier
2004 // #pragma weak identifier '=' identifier
2005 void PragmaWeakHandler::HandlePragma(Preprocessor &PP,
2006  PragmaIntroducer Introducer,
2007  Token &WeakTok) {
2008  SourceLocation WeakLoc = WeakTok.getLocation();
2009 
2010  Token Tok;
2011  PP.Lex(Tok);
2012  if (Tok.isNot(tok::identifier)) {
2013  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "weak";
2014  return;
2015  }
2016 
2017  Token WeakName = Tok;
2018  bool HasAlias = false;
2019  Token AliasName;
2020 
2021  PP.Lex(Tok);
2022  if (Tok.is(tok::equal)) {
2023  HasAlias = true;
2024  PP.Lex(Tok);
2025  if (Tok.isNot(tok::identifier)) {
2026  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
2027  << "weak";
2028  return;
2029  }
2030  AliasName = Tok;
2031  PP.Lex(Tok);
2032  }
2033 
2034  if (Tok.isNot(tok::eod)) {
2035  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "weak";
2036  return;
2037  }
2038 
2039  if (HasAlias) {
2041  PP.getPreprocessorAllocator().Allocate<Token>(3), 3);
2042  Token &pragmaUnusedTok = Toks[0];
2043  pragmaUnusedTok.startToken();
2044  pragmaUnusedTok.setKind(tok::annot_pragma_weakalias);
2045  pragmaUnusedTok.setLocation(WeakLoc);
2046  pragmaUnusedTok.setAnnotationEndLoc(AliasName.getLocation());
2047  Toks[1] = WeakName;
2048  Toks[2] = AliasName;
2049  PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
2050  /*IsReinject=*/false);
2051  } else {
2053  PP.getPreprocessorAllocator().Allocate<Token>(2), 2);
2054  Token &pragmaUnusedTok = Toks[0];
2055  pragmaUnusedTok.startToken();
2056  pragmaUnusedTok.setKind(tok::annot_pragma_weak);
2057  pragmaUnusedTok.setLocation(WeakLoc);
2058  pragmaUnusedTok.setAnnotationEndLoc(WeakLoc);
2059  Toks[1] = WeakName;
2060  PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
2061  /*IsReinject=*/false);
2062  }
2063 }
2064 
2065 // #pragma redefine_extname identifier identifier
2066 void PragmaRedefineExtnameHandler::HandlePragma(Preprocessor &PP,
2067  PragmaIntroducer Introducer,
2068  Token &RedefToken) {
2069  SourceLocation RedefLoc = RedefToken.getLocation();
2070 
2071  Token Tok;
2072  PP.Lex(Tok);
2073  if (Tok.isNot(tok::identifier)) {
2074  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) <<
2075  "redefine_extname";
2076  return;
2077  }
2078 
2079  Token RedefName = Tok;
2080  PP.Lex(Tok);
2081 
2082  if (Tok.isNot(tok::identifier)) {
2083  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
2084  << "redefine_extname";
2085  return;
2086  }
2087 
2088  Token AliasName = Tok;
2089  PP.Lex(Tok);
2090 
2091  if (Tok.isNot(tok::eod)) {
2092  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
2093  "redefine_extname";
2094  return;
2095  }
2096 
2097  MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(3),
2098  3);
2099  Token &pragmaRedefTok = Toks[0];
2100  pragmaRedefTok.startToken();
2101  pragmaRedefTok.setKind(tok::annot_pragma_redefine_extname);
2102  pragmaRedefTok.setLocation(RedefLoc);
2103  pragmaRedefTok.setAnnotationEndLoc(AliasName.getLocation());
2104  Toks[1] = RedefName;
2105  Toks[2] = AliasName;
2106  PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
2107  /*IsReinject=*/false);
2108 }
2109 
2110 void PragmaFPContractHandler::HandlePragma(Preprocessor &PP,
2111  PragmaIntroducer Introducer,
2112  Token &Tok) {
2113  tok::OnOffSwitch OOS;
2114  if (PP.LexOnOffSwitch(OOS))
2115  return;
2116 
2117  MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
2118  1);
2119  Toks[0].startToken();
2120  Toks[0].setKind(tok::annot_pragma_fp_contract);
2121  Toks[0].setLocation(Tok.getLocation());
2122  Toks[0].setAnnotationEndLoc(Tok.getLocation());
2123  Toks[0].setAnnotationValue(reinterpret_cast<void*>(
2124  static_cast<uintptr_t>(OOS)));
2125  PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
2126  /*IsReinject=*/false);
2127 }
2128 
2129 void PragmaOpenCLExtensionHandler::HandlePragma(Preprocessor &PP,
2130  PragmaIntroducer Introducer,
2131  Token &Tok) {
2132  PP.LexUnexpandedToken(Tok);
2133  if (Tok.isNot(tok::identifier)) {
2134  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) <<
2135  "OPENCL";
2136  return;
2137  }
2138  IdentifierInfo *Ext = Tok.getIdentifierInfo();
2139  SourceLocation NameLoc = Tok.getLocation();
2140 
2141  PP.Lex(Tok);
2142  if (Tok.isNot(tok::colon)) {
2143  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_colon) << Ext;
2144  return;
2145  }
2146 
2147  PP.Lex(Tok);
2148  if (Tok.isNot(tok::identifier)) {
2149  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_predicate) << 0;
2150  return;
2151  }
2152  IdentifierInfo *Pred = Tok.getIdentifierInfo();
2153 
2155  if (Pred->isStr("enable")) {
2156  State = Enable;
2157  } else if (Pred->isStr("disable")) {
2158  State = Disable;
2159  } else if (Pred->isStr("begin"))
2160  State = Begin;
2161  else if (Pred->isStr("end"))
2162  State = End;
2163  else {
2164  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_predicate)
2165  << Ext->isStr("all");
2166  return;
2167  }
2168  SourceLocation StateLoc = Tok.getLocation();
2169 
2170  PP.Lex(Tok);
2171  if (Tok.isNot(tok::eod)) {
2172  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
2173  "OPENCL EXTENSION";
2174  return;
2175  }
2176 
2177  auto Info = PP.getPreprocessorAllocator().Allocate<OpenCLExtData>(1);
2178  Info->first = Ext;
2179  Info->second = State;
2180  MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
2181  1);
2182  Toks[0].startToken();
2183  Toks[0].setKind(tok::annot_pragma_opencl_extension);
2184  Toks[0].setLocation(NameLoc);
2185  Toks[0].setAnnotationValue(static_cast<void*>(Info));
2186  Toks[0].setAnnotationEndLoc(StateLoc);
2187  PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
2188  /*IsReinject=*/false);
2189 
2190  if (PP.getPPCallbacks())
2191  PP.getPPCallbacks()->PragmaOpenCLExtension(NameLoc, Ext,
2192  StateLoc, State);
2193 }
2194 
2195 /// Handle '#pragma omp ...' when OpenMP is disabled.
2196 ///
2197 void PragmaNoOpenMPHandler::HandlePragma(Preprocessor &PP,
2198  PragmaIntroducer Introducer,
2199  Token &FirstTok) {
2200  if (!PP.getDiagnostics().isIgnored(diag::warn_pragma_omp_ignored,
2201  FirstTok.getLocation())) {
2202  PP.Diag(FirstTok, diag::warn_pragma_omp_ignored);
2203  PP.getDiagnostics().setSeverity(diag::warn_pragma_omp_ignored,
2205  }
2207 }
2208 
2209 /// Handle '#pragma omp ...' when OpenMP is enabled.
2210 ///
2211 void PragmaOpenMPHandler::HandlePragma(Preprocessor &PP,
2212  PragmaIntroducer Introducer,
2213  Token &FirstTok) {
2215  Token Tok;
2216  Tok.startToken();
2217  Tok.setKind(tok::annot_pragma_openmp);
2218  Tok.setLocation(Introducer.Loc);
2219 
2220  while (Tok.isNot(tok::eod) && Tok.isNot(tok::eof)) {
2221  Pragma.push_back(Tok);
2222  PP.Lex(Tok);
2223  if (Tok.is(tok::annot_pragma_openmp)) {
2224  PP.Diag(Tok, diag::err_omp_unexpected_directive) << 0;
2225  unsigned InnerPragmaCnt = 1;
2226  while (InnerPragmaCnt != 0) {
2227  PP.Lex(Tok);
2228  if (Tok.is(tok::annot_pragma_openmp))
2229  ++InnerPragmaCnt;
2230  else if (Tok.is(tok::annot_pragma_openmp_end))
2231  --InnerPragmaCnt;
2232  }
2233  PP.Lex(Tok);
2234  }
2235  }
2236  SourceLocation EodLoc = Tok.getLocation();
2237  Tok.startToken();
2238  Tok.setKind(tok::annot_pragma_openmp_end);
2239  Tok.setLocation(EodLoc);
2240  Pragma.push_back(Tok);
2241 
2242  auto Toks = std::make_unique<Token[]>(Pragma.size());
2243  std::copy(Pragma.begin(), Pragma.end(), Toks.get());
2244  PP.EnterTokenStream(std::move(Toks), Pragma.size(),
2245  /*DisableMacroExpansion=*/false, /*IsReinject=*/false);
2246 }
2247 
2248 /// Handle '#pragma pointers_to_members'
2249 // The grammar for this pragma is as follows:
2250 //
2251 // <inheritance model> ::= ('single' | 'multiple' | 'virtual') '_inheritance'
2252 //
2253 // #pragma pointers_to_members '(' 'best_case' ')'
2254 // #pragma pointers_to_members '(' 'full_generality' [',' inheritance-model] ')'
2255 // #pragma pointers_to_members '(' inheritance-model ')'
2256 void PragmaMSPointersToMembers::HandlePragma(Preprocessor &PP,
2257  PragmaIntroducer Introducer,
2258  Token &Tok) {
2259  SourceLocation PointersToMembersLoc = Tok.getLocation();
2260  PP.Lex(Tok);
2261  if (Tok.isNot(tok::l_paren)) {
2262  PP.Diag(PointersToMembersLoc, diag::warn_pragma_expected_lparen)
2263  << "pointers_to_members";
2264  return;
2265  }
2266  PP.Lex(Tok);
2267  const IdentifierInfo *Arg = Tok.getIdentifierInfo();
2268  if (!Arg) {
2269  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
2270  << "pointers_to_members";
2271  return;
2272  }
2273  PP.Lex(Tok);
2274 
2275  LangOptions::PragmaMSPointersToMembersKind RepresentationMethod;
2276  if (Arg->isStr("best_case")) {
2277  RepresentationMethod = LangOptions::PPTMK_BestCase;
2278  } else {
2279  if (Arg->isStr("full_generality")) {
2280  if (Tok.is(tok::comma)) {
2281  PP.Lex(Tok);
2282 
2283  Arg = Tok.getIdentifierInfo();
2284  if (!Arg) {
2285  PP.Diag(Tok.getLocation(),
2286  diag::err_pragma_pointers_to_members_unknown_kind)
2287  << Tok.getKind() << /*OnlyInheritanceModels*/ 0;
2288  return;
2289  }
2290  PP.Lex(Tok);
2291  } else if (Tok.is(tok::r_paren)) {
2292  // #pragma pointers_to_members(full_generality) implicitly specifies
2293  // virtual_inheritance.
2294  Arg = nullptr;
2296  } else {
2297  PP.Diag(Tok.getLocation(), diag::err_expected_punc)
2298  << "full_generality";
2299  return;
2300  }
2301  }
2302 
2303  if (Arg) {
2304  if (Arg->isStr("single_inheritance")) {
2305  RepresentationMethod =
2307  } else if (Arg->isStr("multiple_inheritance")) {
2308  RepresentationMethod =
2310  } else if (Arg->isStr("virtual_inheritance")) {
2311  RepresentationMethod =
2313  } else {
2314  PP.Diag(Tok.getLocation(),
2315  diag::err_pragma_pointers_to_members_unknown_kind)
2316  << Arg << /*HasPointerDeclaration*/ 1;
2317  return;
2318  }
2319  }
2320  }
2321 
2322  if (Tok.isNot(tok::r_paren)) {
2323  PP.Diag(Tok.getLocation(), diag::err_expected_rparen_after)
2324  << (Arg ? Arg->getName() : "full_generality");
2325  return;
2326  }
2327 
2328  SourceLocation EndLoc = Tok.getLocation();
2329  PP.Lex(Tok);
2330  if (Tok.isNot(tok::eod)) {
2331  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
2332  << "pointers_to_members";
2333  return;
2334  }
2335 
2336  Token AnnotTok;
2337  AnnotTok.startToken();
2338  AnnotTok.setKind(tok::annot_pragma_ms_pointers_to_members);
2339  AnnotTok.setLocation(PointersToMembersLoc);
2340  AnnotTok.setAnnotationEndLoc(EndLoc);
2341  AnnotTok.setAnnotationValue(
2342  reinterpret_cast<void *>(static_cast<uintptr_t>(RepresentationMethod)));
2343  PP.EnterToken(AnnotTok, /*IsReinject=*/true);
2344 }
2345 
2346 /// Handle '#pragma vtordisp'
2347 // The grammar for this pragma is as follows:
2348 //
2349 // <vtordisp-mode> ::= ('off' | 'on' | '0' | '1' | '2' )
2350 //
2351 // #pragma vtordisp '(' ['push' ','] vtordisp-mode ')'
2352 // #pragma vtordisp '(' 'pop' ')'
2353 // #pragma vtordisp '(' ')'
2354 void PragmaMSVtorDisp::HandlePragma(Preprocessor &PP,
2355  PragmaIntroducer Introducer, Token &Tok) {
2356  SourceLocation VtorDispLoc = Tok.getLocation();
2357  PP.Lex(Tok);
2358  if (Tok.isNot(tok::l_paren)) {
2359  PP.Diag(VtorDispLoc, diag::warn_pragma_expected_lparen) << "vtordisp";
2360  return;
2361  }
2362  PP.Lex(Tok);
2363 
2365  const IdentifierInfo *II = Tok.getIdentifierInfo();
2366  if (II) {
2367  if (II->isStr("push")) {
2368  // #pragma vtordisp(push, mode)
2369  PP.Lex(Tok);
2370  if (Tok.isNot(tok::comma)) {
2371  PP.Diag(VtorDispLoc, diag::warn_pragma_expected_punc) << "vtordisp";
2372  return;
2373  }
2374  PP.Lex(Tok);
2375  Action = Sema::PSK_Push_Set;
2376  // not push, could be on/off
2377  } else if (II->isStr("pop")) {
2378  // #pragma vtordisp(pop)
2379  PP.Lex(Tok);
2380  Action = Sema::PSK_Pop;
2381  }
2382  // not push or pop, could be on/off
2383  } else {
2384  if (Tok.is(tok::r_paren)) {
2385  // #pragma vtordisp()
2386  Action = Sema::PSK_Reset;
2387  }
2388  }
2389 
2390 
2391  uint64_t Value = 0;
2392  if (Action & Sema::PSK_Push || Action & Sema::PSK_Set) {
2393  const IdentifierInfo *II = Tok.getIdentifierInfo();
2394  if (II && II->isStr("off")) {
2395  PP.Lex(Tok);
2396  Value = 0;
2397  } else if (II && II->isStr("on")) {
2398  PP.Lex(Tok);
2399  Value = 1;
2400  } else if (Tok.is(tok::numeric_constant) &&
2401  PP.parseSimpleIntegerLiteral(Tok, Value)) {
2402  if (Value > 2) {
2403  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_integer)
2404  << 0 << 2 << "vtordisp";
2405  return;
2406  }
2407  } else {
2408  PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_action)
2409  << "vtordisp";
2410  return;
2411  }
2412  }
2413 
2414  // Finish the pragma: ')' $
2415  if (Tok.isNot(tok::r_paren)) {
2416  PP.Diag(VtorDispLoc, diag::warn_pragma_expected_rparen) << "vtordisp";
2417  return;
2418  }
2419  SourceLocation EndLoc = Tok.getLocation();
2420  PP.Lex(Tok);
2421  if (Tok.isNot(tok::eod)) {
2422  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
2423  << "vtordisp";
2424  return;
2425  }
2426 
2427  // Enter the annotation.
2428  Token AnnotTok;
2429  AnnotTok.startToken();
2430  AnnotTok.setKind(tok::annot_pragma_ms_vtordisp);
2431  AnnotTok.setLocation(VtorDispLoc);
2432  AnnotTok.setAnnotationEndLoc(EndLoc);
2433  AnnotTok.setAnnotationValue(reinterpret_cast<void *>(
2434  static_cast<uintptr_t>((Action << 16) | (Value & 0xFFFF))));
2435  PP.EnterToken(AnnotTok, /*IsReinject=*/false);
2436 }
2437 
2438 /// Handle all MS pragmas. Simply forwards the tokens after inserting
2439 /// an annotation token.
2440 void PragmaMSPragma::HandlePragma(Preprocessor &PP,
2441  PragmaIntroducer Introducer, Token &Tok) {
2442  Token EoF, AnnotTok;
2443  EoF.startToken();
2444  EoF.setKind(tok::eof);
2445  AnnotTok.startToken();
2446  AnnotTok.setKind(tok::annot_pragma_ms_pragma);
2447  AnnotTok.setLocation(Tok.getLocation());
2448  AnnotTok.setAnnotationEndLoc(Tok.getLocation());
2449  SmallVector<Token, 8> TokenVector;
2450  // Suck up all of the tokens before the eod.
2451  for (; Tok.isNot(tok::eod); PP.Lex(Tok)) {
2452  TokenVector.push_back(Tok);
2453  AnnotTok.setAnnotationEndLoc(Tok.getLocation());
2454  }
2455  // Add a sentinel EoF token to the end of the list.
2456  TokenVector.push_back(EoF);
2457  // We must allocate this array with new because EnterTokenStream is going to
2458  // delete it later.
2459  auto TokenArray = std::make_unique<Token[]>(TokenVector.size());
2460  std::copy(TokenVector.begin(), TokenVector.end(), TokenArray.get());
2461  auto Value = new (PP.getPreprocessorAllocator())
2462  std::pair<std::unique_ptr<Token[]>, size_t>(std::move(TokenArray),
2463  TokenVector.size());
2464  AnnotTok.setAnnotationValue(Value);
2465  PP.EnterToken(AnnotTok, /*IsReinject*/ false);
2466 }
2467 
2468 /// Handle the Microsoft \#pragma detect_mismatch extension.
2469 ///
2470 /// The syntax is:
2471 /// \code
2472 /// #pragma detect_mismatch("name", "value")
2473 /// \endcode
2474 /// Where 'name' and 'value' are quoted strings. The values are embedded in
2475 /// the object file and passed along to the linker. If the linker detects a
2476 /// mismatch in the object file's values for the given name, a LNK2038 error
2477 /// is emitted. See MSDN for more details.
2478 void PragmaDetectMismatchHandler::HandlePragma(Preprocessor &PP,
2479  PragmaIntroducer Introducer,
2480  Token &Tok) {
2481  SourceLocation DetectMismatchLoc = Tok.getLocation();
2482  PP.Lex(Tok);
2483  if (Tok.isNot(tok::l_paren)) {
2484  PP.Diag(DetectMismatchLoc, diag::err_expected) << tok::l_paren;
2485  return;
2486  }
2487 
2488  // Read the name to embed, which must be a string literal.
2489  std::string NameString;
2490  if (!PP.LexStringLiteral(Tok, NameString,
2491  "pragma detect_mismatch",
2492  /*AllowMacroExpansion=*/true))
2493  return;
2494 
2495  // Read the comma followed by a second string literal.
2496  std::string ValueString;
2497  if (Tok.isNot(tok::comma)) {
2498  PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed);
2499  return;
2500  }
2501 
2502  if (!PP.LexStringLiteral(Tok, ValueString, "pragma detect_mismatch",
2503  /*AllowMacroExpansion=*/true))
2504  return;
2505 
2506  if (Tok.isNot(tok::r_paren)) {
2507  PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
2508  return;
2509  }
2510  PP.Lex(Tok); // Eat the r_paren.
2511 
2512  if (Tok.isNot(tok::eod)) {
2513  PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed);
2514  return;
2515  }
2516 
2517  // If the pragma is lexically sound, notify any interested PPCallbacks.
2518  if (PP.getPPCallbacks())
2519  PP.getPPCallbacks()->PragmaDetectMismatch(DetectMismatchLoc, NameString,
2520  ValueString);
2521 
2522  Actions.ActOnPragmaDetectMismatch(DetectMismatchLoc, NameString, ValueString);
2523 }
2524 
2525 /// Handle the microsoft \#pragma comment extension.
2526 ///
2527 /// The syntax is:
2528 /// \code
2529 /// #pragma comment(linker, "foo")
2530 /// \endcode
2531 /// 'linker' is one of five identifiers: compiler, exestr, lib, linker, user.
2532 /// "foo" is a string, which is fully macro expanded, and permits string
2533 /// concatenation, embedded escape characters etc. See MSDN for more details.
2534 void PragmaCommentHandler::HandlePragma(Preprocessor &PP,
2535  PragmaIntroducer Introducer,
2536  Token &Tok) {
2537  SourceLocation CommentLoc = Tok.getLocation();
2538  PP.Lex(Tok);
2539  if (Tok.isNot(tok::l_paren)) {
2540  PP.Diag(CommentLoc, diag::err_pragma_comment_malformed);
2541  return;
2542  }
2543 
2544  // Read the identifier.
2545  PP.Lex(Tok);
2546  if (Tok.isNot(tok::identifier)) {
2547  PP.Diag(CommentLoc, diag::err_pragma_comment_malformed);
2548  return;
2549  }
2550 
2551  // Verify that this is one of the 5 whitelisted options.
2552  IdentifierInfo *II = Tok.getIdentifierInfo();
2553  PragmaMSCommentKind Kind =
2554  llvm::StringSwitch<PragmaMSCommentKind>(II->getName())
2555  .Case("linker", PCK_Linker)
2556  .Case("lib", PCK_Lib)
2557  .Case("compiler", PCK_Compiler)
2558  .Case("exestr", PCK_ExeStr)
2559  .Case("user", PCK_User)
2560  .Default(PCK_Unknown);
2561  if (Kind == PCK_Unknown) {
2562  PP.Diag(Tok.getLocation(), diag::err_pragma_comment_unknown_kind);
2563  return;
2564  }
2565 
2566  if (PP.getTargetInfo().getTriple().isOSBinFormatELF() && Kind != PCK_Lib) {
2567  PP.Diag(Tok.getLocation(), diag::warn_pragma_comment_ignored)
2568  << II->getName();
2569  return;
2570  }
2571 
2572  // On PS4, issue a warning about any pragma comments other than
2573  // #pragma comment lib.
2574  if (PP.getTargetInfo().getTriple().isPS4() && Kind != PCK_Lib) {
2575  PP.Diag(Tok.getLocation(), diag::warn_pragma_comment_ignored)
2576  << II->getName();
2577  return;
2578  }
2579 
2580  // Read the optional string if present.
2581  PP.Lex(Tok);
2582  std::string ArgumentString;
2583  if (Tok.is(tok::comma) && !PP.LexStringLiteral(Tok, ArgumentString,
2584  "pragma comment",
2585  /*AllowMacroExpansion=*/true))
2586  return;
2587 
2588  // FIXME: warn that 'exestr' is deprecated.
2589  // FIXME: If the kind is "compiler" warn if the string is present (it is
2590  // ignored).
2591  // The MSDN docs say that "lib" and "linker" require a string and have a short
2592  // whitelist of linker options they support, but in practice MSVC doesn't
2593  // issue a diagnostic. Therefore neither does clang.
2594 
2595  if (Tok.isNot(tok::r_paren)) {
2596  PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed);
2597  return;
2598  }
2599  PP.Lex(Tok); // eat the r_paren.
2600 
2601  if (Tok.isNot(tok::eod)) {
2602  PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed);
2603  return;
2604  }
2605 
2606  // If the pragma is lexically sound, notify any interested PPCallbacks.
2607  if (PP.getPPCallbacks())
2608  PP.getPPCallbacks()->PragmaComment(CommentLoc, II, ArgumentString);
2609 
2610  Actions.ActOnPragmaMSComment(CommentLoc, Kind, ArgumentString);
2611 }
2612 
2613 // #pragma clang optimize off
2614 // #pragma clang optimize on
2615 void PragmaOptimizeHandler::HandlePragma(Preprocessor &PP,
2616  PragmaIntroducer Introducer,
2617  Token &FirstToken) {
2618  Token Tok;
2619  PP.Lex(Tok);
2620  if (Tok.is(tok::eod)) {
2621  PP.Diag(Tok.getLocation(), diag::err_pragma_missing_argument)
2622  << "clang optimize" << /*Expected=*/true << "'on' or 'off'";
2623  return;
2624  }
2625  if (Tok.isNot(tok::identifier)) {
2626  PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_invalid_argument)
2627  << PP.getSpelling(Tok);
2628  return;
2629  }
2630  const IdentifierInfo *II = Tok.getIdentifierInfo();
2631  // The only accepted values are 'on' or 'off'.
2632  bool IsOn = false;
2633  if (II->isStr("on")) {
2634  IsOn = true;
2635  } else if (!II->isStr("off")) {
2636  PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_invalid_argument)
2637  << PP.getSpelling(Tok);
2638  return;
2639  }
2640  PP.Lex(Tok);
2641 
2642  if (Tok.isNot(tok::eod)) {
2643  PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_extra_argument)
2644  << PP.getSpelling(Tok);
2645  return;
2646  }
2647 
2648  Actions.ActOnPragmaOptimize(IsOn, FirstToken.getLocation());
2649 }
2650 
2651 namespace {
2652 /// Used as the annotation value for tok::annot_pragma_fp.
2653 struct TokFPAnnotValue {
2654  enum FlagKinds { Contract };
2655  enum FlagValues { On, Off, Fast };
2656 
2657  FlagKinds FlagKind;
2658  FlagValues FlagValue;
2659 };
2660 } // end anonymous namespace
2661 
2662 void PragmaFPHandler::HandlePragma(Preprocessor &PP,
2663  PragmaIntroducer Introducer, Token &Tok) {
2664  // fp
2665  Token PragmaName = Tok;
2666  SmallVector<Token, 1> TokenList;
2667 
2668  PP.Lex(Tok);
2669  if (Tok.isNot(tok::identifier)) {
2670  PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_option)
2671  << /*MissingOption=*/true << "";
2672  return;
2673  }
2674 
2675  while (Tok.is(tok::identifier)) {
2676  IdentifierInfo *OptionInfo = Tok.getIdentifierInfo();
2677 
2678  auto FlagKind =
2679  llvm::StringSwitch<llvm::Optional<TokFPAnnotValue::FlagKinds>>(
2680  OptionInfo->getName())
2681  .Case("contract", TokFPAnnotValue::Contract)
2682  .Default(None);
2683  if (!FlagKind) {
2684  PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_option)
2685  << /*MissingOption=*/false << OptionInfo;
2686  return;
2687  }
2688  PP.Lex(Tok);
2689 
2690  // Read '('
2691  if (Tok.isNot(tok::l_paren)) {
2692  PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren;
2693  return;
2694  }
2695  PP.Lex(Tok);
2696 
2697  if (Tok.isNot(tok::identifier)) {
2698  PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument)
2699  << PP.getSpelling(Tok) << OptionInfo->getName();
2700  return;
2701  }
2702  const IdentifierInfo *II = Tok.getIdentifierInfo();
2703 
2704  auto FlagValue =
2705  llvm::StringSwitch<llvm::Optional<TokFPAnnotValue::FlagValues>>(
2706  II->getName())
2707  .Case("on", TokFPAnnotValue::On)
2708  .Case("off", TokFPAnnotValue::Off)
2709  .Case("fast", TokFPAnnotValue::Fast)
2710  .Default(llvm::None);
2711 
2712  if (!FlagValue) {
2713  PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument)
2714  << PP.getSpelling(Tok) << OptionInfo->getName();
2715  return;
2716  }
2717  PP.Lex(Tok);
2718 
2719  // Read ')'
2720  if (Tok.isNot(tok::r_paren)) {
2721  PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
2722  return;
2723  }
2724  PP.Lex(Tok);
2725 
2726  auto *AnnotValue = new (PP.getPreprocessorAllocator())
2727  TokFPAnnotValue{*FlagKind, *FlagValue};
2728  // Generate the loop hint token.
2729  Token FPTok;
2730  FPTok.startToken();
2731  FPTok.setKind(tok::annot_pragma_fp);
2732  FPTok.setLocation(PragmaName.getLocation());
2733  FPTok.setAnnotationEndLoc(PragmaName.getLocation());
2734  FPTok.setAnnotationValue(reinterpret_cast<void *>(AnnotValue));
2735  TokenList.push_back(FPTok);
2736  }
2737 
2738  if (Tok.isNot(tok::eod)) {
2739  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
2740  << "clang fp";
2741  return;
2742  }
2743 
2744  auto TokenArray = std::make_unique<Token[]>(TokenList.size());
2745  std::copy(TokenList.begin(), TokenList.end(), TokenArray.get());
2746 
2747  PP.EnterTokenStream(std::move(TokenArray), TokenList.size(),
2748  /*DisableMacroExpansion=*/false, /*IsReinject=*/false);
2749 }
2750 
2751 void Parser::HandlePragmaFP() {
2752  assert(Tok.is(tok::annot_pragma_fp));
2753  auto *AnnotValue =
2754  reinterpret_cast<TokFPAnnotValue *>(Tok.getAnnotationValue());
2755 
2757  switch (AnnotValue->FlagValue) {
2758  case TokFPAnnotValue::On:
2759  FPC = LangOptions::FPC_On;
2760  break;
2761  case TokFPAnnotValue::Fast:
2762  FPC = LangOptions::FPC_Fast;
2763  break;
2764  case TokFPAnnotValue::Off:
2765  FPC = LangOptions::FPC_Off;
2766  break;
2767  }
2768 
2769  Actions.ActOnPragmaFPContract(FPC);
2770  ConsumeAnnotationToken();
2771 }
2772 
2773 /// Parses loop or unroll pragma hint value and fills in Info.
2774 static bool ParseLoopHintValue(Preprocessor &PP, Token &Tok, Token PragmaName,
2775  Token Option, bool ValueInParens,
2776  PragmaLoopHintInfo &Info) {
2778  int OpenParens = ValueInParens ? 1 : 0;
2779  // Read constant expression.
2780  while (Tok.isNot(tok::eod)) {
2781  if (Tok.is(tok::l_paren))
2782  OpenParens++;
2783  else if (Tok.is(tok::r_paren)) {
2784  OpenParens--;
2785  if (OpenParens == 0 && ValueInParens)
2786  break;
2787  }
2788 
2789  ValueList.push_back(Tok);
2790  PP.Lex(Tok);
2791  }
2792 
2793  if (ValueInParens) {
2794  // Read ')'
2795  if (Tok.isNot(tok::r_paren)) {
2796  PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
2797  return true;
2798  }
2799  PP.Lex(Tok);
2800  }
2801 
2802  Token EOFTok;
2803  EOFTok.startToken();
2804  EOFTok.setKind(tok::eof);
2805  EOFTok.setLocation(Tok.getLocation());
2806  ValueList.push_back(EOFTok); // Terminates expression for parsing.
2807 
2808  Info.Toks = llvm::makeArrayRef(ValueList).copy(PP.getPreprocessorAllocator());
2809 
2810  Info.PragmaName = PragmaName;
2811  Info.Option = Option;
2812  return false;
2813 }
2814 
2815 /// Handle the \#pragma clang loop directive.
2816 /// #pragma clang 'loop' loop-hints
2817 ///
2818 /// loop-hints:
2819 /// loop-hint loop-hints[opt]
2820 ///
2821 /// loop-hint:
2822 /// 'vectorize' '(' loop-hint-keyword ')'
2823 /// 'interleave' '(' loop-hint-keyword ')'
2824 /// 'unroll' '(' unroll-hint-keyword ')'
2825 /// 'vectorize_predicate' '(' loop-hint-keyword ')'
2826 /// 'vectorize_width' '(' loop-hint-value ')'
2827 /// 'interleave_count' '(' loop-hint-value ')'
2828 /// 'unroll_count' '(' loop-hint-value ')'
2829 /// 'pipeline' '(' disable ')'
2830 /// 'pipeline_initiation_interval' '(' loop-hint-value ')'
2831 ///
2832 /// loop-hint-keyword:
2833 /// 'enable'
2834 /// 'disable'
2835 /// 'assume_safety'
2836 ///
2837 /// unroll-hint-keyword:
2838 /// 'enable'
2839 /// 'disable'
2840 /// 'full'
2841 ///
2842 /// loop-hint-value:
2843 /// constant-expression
2844 ///
2845 /// Specifying vectorize(enable) or vectorize_width(_value_) instructs llvm to
2846 /// try vectorizing the instructions of the loop it precedes. Specifying
2847 /// interleave(enable) or interleave_count(_value_) instructs llvm to try
2848 /// interleaving multiple iterations of the loop it precedes. The width of the
2849 /// vector instructions is specified by vectorize_width() and the number of
2850 /// interleaved loop iterations is specified by interleave_count(). Specifying a
2851 /// value of 1 effectively disables vectorization/interleaving, even if it is
2852 /// possible and profitable, and 0 is invalid. The loop vectorizer currently
2853 /// only works on inner loops.
2854 ///
2855 /// The unroll and unroll_count directives control the concatenation
2856 /// unroller. Specifying unroll(enable) instructs llvm to unroll the loop
2857 /// completely if the trip count is known at compile time and unroll partially
2858 /// if the trip count is not known. Specifying unroll(full) is similar to
2859 /// unroll(enable) but will unroll the loop only if the trip count is known at
2860 /// compile time. Specifying unroll(disable) disables unrolling for the
2861 /// loop. Specifying unroll_count(_value_) instructs llvm to try to unroll the
2862 /// loop the number of times indicated by the value.
2863 void PragmaLoopHintHandler::HandlePragma(Preprocessor &PP,
2864  PragmaIntroducer Introducer,
2865  Token &Tok) {
2866  // Incoming token is "loop" from "#pragma clang loop".
2867  Token PragmaName = Tok;
2868  SmallVector<Token, 1> TokenList;
2869 
2870  // Lex the optimization option and verify it is an identifier.
2871  PP.Lex(Tok);
2872  if (Tok.isNot(tok::identifier)) {
2873  PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option)
2874  << /*MissingOption=*/true << "";
2875  return;
2876  }
2877 
2878  while (Tok.is(tok::identifier)) {
2879  Token Option = Tok;
2880  IdentifierInfo *OptionInfo = Tok.getIdentifierInfo();
2881 
2882  bool OptionValid = llvm::StringSwitch<bool>(OptionInfo->getName())
2883  .Case("vectorize", true)
2884  .Case("interleave", true)
2885  .Case("unroll", true)
2886  .Case("distribute", true)
2887  .Case("vectorize_predicate", true)
2888  .Case("vectorize_width", true)
2889  .Case("interleave_count", true)
2890  .Case("unroll_count", true)
2891  .Case("pipeline", true)
2892  .Case("pipeline_initiation_interval", true)
2893  .Default(false);
2894  if (!OptionValid) {
2895  PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option)
2896  << /*MissingOption=*/false << OptionInfo;
2897  return;
2898  }
2899  PP.Lex(Tok);
2900 
2901  // Read '('
2902  if (Tok.isNot(tok::l_paren)) {
2903  PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren;
2904  return;
2905  }
2906  PP.Lex(Tok);
2907 
2908  auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo;
2909  if (ParseLoopHintValue(PP, Tok, PragmaName, Option, /*ValueInParens=*/true,
2910  *Info))
2911  return;
2912 
2913  // Generate the loop hint token.
2914  Token LoopHintTok;
2915  LoopHintTok.startToken();
2916  LoopHintTok.setKind(tok::annot_pragma_loop_hint);
2917  LoopHintTok.setLocation(PragmaName.getLocation());
2918  LoopHintTok.setAnnotationEndLoc(PragmaName.getLocation());
2919  LoopHintTok.setAnnotationValue(static_cast<void *>(Info));
2920  TokenList.push_back(LoopHintTok);
2921  }
2922 
2923  if (Tok.isNot(tok::eod)) {
2924  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
2925  << "clang loop";
2926  return;
2927  }
2928 
2929  auto TokenArray = std::make_unique<Token[]>(TokenList.size());
2930  std::copy(TokenList.begin(), TokenList.end(), TokenArray.get());
2931 
2932  PP.EnterTokenStream(std::move(TokenArray), TokenList.size(),
2933  /*DisableMacroExpansion=*/false, /*IsReinject=*/false);
2934 }
2935 
2936 /// Handle the loop unroll optimization pragmas.
2937 /// #pragma unroll
2938 /// #pragma unroll unroll-hint-value
2939 /// #pragma unroll '(' unroll-hint-value ')'
2940 /// #pragma nounroll
2941 /// #pragma unroll_and_jam
2942 /// #pragma unroll_and_jam unroll-hint-value
2943 /// #pragma unroll_and_jam '(' unroll-hint-value ')'
2944 /// #pragma nounroll_and_jam
2945 ///
2946 /// unroll-hint-value:
2947 /// constant-expression
2948 ///
2949 /// Loop unrolling hints can be specified with '#pragma unroll' or
2950 /// '#pragma nounroll'. '#pragma unroll' can take a numeric argument optionally
2951 /// contained in parentheses. With no argument the directive instructs llvm to
2952 /// try to unroll the loop completely. A positive integer argument can be
2953 /// specified to indicate the number of times the loop should be unrolled. To
2954 /// maximize compatibility with other compilers the unroll count argument can be
2955 /// specified with or without parentheses. Specifying, '#pragma nounroll'
2956 /// disables unrolling of the loop.
2957 void PragmaUnrollHintHandler::HandlePragma(Preprocessor &PP,
2958  PragmaIntroducer Introducer,
2959  Token &Tok) {
2960  // Incoming token is "unroll" for "#pragma unroll", or "nounroll" for
2961  // "#pragma nounroll".
2962  Token PragmaName = Tok;
2963  PP.Lex(Tok);
2964  auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo;
2965  if (Tok.is(tok::eod)) {
2966  // nounroll or unroll pragma without an argument.
2967  Info->PragmaName = PragmaName;
2968  Info->Option.startToken();
2969  } else if (PragmaName.getIdentifierInfo()->getName() == "nounroll" ||
2970  PragmaName.getIdentifierInfo()->getName() == "nounroll_and_jam") {
2971  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
2972  << PragmaName.getIdentifierInfo()->getName();
2973  return;
2974  } else {
2975  // Unroll pragma with an argument: "#pragma unroll N" or
2976  // "#pragma unroll(N)".
2977  // Read '(' if it exists.
2978  bool ValueInParens = Tok.is(tok::l_paren);
2979  if (ValueInParens)
2980  PP.Lex(Tok);
2981 
2982  Token Option;
2983  Option.startToken();
2984  if (ParseLoopHintValue(PP, Tok, PragmaName, Option, ValueInParens, *Info))
2985  return;
2986 
2987  // In CUDA, the argument to '#pragma unroll' should not be contained in
2988  // parentheses.
2989  if (PP.getLangOpts().CUDA && ValueInParens)
2990  PP.Diag(Info->Toks[0].getLocation(),
2991  diag::warn_pragma_unroll_cuda_value_in_parens);
2992 
2993  if (Tok.isNot(tok::eod)) {
2994  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
2995  << "unroll";
2996  return;
2997  }
2998  }
2999 
3000  // Generate the hint token.
3001  auto TokenArray = std::make_unique<Token[]>(1);
3002  TokenArray[0].startToken();
3003  TokenArray[0].setKind(tok::annot_pragma_loop_hint);
3004  TokenArray[0].setLocation(PragmaName.getLocation());
3005  TokenArray[0].setAnnotationEndLoc(PragmaName.getLocation());
3006  TokenArray[0].setAnnotationValue(static_cast<void *>(Info));
3007  PP.EnterTokenStream(std::move(TokenArray), 1,
3008  /*DisableMacroExpansion=*/false, /*IsReinject=*/false);
3009 }
3010 
3011 /// Handle the Microsoft \#pragma intrinsic extension.
3012 ///
3013 /// The syntax is:
3014 /// \code
3015 /// #pragma intrinsic(memset)
3016 /// #pragma intrinsic(strlen, memcpy)
3017 /// \endcode
3018 ///
3019 /// Pragma intrisic tells the compiler to use a builtin version of the
3020 /// function. Clang does it anyway, so the pragma doesn't really do anything.
3021 /// Anyway, we emit a warning if the function specified in \#pragma intrinsic
3022 /// isn't an intrinsic in clang and suggest to include intrin.h.
3023 void PragmaMSIntrinsicHandler::HandlePragma(Preprocessor &PP,
3024  PragmaIntroducer Introducer,
3025  Token &Tok) {
3026  PP.Lex(Tok);
3027 
3028  if (Tok.isNot(tok::l_paren)) {
3029  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen)
3030  << "intrinsic";
3031  return;
3032  }
3033  PP.Lex(Tok);
3034 
3035  bool SuggestIntrinH = !PP.isMacroDefined("__INTRIN_H");
3036 
3037  while (Tok.is(tok::identifier)) {
3038  IdentifierInfo *II = Tok.getIdentifierInfo();
3039  if (!II->getBuiltinID())
3040  PP.Diag(Tok.getLocation(), diag::warn_pragma_intrinsic_builtin)
3041  << II << SuggestIntrinH;
3042 
3043  PP.Lex(Tok);
3044  if (Tok.isNot(tok::comma))
3045  break;
3046  PP.Lex(Tok);
3047  }
3048 
3049  if (Tok.isNot(tok::r_paren)) {
3050  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen)
3051  << "intrinsic";
3052  return;
3053  }
3054  PP.Lex(Tok);
3055 
3056  if (Tok.isNot(tok::eod))
3057  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
3058  << "intrinsic";
3059 }
3060 
3061 // #pragma optimize("gsty", on|off)
3062 void PragmaMSOptimizeHandler::HandlePragma(Preprocessor &PP,
3063  PragmaIntroducer Introducer,
3064  Token &Tok) {
3065  SourceLocation StartLoc = Tok.getLocation();
3066  PP.Lex(Tok);
3067 
3068  if (Tok.isNot(tok::l_paren)) {
3069  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "optimize";
3070  return;
3071  }
3072  PP.Lex(Tok);
3073 
3074  if (Tok.isNot(tok::string_literal)) {
3075  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_string) << "optimize";
3076  return;
3077  }
3078  // We could syntax check the string but it's probably not worth the effort.
3079  PP.Lex(Tok);
3080 
3081  if (Tok.isNot(tok::comma)) {
3082  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_comma) << "optimize";
3083  return;
3084  }
3085  PP.Lex(Tok);
3086 
3087  if (Tok.is(tok::eod) || Tok.is(tok::r_paren)) {
3088  PP.Diag(Tok.getLocation(), diag::warn_pragma_missing_argument)
3089  << "optimize" << /*Expected=*/true << "'on' or 'off'";
3090  return;
3091  }
3092  IdentifierInfo *II = Tok.getIdentifierInfo();
3093  if (!II || (!II->isStr("on") && !II->isStr("off"))) {
3094  PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_argument)
3095  << PP.getSpelling(Tok) << "optimize" << /*Expected=*/true
3096  << "'on' or 'off'";
3097  return;
3098  }
3099  PP.Lex(Tok);
3100 
3101  if (Tok.isNot(tok::r_paren)) {
3102  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "optimize";
3103  return;
3104  }
3105  PP.Lex(Tok);
3106 
3107  if (Tok.isNot(tok::eod)) {
3108  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
3109  << "optimize";
3110  return;
3111  }
3112  PP.Diag(StartLoc, diag::warn_pragma_optimize);
3113 }
3114 
3115 void PragmaForceCUDAHostDeviceHandler::HandlePragma(
3116  Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {
3117  Token FirstTok = Tok;
3118 
3119  PP.Lex(Tok);
3120  IdentifierInfo *Info = Tok.getIdentifierInfo();
3121  if (!Info || (!Info->isStr("begin") && !Info->isStr("end"))) {
3122  PP.Diag(FirstTok.getLocation(),
3123  diag::warn_pragma_force_cuda_host_device_bad_arg);
3124  return;
3125  }
3126 
3127  if (Info->isStr("begin"))
3128  Actions.PushForceCUDAHostDevice();
3129  else if (!Actions.PopForceCUDAHostDevice())
3130  PP.Diag(FirstTok.getLocation(),
3131  diag::err_pragma_cannot_end_force_cuda_host_device);
3132 
3133  PP.Lex(Tok);
3134  if (!Tok.is(tok::eod))
3135  PP.Diag(FirstTok.getLocation(),
3136  diag::warn_pragma_force_cuda_host_device_bad_arg);
3137 }
3138 
3139 /// Handle the #pragma clang attribute directive.
3140 ///
3141 /// The syntax is:
3142 /// \code
3143 /// #pragma clang attribute push (attribute, subject-set)
3144 /// #pragma clang attribute push
3145 /// #pragma clang attribute (attribute, subject-set)
3146 /// #pragma clang attribute pop
3147 /// \endcode
3148 ///
3149 /// There are also 'namespace' variants of push and pop directives. The bare
3150 /// '#pragma clang attribute (attribute, subject-set)' version doesn't require a
3151 /// namespace, since it always applies attributes to the most recently pushed
3152 /// group, regardless of namespace.
3153 /// \code
3154 /// #pragma clang attribute namespace.push (attribute, subject-set)
3155 /// #pragma clang attribute namespace.push
3156 /// #pragma clang attribute namespace.pop
3157 /// \endcode
3158 ///
3159 /// The subject-set clause defines the set of declarations which receive the
3160 /// attribute. Its exact syntax is described in the LanguageExtensions document
3161 /// in Clang's documentation.
3162 ///
3163 /// This directive instructs the compiler to begin/finish applying the specified
3164 /// attribute to the set of attribute-specific declarations in the active range
3165 /// of the pragma.
3166 void PragmaAttributeHandler::HandlePragma(Preprocessor &PP,
3167  PragmaIntroducer Introducer,
3168  Token &FirstToken) {
3169  Token Tok;
3170  PP.Lex(Tok);
3171  auto *Info = new (PP.getPreprocessorAllocator())
3172  PragmaAttributeInfo(AttributesForPragmaAttribute);
3173 
3174  // Parse the optional namespace followed by a period.
3175  if (Tok.is(tok::identifier)) {
3176  IdentifierInfo *II = Tok.getIdentifierInfo();
3177  if (!II->isStr("push") && !II->isStr("pop")) {
3178  Info->Namespace = II;
3179  PP.Lex(Tok);
3180 
3181  if (!Tok.is(tok::period)) {
3182  PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_expected_period)
3183  << II;
3184  return;
3185  }
3186  PP.Lex(Tok);
3187  }
3188  }
3189 
3190  if (!Tok.isOneOf(tok::identifier, tok::l_paren)) {
3191  PP.Diag(Tok.getLocation(),
3192  diag::err_pragma_attribute_expected_push_pop_paren);
3193  return;
3194  }
3195 
3196  // Determine what action this pragma clang attribute represents.
3197  if (Tok.is(tok::l_paren)) {
3198  if (Info->Namespace) {
3199  PP.Diag(Tok.getLocation(),
3200  diag::err_pragma_attribute_namespace_on_attribute);
3201  PP.Diag(Tok.getLocation(),
3202  diag::note_pragma_attribute_namespace_on_attribute);
3203  return;
3204  }
3205  Info->Action = PragmaAttributeInfo::Attribute;
3206  } else {
3207  const IdentifierInfo *II = Tok.getIdentifierInfo();
3208  if (II->isStr("push"))
3209  Info->Action = PragmaAttributeInfo::Push;
3210  else if (II->isStr("pop"))
3211  Info->Action = PragmaAttributeInfo::Pop;
3212  else {
3213  PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_invalid_argument)
3214  << PP.getSpelling(Tok);
3215  return;
3216  }
3217 
3218  PP.Lex(Tok);
3219  }
3220 
3221  // Parse the actual attribute.
3222  if ((Info->Action == PragmaAttributeInfo::Push && Tok.isNot(tok::eod)) ||
3223  Info->Action == PragmaAttributeInfo::Attribute) {
3224  if (Tok.isNot(tok::l_paren)) {
3225  PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren;
3226  return;
3227  }
3228  PP.Lex(Tok);
3229 
3230  // Lex the attribute tokens.
3231  SmallVector<Token, 16> AttributeTokens;
3232  int OpenParens = 1;
3233  while (Tok.isNot(tok::eod)) {
3234  if (Tok.is(tok::l_paren))
3235  OpenParens++;
3236  else if (Tok.is(tok::r_paren)) {
3237  OpenParens--;
3238  if (OpenParens == 0)
3239  break;
3240  }
3241 
3242  AttributeTokens.push_back(Tok);
3243  PP.Lex(Tok);
3244  }
3245 
3246  if (AttributeTokens.empty()) {
3247  PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_expected_attribute);
3248  return;
3249  }
3250  if (Tok.isNot(tok::r_paren)) {
3251  PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
3252  return;
3253  }
3254  SourceLocation EndLoc = Tok.getLocation();
3255  PP.Lex(Tok);
3256 
3257  // Terminate the attribute for parsing.
3258  Token EOFTok;
3259  EOFTok.startToken();
3260  EOFTok.setKind(tok::eof);
3261  EOFTok.setLocation(EndLoc);
3262  AttributeTokens.push_back(EOFTok);
3263 
3264  Info->Tokens =
3265  llvm::makeArrayRef(AttributeTokens).copy(PP.getPreprocessorAllocator());
3266  }
3267 
3268  if (Tok.isNot(tok::eod))
3269  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
3270  << "clang attribute";
3271 
3272  // Generate the annotated pragma token.
3273  auto TokenArray = std::make_unique<Token[]>(1);
3274  TokenArray[0].startToken();
3275  TokenArray[0].setKind(tok::annot_pragma_attribute);
3276  TokenArray[0].setLocation(FirstToken.getLocation());
3277  TokenArray[0].setAnnotationEndLoc(FirstToken.getLocation());
3278  TokenArray[0].setAnnotationValue(static_cast<void *>(Info));
3279  PP.EnterTokenStream(std::move(TokenArray), 1,
3280  /*DisableMacroExpansion=*/false, /*IsReinject=*/false);
3281 }
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:915
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
SourceLocation getEndOfPreviousToken()
Definition: Parser.h:494
SizeType size() const
Definition: ParsedAttr.h:734
void AddPragmaHandler(StringRef Namespace, PragmaHandler *Handler)
Add the specified pragma handler to this preprocessor.
Definition: Pragma.cpp:889
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:245
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:991
bool Pop(InterpState &S, CodePtr OpPC)
Definition: Interp.h:287
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:8839
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
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
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:1104
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:151
const TargetInfo & getTargetInfo() const
Definition: Preprocessor.h:905
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:1799
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:904
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:1798
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
RangeSelector name(std::string ID)
Given a node with a "name", (like NamedDecl, DeclRefExpr or CxxCtorInitializer) selects the name&#39;s to...
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:331
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:1043
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
__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:920
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:995
virtual void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind, StringRef Str)
Callback invoked when a #pragma comment directive is read.
Definition: PPCallbacks.h:190
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:28
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:117
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:850
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:2456
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:196
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
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:448
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:942
void setEnd(SourceLocation e)
A factory, from which one makes pools, from which one creates individual attributes which are dealloc...
Definition: ParsedAttr.h:546
DiagnosticsEngine & getDiagnostics() const
Definition: Preprocessor.h:901
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:1317
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1686
Defines the clang::TargetInfo interface.
bool isSupportedByPragmaAttribute() const
Definition: ParsedAttr.cpp:176
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:819
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:824
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:125
Stop skipping at specified token, but don&#39;t skip the token itself.
Definition: Parser.h:1086
SourceLocation getEndLoc() const
Definition: Token.h:153