1/* Handle #pragma, system V.4 style. Supports #pragma weak and #pragma pack. 2 Copyright (C) 1992, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 3 2006, 2007, 2008 Free Software Foundation, Inc. 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 3, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING3. If not see 19<http://www.gnu.org/licenses/>. */ 20 21#include "config.h" 22#include "system.h" 23#include "coretypes.h" 24#include "tm.h" 25#include "rtl.h" 26#include "tree.h" 27#include "function.h" 28#include "cpplib.h" 29#include "c-pragma.h" 30#include "flags.h" 31#include "toplev.h" 32#include "ggc.h" 33#include "c-common.h" 34#include "output.h" 35#include "tm_p.h" 36#include "vec.h" 37#include "target.h" 38#include "diagnostic.h" 39#include "opts.h" 40#include "plugin.h" 41 42#define GCC_BAD(gmsgid) \ 43 do { warning (OPT_Wpragmas, gmsgid); return; } while (0) 44#define GCC_BAD2(gmsgid, arg) \ 45 do { warning (OPT_Wpragmas, gmsgid, arg); return; } while (0) 46 47typedef struct GTY(()) align_stack { 48 int alignment; 49 tree id; 50 struct align_stack * prev; 51} align_stack; 52 53static GTY(()) struct align_stack * alignment_stack; 54 55#ifdef HANDLE_PRAGMA_PACK 56static void handle_pragma_pack (cpp_reader *); 57 58#ifdef HANDLE_PRAGMA_PACK_PUSH_POP 59/* If we have a "global" #pragma pack(<n>) in effect when the first 60 #pragma pack(push,<n>) is encountered, this stores the value of 61 maximum_field_alignment in effect. When the final pop_alignment() 62 happens, we restore the value to this, not to a value of 0 for 63 maximum_field_alignment. Value is in bits. */ 64static int default_alignment; 65#define SET_GLOBAL_ALIGNMENT(ALIGN) (maximum_field_alignment = *(alignment_stack == NULL \ 66 ? &default_alignment \ 67 : &alignment_stack->alignment) = (ALIGN)) 68 69static void push_alignment (int, tree); 70static void pop_alignment (tree); 71 72/* Push an alignment value onto the stack. */ 73static void 74push_alignment (int alignment, tree id) 75{ 76 align_stack * entry; 77 78 entry = GGC_NEW (align_stack); 79 80 entry->alignment = alignment; 81 entry->id = id; 82 entry->prev = alignment_stack; 83 84 /* The current value of maximum_field_alignment is not necessarily 85 0 since there may be a #pragma pack(<n>) in effect; remember it 86 so that we can restore it after the final #pragma pop(). */ 87 if (alignment_stack == NULL) 88 default_alignment = maximum_field_alignment; 89 90 alignment_stack = entry; 91 92 maximum_field_alignment = alignment; 93} 94 95/* Undo a push of an alignment onto the stack. */ 96static void 97pop_alignment (tree id) 98{ 99 align_stack * entry; 100 101 if (alignment_stack == NULL) 102 GCC_BAD ("#pragma pack (pop) encountered without matching #pragma pack (push)"); 103 104 /* If we got an identifier, strip away everything above the target 105 entry so that the next step will restore the state just below it. */ 106 if (id) 107 { 108 for (entry = alignment_stack; entry; entry = entry->prev) 109 if (entry->id == id) 110 { 111 alignment_stack = entry; 112 break; 113 } 114 if (entry == NULL) 115 warning (OPT_Wpragmas, "\ 116#pragma pack(pop, %E) encountered without matching #pragma pack(push, %E)" 117 , id, id); 118 } 119 120 entry = alignment_stack->prev; 121 122 maximum_field_alignment = entry ? entry->alignment : default_alignment; 123 124 alignment_stack = entry; 125} 126#else /* not HANDLE_PRAGMA_PACK_PUSH_POP */ 127#define SET_GLOBAL_ALIGNMENT(ALIGN) (maximum_field_alignment = (ALIGN)) 128#define push_alignment(ID, N) \ 129 GCC_BAD ("#pragma pack(push[, id], <n>) is not supported on this target") 130#define pop_alignment(ID) \ 131 GCC_BAD ("#pragma pack(pop[, id], <n>) is not supported on this target") 132#endif /* HANDLE_PRAGMA_PACK_PUSH_POP */ 133 134/* #pragma pack () 135 #pragma pack (N) 136 137 #pragma pack (push) 138 #pragma pack (push, N) 139 #pragma pack (push, ID) 140 #pragma pack (push, ID, N) 141 #pragma pack (pop) 142 #pragma pack (pop, ID) */ 143static void 144handle_pragma_pack (cpp_reader * ARG_UNUSED (dummy)) 145{ 146 tree x, id = 0; 147 int align = -1; 148 enum cpp_ttype token; 149 enum { set, push, pop } action; 150 151 if (pragma_lex (&x) != CPP_OPEN_PAREN) 152 GCC_BAD ("missing %<(%> after %<#pragma pack%> - ignored"); 153 154 token = pragma_lex (&x); 155 if (token == CPP_CLOSE_PAREN) 156 { 157 action = set; 158 align = initial_max_fld_align; 159 } 160 else if (token == CPP_NUMBER) 161 { 162 if (TREE_CODE (x) != INTEGER_CST) 163 GCC_BAD ("invalid constant in %<#pragma pack%> - ignored"); 164 align = TREE_INT_CST_LOW (x); 165 action = set; 166 if (pragma_lex (&x) != CPP_CLOSE_PAREN) 167 GCC_BAD ("malformed %<#pragma pack%> - ignored"); 168 } 169 else if (token == CPP_NAME) 170 { 171#define GCC_BAD_ACTION do { if (action != pop) \ 172 GCC_BAD ("malformed %<#pragma pack(push[, id][, <n>])%> - ignored"); \ 173 else \ 174 GCC_BAD ("malformed %<#pragma pack(pop[, id])%> - ignored"); \ 175 } while (0) 176 177 const char *op = IDENTIFIER_POINTER (x); 178 if (!strcmp (op, "push")) 179 action = push; 180 else if (!strcmp (op, "pop")) 181 action = pop; 182 else 183 GCC_BAD2 ("unknown action %qE for %<#pragma pack%> - ignored", x); 184 185 while ((token = pragma_lex (&x)) == CPP_COMMA) 186 { 187 token = pragma_lex (&x); 188 if (token == CPP_NAME && id == 0) 189 { 190 id = x; 191 } 192 else if (token == CPP_NUMBER && action == push && align == -1) 193 { 194 if (TREE_CODE (x) != INTEGER_CST) 195 GCC_BAD ("invalid constant in %<#pragma pack%> - ignored"); 196 align = TREE_INT_CST_LOW (x); 197 if (align == -1) 198 action = set; 199 } 200 else 201 GCC_BAD_ACTION; 202 } 203 204 if (token != CPP_CLOSE_PAREN) 205 GCC_BAD_ACTION; 206#undef GCC_BAD_ACTION 207 } 208 else 209 GCC_BAD ("malformed %<#pragma pack%> - ignored"); 210 211 if (pragma_lex (&x) != CPP_EOF) 212 warning (OPT_Wpragmas, "junk at end of %<#pragma pack%>"); 213 214 if (flag_pack_struct) 215 GCC_BAD ("#pragma pack has no effect with -fpack-struct - ignored"); 216 217 if (action != pop) 218 switch (align) 219 { 220 case 0: 221 case 1: 222 case 2: 223 case 4: 224 case 8: 225 case 16: 226 align *= BITS_PER_UNIT; 227 break; 228 case -1: 229 if (action == push) 230 { 231 align = maximum_field_alignment; 232 break; 233 } 234 default: 235 GCC_BAD2 ("alignment must be a small power of two, not %d", align); 236 } 237 238 switch (action) 239 { 240 case set: SET_GLOBAL_ALIGNMENT (align); break; 241 case push: push_alignment (align, id); break; 242 case pop: pop_alignment (id); break; 243 } 244} 245#endif /* HANDLE_PRAGMA_PACK */ 246 247static GTY(()) tree pending_weaks; 248 249#ifdef HANDLE_PRAGMA_WEAK 250static void apply_pragma_weak (tree, tree); 251static void handle_pragma_weak (cpp_reader *); 252 253static void 254apply_pragma_weak (tree decl, tree value) 255{ 256 if (value) 257 { 258 value = build_string (IDENTIFIER_LENGTH (value), 259 IDENTIFIER_POINTER (value)); 260 decl_attributes (&decl, build_tree_list (get_identifier ("alias"), 261 build_tree_list (NULL, value)), 262 0); 263 } 264 265 if (SUPPORTS_WEAK && DECL_EXTERNAL (decl) && TREE_USED (decl) 266 && !DECL_WEAK (decl) /* Don't complain about a redundant #pragma. */ 267 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))) 268 warning (OPT_Wpragmas, "applying #pragma weak %q+D after first use " 269 "results in unspecified behavior", decl); 270 271 declare_weak (decl); 272} 273 274void 275maybe_apply_pragma_weak (tree decl) 276{ 277 tree *p, t, id; 278 279 /* Avoid asking for DECL_ASSEMBLER_NAME when it's not needed. */ 280 281 /* No weak symbols pending, take the short-cut. */ 282 if (!pending_weaks) 283 return; 284 /* If it's not visible outside this file, it doesn't matter whether 285 it's weak. */ 286 if (!DECL_EXTERNAL (decl) && !TREE_PUBLIC (decl)) 287 return; 288 /* If it's not a function or a variable, it can't be weak. 289 FIXME: what kinds of things are visible outside this file but 290 aren't functions or variables? Should this be an assert instead? */ 291 if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL) 292 return; 293 294 id = DECL_ASSEMBLER_NAME (decl); 295 296 for (p = &pending_weaks; (t = *p) ; p = &TREE_CHAIN (t)) 297 if (id == TREE_PURPOSE (t)) 298 { 299 apply_pragma_weak (decl, TREE_VALUE (t)); 300 *p = TREE_CHAIN (t); 301 break; 302 } 303} 304 305/* Process all "#pragma weak A = B" directives where we have not seen 306 a decl for A. */ 307void 308maybe_apply_pending_pragma_weaks (void) 309{ 310 tree *p, t, alias_id, id, decl, *next; 311 312 for (p = &pending_weaks; (t = *p) ; p = next) 313 { 314 next = &TREE_CHAIN (t); 315 alias_id = TREE_PURPOSE (t); 316 id = TREE_VALUE (t); 317 318 if (TREE_VALUE (t) == NULL) 319 continue; 320 321 decl = build_decl (UNKNOWN_LOCATION, 322 FUNCTION_DECL, alias_id, default_function_type); 323 324 DECL_ARTIFICIAL (decl) = 1; 325 TREE_PUBLIC (decl) = 1; 326 DECL_EXTERNAL (decl) = 1; 327 DECL_WEAK (decl) = 1; 328 329 assemble_alias (decl, id); 330 } 331} 332 333/* #pragma weak name [= value] */ 334static void 335handle_pragma_weak (cpp_reader * ARG_UNUSED (dummy)) 336{ 337 tree name, value, x, decl; 338 enum cpp_ttype t; 339 340 value = 0; 341 342 if (pragma_lex (&name) != CPP_NAME) 343 GCC_BAD ("malformed #pragma weak, ignored"); 344 t = pragma_lex (&x); 345 if (t == CPP_EQ) 346 { 347 if (pragma_lex (&value) != CPP_NAME) 348 GCC_BAD ("malformed #pragma weak, ignored"); 349 t = pragma_lex (&x); 350 } 351 if (t != CPP_EOF) 352 warning (OPT_Wpragmas, "junk at end of %<#pragma weak%>"); 353 354 decl = identifier_global_value (name); 355 if (decl && DECL_P (decl)) 356 { 357 apply_pragma_weak (decl, value); 358 if (value) 359 assemble_alias (decl, value); 360 } 361 else 362 pending_weaks = tree_cons (name, value, pending_weaks); 363} 364#else 365void 366maybe_apply_pragma_weak (tree ARG_UNUSED (decl)) 367{ 368} 369 370void 371maybe_apply_pending_pragma_weaks (void) 372{ 373} 374#endif /* HANDLE_PRAGMA_WEAK */ 375 376/* GCC supports two #pragma directives for renaming the external 377 symbol associated with a declaration (DECL_ASSEMBLER_NAME), for 378 compatibility with the Solaris and Tru64 system headers. GCC also 379 has its own notation for this, __asm__("name") annotations. 380 381 Corner cases of these features and their interaction: 382 383 1) Both pragmas silently apply only to declarations with external 384 linkage (that is, TREE_PUBLIC || DECL_EXTERNAL). Asm labels 385 do not have this restriction. 386 387 2) In C++, both #pragmas silently apply only to extern "C" declarations. 388 Asm labels do not have this restriction. 389 390 3) If any of the three ways of changing DECL_ASSEMBLER_NAME is 391 applied to a decl whose DECL_ASSEMBLER_NAME is already set, and the 392 new name is different, a warning issues and the name does not change. 393 394 4) The "source name" for #pragma redefine_extname is the DECL_NAME, 395 *not* the DECL_ASSEMBLER_NAME. 396 397 5) If #pragma extern_prefix is in effect and a declaration occurs 398 with an __asm__ name, the #pragma extern_prefix is silently 399 ignored for that declaration. 400 401 6) If #pragma extern_prefix and #pragma redefine_extname apply to 402 the same declaration, whichever triggered first wins, and a warning 403 is issued. (We would like to have #pragma redefine_extname always 404 win, but it can appear either before or after the declaration, and 405 if it appears afterward, we have no way of knowing whether a modified 406 DECL_ASSEMBLER_NAME is due to #pragma extern_prefix.) */ 407 408static GTY(()) tree pending_redefine_extname; 409 410static void handle_pragma_redefine_extname (cpp_reader *); 411 412/* #pragma redefine_extname oldname newname */ 413static void 414handle_pragma_redefine_extname (cpp_reader * ARG_UNUSED (dummy)) 415{ 416 tree oldname, newname, decl, x; 417 enum cpp_ttype t; 418 419 if (pragma_lex (&oldname) != CPP_NAME) 420 GCC_BAD ("malformed #pragma redefine_extname, ignored"); 421 if (pragma_lex (&newname) != CPP_NAME) 422 GCC_BAD ("malformed #pragma redefine_extname, ignored"); 423 t = pragma_lex (&x); 424 if (t != CPP_EOF) 425 warning (OPT_Wpragmas, "junk at end of %<#pragma redefine_extname%>"); 426 427 decl = identifier_global_value (oldname); 428 if (decl 429 && (TREE_PUBLIC (decl) || DECL_EXTERNAL (decl)) 430 && (TREE_CODE (decl) == FUNCTION_DECL 431 || TREE_CODE (decl) == VAR_DECL) 432 && has_c_linkage (decl)) 433 { 434 if (DECL_ASSEMBLER_NAME_SET_P (decl)) 435 { 436 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 437 name = targetm.strip_name_encoding (name); 438 439 if (strcmp (name, IDENTIFIER_POINTER (newname))) 440 warning (OPT_Wpragmas, "#pragma redefine_extname ignored due to " 441 "conflict with previous rename"); 442 } 443 else 444 change_decl_assembler_name (decl, newname); 445 } 446 else 447 /* We have to add this to the rename list even if there's already 448 a global value that doesn't meet the above criteria, because in 449 C++ "struct foo {...};" puts "foo" in the current namespace but 450 does *not* conflict with a subsequent declaration of a function 451 or variable foo. See g++.dg/other/pragma-re-2.C. */ 452 add_to_renaming_pragma_list (oldname, newname); 453} 454 455/* This is called from here and from ia64.c. */ 456void 457add_to_renaming_pragma_list (tree oldname, tree newname) 458{ 459 tree previous = purpose_member (oldname, pending_redefine_extname); 460 if (previous) 461 { 462 if (TREE_VALUE (previous) != newname) 463 warning (OPT_Wpragmas, "#pragma redefine_extname ignored due to " 464 "conflict with previous #pragma redefine_extname"); 465 return; 466 } 467 468 pending_redefine_extname 469 = tree_cons (oldname, newname, pending_redefine_extname); 470} 471 472static GTY(()) tree pragma_extern_prefix; 473 474/* #pragma extern_prefix "prefix" */ 475static void 476handle_pragma_extern_prefix (cpp_reader * ARG_UNUSED (dummy)) 477{ 478 tree prefix, x; 479 enum cpp_ttype t; 480 481 if (pragma_lex (&prefix) != CPP_STRING) 482 GCC_BAD ("malformed #pragma extern_prefix, ignored"); 483 t = pragma_lex (&x); 484 if (t != CPP_EOF) 485 warning (OPT_Wpragmas, "junk at end of %<#pragma extern_prefix%>"); 486 487 if (targetm.handle_pragma_extern_prefix) 488 /* Note that the length includes the null terminator. */ 489 pragma_extern_prefix = (TREE_STRING_LENGTH (prefix) > 1 ? prefix : NULL); 490 else if (warn_unknown_pragmas > in_system_header) 491 warning (OPT_Wunknown_pragmas, 492 "#pragma extern_prefix not supported on this target"); 493} 494 495/* Hook from the front ends to apply the results of one of the preceding 496 pragmas that rename variables. */ 497 498tree 499maybe_apply_renaming_pragma (tree decl, tree asmname) 500{ 501 tree *p, t; 502 503 /* The renaming pragmas are only applied to declarations with 504 external linkage. */ 505 if ((TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL) 506 || (!TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl)) 507 || !has_c_linkage (decl)) 508 return asmname; 509 510 /* If the DECL_ASSEMBLER_NAME is already set, it does not change, 511 but we may warn about a rename that conflicts. */ 512 if (DECL_ASSEMBLER_NAME_SET_P (decl)) 513 { 514 const char *oldname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 515 oldname = targetm.strip_name_encoding (oldname); 516 517 if (asmname && strcmp (TREE_STRING_POINTER (asmname), oldname)) 518 warning (OPT_Wpragmas, "asm declaration ignored due to " 519 "conflict with previous rename"); 520 521 /* Take any pending redefine_extname off the list. */ 522 for (p = &pending_redefine_extname; (t = *p); p = &TREE_CHAIN (t)) 523 if (DECL_NAME (decl) == TREE_PURPOSE (t)) 524 { 525 /* Only warn if there is a conflict. */ 526 if (strcmp (IDENTIFIER_POINTER (TREE_VALUE (t)), oldname)) 527 warning (OPT_Wpragmas, "#pragma redefine_extname ignored due to " 528 "conflict with previous rename"); 529 530 *p = TREE_CHAIN (t); 531 break; 532 } 533 return 0; 534 } 535 536 /* Find out if we have a pending #pragma redefine_extname. */ 537 for (p = &pending_redefine_extname; (t = *p); p = &TREE_CHAIN (t)) 538 if (DECL_NAME (decl) == TREE_PURPOSE (t)) 539 { 540 tree newname = TREE_VALUE (t); 541 *p = TREE_CHAIN (t); 542 543 /* If we already have an asmname, #pragma redefine_extname is 544 ignored (with a warning if it conflicts). */ 545 if (asmname) 546 { 547 if (strcmp (TREE_STRING_POINTER (asmname), 548 IDENTIFIER_POINTER (newname)) != 0) 549 warning (OPT_Wpragmas, "#pragma redefine_extname ignored due to " 550 "conflict with __asm__ declaration"); 551 return asmname; 552 } 553 554 /* Otherwise we use what we've got; #pragma extern_prefix is 555 silently ignored. */ 556 return build_string (IDENTIFIER_LENGTH (newname), 557 IDENTIFIER_POINTER (newname)); 558 } 559 560 /* If we've got an asmname, #pragma extern_prefix is silently ignored. */ 561 if (asmname) 562 return asmname; 563 564 /* If #pragma extern_prefix is in effect, apply it. */ 565 if (pragma_extern_prefix) 566 { 567 const char *prefix = TREE_STRING_POINTER (pragma_extern_prefix); 568 size_t plen = TREE_STRING_LENGTH (pragma_extern_prefix) - 1; 569 570 const char *id = IDENTIFIER_POINTER (DECL_NAME (decl)); 571 size_t ilen = IDENTIFIER_LENGTH (DECL_NAME (decl)); 572 573 char *newname = (char *) alloca (plen + ilen + 1); 574 575 memcpy (newname, prefix, plen); 576 memcpy (newname + plen, id, ilen + 1); 577 578 return build_string (plen + ilen, newname); 579 } 580 581 /* Nada. */ 582 return 0; 583} 584 585 586#ifdef HANDLE_PRAGMA_VISIBILITY 587static void handle_pragma_visibility (cpp_reader *); 588 589static VEC (int, heap) *visstack; 590 591/* Push the visibility indicated by STR onto the top of the #pragma 592 visibility stack. KIND is 0 for #pragma GCC visibility, 1 for 593 C++ namespace with visibility attribute and 2 for C++ builtin 594 ABI namespace. push_visibility/pop_visibility calls must have 595 matching KIND, it is not allowed to push visibility using one 596 KIND and pop using a different one. */ 597 598void 599push_visibility (const char *str, int kind) 600{ 601 VEC_safe_push (int, heap, visstack, 602 ((int) default_visibility) | (kind << 8)); 603 if (!strcmp (str, "default")) 604 default_visibility = VISIBILITY_DEFAULT; 605 else if (!strcmp (str, "internal")) 606 default_visibility = VISIBILITY_INTERNAL; 607 else if (!strcmp (str, "hidden")) 608 default_visibility = VISIBILITY_HIDDEN; 609 else if (!strcmp (str, "protected")) 610 default_visibility = VISIBILITY_PROTECTED; 611 else 612 GCC_BAD ("#pragma GCC visibility push() must specify default, internal, hidden or protected"); 613 visibility_options.inpragma = 1; 614} 615 616/* Pop a level of the #pragma visibility stack. Return true if 617 successful. */ 618 619bool 620pop_visibility (int kind) 621{ 622 if (!VEC_length (int, visstack)) 623 return false; 624 if ((VEC_last (int, visstack) >> 8) != kind) 625 return false; 626 default_visibility 627 = (enum symbol_visibility) (VEC_pop (int, visstack) & 0xff); 628 visibility_options.inpragma 629 = VEC_length (int, visstack) != 0; 630 return true; 631} 632 633/* Sets the default visibility for symbols to something other than that 634 specified on the command line. */ 635 636static void 637handle_pragma_visibility (cpp_reader *dummy ATTRIBUTE_UNUSED) 638{ 639 /* Form is #pragma GCC visibility push(hidden)|pop */ 640 tree x; 641 enum cpp_ttype token; 642 enum { bad, push, pop } action = bad; 643 644 token = pragma_lex (&x); 645 if (token == CPP_NAME) 646 { 647 const char *op = IDENTIFIER_POINTER (x); 648 if (!strcmp (op, "push")) 649 action = push; 650 else if (!strcmp (op, "pop")) 651 action = pop; 652 } 653 if (bad == action) 654 GCC_BAD ("#pragma GCC visibility must be followed by push or pop"); 655 else 656 { 657 if (pop == action) 658 { 659 if (! pop_visibility (0)) 660 GCC_BAD ("no matching push for %<#pragma GCC visibility pop%>"); 661 } 662 else 663 { 664 if (pragma_lex (&x) != CPP_OPEN_PAREN) 665 GCC_BAD ("missing %<(%> after %<#pragma GCC visibility push%> - ignored"); 666 token = pragma_lex (&x); 667 if (token != CPP_NAME) 668 GCC_BAD ("malformed #pragma GCC visibility push"); 669 else 670 push_visibility (IDENTIFIER_POINTER (x), 0); 671 if (pragma_lex (&x) != CPP_CLOSE_PAREN) 672 GCC_BAD ("missing %<(%> after %<#pragma GCC visibility push%> - ignored"); 673 } 674 } 675 if (pragma_lex (&x) != CPP_EOF) 676 warning (OPT_Wpragmas, "junk at end of %<#pragma GCC visibility%>"); 677} 678 679#endif 680 681static void 682handle_pragma_diagnostic(cpp_reader *ARG_UNUSED(dummy)) 683{ 684 const char *kind_string, *option_string; 685 unsigned int option_index; 686 enum cpp_ttype token; 687 diagnostic_t kind; 688 tree x; 689 690 if (cfun) 691 { 692 error ("#pragma GCC diagnostic not allowed inside functions"); 693 return; 694 } 695 696 token = pragma_lex (&x); 697 if (token != CPP_NAME) 698 GCC_BAD ("missing [error|warning|ignored] after %<#pragma GCC diagnostic%>"); 699 kind_string = IDENTIFIER_POINTER (x); 700 if (strcmp (kind_string, "error") == 0) 701 kind = DK_ERROR; 702 else if (strcmp (kind_string, "warning") == 0) 703 kind = DK_WARNING; 704 else if (strcmp (kind_string, "ignored") == 0) 705 kind = DK_IGNORED; 706 else 707 GCC_BAD ("expected [error|warning|ignored] after %<#pragma GCC diagnostic%>"); 708 709 token = pragma_lex (&x); 710 if (token != CPP_STRING) 711 GCC_BAD ("missing option after %<#pragma GCC diagnostic%> kind"); 712 option_string = TREE_STRING_POINTER (x); 713 for (option_index = 0; option_index < cl_options_count; option_index++) 714 if (strcmp (cl_options[option_index].opt_text, option_string) == 0) 715 { 716 /* This overrides -Werror, for example. */ 717 diagnostic_classify_diagnostic (global_dc, option_index, kind); 718 /* This makes sure the option is enabled, like -Wfoo would do. */ 719 if (cl_options[option_index].var_type == CLVC_BOOLEAN 720 && cl_options[option_index].flag_var 721 && kind != DK_IGNORED) 722 *(int *) cl_options[option_index].flag_var = 1; 723 return; 724 } 725 GCC_BAD ("unknown option after %<#pragma GCC diagnostic%> kind"); 726} 727 728/* Parse #pragma GCC target (xxx) to set target specific options. */ 729static void 730handle_pragma_target(cpp_reader *ARG_UNUSED(dummy)) 731{ 732 enum cpp_ttype token; 733 tree x; 734 bool close_paren_needed_p = false; 735 736 if (cfun) 737 { 738 error ("#pragma GCC option is not allowed inside functions"); 739 return; 740 } 741 742 token = pragma_lex (&x); 743 if (token == CPP_OPEN_PAREN) 744 { 745 close_paren_needed_p = true; 746 token = pragma_lex (&x); 747 } 748 749 if (token != CPP_STRING) 750 { 751 GCC_BAD ("%<#pragma GCC option%> is not a string"); 752 return; 753 } 754 755 /* Strings are user options. */ 756 else 757 { 758 tree args = NULL_TREE; 759 760 do 761 { 762 /* Build up the strings now as a tree linked list. Skip empty 763 strings. */ 764 if (TREE_STRING_LENGTH (x) > 0) 765 args = tree_cons (NULL_TREE, x, args); 766 767 token = pragma_lex (&x); 768 while (token == CPP_COMMA) 769 token = pragma_lex (&x); 770 } 771 while (token == CPP_STRING); 772 773 if (close_paren_needed_p) 774 { 775 if (token == CPP_CLOSE_PAREN) 776 token = pragma_lex (&x); 777 else 778 GCC_BAD ("%<#pragma GCC target (string [,string]...)%> does " 779 "not have a final %<)%>."); 780 } 781 782 if (token != CPP_EOF) 783 { 784 error ("#pragma GCC target string... is badly formed"); 785 return; 786 } 787 788 /* put arguments in the order the user typed them. */ 789 args = nreverse (args); 790 791 if (targetm.target_option.pragma_parse (args, NULL_TREE)) 792 current_target_pragma = args; 793 } 794} 795 796/* Handle #pragma GCC optimize to set optimization options. */ 797static void 798handle_pragma_optimize (cpp_reader *ARG_UNUSED(dummy)) 799{ 800 enum cpp_ttype token; 801 tree x; 802 bool close_paren_needed_p = false; 803 tree optimization_previous_node = optimization_current_node; 804 805 if (cfun) 806 { 807 error ("#pragma GCC optimize is not allowed inside functions"); 808 return; 809 } 810 811 token = pragma_lex (&x); 812 if (token == CPP_OPEN_PAREN) 813 { 814 close_paren_needed_p = true; 815 token = pragma_lex (&x); 816 } 817 818 if (token != CPP_STRING && token != CPP_NUMBER) 819 { 820 GCC_BAD ("%<#pragma GCC optimize%> is not a string or number"); 821 return; 822 } 823 824 /* Strings/numbers are user options. */ 825 else 826 { 827 tree args = NULL_TREE; 828 829 do 830 { 831 /* Build up the numbers/strings now as a list. */ 832 if (token != CPP_STRING || TREE_STRING_LENGTH (x) > 0) 833 args = tree_cons (NULL_TREE, x, args); 834 835 token = pragma_lex (&x); 836 while (token == CPP_COMMA) 837 token = pragma_lex (&x); 838 } 839 while (token == CPP_STRING || token == CPP_NUMBER); 840 841 if (close_paren_needed_p) 842 { 843 if (token == CPP_CLOSE_PAREN) 844 token = pragma_lex (&x); 845 else 846 GCC_BAD ("%<#pragma GCC optimize (string [,string]...)%> does " 847 "not have a final %<)%>."); 848 } 849 850 if (token != CPP_EOF) 851 { 852 error ("#pragma GCC optimize string... is badly formed"); 853 return; 854 } 855 856 /* put arguments in the order the user typed them. */ 857 args = nreverse (args); 858 859 parse_optimize_options (args, false); 860 current_optimize_pragma = chainon (current_optimize_pragma, args); 861 optimization_current_node = build_optimization_node (); 862 c_cpp_builtins_optimize_pragma (parse_in, 863 optimization_previous_node, 864 optimization_current_node); 865 } 866} 867 868/* Stack of the #pragma GCC options created with #pragma GCC push_option. Save 869 both the binary representation of the options and the TREE_LIST of 870 strings that will be added to the function's attribute list. */ 871typedef struct GTY(()) opt_stack { 872 struct opt_stack *prev; 873 tree target_binary; 874 tree target_strings; 875 tree optimize_binary; 876 tree optimize_strings; 877} opt_stack; 878 879static GTY(()) struct opt_stack * options_stack; 880 881/* Handle #pragma GCC push_options to save the current target and optimization 882 options. */ 883 884static void 885handle_pragma_push_options (cpp_reader *ARG_UNUSED(dummy)) 886{ 887 enum cpp_ttype token; 888 tree x = 0; 889 opt_stack *p; 890 891 token = pragma_lex (&x); 892 if (token != CPP_EOF) 893 { 894 warning (OPT_Wpragmas, "junk at end of %<#pragma push_options%>"); 895 return; 896 } 897 898 p = GGC_NEW (opt_stack); 899 p->prev = options_stack; 900 options_stack = p; 901 902 /* Save optimization and target flags in binary format. */ 903 p->optimize_binary = build_optimization_node (); 904 p->target_binary = build_target_option_node (); 905 906 /* Save optimization and target flags in string list format. */ 907 p->optimize_strings = copy_list (current_optimize_pragma); 908 p->target_strings = copy_list (current_target_pragma); 909} 910 911/* Handle #pragma GCC pop_options to restore the current target and 912 optimization options from a previous push_options. */ 913 914static void 915handle_pragma_pop_options (cpp_reader *ARG_UNUSED(dummy)) 916{ 917 enum cpp_ttype token; 918 tree x = 0; 919 opt_stack *p; 920 921 token = pragma_lex (&x); 922 if (token != CPP_EOF) 923 { 924 warning (OPT_Wpragmas, "junk at end of %<#pragma pop_options%>"); 925 return; 926 } 927 928 if (! options_stack) 929 { 930 warning (OPT_Wpragmas, 931 "%<#pragma GCC pop_options%> without a corresponding " 932 "%<#pragma GCC push_options%>"); 933 return; 934 } 935 936 p = options_stack; 937 options_stack = p->prev; 938 939 if (p->target_binary != target_option_current_node) 940 { 941 (void) targetm.target_option.pragma_parse (NULL_TREE, p->target_binary); 942 target_option_current_node = p->target_binary; 943 } 944 945 if (p->optimize_binary != optimization_current_node) 946 { 947 tree old_optimize = optimization_current_node; 948 cl_optimization_restore (TREE_OPTIMIZATION (p->optimize_binary)); 949 c_cpp_builtins_optimize_pragma (parse_in, old_optimize, 950 p->optimize_binary); 951 optimization_current_node = p->optimize_binary; 952 } 953 954 current_target_pragma = p->target_strings; 955 current_optimize_pragma = p->optimize_strings; 956} 957 958/* Handle #pragma GCC reset_options to restore the current target and 959 optimization options to the original options used on the command line. */ 960 961static void 962handle_pragma_reset_options (cpp_reader *ARG_UNUSED(dummy)) 963{ 964 enum cpp_ttype token; 965 tree x = 0; 966 tree new_optimize = optimization_default_node; 967 tree new_target = target_option_default_node; 968 969 token = pragma_lex (&x); 970 if (token != CPP_EOF) 971 { 972 warning (OPT_Wpragmas, "junk at end of %<#pragma reset_options%>"); 973 return; 974 } 975 976 if (new_target != target_option_current_node) 977 { 978 (void) targetm.target_option.pragma_parse (NULL_TREE, new_target); 979 target_option_current_node = new_target; 980 } 981 982 if (new_optimize != optimization_current_node) 983 { 984 tree old_optimize = optimization_current_node; 985 cl_optimization_restore (TREE_OPTIMIZATION (new_optimize)); 986 c_cpp_builtins_optimize_pragma (parse_in, old_optimize, new_optimize); 987 optimization_current_node = new_optimize; 988 } 989 990 current_target_pragma = NULL_TREE; 991 current_optimize_pragma = NULL_TREE; 992} 993 994/* Print a plain user-specified message. */ 995 996static void 997handle_pragma_message (cpp_reader *ARG_UNUSED(dummy)) 998{ 999 enum cpp_ttype token; 1000 tree x, message = 0; 1001 1002 token = pragma_lex (&x); 1003 if (token == CPP_OPEN_PAREN) 1004 { 1005 token = pragma_lex (&x); 1006 if (token == CPP_STRING) 1007 message = x; 1008 else 1009 GCC_BAD ("expected a string after %<#pragma message%>"); 1010 if (pragma_lex (&x) != CPP_CLOSE_PAREN) 1011 GCC_BAD ("malformed %<#pragma message%>, ignored"); 1012 } 1013 else if (token == CPP_STRING) 1014 message = x; 1015 else 1016 GCC_BAD ("expected a string after %<#pragma message%>"); 1017 1018 gcc_assert (message); 1019 1020 if (pragma_lex (&x) != CPP_EOF) 1021 warning (OPT_Wpragmas, "junk at end of %<#pragma message%>"); 1022 1023 if (TREE_STRING_LENGTH (message) > 1) 1024 inform (input_location, "#pragma message: %s", TREE_STRING_POINTER (message)); 1025} 1026 1027/* Mark whether the current location is valid for a STDC pragma. */ 1028 1029static bool valid_location_for_stdc_pragma; 1030 1031void 1032mark_valid_location_for_stdc_pragma (bool flag) 1033{ 1034 valid_location_for_stdc_pragma = flag; 1035} 1036 1037/* Return true if the current location is valid for a STDC pragma. */ 1038 1039bool 1040valid_location_for_stdc_pragma_p (void) 1041{ 1042 return valid_location_for_stdc_pragma; 1043} 1044 1045enum pragma_switch_t { PRAGMA_ON, PRAGMA_OFF, PRAGMA_DEFAULT, PRAGMA_BAD }; 1046 1047/* A STDC pragma must appear outside of external declarations or 1048 preceding all explicit declarations and statements inside a compound 1049 statement; its behavior is undefined if used in any other context. 1050 It takes a switch of ON, OFF, or DEFAULT. */ 1051 1052static enum pragma_switch_t 1053handle_stdc_pragma (const char *pname) 1054{ 1055 const char *arg; 1056 tree t; 1057 enum pragma_switch_t ret; 1058 1059 if (!valid_location_for_stdc_pragma_p ()) 1060 { 1061 warning (OPT_Wpragmas, "invalid location for %<pragma %s%>, ignored", 1062 pname); 1063 return PRAGMA_BAD; 1064 } 1065 1066 if (pragma_lex (&t) != CPP_NAME) 1067 { 1068 warning (OPT_Wpragmas, "malformed %<#pragma %s%>, ignored", pname); 1069 return PRAGMA_BAD; 1070 } 1071 1072 arg = IDENTIFIER_POINTER (t); 1073 1074 if (!strcmp (arg, "ON")) 1075 ret = PRAGMA_ON; 1076 else if (!strcmp (arg, "OFF")) 1077 ret = PRAGMA_OFF; 1078 else if (!strcmp (arg, "DEFAULT")) 1079 ret = PRAGMA_DEFAULT; 1080 else 1081 { 1082 warning (OPT_Wpragmas, "malformed %<#pragma %s%>, ignored", pname); 1083 return PRAGMA_BAD; 1084 } 1085 1086 if (pragma_lex (&t) != CPP_EOF) 1087 { 1088 warning (OPT_Wpragmas, "junk at end of %<#pragma %s%>", pname); 1089 return PRAGMA_BAD; 1090 } 1091 1092 return ret; 1093} 1094 1095/* #pragma STDC FLOAT_CONST_DECIMAL64 ON 1096 #pragma STDC FLOAT_CONST_DECIMAL64 OFF 1097 #pragma STDC FLOAT_CONST_DECIMAL64 DEFAULT */ 1098 1099static void 1100handle_pragma_float_const_decimal64 (cpp_reader *ARG_UNUSED (dummy)) 1101{ 1102 if (c_dialect_cxx ()) 1103 { 1104 if (warn_unknown_pragmas > in_system_header) 1105 warning (OPT_Wunknown_pragmas, 1106 "%<#pragma STDC FLOAT_CONST_DECIMAL64%> is not supported" 1107 " for C++"); 1108 return; 1109 } 1110 1111 if (!targetm.decimal_float_supported_p ()) 1112 { 1113 if (warn_unknown_pragmas > in_system_header) 1114 warning (OPT_Wunknown_pragmas, 1115 "%<#pragma STDC FLOAT_CONST_DECIMAL64%> is not supported" 1116 " on this target"); 1117 return; 1118 } 1119 1120 pedwarn (input_location, OPT_pedantic, 1121 "ISO C does not support %<#pragma STDC FLOAT_CONST_DECIMAL64%>"); 1122 1123 switch (handle_stdc_pragma ("STDC FLOAT_CONST_DECIMAL64")) 1124 { 1125 case PRAGMA_ON: 1126 set_float_const_decimal64 (); 1127 break; 1128 case PRAGMA_OFF: 1129 case PRAGMA_DEFAULT: 1130 clear_float_const_decimal64 (); 1131 break; 1132 case PRAGMA_BAD: 1133 break; 1134 } 1135} 1136 1137/* A vector of registered pragma callbacks. */ 1138 1139DEF_VEC_O (pragma_handler); 1140DEF_VEC_ALLOC_O (pragma_handler, heap); 1141 1142static VEC(pragma_handler, heap) *registered_pragmas; 1143 1144typedef struct 1145{ 1146 const char *space; 1147 const char *name; 1148} pragma_ns_name; 1149 1150DEF_VEC_O (pragma_ns_name); 1151DEF_VEC_ALLOC_O (pragma_ns_name, heap); 1152 1153static VEC(pragma_ns_name, heap) *registered_pp_pragmas; 1154 1155struct omp_pragma_def { const char *name; unsigned int id; }; 1156static const struct omp_pragma_def omp_pragmas[] = { 1157 { "atomic", PRAGMA_OMP_ATOMIC }, 1158 { "barrier", PRAGMA_OMP_BARRIER }, 1159 { "critical", PRAGMA_OMP_CRITICAL }, 1160 { "flush", PRAGMA_OMP_FLUSH }, 1161 { "for", PRAGMA_OMP_FOR }, 1162 { "master", PRAGMA_OMP_MASTER }, 1163 { "ordered", PRAGMA_OMP_ORDERED }, 1164 { "parallel", PRAGMA_OMP_PARALLEL }, 1165 { "section", PRAGMA_OMP_SECTION }, 1166 { "sections", PRAGMA_OMP_SECTIONS }, 1167 { "single", PRAGMA_OMP_SINGLE }, 1168 { "task", PRAGMA_OMP_TASK }, 1169 { "taskwait", PRAGMA_OMP_TASKWAIT }, 1170 { "threadprivate", PRAGMA_OMP_THREADPRIVATE } 1171}; 1172 1173void 1174c_pp_lookup_pragma (unsigned int id, const char **space, const char **name) 1175{ 1176 const int n_omp_pragmas = sizeof (omp_pragmas) / sizeof (*omp_pragmas); 1177 int i; 1178 1179 for (i = 0; i < n_omp_pragmas; ++i) 1180 if (omp_pragmas[i].id == id) 1181 { 1182 *space = "omp"; 1183 *name = omp_pragmas[i].name; 1184 return; 1185 } 1186 1187 if (id >= PRAGMA_FIRST_EXTERNAL 1188 && (id < PRAGMA_FIRST_EXTERNAL 1189 + VEC_length (pragma_ns_name, registered_pp_pragmas))) 1190 { 1191 *space = VEC_index (pragma_ns_name, registered_pp_pragmas, 1192 id - PRAGMA_FIRST_EXTERNAL)->space; 1193 *name = VEC_index (pragma_ns_name, registered_pp_pragmas, 1194 id - PRAGMA_FIRST_EXTERNAL)->name; 1195 return; 1196 } 1197 1198 gcc_unreachable (); 1199} 1200 1201/* Front-end wrappers for pragma registration to avoid dragging 1202 cpplib.h in almost everywhere. */ 1203 1204static void 1205c_register_pragma_1 (const char *space, const char *name, 1206 pragma_handler handler, bool allow_expansion) 1207{ 1208 unsigned id; 1209 1210 if (flag_preprocess_only) 1211 { 1212 pragma_ns_name ns_name; 1213 1214 if (!allow_expansion) 1215 return; 1216 1217 ns_name.space = space; 1218 ns_name.name = name; 1219 VEC_safe_push (pragma_ns_name, heap, registered_pp_pragmas, &ns_name); 1220 id = VEC_length (pragma_ns_name, registered_pp_pragmas); 1221 id += PRAGMA_FIRST_EXTERNAL - 1; 1222 } 1223 else 1224 { 1225 VEC_safe_push (pragma_handler, heap, registered_pragmas, &handler); 1226 id = VEC_length (pragma_handler, registered_pragmas); 1227 id += PRAGMA_FIRST_EXTERNAL - 1; 1228 1229 /* The C++ front end allocates 6 bits in cp_token; the C front end 1230 allocates 7 bits in c_token. At present this is sufficient. */ 1231 gcc_assert (id < 64); 1232 } 1233 1234 cpp_register_deferred_pragma (parse_in, space, name, id, 1235 allow_expansion, false); 1236} 1237 1238void 1239c_register_pragma (const char *space, const char *name, pragma_handler handler) 1240{ 1241 c_register_pragma_1 (space, name, handler, false); 1242} 1243 1244void 1245c_register_pragma_with_expansion (const char *space, const char *name, 1246 pragma_handler handler) 1247{ 1248 c_register_pragma_1 (space, name, handler, true); 1249} 1250 1251void 1252c_invoke_pragma_handler (unsigned int id) 1253{ 1254 pragma_handler handler; 1255 1256 id -= PRAGMA_FIRST_EXTERNAL; 1257 handler = *VEC_index (pragma_handler, registered_pragmas, id); 1258 1259 handler (parse_in); 1260} 1261 1262/* Set up front-end pragmas. */ 1263void 1264init_pragma (void) 1265{ 1266 if (flag_openmp) 1267 { 1268 const int n_omp_pragmas = sizeof (omp_pragmas) / sizeof (*omp_pragmas); 1269 int i; 1270 1271 for (i = 0; i < n_omp_pragmas; ++i) 1272 cpp_register_deferred_pragma (parse_in, "omp", omp_pragmas[i].name, 1273 omp_pragmas[i].id, true, true); 1274 } 1275 1276 if (!flag_preprocess_only) 1277 cpp_register_deferred_pragma (parse_in, "GCC", "pch_preprocess", 1278 PRAGMA_GCC_PCH_PREPROCESS, false, false); 1279 1280#ifdef HANDLE_PRAGMA_PACK 1281#ifdef HANDLE_PRAGMA_PACK_WITH_EXPANSION 1282 c_register_pragma_with_expansion (0, "pack", handle_pragma_pack); 1283#else 1284 c_register_pragma (0, "pack", handle_pragma_pack); 1285#endif 1286#endif 1287#ifdef HANDLE_PRAGMA_WEAK 1288 c_register_pragma (0, "weak", handle_pragma_weak); 1289#endif 1290#ifdef HANDLE_PRAGMA_VISIBILITY 1291 c_register_pragma ("GCC", "visibility", handle_pragma_visibility); 1292#endif 1293 1294 c_register_pragma ("GCC", "diagnostic", handle_pragma_diagnostic); 1295 c_register_pragma ("GCC", "target", handle_pragma_target); 1296 c_register_pragma ("GCC", "optimize", handle_pragma_optimize); 1297 c_register_pragma ("GCC", "push_options", handle_pragma_push_options); 1298 c_register_pragma ("GCC", "pop_options", handle_pragma_pop_options); 1299 c_register_pragma ("GCC", "reset_options", handle_pragma_reset_options); 1300 1301 c_register_pragma ("STDC", "FLOAT_CONST_DECIMAL64", 1302 handle_pragma_float_const_decimal64); 1303 1304 c_register_pragma_with_expansion (0, "redefine_extname", handle_pragma_redefine_extname); 1305 c_register_pragma (0, "extern_prefix", handle_pragma_extern_prefix); 1306 1307 c_register_pragma_with_expansion (0, "message", handle_pragma_message); 1308 1309#ifdef REGISTER_TARGET_PRAGMAS 1310 REGISTER_TARGET_PRAGMAS (); 1311#endif 1312 1313 /* Allow plugins to register their own pragmas. */ 1314 invoke_plugin_callbacks (PLUGIN_PRAGMAS, NULL); 1315} 1316 1317#include "gt-c-pragma.h" 1318