ParsePragma.cpp revision 243830 
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/Parse/ParseDiagnostic.h"
16#include "clang/Parse/Parser.h"
17#include "clang/Lex/Preprocessor.h"
18using namespace clang;
19
20/// \brief Handle the annotation token produced for #pragma unused(...)
21///
22/// Each annot_pragma_unused is followed by the argument token so e.g.
23/// "#pragma unused(x,y)" becomes:
24/// annot_pragma_unused 'x' annot_pragma_unused 'y'
25void Parser::HandlePragmaUnused() {
26  assert(Tok.is(tok::annot_pragma_unused));
27  SourceLocation UnusedLoc = ConsumeToken();
28  Actions.ActOnPragmaUnused(Tok, getCurScope(), UnusedLoc);
29  ConsumeToken(); // The argument token.
30}
31
32void Parser::HandlePragmaVisibility() {
33  assert(Tok.is(tok::annot_pragma_vis));
34  const IdentifierInfo *VisType =
35    static_cast<IdentifierInfo *>(Tok.getAnnotationValue());
36  SourceLocation VisLoc = ConsumeToken();
37  Actions.ActOnPragmaVisibility(VisType, VisLoc);
38}
39
40struct PragmaPackInfo {
41  Sema::PragmaPackKind Kind;
42  IdentifierInfo *Name;
43  Token Alignment;
44  SourceLocation LParenLoc;
45  SourceLocation RParenLoc;
46};
47
48void Parser::HandlePragmaPack() {
49  assert(Tok.is(tok::annot_pragma_pack));
50  PragmaPackInfo *Info =
51    static_cast<PragmaPackInfo *>(Tok.getAnnotationValue());
52  SourceLocation PragmaLoc = ConsumeToken();
53  ExprResult Alignment;
54  if (Info->Alignment.is(tok::numeric_constant)) {
55    Alignment = Actions.ActOnNumericConstant(Info->Alignment);
56    if (Alignment.isInvalid())
57      return;
58  }
59  Actions.ActOnPragmaPack(Info->Kind, Info->Name, Alignment.get(), PragmaLoc,
60                          Info->LParenLoc, Info->RParenLoc);
61}
62
63void Parser::HandlePragmaMSStruct() {
64  assert(Tok.is(tok::annot_pragma_msstruct));
65  Sema::PragmaMSStructKind Kind =
66    static_cast<Sema::PragmaMSStructKind>(
67    reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
68  Actions.ActOnPragmaMSStruct(Kind);
69  ConsumeToken(); // The annotation token.
70}
71
72void Parser::HandlePragmaAlign() {
73  assert(Tok.is(tok::annot_pragma_align));
74  Sema::PragmaOptionsAlignKind Kind =
75    static_cast<Sema::PragmaOptionsAlignKind>(
76    reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
77  SourceLocation PragmaLoc = ConsumeToken();
78  Actions.ActOnPragmaOptionsAlign(Kind, PragmaLoc);
79}
80
81void Parser::HandlePragmaWeak() {
82  assert(Tok.is(tok::annot_pragma_weak));
83  SourceLocation PragmaLoc = ConsumeToken();
84  Actions.ActOnPragmaWeakID(Tok.getIdentifierInfo(), PragmaLoc,
85                            Tok.getLocation());
86  ConsumeToken(); // The weak name.
87}
88
89void Parser::HandlePragmaWeakAlias() {
90  assert(Tok.is(tok::annot_pragma_weakalias));
91  SourceLocation PragmaLoc = ConsumeToken();
92  IdentifierInfo *WeakName = Tok.getIdentifierInfo();
93  SourceLocation WeakNameLoc = Tok.getLocation();
94  ConsumeToken();
95  IdentifierInfo *AliasName = Tok.getIdentifierInfo();
96  SourceLocation AliasNameLoc = Tok.getLocation();
97  ConsumeToken();
98  Actions.ActOnPragmaWeakAlias(WeakName, AliasName, PragmaLoc,
99                               WeakNameLoc, AliasNameLoc);
100
101}
102
103void Parser::HandlePragmaRedefineExtname() {
104  assert(Tok.is(tok::annot_pragma_redefine_extname));
105  SourceLocation RedefLoc = ConsumeToken();
106  IdentifierInfo *RedefName = Tok.getIdentifierInfo();
107  SourceLocation RedefNameLoc = Tok.getLocation();
108  ConsumeToken();
109  IdentifierInfo *AliasName = Tok.getIdentifierInfo();
110  SourceLocation AliasNameLoc = Tok.getLocation();
111  ConsumeToken();
112  Actions.ActOnPragmaRedefineExtname(RedefName, AliasName, RedefLoc,
113                                     RedefNameLoc, AliasNameLoc);
114}
115
116void Parser::HandlePragmaFPContract() {
117  assert(Tok.is(tok::annot_pragma_fp_contract));
118  tok::OnOffSwitch OOS =
119    static_cast<tok::OnOffSwitch>(
120    reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
121  Actions.ActOnPragmaFPContract(OOS);
122  ConsumeToken(); // The annotation token.
123}
124
125namespace {
126  typedef llvm::PointerIntPair<IdentifierInfo *, 1, bool> OpenCLExtData;
127}
128
129void Parser::HandlePragmaOpenCLExtension() {
130  assert(Tok.is(tok::annot_pragma_opencl_extension));
131  OpenCLExtData data =
132      OpenCLExtData::getFromOpaqueValue(Tok.getAnnotationValue());
133  unsigned state = data.getInt();
134  IdentifierInfo *ename = data.getPointer();
135  SourceLocation NameLoc = Tok.getLocation();
136  ConsumeToken(); // The annotation token.
137
138  OpenCLOptions &f = Actions.getOpenCLOptions();
139  // OpenCL 1.1 9.1: "The all variant sets the behavior for all extensions,
140  // overriding all previously issued extension directives, but only if the
141  // behavior is set to disable."
142  if (state == 0 && ename->isStr("all")) {
143#define OPENCLEXT(nm)   f.nm = 0;
144#include "clang/Basic/OpenCLExtensions.def"
145  }
146#define OPENCLEXT(nm) else if (ename->isStr(#nm)) { f.nm = state; }
147#include "clang/Basic/OpenCLExtensions.def"
148  else {
149    PP.Diag(NameLoc, diag::warn_pragma_unknown_extension) << ename;
150    return;
151  }
152}
153
154// #pragma GCC visibility comes in two variants:
155//   'push' '(' [visibility] ')'
156//   'pop'
157void PragmaGCCVisibilityHandler::HandlePragma(Preprocessor &PP,
158                                              PragmaIntroducerKind Introducer,
159                                              Token &VisTok) {
160  SourceLocation VisLoc = VisTok.getLocation();
161
162  Token Tok;
163  PP.LexUnexpandedToken(Tok);
164
165  const IdentifierInfo *PushPop = Tok.getIdentifierInfo();
166
167  const IdentifierInfo *VisType;
168  if (PushPop && PushPop->isStr("pop")) {
169    VisType = 0;
170  } else if (PushPop && PushPop->isStr("push")) {
171    PP.LexUnexpandedToken(Tok);
172    if (Tok.isNot(tok::l_paren)) {
173      PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen)
174        << "visibility";
175      return;
176    }
177    PP.LexUnexpandedToken(Tok);
178    VisType = Tok.getIdentifierInfo();
179    if (!VisType) {
180      PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
181        << "visibility";
182      return;
183    }
184    PP.LexUnexpandedToken(Tok);
185    if (Tok.isNot(tok::r_paren)) {
186      PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen)
187        << "visibility";
188      return;
189    }
190  } else {
191    PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
192      << "visibility";
193    return;
194  }
195  PP.LexUnexpandedToken(Tok);
196  if (Tok.isNot(tok::eod)) {
197    PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
198      << "visibility";
199    return;
200  }
201
202  Token *Toks = new Token[1];
203  Toks[0].startToken();
204  Toks[0].setKind(tok::annot_pragma_vis);
205  Toks[0].setLocation(VisLoc);
206  Toks[0].setAnnotationValue(
207                          const_cast<void*>(static_cast<const void*>(VisType)));
208  PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true,
209                      /*OwnsTokens=*/true);
210}
211
212// #pragma pack(...) comes in the following delicious flavors:
213//   pack '(' [integer] ')'
214//   pack '(' 'show' ')'
215//   pack '(' ('push' | 'pop') [',' identifier] [, integer] ')'
216void PragmaPackHandler::HandlePragma(Preprocessor &PP,
217                                     PragmaIntroducerKind Introducer,
218                                     Token &PackTok) {
219  SourceLocation PackLoc = PackTok.getLocation();
220
221  Token Tok;
222  PP.Lex(Tok);
223  if (Tok.isNot(tok::l_paren)) {
224    PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "pack";
225    return;
226  }
227
228  Sema::PragmaPackKind Kind = Sema::PPK_Default;
229  IdentifierInfo *Name = 0;
230  Token Alignment;
231  Alignment.startToken();
232  SourceLocation LParenLoc = Tok.getLocation();
233  PP.Lex(Tok);
234  if (Tok.is(tok::numeric_constant)) {
235    Alignment = Tok;
236
237    PP.Lex(Tok);
238
239    // In MSVC/gcc, #pragma pack(4) sets the alignment without affecting
240    // the push/pop stack.
241    // In Apple gcc, #pragma pack(4) is equivalent to #pragma pack(push, 4)
242    if (PP.getLangOpts().ApplePragmaPack)
243      Kind = Sema::PPK_Push;
244  } else if (Tok.is(tok::identifier)) {
245    const IdentifierInfo *II = Tok.getIdentifierInfo();
246    if (II->isStr("show")) {
247      Kind = Sema::PPK_Show;
248      PP.Lex(Tok);
249    } else {
250      if (II->isStr("push")) {
251        Kind = Sema::PPK_Push;
252      } else if (II->isStr("pop")) {
253        Kind = Sema::PPK_Pop;
254      } else {
255        PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_invalid_action);
256        return;
257      }
258      PP.Lex(Tok);
259
260      if (Tok.is(tok::comma)) {
261        PP.Lex(Tok);
262
263        if (Tok.is(tok::numeric_constant)) {
264          Alignment = Tok;
265
266          PP.Lex(Tok);
267        } else if (Tok.is(tok::identifier)) {
268          Name = Tok.getIdentifierInfo();
269          PP.Lex(Tok);
270
271          if (Tok.is(tok::comma)) {
272            PP.Lex(Tok);
273
274            if (Tok.isNot(tok::numeric_constant)) {
275              PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed);
276              return;
277            }
278
279            Alignment = Tok;
280
281            PP.Lex(Tok);
282          }
283        } else {
284          PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed);
285          return;
286        }
287      }
288    }
289  } else if (PP.getLangOpts().ApplePragmaPack) {
290    // In MSVC/gcc, #pragma pack() resets the alignment without affecting
291    // the push/pop stack.
292    // In Apple gcc #pragma pack() is equivalent to #pragma pack(pop).
293    Kind = Sema::PPK_Pop;
294  }
295
296  if (Tok.isNot(tok::r_paren)) {
297    PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "pack";
298    return;
299  }
300
301  SourceLocation RParenLoc = Tok.getLocation();
302  PP.Lex(Tok);
303  if (Tok.isNot(tok::eod)) {
304    PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "pack";
305    return;
306  }
307
308  PragmaPackInfo *Info =
309    (PragmaPackInfo*) PP.getPreprocessorAllocator().Allocate(
310      sizeof(PragmaPackInfo), llvm::alignOf<PragmaPackInfo>());
311  new (Info) PragmaPackInfo();
312  Info->Kind = Kind;
313  Info->Name = Name;
314  Info->Alignment = Alignment;
315  Info->LParenLoc = LParenLoc;
316  Info->RParenLoc = RParenLoc;
317
318  Token *Toks =
319    (Token*) PP.getPreprocessorAllocator().Allocate(
320      sizeof(Token) * 1, llvm::alignOf<Token>());
321  new (Toks) Token();
322  Toks[0].startToken();
323  Toks[0].setKind(tok::annot_pragma_pack);
324  Toks[0].setLocation(PackLoc);
325  Toks[0].setAnnotationValue(static_cast<void*>(Info));
326  PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true,
327                      /*OwnsTokens=*/false);
328}
329
330// #pragma ms_struct on
331// #pragma ms_struct off
332void PragmaMSStructHandler::HandlePragma(Preprocessor &PP,
333                                         PragmaIntroducerKind Introducer,
334                                         Token &MSStructTok) {
335  Sema::PragmaMSStructKind Kind = Sema::PMSST_OFF;
336
337  Token Tok;
338  PP.Lex(Tok);
339  if (Tok.isNot(tok::identifier)) {
340    PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct);
341    return;
342  }
343  const IdentifierInfo *II = Tok.getIdentifierInfo();
344  if (II->isStr("on")) {
345    Kind = Sema::PMSST_ON;
346    PP.Lex(Tok);
347  }
348  else if (II->isStr("off") || II->isStr("reset"))
349    PP.Lex(Tok);
350  else {
351    PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct);
352    return;
353  }
354
355  if (Tok.isNot(tok::eod)) {
356    PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
357      << "ms_struct";
358    return;
359  }
360
361  Token *Toks =
362    (Token*) PP.getPreprocessorAllocator().Allocate(
363      sizeof(Token) * 1, llvm::alignOf<Token>());
364  new (Toks) Token();
365  Toks[0].startToken();
366  Toks[0].setKind(tok::annot_pragma_msstruct);
367  Toks[0].setLocation(MSStructTok.getLocation());
368  Toks[0].setAnnotationValue(reinterpret_cast<void*>(
369                             static_cast<uintptr_t>(Kind)));
370  PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true,
371                      /*OwnsTokens=*/false);
372}
373
374// #pragma 'align' '=' {'native','natural','mac68k','power','reset'}
375// #pragma 'options 'align' '=' {'native','natural','mac68k','power','reset'}
376static void ParseAlignPragma(Preprocessor &PP, Token &FirstTok,
377                             bool IsOptions) {
378  Token Tok;
379
380  if (IsOptions) {
381    PP.Lex(Tok);
382    if (Tok.isNot(tok::identifier) ||
383        !Tok.getIdentifierInfo()->isStr("align")) {
384      PP.Diag(Tok.getLocation(), diag::warn_pragma_options_expected_align);
385      return;
386    }
387  }
388
389  PP.Lex(Tok);
390  if (Tok.isNot(tok::equal)) {
391    PP.Diag(Tok.getLocation(), diag::warn_pragma_align_expected_equal)
392      << IsOptions;
393    return;
394  }
395
396  PP.Lex(Tok);
397  if (Tok.isNot(tok::identifier)) {
398    PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
399      << (IsOptions ? "options" : "align");
400    return;
401  }
402
403  Sema::PragmaOptionsAlignKind Kind = Sema::POAK_Natural;
404  const IdentifierInfo *II = Tok.getIdentifierInfo();
405  if (II->isStr("native"))
406    Kind = Sema::POAK_Native;
407  else if (II->isStr("natural"))
408    Kind = Sema::POAK_Natural;
409  else if (II->isStr("packed"))
410    Kind = Sema::POAK_Packed;
411  else if (II->isStr("power"))
412    Kind = Sema::POAK_Power;
413  else if (II->isStr("mac68k"))
414    Kind = Sema::POAK_Mac68k;
415  else if (II->isStr("reset"))
416    Kind = Sema::POAK_Reset;
417  else {
418    PP.Diag(Tok.getLocation(), diag::warn_pragma_align_invalid_option)
419      << IsOptions;
420    return;
421  }
422
423  PP.Lex(Tok);
424  if (Tok.isNot(tok::eod)) {
425    PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
426      << (IsOptions ? "options" : "align");
427    return;
428  }
429
430  Token *Toks =
431    (Token*) PP.getPreprocessorAllocator().Allocate(
432      sizeof(Token) * 1, llvm::alignOf<Token>());
433  new (Toks) Token();
434  Toks[0].startToken();
435  Toks[0].setKind(tok::annot_pragma_align);
436  Toks[0].setLocation(FirstTok.getLocation());
437  Toks[0].setAnnotationValue(reinterpret_cast<void*>(
438                             static_cast<uintptr_t>(Kind)));
439  PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true,
440                      /*OwnsTokens=*/false);
441}
442
443void PragmaAlignHandler::HandlePragma(Preprocessor &PP,
444                                      PragmaIntroducerKind Introducer,
445                                      Token &AlignTok) {
446  ParseAlignPragma(PP, AlignTok, /*IsOptions=*/false);
447}
448
449void PragmaOptionsHandler::HandlePragma(Preprocessor &PP,
450                                        PragmaIntroducerKind Introducer,
451                                        Token &OptionsTok) {
452  ParseAlignPragma(PP, OptionsTok, /*IsOptions=*/true);
453}
454
455// #pragma unused(identifier)
456void PragmaUnusedHandler::HandlePragma(Preprocessor &PP,
457                                       PragmaIntroducerKind Introducer,
458                                       Token &UnusedTok) {
459  // FIXME: Should we be expanding macros here? My guess is no.
460  SourceLocation UnusedLoc = UnusedTok.getLocation();
461
462  // Lex the left '('.
463  Token Tok;
464  PP.Lex(Tok);
465  if (Tok.isNot(tok::l_paren)) {
466    PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "unused";
467    return;
468  }
469
470  // Lex the declaration reference(s).
471  SmallVector<Token, 5> Identifiers;
472  SourceLocation RParenLoc;
473  bool LexID = true;
474
475  while (true) {
476    PP.Lex(Tok);
477
478    if (LexID) {
479      if (Tok.is(tok::identifier)) {
480        Identifiers.push_back(Tok);
481        LexID = false;
482        continue;
483      }
484
485      // Illegal token!
486      PP.Diag(Tok.getLocation(), diag::warn_pragma_unused_expected_var);
487      return;
488    }
489
490    // We are execting a ')' or a ','.
491    if (Tok.is(tok::comma)) {
492      LexID = true;
493      continue;
494    }
495
496    if (Tok.is(tok::r_paren)) {
497      RParenLoc = Tok.getLocation();
498      break;
499    }
500
501    // Illegal token!
502    PP.Diag(Tok.getLocation(), diag::warn_pragma_unused_expected_punc);
503    return;
504  }
505
506  PP.Lex(Tok);
507  if (Tok.isNot(tok::eod)) {
508    PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
509        "unused";
510    return;
511  }
512
513  // Verify that we have a location for the right parenthesis.
514  assert(RParenLoc.isValid() && "Valid '#pragma unused' must have ')'");
515  assert(!Identifiers.empty() && "Valid '#pragma unused' must have arguments");
516
517  // For each identifier token, insert into the token stream a
518  // annot_pragma_unused token followed by the identifier token.
519  // This allows us to cache a "#pragma unused" that occurs inside an inline
520  // C++ member function.
521
522  Token *Toks =
523    (Token*) PP.getPreprocessorAllocator().Allocate(
524      sizeof(Token) * 2 * Identifiers.size(), llvm::alignOf<Token>());
525  for (unsigned i=0; i != Identifiers.size(); i++) {
526    Token &pragmaUnusedTok = Toks[2*i], &idTok = Toks[2*i+1];
527    pragmaUnusedTok.startToken();
528    pragmaUnusedTok.setKind(tok::annot_pragma_unused);
529    pragmaUnusedTok.setLocation(UnusedLoc);
530    idTok = Identifiers[i];
531  }
532  PP.EnterTokenStream(Toks, 2*Identifiers.size(),
533                      /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false);
534}
535
536// #pragma weak identifier
537// #pragma weak identifier '=' identifier
538void PragmaWeakHandler::HandlePragma(Preprocessor &PP,
539                                     PragmaIntroducerKind Introducer,
540                                     Token &WeakTok) {
541  SourceLocation WeakLoc = WeakTok.getLocation();
542
543  Token Tok;
544  PP.Lex(Tok);
545  if (Tok.isNot(tok::identifier)) {
546    PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "weak";
547    return;
548  }
549
550  Token WeakName = Tok;
551  bool HasAlias = false;
552  Token AliasName;
553
554  PP.Lex(Tok);
555  if (Tok.is(tok::equal)) {
556    HasAlias = true;
557    PP.Lex(Tok);
558    if (Tok.isNot(tok::identifier)) {
559      PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
560          << "weak";
561      return;
562    }
563    AliasName = Tok;
564    PP.Lex(Tok);
565  }
566
567  if (Tok.isNot(tok::eod)) {
568    PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "weak";
569    return;
570  }
571
572  if (HasAlias) {
573    Token *Toks =
574      (Token*) PP.getPreprocessorAllocator().Allocate(
575        sizeof(Token) * 3, llvm::alignOf<Token>());
576    Token &pragmaUnusedTok = Toks[0];
577    pragmaUnusedTok.startToken();
578    pragmaUnusedTok.setKind(tok::annot_pragma_weakalias);
579    pragmaUnusedTok.setLocation(WeakLoc);
580    Toks[1] = WeakName;
581    Toks[2] = AliasName;
582    PP.EnterTokenStream(Toks, 3,
583                        /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false);
584  } else {
585    Token *Toks =
586      (Token*) PP.getPreprocessorAllocator().Allocate(
587        sizeof(Token) * 2, llvm::alignOf<Token>());
588    Token &pragmaUnusedTok = Toks[0];
589    pragmaUnusedTok.startToken();
590    pragmaUnusedTok.setKind(tok::annot_pragma_weak);
591    pragmaUnusedTok.setLocation(WeakLoc);
592    Toks[1] = WeakName;
593    PP.EnterTokenStream(Toks, 2,
594                        /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false);
595  }
596}
597
598// #pragma redefine_extname identifier identifier
599void PragmaRedefineExtnameHandler::HandlePragma(Preprocessor &PP,
600                                               PragmaIntroducerKind Introducer,
601                                                Token &RedefToken) {
602  SourceLocation RedefLoc = RedefToken.getLocation();
603
604  Token Tok;
605  PP.Lex(Tok);
606  if (Tok.isNot(tok::identifier)) {
607    PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) <<
608      "redefine_extname";
609    return;
610  }
611
612  Token RedefName = Tok;
613  PP.Lex(Tok);
614
615  if (Tok.isNot(tok::identifier)) {
616    PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
617        << "redefine_extname";
618    return;
619  }
620
621  Token AliasName = Tok;
622  PP.Lex(Tok);
623
624  if (Tok.isNot(tok::eod)) {
625    PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
626      "redefine_extname";
627    return;
628  }
629
630  Token *Toks =
631    (Token*) PP.getPreprocessorAllocator().Allocate(
632      sizeof(Token) * 3, llvm::alignOf<Token>());
633  Token &pragmaRedefTok = Toks[0];
634  pragmaRedefTok.startToken();
635  pragmaRedefTok.setKind(tok::annot_pragma_redefine_extname);
636  pragmaRedefTok.setLocation(RedefLoc);
637  Toks[1] = RedefName;
638  Toks[2] = AliasName;
639  PP.EnterTokenStream(Toks, 3,
640                      /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false);
641}
642
643
644void
645PragmaFPContractHandler::HandlePragma(Preprocessor &PP,
646                                      PragmaIntroducerKind Introducer,
647                                      Token &Tok) {
648  tok::OnOffSwitch OOS;
649  if (PP.LexOnOffSwitch(OOS))
650    return;
651
652  Token *Toks =
653    (Token*) PP.getPreprocessorAllocator().Allocate(
654      sizeof(Token) * 1, llvm::alignOf<Token>());
655  new (Toks) Token();
656  Toks[0].startToken();
657  Toks[0].setKind(tok::annot_pragma_fp_contract);
658  Toks[0].setLocation(Tok.getLocation());
659  Toks[0].setAnnotationValue(reinterpret_cast<void*>(
660                             static_cast<uintptr_t>(OOS)));
661  PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true,
662                      /*OwnsTokens=*/false);
663}
664
665void
666PragmaOpenCLExtensionHandler::HandlePragma(Preprocessor &PP,
667                                           PragmaIntroducerKind Introducer,
668                                           Token &Tok) {
669  PP.LexUnexpandedToken(Tok);
670  if (Tok.isNot(tok::identifier)) {
671    PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) <<
672      "OPENCL";
673    return;
674  }
675  IdentifierInfo *ename = Tok.getIdentifierInfo();
676  SourceLocation NameLoc = Tok.getLocation();
677
678  PP.Lex(Tok);
679  if (Tok.isNot(tok::colon)) {
680    PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_colon) << ename;
681    return;
682  }
683
684  PP.Lex(Tok);
685  if (Tok.isNot(tok::identifier)) {
686    PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable);
687    return;
688  }
689  IdentifierInfo *op = Tok.getIdentifierInfo();
690
691  unsigned state;
692  if (op->isStr("enable")) {
693    state = 1;
694  } else if (op->isStr("disable")) {
695    state = 0;
696  } else {
697    PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable);
698    return;
699  }
700
701  PP.Lex(Tok);
702  if (Tok.isNot(tok::eod)) {
703    PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
704      "OPENCL EXTENSION";
705    return;
706  }
707
708  OpenCLExtData data(ename, state);
709  Token *Toks =
710    (Token*) PP.getPreprocessorAllocator().Allocate(
711      sizeof(Token) * 1, llvm::alignOf<Token>());
712  new (Toks) Token();
713  Toks[0].startToken();
714  Toks[0].setKind(tok::annot_pragma_opencl_extension);
715  Toks[0].setLocation(NameLoc);
716  Toks[0].setAnnotationValue(data.getOpaqueValue());
717  PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true,
718                      /*OwnsTokens=*/false);
719}
720
721