contrib/llvm/tools/clang/lib/Parse/ParsePragma.cpp

   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"
  18 using 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'
  25 void 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
  32 void 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
  40 struct PragmaPackInfo {
  41   Sema::PragmaPackKind Kind;
  42   IdentifierInfo *Name;
  43   Expr *Alignment;
  44   SourceLocation LParenLoc;
  45   SourceLocation RParenLoc;
  46 };
  47
  48 void Parser::HandlePragmaPack() {
  49   assert(Tok.is(tok::annot_pragma_pack));
  50   PragmaPackInfo *Info =
  51     static_cast<PragmaPackInfo *>(Tok.getAnnotationValue());
  52   SourceLocation PragmaLoc = ConsumeToken();
  53   Actions.ActOnPragmaPack(Info->Kind, Info->Name, Info->Alignment, PragmaLoc,
  54                           Info->LParenLoc, Info->RParenLoc);
  55 }
  56
  57 // #pragma GCC visibility comes in two variants:
  58 //   'push' '(' [visibility] ')'
  59 //   'pop'
  60 void PragmaGCCVisibilityHandler::HandlePragma(Preprocessor &PP,
  61                                               PragmaIntroducerKind Introducer,
  62                                               Token &VisTok) {
  63   SourceLocation VisLoc = VisTok.getLocation();
  64
  65   Token Tok;
  66   PP.LexUnexpandedToken(Tok);
  67
  68   const IdentifierInfo *PushPop = Tok.getIdentifierInfo();
  69
  70   const IdentifierInfo *VisType;
  71   if (PushPop && PushPop->isStr("pop")) {
  72     VisType = 0;
  73   } else if (PushPop && PushPop->isStr("push")) {
  74     PP.LexUnexpandedToken(Tok);
  75     if (Tok.isNot(tok::l_paren)) {
  76       PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen)
  77         << "visibility";
  78       return;
  79     }
  80     PP.LexUnexpandedToken(Tok);
  81     VisType = Tok.getIdentifierInfo();
  82     if (!VisType) {
  83       PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
  84         << "visibility";
  85       return;
  86     }
  87     PP.LexUnexpandedToken(Tok);
  88     if (Tok.isNot(tok::r_paren)) {
  89       PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen)
  90         << "visibility";
  91       return;
  92     }
  93   } else {
  94     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
  95       << "visibility";
  96     return;
  97   }
  98   PP.LexUnexpandedToken(Tok);
  99   if (Tok.isNot(tok::eod)) {
 100     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
 101       << "visibility";
 102     return;
 103   }
 104
 105   Token *Toks = new Token[1];
 106   Toks[0].startToken();
 107   Toks[0].setKind(tok::annot_pragma_vis);
 108   Toks[0].setLocation(VisLoc);
 109   Toks[0].setAnnotationValue(
 110                           const_cast<void*>(static_cast<const void*>(VisType)));
 111   PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true,
 112                       /*OwnsTokens=*/true);
 113 }
 114
 115 // #pragma pack(...) comes in the following delicious flavors:
 116 //   pack '(' [integer] ')'
 117 //   pack '(' 'show' ')'
 118 //   pack '(' ('push' | 'pop') [',' identifier] [, integer] ')'
 119 void PragmaPackHandler::HandlePragma(Preprocessor &PP,
 120                                      PragmaIntroducerKind Introducer,
 121                                      Token &PackTok) {
 122   SourceLocation PackLoc = PackTok.getLocation();
 123
 124   Token Tok;
 125   PP.Lex(Tok);
 126   if (Tok.isNot(tok::l_paren)) {
 127     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "pack";
 128     return;
 129   }
 130
 131   Sema::PragmaPackKind Kind = Sema::PPK_Default;
 132   IdentifierInfo *Name = 0;
 133   ExprResult Alignment;
 134   SourceLocation LParenLoc = Tok.getLocation();
 135   PP.Lex(Tok);
 136   if (Tok.is(tok::numeric_constant)) {
 137     Alignment = Actions.ActOnNumericConstant(Tok);
 138     if (Alignment.isInvalid())
 139       return;
 140
 141     PP.Lex(Tok);
 142
 143     // In MSVC/gcc, #pragma pack(4) sets the alignment without affecting
 144     // the push/pop stack.
 145     // In Apple gcc, #pragma pack(4) is equivalent to #pragma pack(push, 4)
 146     if (PP.getLangOpts().ApplePragmaPack)
 147       Kind = Sema::PPK_Push;
 148   } else if (Tok.is(tok::identifier)) {
 149     const IdentifierInfo *II = Tok.getIdentifierInfo();
 150     if (II->isStr("show")) {
 151       Kind = Sema::PPK_Show;
 152       PP.Lex(Tok);
 153     } else {
 154       if (II->isStr("push")) {
 155         Kind = Sema::PPK_Push;
 156       } else if (II->isStr("pop")) {
 157         Kind = Sema::PPK_Pop;
 158       } else {
 159         PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_invalid_action);
 160         return;
 161       }
 162       PP.Lex(Tok);
 163
 164       if (Tok.is(tok::comma)) {
 165         PP.Lex(Tok);
 166
 167         if (Tok.is(tok::numeric_constant)) {
 168           Alignment = Actions.ActOnNumericConstant(Tok);
 169           if (Alignment.isInvalid())
 170             return;
 171
 172           PP.Lex(Tok);
 173         } else if (Tok.is(tok::identifier)) {
 174           Name = Tok.getIdentifierInfo();
 175           PP.Lex(Tok);
 176
 177           if (Tok.is(tok::comma)) {
 178             PP.Lex(Tok);
 179
 180             if (Tok.isNot(tok::numeric_constant)) {
 181               PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed);
 182               return;
 183             }
 184
 185             Alignment = Actions.ActOnNumericConstant(Tok);
 186             if (Alignment.isInvalid())
 187               return;
 188
 189             PP.Lex(Tok);
 190           }
 191         } else {
 192           PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed);
 193           return;
 194         }
 195       }
 196     }
 197   } else if (PP.getLangOpts().ApplePragmaPack) {
 198     // In MSVC/gcc, #pragma pack() resets the alignment without affecting
 199     // the push/pop stack.
 200     // In Apple gcc #pragma pack() is equivalent to #pragma pack(pop).
 201     Kind = Sema::PPK_Pop;
 202   }
 203
 204   if (Tok.isNot(tok::r_paren)) {
 205     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "pack";
 206     return;
 207   }
 208
 209   SourceLocation RParenLoc = Tok.getLocation();
 210   PP.Lex(Tok);
 211   if (Tok.isNot(tok::eod)) {
 212     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "pack";
 213     return;
 214   }
 215
 216   PragmaPackInfo *Info =
 217     (PragmaPackInfo*) PP.getPreprocessorAllocator().Allocate(
 218       sizeof(PragmaPackInfo), llvm::alignOf<PragmaPackInfo>());
 219   new (Info) PragmaPackInfo();
 220   Info->Kind = Kind;
 221   Info->Name = Name;
 222   Info->Alignment = Alignment.release();
 223   Info->LParenLoc = LParenLoc;
 224   Info->RParenLoc = RParenLoc;
 225
 226   Token *Toks =
 227     (Token*) PP.getPreprocessorAllocator().Allocate(
 228       sizeof(Token) * 1, llvm::alignOf<Token>());
 229   new (Toks) Token();
 230   Toks[0].startToken();
 231   Toks[0].setKind(tok::annot_pragma_pack);
 232   Toks[0].setLocation(PackLoc);
 233   Toks[0].setAnnotationValue(static_cast<void*>(Info));
 234   PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true,
 235                       /*OwnsTokens=*/false);
 236 }
 237
 238 // #pragma ms_struct on
 239 // #pragma ms_struct off
 240 void PragmaMSStructHandler::HandlePragma(Preprocessor &PP,
 241                                          PragmaIntroducerKind Introducer,
 242                                          Token &MSStructTok) {
 243   Sema::PragmaMSStructKind Kind = Sema::PMSST_OFF;
 244
 245   Token Tok;
 246   PP.Lex(Tok);
 247   if (Tok.isNot(tok::identifier)) {
 248     PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct);
 249     return;
 250   }
 251   const IdentifierInfo *II = Tok.getIdentifierInfo();
 252   if (II->isStr("on")) {
 253     Kind = Sema::PMSST_ON;
 254     PP.Lex(Tok);
 255   }
 256   else if (II->isStr("off") || II->isStr("reset"))
 257     PP.Lex(Tok);
 258   else {
 259     PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct);
 260     return;
 261   }
 262
 263   if (Tok.isNot(tok::eod)) {
 264     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
 265       << "ms_struct";
 266     return;
 267   }
 268   Actions.ActOnPragmaMSStruct(Kind);
 269 }
 270
 271 // #pragma 'align' '=' {'native','natural','mac68k','power','reset'}
 272 // #pragma 'options 'align' '=' {'native','natural','mac68k','power','reset'}
 273 static void ParseAlignPragma(Sema &Actions, Preprocessor &PP, Token &FirstTok,
 274                              bool IsOptions) {
 275   Token Tok;
 276
 277   if (IsOptions) {
 278     PP.Lex(Tok);
 279     if (Tok.isNot(tok::identifier) ||
 280         !Tok.getIdentifierInfo()->isStr("align")) {
 281       PP.Diag(Tok.getLocation(), diag::warn_pragma_options_expected_align);
 282       return;
 283     }
 284   }
 285
 286   PP.Lex(Tok);
 287   if (Tok.isNot(tok::equal)) {
 288     PP.Diag(Tok.getLocation(), diag::warn_pragma_align_expected_equal)
 289       << IsOptions;
 290     return;
 291   }
 292
 293   PP.Lex(Tok);
 294   if (Tok.isNot(tok::identifier)) {
 295     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
 296       << (IsOptions ? "options" : "align");
 297     return;
 298   }
 299
 300   Sema::PragmaOptionsAlignKind Kind = Sema::POAK_Natural;
 301   const IdentifierInfo *II = Tok.getIdentifierInfo();
 302   if (II->isStr("native"))
 303     Kind = Sema::POAK_Native;
 304   else if (II->isStr("natural"))
 305     Kind = Sema::POAK_Natural;
 306   else if (II->isStr("packed"))
 307     Kind = Sema::POAK_Packed;
 308   else if (II->isStr("power"))
 309     Kind = Sema::POAK_Power;
 310   else if (II->isStr("mac68k"))
 311     Kind = Sema::POAK_Mac68k;
 312   else if (II->isStr("reset"))
 313     Kind = Sema::POAK_Reset;
 314   else {
 315     PP.Diag(Tok.getLocation(), diag::warn_pragma_align_invalid_option)
 316       << IsOptions;
 317     return;
 318   }
 319
 320   SourceLocation KindLoc = Tok.getLocation();
 321   PP.Lex(Tok);
 322   if (Tok.isNot(tok::eod)) {
 323     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
 324       << (IsOptions ? "options" : "align");
 325     return;
 326   }
 327
 328   Actions.ActOnPragmaOptionsAlign(Kind, FirstTok.getLocation(), KindLoc);
 329 }
 330
 331 void PragmaAlignHandler::HandlePragma(Preprocessor &PP,
 332                                       PragmaIntroducerKind Introducer,
 333                                       Token &AlignTok) {
 334   ParseAlignPragma(Actions, PP, AlignTok, /*IsOptions=*/false);
 335 }
 336
 337 void PragmaOptionsHandler::HandlePragma(Preprocessor &PP,
 338                                         PragmaIntroducerKind Introducer,
 339                                         Token &OptionsTok) {
 340   ParseAlignPragma(Actions, PP, OptionsTok, /*IsOptions=*/true);
 341 }
 342
 343 // #pragma unused(identifier)
 344 void PragmaUnusedHandler::HandlePragma(Preprocessor &PP,
 345                                        PragmaIntroducerKind Introducer,
 346                                        Token &UnusedTok) {
 347   // FIXME: Should we be expanding macros here? My guess is no.
 348   SourceLocation UnusedLoc = UnusedTok.getLocation();
 349
 350   // Lex the left '('.
 351   Token Tok;
 352   PP.Lex(Tok);
 353   if (Tok.isNot(tok::l_paren)) {
 354     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "unused";
 355     return;
 356   }
 357
 358   // Lex the declaration reference(s).
 359   SmallVector<Token, 5> Identifiers;
 360   SourceLocation RParenLoc;
 361   bool LexID = true;
 362
 363   while (true) {
 364     PP.Lex(Tok);
 365
 366     if (LexID) {
 367       if (Tok.is(tok::identifier)) {
 368         Identifiers.push_back(Tok);
 369         LexID = false;
 370         continue;
 371       }
 372
 373       // Illegal token!
 374       PP.Diag(Tok.getLocation(), diag::warn_pragma_unused_expected_var);
 375       return;
 376     }
 377
 378     // We are execting a ')' or a ','.
 379     if (Tok.is(tok::comma)) {
 380       LexID = true;
 381       continue;
 382     }
 383
 384     if (Tok.is(tok::r_paren)) {
 385       RParenLoc = Tok.getLocation();
 386       break;
 387     }
 388
 389     // Illegal token!
 390     PP.Diag(Tok.getLocation(), diag::warn_pragma_unused_expected_punc);
 391     return;
 392   }
 393
 394   PP.Lex(Tok);
 395   if (Tok.isNot(tok::eod)) {
 396     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
 397         "unused";
 398     return;
 399   }
 400
 401   // Verify that we have a location for the right parenthesis.
 402   assert(RParenLoc.isValid() && "Valid '#pragma unused' must have ')'");
 403   assert(!Identifiers.empty() && "Valid '#pragma unused' must have arguments");
 404
 405   // For each identifier token, insert into the token stream a
 406   // annot_pragma_unused token followed by the identifier token.
 407   // This allows us to cache a "#pragma unused" that occurs inside an inline
 408   // C++ member function.
 409
 410   Token *Toks =
 411     (Token*) PP.getPreprocessorAllocator().Allocate(
 412       sizeof(Token) * 2 * Identifiers.size(), llvm::alignOf<Token>());
 413   for (unsigned i=0; i != Identifiers.size(); i++) {
 414     Token &pragmaUnusedTok = Toks[2*i], &idTok = Toks[2*i+1];
 415     pragmaUnusedTok.startToken();
 416     pragmaUnusedTok.setKind(tok::annot_pragma_unused);
 417     pragmaUnusedTok.setLocation(UnusedLoc);
 418     idTok = Identifiers[i];
 419   }
 420   PP.EnterTokenStream(Toks, 2*Identifiers.size(),
 421                       /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false);
 422 }
 423
 424 // #pragma weak identifier
 425 // #pragma weak identifier '=' identifier
 426 void PragmaWeakHandler::HandlePragma(Preprocessor &PP,
 427                                      PragmaIntroducerKind Introducer,
 428                                      Token &WeakTok) {
 429   // FIXME: Should we be expanding macros here? My guess is no.
 430   SourceLocation WeakLoc = WeakTok.getLocation();
 431
 432   Token Tok;
 433   PP.Lex(Tok);
 434   if (Tok.isNot(tok::identifier)) {
 435     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "weak";
 436     return;
 437   }
 438
 439   IdentifierInfo *WeakName = Tok.getIdentifierInfo(), *AliasName = 0;
 440   SourceLocation WeakNameLoc = Tok.getLocation(), AliasNameLoc;
 441
 442   PP.Lex(Tok);
 443   if (Tok.is(tok::equal)) {
 444     PP.Lex(Tok);
 445     if (Tok.isNot(tok::identifier)) {
 446       PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
 447           << "weak";
 448       return;
 449     }
 450     AliasName = Tok.getIdentifierInfo();
 451     AliasNameLoc = Tok.getLocation();
 452     PP.Lex(Tok);
 453   }
 454
 455   if (Tok.isNot(tok::eod)) {
 456     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "weak";
 457     return;
 458   }
 459
 460   if (AliasName) {
 461     Actions.ActOnPragmaWeakAlias(WeakName, AliasName, WeakLoc, WeakNameLoc,
 462                                  AliasNameLoc);
 463   } else {
 464     Actions.ActOnPragmaWeakID(WeakName, WeakLoc, WeakNameLoc);
 465   }
 466 }
 467
 468 // #pragma redefine_extname identifier identifier
 469 void PragmaRedefineExtnameHandler::HandlePragma(Preprocessor &PP,
 470                                                PragmaIntroducerKind Introducer,
 471                                                 Token &RedefToken) {
 472   SourceLocation RedefLoc = RedefToken.getLocation();
 473
 474   Token Tok;
 475   PP.Lex(Tok);
 476   if (Tok.isNot(tok::identifier)) {
 477     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) <<
 478       "redefine_extname";
 479     return;
 480   }
 481
 482   IdentifierInfo *RedefName = Tok.getIdentifierInfo(), *AliasName = 0;
 483   SourceLocation RedefNameLoc = Tok.getLocation(), AliasNameLoc;
 484
 485   PP.Lex(Tok);
 486   if (Tok.isNot(tok::identifier)) {
 487     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
 488         << "redefine_extname";
 489     return;
 490   }
 491   AliasName = Tok.getIdentifierInfo();
 492   AliasNameLoc = Tok.getLocation();
 493   PP.Lex(Tok);
 494
 495   if (Tok.isNot(tok::eod)) {
 496     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
 497       "redefine_extname";
 498     return;
 499   }
 500
 501   Actions.ActOnPragmaRedefineExtname(RedefName, AliasName, RedefLoc,
 502       RedefNameLoc, AliasNameLoc);
 503 }
 504
 505
 506 void
 507 PragmaFPContractHandler::HandlePragma(Preprocessor &PP,
 508                                       PragmaIntroducerKind Introducer,
 509                                       Token &Tok) {
 510   tok::OnOffSwitch OOS;
 511   if (PP.LexOnOffSwitch(OOS))
 512     return;
 513
 514   Actions.ActOnPragmaFPContract(OOS);
 515 }
 516
 517 void
 518 PragmaOpenCLExtensionHandler::HandlePragma(Preprocessor &PP,
 519                                            PragmaIntroducerKind Introducer,
 520                                            Token &Tok) {
 521   PP.LexUnexpandedToken(Tok);
 522   if (Tok.isNot(tok::identifier)) {
 523     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) <<
 524       "OPENCL";
 525     return;
 526   }
 527   IdentifierInfo *ename = Tok.getIdentifierInfo();
 528   SourceLocation NameLoc = Tok.getLocation();
 529
 530   PP.Lex(Tok);
 531   if (Tok.isNot(tok::colon)) {
 532     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_colon) << ename;
 533     return;
 534   }
 535
 536   PP.Lex(Tok);
 537   if (Tok.isNot(tok::identifier)) {
 538     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable);
 539     return;
 540   }
 541   IdentifierInfo *op = Tok.getIdentifierInfo();
 542
 543   unsigned state;
 544   if (op->isStr("enable")) {
 545     state = 1;
 546   } else if (op->isStr("disable")) {
 547     state = 0;
 548   } else {
 549     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable);
 550     return;
 551   }
 552
 553   OpenCLOptions &f = Actions.getOpenCLOptions();
 554   // OpenCL 1.1 9.1: "The all variant sets the behavior for all extensions,
 555   // overriding all previously issued extension directives, but only if the
 556   // behavior is set to disable."
 557   if (state == 0 && ename->isStr("all")) {
 558 #define OPENCLEXT(nm)   f.nm = 0;
 559 #include "clang/Basic/OpenCLExtensions.def"
 560   }
 561 #define OPENCLEXT(nm) else if (ename->isStr(#nm)) { f.nm = state; }
 562 #include "clang/Basic/OpenCLExtensions.def"
 563   else {
 564     PP.Diag(NameLoc, diag::warn_pragma_unknown_extension) << ename;
 565     return;
 566   }
 567 }
 568