1 //===--- ParsePragma.cpp - Language specific pragma parsing ---------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the language specific #pragma handlers.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "ParsePragma.h"
15 #include "clang/Lex/Preprocessor.h"
16 #include "clang/Parse/ParseDiagnostic.h"
17 #include "clang/Parse/Parser.h"
18 #include "clang/Sema/Scope.h"
19 #include "llvm/ADT/StringSwitch.h"
20 using namespace clang;
21
22 /// \brief Handle the annotation token produced for #pragma unused(...)
23 ///
24 /// Each annot_pragma_unused is followed by the argument token so e.g.
25 /// "#pragma unused(x,y)" becomes:
26 /// annot_pragma_unused 'x' annot_pragma_unused 'y'
HandlePragmaUnused()27 void Parser::HandlePragmaUnused() {
28 assert(Tok.is(tok::annot_pragma_unused));
29 SourceLocation UnusedLoc = ConsumeToken();
30 Actions.ActOnPragmaUnused(Tok, getCurScope(), UnusedLoc);
31 ConsumeToken(); // The argument token.
32 }
33
HandlePragmaVisibility()34 void Parser::HandlePragmaVisibility() {
35 assert(Tok.is(tok::annot_pragma_vis));
36 const IdentifierInfo *VisType =
37 static_cast<IdentifierInfo *>(Tok.getAnnotationValue());
38 SourceLocation VisLoc = ConsumeToken();
39 Actions.ActOnPragmaVisibility(VisType, VisLoc);
40 }
41
42 struct PragmaPackInfo {
43 Sema::PragmaPackKind Kind;
44 IdentifierInfo *Name;
45 Token Alignment;
46 SourceLocation LParenLoc;
47 SourceLocation RParenLoc;
48 };
49
HandlePragmaPack()50 void Parser::HandlePragmaPack() {
51 assert(Tok.is(tok::annot_pragma_pack));
52 PragmaPackInfo *Info =
53 static_cast<PragmaPackInfo *>(Tok.getAnnotationValue());
54 SourceLocation PragmaLoc = ConsumeToken();
55 ExprResult Alignment;
56 if (Info->Alignment.is(tok::numeric_constant)) {
57 Alignment = Actions.ActOnNumericConstant(Info->Alignment);
58 if (Alignment.isInvalid())
59 return;
60 }
61 Actions.ActOnPragmaPack(Info->Kind, Info->Name, Alignment.get(), PragmaLoc,
62 Info->LParenLoc, Info->RParenLoc);
63 }
64
HandlePragmaMSStruct()65 void Parser::HandlePragmaMSStruct() {
66 assert(Tok.is(tok::annot_pragma_msstruct));
67 Sema::PragmaMSStructKind Kind =
68 static_cast<Sema::PragmaMSStructKind>(
69 reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
70 Actions.ActOnPragmaMSStruct(Kind);
71 ConsumeToken(); // The annotation token.
72 }
73
HandlePragmaAlign()74 void Parser::HandlePragmaAlign() {
75 assert(Tok.is(tok::annot_pragma_align));
76 Sema::PragmaOptionsAlignKind Kind =
77 static_cast<Sema::PragmaOptionsAlignKind>(
78 reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
79 SourceLocation PragmaLoc = ConsumeToken();
80 Actions.ActOnPragmaOptionsAlign(Kind, PragmaLoc);
81 }
82
HandlePragmaWeak()83 void Parser::HandlePragmaWeak() {
84 assert(Tok.is(tok::annot_pragma_weak));
85 SourceLocation PragmaLoc = ConsumeToken();
86 Actions.ActOnPragmaWeakID(Tok.getIdentifierInfo(), PragmaLoc,
87 Tok.getLocation());
88 ConsumeToken(); // The weak name.
89 }
90
HandlePragmaWeakAlias()91 void Parser::HandlePragmaWeakAlias() {
92 assert(Tok.is(tok::annot_pragma_weakalias));
93 SourceLocation PragmaLoc = ConsumeToken();
94 IdentifierInfo *WeakName = Tok.getIdentifierInfo();
95 SourceLocation WeakNameLoc = Tok.getLocation();
96 ConsumeToken();
97 IdentifierInfo *AliasName = Tok.getIdentifierInfo();
98 SourceLocation AliasNameLoc = Tok.getLocation();
99 ConsumeToken();
100 Actions.ActOnPragmaWeakAlias(WeakName, AliasName, PragmaLoc,
101 WeakNameLoc, AliasNameLoc);
102
103 }
104
HandlePragmaRedefineExtname()105 void Parser::HandlePragmaRedefineExtname() {
106 assert(Tok.is(tok::annot_pragma_redefine_extname));
107 SourceLocation RedefLoc = ConsumeToken();
108 IdentifierInfo *RedefName = Tok.getIdentifierInfo();
109 SourceLocation RedefNameLoc = Tok.getLocation();
110 ConsumeToken();
111 IdentifierInfo *AliasName = Tok.getIdentifierInfo();
112 SourceLocation AliasNameLoc = Tok.getLocation();
113 ConsumeToken();
114 Actions.ActOnPragmaRedefineExtname(RedefName, AliasName, RedefLoc,
115 RedefNameLoc, AliasNameLoc);
116 }
117
HandlePragmaFPContract()118 void Parser::HandlePragmaFPContract() {
119 assert(Tok.is(tok::annot_pragma_fp_contract));
120 tok::OnOffSwitch OOS =
121 static_cast<tok::OnOffSwitch>(
122 reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
123 Actions.ActOnPragmaFPContract(OOS);
124 ConsumeToken(); // The annotation token.
125 }
126
HandlePragmaCaptured()127 StmtResult Parser::HandlePragmaCaptured()
128 {
129 assert(Tok.is(tok::annot_pragma_captured));
130 ConsumeToken();
131
132 if (Tok.isNot(tok::l_brace)) {
133 PP.Diag(Tok, diag::err_expected_lbrace);
134 return StmtError();
135 }
136
137 SourceLocation Loc = Tok.getLocation();
138
139 ParseScope CapturedRegionScope(this, Scope::FnScope | Scope::DeclScope);
140 Actions.ActOnCapturedRegionStart(Loc, getCurScope(), CR_Default,
141 /*NumParams=*/1);
142
143 StmtResult R = ParseCompoundStatement();
144 CapturedRegionScope.Exit();
145
146 if (R.isInvalid()) {
147 Actions.ActOnCapturedRegionError();
148 return StmtError();
149 }
150
151 return Actions.ActOnCapturedRegionEnd(R.get());
152 }
153
154 namespace {
155 typedef llvm::PointerIntPair<IdentifierInfo *, 1, bool> OpenCLExtData;
156 }
157
HandlePragmaOpenCLExtension()158 void Parser::HandlePragmaOpenCLExtension() {
159 assert(Tok.is(tok::annot_pragma_opencl_extension));
160 OpenCLExtData data =
161 OpenCLExtData::getFromOpaqueValue(Tok.getAnnotationValue());
162 unsigned state = data.getInt();
163 IdentifierInfo *ename = data.getPointer();
164 SourceLocation NameLoc = Tok.getLocation();
165 ConsumeToken(); // The annotation token.
166
167 OpenCLOptions &f = Actions.getOpenCLOptions();
168 // OpenCL 1.1 9.1: "The all variant sets the behavior for all extensions,
169 // overriding all previously issued extension directives, but only if the
170 // behavior is set to disable."
171 if (state == 0 && ename->isStr("all")) {
172 #define OPENCLEXT(nm) f.nm = 0;
173 #include "clang/Basic/OpenCLExtensions.def"
174 }
175 #define OPENCLEXT(nm) else if (ename->isStr(#nm)) { f.nm = state; }
176 #include "clang/Basic/OpenCLExtensions.def"
177 else {
178 PP.Diag(NameLoc, diag::warn_pragma_unknown_extension) << ename;
179 return;
180 }
181 }
182
183
184
185 // #pragma GCC visibility comes in two variants:
186 // 'push' '(' [visibility] ')'
187 // 'pop'
HandlePragma(Preprocessor & PP,PragmaIntroducerKind Introducer,Token & VisTok)188 void PragmaGCCVisibilityHandler::HandlePragma(Preprocessor &PP,
189 PragmaIntroducerKind Introducer,
190 Token &VisTok) {
191 SourceLocation VisLoc = VisTok.getLocation();
192
193 Token Tok;
194 PP.LexUnexpandedToken(Tok);
195
196 const IdentifierInfo *PushPop = Tok.getIdentifierInfo();
197
198 const IdentifierInfo *VisType;
199 if (PushPop && PushPop->isStr("pop")) {
200 VisType = 0;
201 } else if (PushPop && PushPop->isStr("push")) {
202 PP.LexUnexpandedToken(Tok);
203 if (Tok.isNot(tok::l_paren)) {
204 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen)
205 << "visibility";
206 return;
207 }
208 PP.LexUnexpandedToken(Tok);
209 VisType = Tok.getIdentifierInfo();
210 if (!VisType) {
211 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
212 << "visibility";
213 return;
214 }
215 PP.LexUnexpandedToken(Tok);
216 if (Tok.isNot(tok::r_paren)) {
217 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen)
218 << "visibility";
219 return;
220 }
221 } else {
222 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
223 << "visibility";
224 return;
225 }
226 PP.LexUnexpandedToken(Tok);
227 if (Tok.isNot(tok::eod)) {
228 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
229 << "visibility";
230 return;
231 }
232
233 Token *Toks = new Token[1];
234 Toks[0].startToken();
235 Toks[0].setKind(tok::annot_pragma_vis);
236 Toks[0].setLocation(VisLoc);
237 Toks[0].setAnnotationValue(
238 const_cast<void*>(static_cast<const void*>(VisType)));
239 PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true,
240 /*OwnsTokens=*/true);
241 }
242
243 // #pragma pack(...) comes in the following delicious flavors:
244 // pack '(' [integer] ')'
245 // pack '(' 'show' ')'
246 // pack '(' ('push' | 'pop') [',' identifier] [, integer] ')'
HandlePragma(Preprocessor & PP,PragmaIntroducerKind Introducer,Token & PackTok)247 void PragmaPackHandler::HandlePragma(Preprocessor &PP,
248 PragmaIntroducerKind Introducer,
249 Token &PackTok) {
250 SourceLocation PackLoc = PackTok.getLocation();
251
252 Token Tok;
253 PP.Lex(Tok);
254 if (Tok.isNot(tok::l_paren)) {
255 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "pack";
256 return;
257 }
258
259 Sema::PragmaPackKind Kind = Sema::PPK_Default;
260 IdentifierInfo *Name = 0;
261 Token Alignment;
262 Alignment.startToken();
263 SourceLocation LParenLoc = Tok.getLocation();
264 PP.Lex(Tok);
265 if (Tok.is(tok::numeric_constant)) {
266 Alignment = Tok;
267
268 PP.Lex(Tok);
269
270 // In MSVC/gcc, #pragma pack(4) sets the alignment without affecting
271 // the push/pop stack.
272 // In Apple gcc, #pragma pack(4) is equivalent to #pragma pack(push, 4)
273 if (PP.getLangOpts().ApplePragmaPack)
274 Kind = Sema::PPK_Push;
275 } else if (Tok.is(tok::identifier)) {
276 const IdentifierInfo *II = Tok.getIdentifierInfo();
277 if (II->isStr("show")) {
278 Kind = Sema::PPK_Show;
279 PP.Lex(Tok);
280 } else {
281 if (II->isStr("push")) {
282 Kind = Sema::PPK_Push;
283 } else if (II->isStr("pop")) {
284 Kind = Sema::PPK_Pop;
285 } else {
286 PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_invalid_action);
287 return;
288 }
289 PP.Lex(Tok);
290
291 if (Tok.is(tok::comma)) {
292 PP.Lex(Tok);
293
294 if (Tok.is(tok::numeric_constant)) {
295 Alignment = Tok;
296
297 PP.Lex(Tok);
298 } else if (Tok.is(tok::identifier)) {
299 Name = Tok.getIdentifierInfo();
300 PP.Lex(Tok);
301
302 if (Tok.is(tok::comma)) {
303 PP.Lex(Tok);
304
305 if (Tok.isNot(tok::numeric_constant)) {
306 PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed);
307 return;
308 }
309
310 Alignment = Tok;
311
312 PP.Lex(Tok);
313 }
314 } else {
315 PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed);
316 return;
317 }
318 }
319 }
320 } else if (PP.getLangOpts().ApplePragmaPack) {
321 // In MSVC/gcc, #pragma pack() resets the alignment without affecting
322 // the push/pop stack.
323 // In Apple gcc #pragma pack() is equivalent to #pragma pack(pop).
324 Kind = Sema::PPK_Pop;
325 }
326
327 if (Tok.isNot(tok::r_paren)) {
328 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "pack";
329 return;
330 }
331
332 SourceLocation RParenLoc = Tok.getLocation();
333 PP.Lex(Tok);
334 if (Tok.isNot(tok::eod)) {
335 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "pack";
336 return;
337 }
338
339 PragmaPackInfo *Info =
340 (PragmaPackInfo*) PP.getPreprocessorAllocator().Allocate(
341 sizeof(PragmaPackInfo), llvm::alignOf<PragmaPackInfo>());
342 new (Info) PragmaPackInfo();
343 Info->Kind = Kind;
344 Info->Name = Name;
345 Info->Alignment = Alignment;
346 Info->LParenLoc = LParenLoc;
347 Info->RParenLoc = RParenLoc;
348
349 Token *Toks =
350 (Token*) PP.getPreprocessorAllocator().Allocate(
351 sizeof(Token) * 1, llvm::alignOf<Token>());
352 new (Toks) Token();
353 Toks[0].startToken();
354 Toks[0].setKind(tok::annot_pragma_pack);
355 Toks[0].setLocation(PackLoc);
356 Toks[0].setAnnotationValue(static_cast<void*>(Info));
357 PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true,
358 /*OwnsTokens=*/false);
359 }
360
361 // #pragma ms_struct on
362 // #pragma ms_struct off
HandlePragma(Preprocessor & PP,PragmaIntroducerKind Introducer,Token & MSStructTok)363 void PragmaMSStructHandler::HandlePragma(Preprocessor &PP,
364 PragmaIntroducerKind Introducer,
365 Token &MSStructTok) {
366 Sema::PragmaMSStructKind Kind = Sema::PMSST_OFF;
367
368 Token Tok;
369 PP.Lex(Tok);
370 if (Tok.isNot(tok::identifier)) {
371 PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct);
372 return;
373 }
374 const IdentifierInfo *II = Tok.getIdentifierInfo();
375 if (II->isStr("on")) {
376 Kind = Sema::PMSST_ON;
377 PP.Lex(Tok);
378 }
379 else if (II->isStr("off") || II->isStr("reset"))
380 PP.Lex(Tok);
381 else {
382 PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct);
383 return;
384 }
385
386 if (Tok.isNot(tok::eod)) {
387 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
388 << "ms_struct";
389 return;
390 }
391
392 Token *Toks =
393 (Token*) PP.getPreprocessorAllocator().Allocate(
394 sizeof(Token) * 1, llvm::alignOf<Token>());
395 new (Toks) Token();
396 Toks[0].startToken();
397 Toks[0].setKind(tok::annot_pragma_msstruct);
398 Toks[0].setLocation(MSStructTok.getLocation());
399 Toks[0].setAnnotationValue(reinterpret_cast<void*>(
400 static_cast<uintptr_t>(Kind)));
401 PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true,
402 /*OwnsTokens=*/false);
403 }
404
405 // #pragma 'align' '=' {'native','natural','mac68k','power','reset'}
406 // #pragma 'options 'align' '=' {'native','natural','mac68k','power','reset'}
ParseAlignPragma(Preprocessor & PP,Token & FirstTok,bool IsOptions)407 static void ParseAlignPragma(Preprocessor &PP, Token &FirstTok,
408 bool IsOptions) {
409 Token Tok;
410
411 if (IsOptions) {
412 PP.Lex(Tok);
413 if (Tok.isNot(tok::identifier) ||
414 !Tok.getIdentifierInfo()->isStr("align")) {
415 PP.Diag(Tok.getLocation(), diag::warn_pragma_options_expected_align);
416 return;
417 }
418 }
419
420 PP.Lex(Tok);
421 if (Tok.isNot(tok::equal)) {
422 PP.Diag(Tok.getLocation(), diag::warn_pragma_align_expected_equal)
423 << IsOptions;
424 return;
425 }
426
427 PP.Lex(Tok);
428 if (Tok.isNot(tok::identifier)) {
429 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
430 << (IsOptions ? "options" : "align");
431 return;
432 }
433
434 Sema::PragmaOptionsAlignKind Kind = Sema::POAK_Natural;
435 const IdentifierInfo *II = Tok.getIdentifierInfo();
436 if (II->isStr("native"))
437 Kind = Sema::POAK_Native;
438 else if (II->isStr("natural"))
439 Kind = Sema::POAK_Natural;
440 else if (II->isStr("packed"))
441 Kind = Sema::POAK_Packed;
442 else if (II->isStr("power"))
443 Kind = Sema::POAK_Power;
444 else if (II->isStr("mac68k"))
445 Kind = Sema::POAK_Mac68k;
446 else if (II->isStr("reset"))
447 Kind = Sema::POAK_Reset;
448 else {
449 PP.Diag(Tok.getLocation(), diag::warn_pragma_align_invalid_option)
450 << IsOptions;
451 return;
452 }
453
454 PP.Lex(Tok);
455 if (Tok.isNot(tok::eod)) {
456 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
457 << (IsOptions ? "options" : "align");
458 return;
459 }
460
461 Token *Toks =
462 (Token*) PP.getPreprocessorAllocator().Allocate(
463 sizeof(Token) * 1, llvm::alignOf<Token>());
464 new (Toks) Token();
465 Toks[0].startToken();
466 Toks[0].setKind(tok::annot_pragma_align);
467 Toks[0].setLocation(FirstTok.getLocation());
468 Toks[0].setAnnotationValue(reinterpret_cast<void*>(
469 static_cast<uintptr_t>(Kind)));
470 PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true,
471 /*OwnsTokens=*/false);
472 }
473
HandlePragma(Preprocessor & PP,PragmaIntroducerKind Introducer,Token & AlignTok)474 void PragmaAlignHandler::HandlePragma(Preprocessor &PP,
475 PragmaIntroducerKind Introducer,
476 Token &AlignTok) {
477 ParseAlignPragma(PP, AlignTok, /*IsOptions=*/false);
478 }
479
HandlePragma(Preprocessor & PP,PragmaIntroducerKind Introducer,Token & OptionsTok)480 void PragmaOptionsHandler::HandlePragma(Preprocessor &PP,
481 PragmaIntroducerKind Introducer,
482 Token &OptionsTok) {
483 ParseAlignPragma(PP, OptionsTok, /*IsOptions=*/true);
484 }
485
486 // #pragma unused(identifier)
HandlePragma(Preprocessor & PP,PragmaIntroducerKind Introducer,Token & UnusedTok)487 void PragmaUnusedHandler::HandlePragma(Preprocessor &PP,
488 PragmaIntroducerKind Introducer,
489 Token &UnusedTok) {
490 // FIXME: Should we be expanding macros here? My guess is no.
491 SourceLocation UnusedLoc = UnusedTok.getLocation();
492
493 // Lex the left '('.
494 Token Tok;
495 PP.Lex(Tok);
496 if (Tok.isNot(tok::l_paren)) {
497 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "unused";
498 return;
499 }
500
501 // Lex the declaration reference(s).
502 SmallVector<Token, 5> Identifiers;
503 SourceLocation RParenLoc;
504 bool LexID = true;
505
506 while (true) {
507 PP.Lex(Tok);
508
509 if (LexID) {
510 if (Tok.is(tok::identifier)) {
511 Identifiers.push_back(Tok);
512 LexID = false;
513 continue;
514 }
515
516 // Illegal token!
517 PP.Diag(Tok.getLocation(), diag::warn_pragma_unused_expected_var);
518 return;
519 }
520
521 // We are execting a ')' or a ','.
522 if (Tok.is(tok::comma)) {
523 LexID = true;
524 continue;
525 }
526
527 if (Tok.is(tok::r_paren)) {
528 RParenLoc = Tok.getLocation();
529 break;
530 }
531
532 // Illegal token!
533 PP.Diag(Tok.getLocation(), diag::warn_pragma_unused_expected_punc);
534 return;
535 }
536
537 PP.Lex(Tok);
538 if (Tok.isNot(tok::eod)) {
539 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
540 "unused";
541 return;
542 }
543
544 // Verify that we have a location for the right parenthesis.
545 assert(RParenLoc.isValid() && "Valid '#pragma unused' must have ')'");
546 assert(!Identifiers.empty() && "Valid '#pragma unused' must have arguments");
547
548 // For each identifier token, insert into the token stream a
549 // annot_pragma_unused token followed by the identifier token.
550 // This allows us to cache a "#pragma unused" that occurs inside an inline
551 // C++ member function.
552
553 Token *Toks =
554 (Token*) PP.getPreprocessorAllocator().Allocate(
555 sizeof(Token) * 2 * Identifiers.size(), llvm::alignOf<Token>());
556 for (unsigned i=0; i != Identifiers.size(); i++) {
557 Token &pragmaUnusedTok = Toks[2*i], &idTok = Toks[2*i+1];
558 pragmaUnusedTok.startToken();
559 pragmaUnusedTok.setKind(tok::annot_pragma_unused);
560 pragmaUnusedTok.setLocation(UnusedLoc);
561 idTok = Identifiers[i];
562 }
563 PP.EnterTokenStream(Toks, 2*Identifiers.size(),
564 /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false);
565 }
566
567 // #pragma weak identifier
568 // #pragma weak identifier '=' identifier
HandlePragma(Preprocessor & PP,PragmaIntroducerKind Introducer,Token & WeakTok)569 void PragmaWeakHandler::HandlePragma(Preprocessor &PP,
570 PragmaIntroducerKind Introducer,
571 Token &WeakTok) {
572 SourceLocation WeakLoc = WeakTok.getLocation();
573
574 Token Tok;
575 PP.Lex(Tok);
576 if (Tok.isNot(tok::identifier)) {
577 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "weak";
578 return;
579 }
580
581 Token WeakName = Tok;
582 bool HasAlias = false;
583 Token AliasName;
584
585 PP.Lex(Tok);
586 if (Tok.is(tok::equal)) {
587 HasAlias = true;
588 PP.Lex(Tok);
589 if (Tok.isNot(tok::identifier)) {
590 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
591 << "weak";
592 return;
593 }
594 AliasName = Tok;
595 PP.Lex(Tok);
596 }
597
598 if (Tok.isNot(tok::eod)) {
599 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "weak";
600 return;
601 }
602
603 if (HasAlias) {
604 Token *Toks =
605 (Token*) PP.getPreprocessorAllocator().Allocate(
606 sizeof(Token) * 3, llvm::alignOf<Token>());
607 Token &pragmaUnusedTok = Toks[0];
608 pragmaUnusedTok.startToken();
609 pragmaUnusedTok.setKind(tok::annot_pragma_weakalias);
610 pragmaUnusedTok.setLocation(WeakLoc);
611 Toks[1] = WeakName;
612 Toks[2] = AliasName;
613 PP.EnterTokenStream(Toks, 3,
614 /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false);
615 } else {
616 Token *Toks =
617 (Token*) PP.getPreprocessorAllocator().Allocate(
618 sizeof(Token) * 2, llvm::alignOf<Token>());
619 Token &pragmaUnusedTok = Toks[0];
620 pragmaUnusedTok.startToken();
621 pragmaUnusedTok.setKind(tok::annot_pragma_weak);
622 pragmaUnusedTok.setLocation(WeakLoc);
623 Toks[1] = WeakName;
624 PP.EnterTokenStream(Toks, 2,
625 /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false);
626 }
627 }
628
629 // #pragma redefine_extname identifier identifier
HandlePragma(Preprocessor & PP,PragmaIntroducerKind Introducer,Token & RedefToken)630 void PragmaRedefineExtnameHandler::HandlePragma(Preprocessor &PP,
631 PragmaIntroducerKind Introducer,
632 Token &RedefToken) {
633 SourceLocation RedefLoc = RedefToken.getLocation();
634
635 Token Tok;
636 PP.Lex(Tok);
637 if (Tok.isNot(tok::identifier)) {
638 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) <<
639 "redefine_extname";
640 return;
641 }
642
643 Token RedefName = Tok;
644 PP.Lex(Tok);
645
646 if (Tok.isNot(tok::identifier)) {
647 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
648 << "redefine_extname";
649 return;
650 }
651
652 Token AliasName = Tok;
653 PP.Lex(Tok);
654
655 if (Tok.isNot(tok::eod)) {
656 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
657 "redefine_extname";
658 return;
659 }
660
661 Token *Toks =
662 (Token*) PP.getPreprocessorAllocator().Allocate(
663 sizeof(Token) * 3, llvm::alignOf<Token>());
664 Token &pragmaRedefTok = Toks[0];
665 pragmaRedefTok.startToken();
666 pragmaRedefTok.setKind(tok::annot_pragma_redefine_extname);
667 pragmaRedefTok.setLocation(RedefLoc);
668 Toks[1] = RedefName;
669 Toks[2] = AliasName;
670 PP.EnterTokenStream(Toks, 3,
671 /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false);
672 }
673
674
675 void
HandlePragma(Preprocessor & PP,PragmaIntroducerKind Introducer,Token & Tok)676 PragmaFPContractHandler::HandlePragma(Preprocessor &PP,
677 PragmaIntroducerKind Introducer,
678 Token &Tok) {
679 tok::OnOffSwitch OOS;
680 if (PP.LexOnOffSwitch(OOS))
681 return;
682
683 Token *Toks =
684 (Token*) PP.getPreprocessorAllocator().Allocate(
685 sizeof(Token) * 1, llvm::alignOf<Token>());
686 new (Toks) Token();
687 Toks[0].startToken();
688 Toks[0].setKind(tok::annot_pragma_fp_contract);
689 Toks[0].setLocation(Tok.getLocation());
690 Toks[0].setAnnotationValue(reinterpret_cast<void*>(
691 static_cast<uintptr_t>(OOS)));
692 PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true,
693 /*OwnsTokens=*/false);
694 }
695
696 void
HandlePragma(Preprocessor & PP,PragmaIntroducerKind Introducer,Token & Tok)697 PragmaOpenCLExtensionHandler::HandlePragma(Preprocessor &PP,
698 PragmaIntroducerKind Introducer,
699 Token &Tok) {
700 PP.LexUnexpandedToken(Tok);
701 if (Tok.isNot(tok::identifier)) {
702 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) <<
703 "OPENCL";
704 return;
705 }
706 IdentifierInfo *ename = Tok.getIdentifierInfo();
707 SourceLocation NameLoc = Tok.getLocation();
708
709 PP.Lex(Tok);
710 if (Tok.isNot(tok::colon)) {
711 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_colon) << ename;
712 return;
713 }
714
715 PP.Lex(Tok);
716 if (Tok.isNot(tok::identifier)) {
717 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable);
718 return;
719 }
720 IdentifierInfo *op = Tok.getIdentifierInfo();
721
722 unsigned state;
723 if (op->isStr("enable")) {
724 state = 1;
725 } else if (op->isStr("disable")) {
726 state = 0;
727 } else {
728 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable);
729 return;
730 }
731 SourceLocation StateLoc = Tok.getLocation();
732
733 PP.Lex(Tok);
734 if (Tok.isNot(tok::eod)) {
735 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
736 "OPENCL EXTENSION";
737 return;
738 }
739
740 OpenCLExtData data(ename, state);
741 Token *Toks =
742 (Token*) PP.getPreprocessorAllocator().Allocate(
743 sizeof(Token) * 1, llvm::alignOf<Token>());
744 new (Toks) Token();
745 Toks[0].startToken();
746 Toks[0].setKind(tok::annot_pragma_opencl_extension);
747 Toks[0].setLocation(NameLoc);
748 Toks[0].setAnnotationValue(data.getOpaqueValue());
749 PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true,
750 /*OwnsTokens=*/false);
751
752 if (PP.getPPCallbacks())
753 PP.getPPCallbacks()->PragmaOpenCLExtension(NameLoc, ename,
754 StateLoc, state);
755 }
756
757 /// \brief Handle '#pragma omp ...' when OpenMP is disabled.
758 ///
759 void
HandlePragma(Preprocessor & PP,PragmaIntroducerKind Introducer,Token & FirstTok)760 PragmaNoOpenMPHandler::HandlePragma(Preprocessor &PP,
761 PragmaIntroducerKind Introducer,
762 Token &FirstTok) {
763 if (PP.getDiagnostics().getDiagnosticLevel(diag::warn_pragma_omp_ignored,
764 FirstTok.getLocation()) !=
765 DiagnosticsEngine::Ignored) {
766 PP.Diag(FirstTok, diag::warn_pragma_omp_ignored);
767 PP.getDiagnostics().setDiagnosticMapping(diag::warn_pragma_omp_ignored,
768 diag::MAP_IGNORE,
769 SourceLocation());
770 }
771 PP.DiscardUntilEndOfDirective();
772 }
773
774 /// \brief Handle '#pragma omp ...' when OpenMP is enabled.
775 ///
776 void
HandlePragma(Preprocessor & PP,PragmaIntroducerKind Introducer,Token & FirstTok)777 PragmaOpenMPHandler::HandlePragma(Preprocessor &PP,
778 PragmaIntroducerKind Introducer,
779 Token &FirstTok) {
780 SmallVector<Token, 16> Pragma;
781 Token Tok;
782 Tok.startToken();
783 Tok.setKind(tok::annot_pragma_openmp);
784 Tok.setLocation(FirstTok.getLocation());
785
786 while (Tok.isNot(tok::eod)) {
787 Pragma.push_back(Tok);
788 PP.Lex(Tok);
789 }
790 SourceLocation EodLoc = Tok.getLocation();
791 Tok.startToken();
792 Tok.setKind(tok::annot_pragma_openmp_end);
793 Tok.setLocation(EodLoc);
794 Pragma.push_back(Tok);
795
796 Token *Toks = new Token[Pragma.size()];
797 std::copy(Pragma.begin(), Pragma.end(), Toks);
798 PP.EnterTokenStream(Toks, Pragma.size(),
799 /*DisableMacroExpansion=*/true, /*OwnsTokens=*/true);
800 }
801
802 /// \brief Handle the Microsoft \#pragma detect_mismatch extension.
803 ///
804 /// The syntax is:
805 /// \code
806 /// #pragma detect_mismatch("name", "value")
807 /// \endcode
808 /// Where 'name' and 'value' are quoted strings. The values are embedded in
809 /// the object file and passed along to the linker. If the linker detects a
810 /// mismatch in the object file's values for the given name, a LNK2038 error
811 /// is emitted. See MSDN for more details.
HandlePragma(Preprocessor & PP,PragmaIntroducerKind Introducer,Token & Tok)812 void PragmaDetectMismatchHandler::HandlePragma(Preprocessor &PP,
813 PragmaIntroducerKind Introducer,
814 Token &Tok) {
815 SourceLocation CommentLoc = Tok.getLocation();
816 PP.Lex(Tok);
817 if (Tok.isNot(tok::l_paren)) {
818 PP.Diag(CommentLoc, diag::err_expected_lparen);
819 return;
820 }
821
822 // Read the name to embed, which must be a string literal.
823 std::string NameString;
824 if (!PP.LexStringLiteral(Tok, NameString,
825 "pragma detect_mismatch",
826 /*MacroExpansion=*/true))
827 return;
828
829 // Read the comma followed by a second string literal.
830 std::string ValueString;
831 if (Tok.isNot(tok::comma)) {
832 PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed);
833 return;
834 }
835
836 if (!PP.LexStringLiteral(Tok, ValueString, "pragma detect_mismatch",
837 /*MacroExpansion=*/true))
838 return;
839
840 if (Tok.isNot(tok::r_paren)) {
841 PP.Diag(Tok.getLocation(), diag::err_expected_rparen);
842 return;
843 }
844 PP.Lex(Tok); // Eat the r_paren.
845
846 if (Tok.isNot(tok::eod)) {
847 PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed);
848 return;
849 }
850
851 // If the pragma is lexically sound, notify any interested PPCallbacks.
852 if (PP.getPPCallbacks())
853 PP.getPPCallbacks()->PragmaDetectMismatch(CommentLoc, NameString,
854 ValueString);
855
856 Actions.ActOnPragmaDetectMismatch(NameString, ValueString);
857 }
858
859 /// \brief Handle the microsoft \#pragma comment extension.
860 ///
861 /// The syntax is:
862 /// \code
863 /// #pragma comment(linker, "foo")
864 /// \endcode
865 /// 'linker' is one of five identifiers: compiler, exestr, lib, linker, user.
866 /// "foo" is a string, which is fully macro expanded, and permits string
867 /// concatenation, embedded escape characters etc. See MSDN for more details.
HandlePragma(Preprocessor & PP,PragmaIntroducerKind Introducer,Token & Tok)868 void PragmaCommentHandler::HandlePragma(Preprocessor &PP,
869 PragmaIntroducerKind Introducer,
870 Token &Tok) {
871 SourceLocation CommentLoc = Tok.getLocation();
872 PP.Lex(Tok);
873 if (Tok.isNot(tok::l_paren)) {
874 PP.Diag(CommentLoc, diag::err_pragma_comment_malformed);
875 return;
876 }
877
878 // Read the identifier.
879 PP.Lex(Tok);
880 if (Tok.isNot(tok::identifier)) {
881 PP.Diag(CommentLoc, diag::err_pragma_comment_malformed);
882 return;
883 }
884
885 // Verify that this is one of the 5 whitelisted options.
886 IdentifierInfo *II = Tok.getIdentifierInfo();
887 Sema::PragmaMSCommentKind Kind =
888 llvm::StringSwitch<Sema::PragmaMSCommentKind>(II->getName())
889 .Case("linker", Sema::PCK_Linker)
890 .Case("lib", Sema::PCK_Lib)
891 .Case("compiler", Sema::PCK_Compiler)
892 .Case("exestr", Sema::PCK_ExeStr)
893 .Case("user", Sema::PCK_User)
894 .Default(Sema::PCK_Unknown);
895 if (Kind == Sema::PCK_Unknown) {
896 PP.Diag(Tok.getLocation(), diag::err_pragma_comment_unknown_kind);
897 return;
898 }
899
900 // Read the optional string if present.
901 PP.Lex(Tok);
902 std::string ArgumentString;
903 if (Tok.is(tok::comma) && !PP.LexStringLiteral(Tok, ArgumentString,
904 "pragma comment",
905 /*MacroExpansion=*/true))
906 return;
907
908 // FIXME: warn that 'exestr' is deprecated.
909 // FIXME: If the kind is "compiler" warn if the string is present (it is
910 // ignored).
911 // The MSDN docs say that "lib" and "linker" require a string and have a short
912 // whitelist of linker options they support, but in practice MSVC doesn't
913 // issue a diagnostic. Therefore neither does clang.
914
915 if (Tok.isNot(tok::r_paren)) {
916 PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed);
917 return;
918 }
919 PP.Lex(Tok); // eat the r_paren.
920
921 if (Tok.isNot(tok::eod)) {
922 PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed);
923 return;
924 }
925
926 // If the pragma is lexically sound, notify any interested PPCallbacks.
927 if (PP.getPPCallbacks())
928 PP.getPPCallbacks()->PragmaComment(CommentLoc, II, ArgumentString);
929
930 Actions.ActOnPragmaMSComment(Kind, ArgumentString);
931 }
932