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 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 2, 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 COPYING. If not, write to the Free 19Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2002110-1301, USA. */ 21 22#include "config.h" 23#include "system.h" 24#include "coretypes.h" 25#include "tm.h" 26#include "rtl.h" 27#include "tree.h" 28#include "function.h" 29#include "cpplib.h" 30#include "c-pragma.h" 31#include "flags.h" 32#include "toplev.h" 33#include "ggc.h" 34#include "c-common.h" 35#include "output.h" 36#include "tm_p.h" 37#include "vec.h" 38#include "target.h" 39 40#define GCC_BAD(gmsgid) \ 41 do { warning (OPT_Wpragmas, gmsgid); return; } while (0) 42#define GCC_BAD2(gmsgid, arg) \ 43 do { warning (OPT_Wpragmas, gmsgid, arg); return; } while (0) 44 45typedef struct align_stack GTY(()) 46{ 47 int alignment; 48 tree id; 49 struct align_stack * prev; 50} align_stack; 51 52static GTY(()) struct align_stack * alignment_stack; 53 54#ifdef HANDLE_PRAGMA_PACK 55static void handle_pragma_pack (cpp_reader *); 56 57#ifdef HANDLE_PRAGMA_PACK_PUSH_POP 58/* If we have a "global" #pragma pack(<n>) in effect when the first 59 #pragma pack(push,<n>) is encountered, this stores the value of 60 maximum_field_alignment in effect. When the final pop_alignment() 61 happens, we restore the value to this, not to a value of 0 for 62 maximum_field_alignment. Value is in bits. */ 63static int default_alignment; 64#define SET_GLOBAL_ALIGNMENT(ALIGN) (maximum_field_alignment = *(alignment_stack == NULL \ 65 ? &default_alignment \ 66 : &alignment_stack->alignment) = (ALIGN)) 67 68static void push_alignment (int, tree); 69static void pop_alignment (tree); 70 71/* Push an alignment value onto the stack. */ 72static void 73push_alignment (int alignment, tree id) 74{ 75 align_stack * entry; 76 77 entry = ggc_alloc (sizeof (* entry)); 78 79 entry->alignment = alignment; 80 entry->id = id; 81 entry->prev = alignment_stack; 82 83 /* The current value of maximum_field_alignment is not necessarily 84 0 since there may be a #pragma pack(<n>) in effect; remember it 85 so that we can restore it after the final #pragma pop(). */ 86 if (alignment_stack == NULL) 87 default_alignment = maximum_field_alignment; 88 89 alignment_stack = entry; 90 91 maximum_field_alignment = alignment; 92} 93 94/* Undo a push of an alignment onto the stack. */ 95static void 96pop_alignment (tree id) 97{ 98 align_stack * entry; 99 100 if (alignment_stack == NULL) 101 GCC_BAD ("#pragma pack (pop) encountered without matching #pragma pack (push)"); 102 103 /* If we got an identifier, strip away everything above the target 104 entry so that the next step will restore the state just below it. */ 105 if (id) 106 { 107 for (entry = alignment_stack; entry; entry = entry->prev) 108 if (entry->id == id) 109 { 110 alignment_stack = entry; 111 break; 112 } 113 if (entry == NULL) 114 warning (OPT_Wpragmas, "\ 115#pragma pack(pop, %s) encountered without matching #pragma pack(push, %s)" 116 , IDENTIFIER_POINTER (id), IDENTIFIER_POINTER (id)); 117 } 118 119 entry = alignment_stack->prev; 120 121 maximum_field_alignment = entry ? entry->alignment : default_alignment; 122 123 alignment_stack = entry; 124} 125#else /* not HANDLE_PRAGMA_PACK_PUSH_POP */ 126#define SET_GLOBAL_ALIGNMENT(ALIGN) (maximum_field_alignment = (ALIGN)) 127#define push_alignment(ID, N) \ 128 GCC_BAD ("#pragma pack(push[, id], <n>) is not supported on this target") 129#define pop_alignment(ID) \ 130 GCC_BAD ("#pragma pack(pop[, id], <n>) is not supported on this target") 131#endif /* HANDLE_PRAGMA_PACK_PUSH_POP */ 132 133/* #pragma pack () 134 #pragma pack (N) 135 136 #pragma pack (push) 137 #pragma pack (push, N) 138 #pragma pack (push, ID) 139 #pragma pack (push, ID, N) 140 #pragma pack (pop) 141 #pragma pack (pop, ID) */ 142static void 143handle_pragma_pack (cpp_reader * ARG_UNUSED (dummy)) 144{ 145 tree x, id = 0; 146 int align = -1; 147 enum cpp_ttype token; 148 enum { set, push, pop } action; 149 150 if (c_lex (&x) != CPP_OPEN_PAREN) 151 GCC_BAD ("missing %<(%> after %<#pragma pack%> - ignored"); 152 153 token = c_lex (&x); 154 if (token == CPP_CLOSE_PAREN) 155 { 156 action = set; 157 align = initial_max_fld_align; 158 } 159 else if (token == CPP_NUMBER) 160 { 161 if (TREE_CODE (x) != INTEGER_CST) 162 GCC_BAD ("invalid constant in %<#pragma pack%> - ignored"); 163 align = TREE_INT_CST_LOW (x); 164 action = set; 165 if (c_lex (&x) != CPP_CLOSE_PAREN) 166 GCC_BAD ("malformed %<#pragma pack%> - ignored"); 167 } 168 else if (token == CPP_NAME) 169 { 170#define GCC_BAD_ACTION do { if (action != pop) \ 171 GCC_BAD ("malformed %<#pragma pack(push[, id][, <n>])%> - ignored"); \ 172 else \ 173 GCC_BAD ("malformed %<#pragma pack(pop[, id])%> - ignored"); \ 174 } while (0) 175 176 const char *op = IDENTIFIER_POINTER (x); 177 if (!strcmp (op, "push")) 178 action = push; 179 else if (!strcmp (op, "pop")) 180 action = pop; 181 else 182 GCC_BAD2 ("unknown action %qs for %<#pragma pack%> - ignored", op); 183 184 while ((token = c_lex (&x)) == CPP_COMMA) 185 { 186 token = c_lex (&x); 187 if (token == CPP_NAME && id == 0) 188 { 189 id = x; 190 } 191 else if (token == CPP_NUMBER && action == push && align == -1) 192 { 193 if (TREE_CODE (x) != INTEGER_CST) 194 GCC_BAD ("invalid constant in %<#pragma pack%> - ignored"); 195 align = TREE_INT_CST_LOW (x); 196 if (align == -1) 197 action = set; 198 } 199 else 200 GCC_BAD_ACTION; 201 } 202 203 if (token != CPP_CLOSE_PAREN) 204 GCC_BAD_ACTION; 205#undef GCC_BAD_ACTION 206 } 207 else 208 GCC_BAD ("malformed %<#pragma pack%> - ignored"); 209 210 if (c_lex (&x) != CPP_EOF) 211 warning (OPT_Wpragmas, "junk at end of %<#pragma pack%>"); 212 213 if (flag_pack_struct) 214 GCC_BAD ("#pragma pack has no effect with -fpack-struct - ignored"); 215 216 if (action != pop) 217 switch (align) 218 { 219 case 0: 220 case 1: 221 case 2: 222 case 4: 223 case 8: 224 case 16: 225 align *= BITS_PER_UNIT; 226 break; 227 case -1: 228 if (action == push) 229 { 230 align = maximum_field_alignment; 231 break; 232 } 233 default: 234 GCC_BAD2 ("alignment must be a small power of two, not %d", align); 235 } 236 237 switch (action) 238 { 239 case set: SET_GLOBAL_ALIGNMENT (align); break; 240 case push: push_alignment (align, id); break; 241 case pop: pop_alignment (id); break; 242 } 243} 244#endif /* HANDLE_PRAGMA_PACK */ 245 246static GTY(()) tree pending_weaks; 247 248#ifdef HANDLE_PRAGMA_WEAK 249static void apply_pragma_weak (tree, tree); 250static void handle_pragma_weak (cpp_reader *); 251 252static void 253apply_pragma_weak (tree decl, tree value) 254{ 255 if (value) 256 { 257 value = build_string (IDENTIFIER_LENGTH (value), 258 IDENTIFIER_POINTER (value)); 259 decl_attributes (&decl, build_tree_list (get_identifier ("alias"), 260 build_tree_list (NULL, value)), 261 0); 262 } 263 264 if (SUPPORTS_WEAK && DECL_EXTERNAL (decl) && TREE_USED (decl) 265 && !DECL_WEAK (decl) /* Don't complain about a redundant #pragma. */ 266 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))) 267 warning (OPT_Wpragmas, "applying #pragma weak %q+D after first use " 268 "results in unspecified behavior", decl); 269 270 declare_weak (decl); 271} 272 273void 274maybe_apply_pragma_weak (tree decl) 275{ 276 tree *p, t, id; 277 278 /* Avoid asking for DECL_ASSEMBLER_NAME when it's not needed. */ 279 280 /* No weak symbols pending, take the short-cut. */ 281 if (!pending_weaks) 282 return; 283 /* If it's not visible outside this file, it doesn't matter whether 284 it's weak. */ 285 if (!DECL_EXTERNAL (decl) && !TREE_PUBLIC (decl)) 286 return; 287 /* If it's not a function or a variable, it can't be weak. 288 FIXME: what kinds of things are visible outside this file but 289 aren't functions or variables? Should this be an assert instead? */ 290 if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL) 291 return; 292 293 id = DECL_ASSEMBLER_NAME (decl); 294 295 for (p = &pending_weaks; (t = *p) ; p = &TREE_CHAIN (t)) 296 if (id == TREE_PURPOSE (t)) 297 { 298 apply_pragma_weak (decl, TREE_VALUE (t)); 299 *p = TREE_CHAIN (t); 300 break; 301 } 302} 303 304/* Process all "#pragma weak A = B" directives where we have not seen 305 a decl for A. */ 306void 307maybe_apply_pending_pragma_weaks (void) 308{ 309 tree *p, t, alias_id, id, decl, *next; 310 311 for (p = &pending_weaks; (t = *p) ; p = next) 312 { 313 next = &TREE_CHAIN (t); 314 alias_id = TREE_PURPOSE (t); 315 id = TREE_VALUE (t); 316 317 if (TREE_VALUE (t) == NULL) 318 continue; 319 320 decl = build_decl (FUNCTION_DECL, alias_id, default_function_type); 321 322 DECL_ARTIFICIAL (decl) = 1; 323 TREE_PUBLIC (decl) = 1; 324 DECL_EXTERNAL (decl) = 1; 325 DECL_WEAK (decl) = 1; 326 327 assemble_alias (decl, id); 328 } 329} 330 331/* #pragma weak name [= value] */ 332static void 333handle_pragma_weak (cpp_reader * ARG_UNUSED (dummy)) 334{ 335 tree name, value, x, decl; 336 enum cpp_ttype t; 337 338 value = 0; 339 340 if (c_lex (&name) != CPP_NAME) 341 GCC_BAD ("malformed #pragma weak, ignored"); 342 t = c_lex (&x); 343 if (t == CPP_EQ) 344 { 345 if (c_lex (&value) != CPP_NAME) 346 GCC_BAD ("malformed #pragma weak, ignored"); 347 t = c_lex (&x); 348 } 349 if (t != CPP_EOF) 350 warning (OPT_Wpragmas, "junk at end of #pragma weak"); 351 352 decl = identifier_global_value (name); 353 if (decl && DECL_P (decl)) 354 { 355 apply_pragma_weak (decl, value); 356 if (value) 357 assemble_alias (decl, value); 358 } 359 else 360 pending_weaks = tree_cons (name, value, pending_weaks); 361} 362#else 363void 364maybe_apply_pragma_weak (tree ARG_UNUSED (decl)) 365{ 366} 367 368void 369maybe_apply_pending_pragma_weaks (void) 370{ 371} 372#endif /* HANDLE_PRAGMA_WEAK */ 373 374/* GCC supports two #pragma directives for renaming the external 375 symbol associated with a declaration (DECL_ASSEMBLER_NAME), for 376 compatibility with the Solaris and Tru64 system headers. GCC also 377 has its own notation for this, __asm__("name") annotations. 378 379 Corner cases of these features and their interaction: 380 381 1) Both pragmas silently apply only to declarations with external 382 linkage (that is, TREE_PUBLIC || DECL_EXTERNAL). Asm labels 383 do not have this restriction. 384 385 2) In C++, both #pragmas silently apply only to extern "C" declarations. 386 Asm labels do not have this restriction. 387 388 3) If any of the three ways of changing DECL_ASSEMBLER_NAME is 389 applied to a decl whose DECL_ASSEMBLER_NAME is already set, and the 390 new name is different, a warning issues and the name does not change. 391 392 4) The "source name" for #pragma redefine_extname is the DECL_NAME, 393 *not* the DECL_ASSEMBLER_NAME. 394 395 5) If #pragma extern_prefix is in effect and a declaration occurs 396 with an __asm__ name, the #pragma extern_prefix is silently 397 ignored for that declaration. 398 399 6) If #pragma extern_prefix and #pragma redefine_extname apply to 400 the same declaration, whichever triggered first wins, and a warning 401 is issued. (We would like to have #pragma redefine_extname always 402 win, but it can appear either before or after the declaration, and 403 if it appears afterward, we have no way of knowing whether a modified 404 DECL_ASSEMBLER_NAME is due to #pragma extern_prefix.) */ 405 406static GTY(()) tree pending_redefine_extname; 407 408static void handle_pragma_redefine_extname (cpp_reader *); 409 410/* #pragma redefine_extname oldname newname */ 411static void 412handle_pragma_redefine_extname (cpp_reader * ARG_UNUSED (dummy)) 413{ 414 tree oldname, newname, decl, x; 415 enum cpp_ttype t; 416 417 if (c_lex (&oldname) != CPP_NAME) 418 GCC_BAD ("malformed #pragma redefine_extname, ignored"); 419 if (c_lex (&newname) != CPP_NAME) 420 GCC_BAD ("malformed #pragma redefine_extname, ignored"); 421 t = c_lex (&x); 422 if (t != CPP_EOF) 423 warning (OPT_Wpragmas, "junk at end of #pragma redefine_extname"); 424 425 if (!flag_mudflap && !targetm.handle_pragma_redefine_extname) 426 { 427 if (warn_unknown_pragmas > in_system_header) 428 warning (OPT_Wunknown_pragmas, 429 "#pragma redefine_extname not supported on this target"); 430 return; 431 } 432 433 decl = identifier_global_value (oldname); 434 if (decl 435 && (TREE_PUBLIC (decl) || DECL_EXTERNAL (decl)) 436 && (TREE_CODE (decl) == FUNCTION_DECL 437 || TREE_CODE (decl) == VAR_DECL) 438 && has_c_linkage (decl)) 439 { 440 if (DECL_ASSEMBLER_NAME_SET_P (decl)) 441 { 442 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 443 name = targetm.strip_name_encoding (name); 444 445 if (strcmp (name, IDENTIFIER_POINTER (newname))) 446 warning (OPT_Wpragmas, "#pragma redefine_extname ignored due to " 447 "conflict with previous rename"); 448 } 449 else 450 change_decl_assembler_name (decl, newname); 451 } 452 else 453 /* We have to add this to the rename list even if there's already 454 a global value that doesn't meet the above criteria, because in 455 C++ "struct foo {...};" puts "foo" in the current namespace but 456 does *not* conflict with a subsequent declaration of a function 457 or variable foo. See g++.dg/other/pragma-re-2.C. */ 458 add_to_renaming_pragma_list (oldname, newname); 459} 460 461/* This is called from here and from ia64.c. */ 462void 463add_to_renaming_pragma_list (tree oldname, tree newname) 464{ 465 tree previous = purpose_member (oldname, pending_redefine_extname); 466 if (previous) 467 { 468 if (TREE_VALUE (previous) != newname) 469 warning (OPT_Wpragmas, "#pragma redefine_extname ignored due to " 470 "conflict with previous #pragma redefine_extname"); 471 return; 472 } 473 474 pending_redefine_extname 475 = tree_cons (oldname, newname, pending_redefine_extname); 476} 477 478static GTY(()) tree pragma_extern_prefix; 479 480/* #pragma extern_prefix "prefix" */ 481static void 482handle_pragma_extern_prefix (cpp_reader * ARG_UNUSED (dummy)) 483{ 484 tree prefix, x; 485 enum cpp_ttype t; 486 487 if (c_lex (&prefix) != CPP_STRING) 488 GCC_BAD ("malformed #pragma extern_prefix, ignored"); 489 t = c_lex (&x); 490 if (t != CPP_EOF) 491 warning (OPT_Wpragmas, "junk at end of #pragma extern_prefix"); 492 493 if (targetm.handle_pragma_extern_prefix) 494 /* Note that the length includes the null terminator. */ 495 pragma_extern_prefix = (TREE_STRING_LENGTH (prefix) > 1 ? prefix : NULL); 496 else if (warn_unknown_pragmas > in_system_header) 497 warning (OPT_Wunknown_pragmas, 498 "#pragma extern_prefix not supported on this target"); 499} 500 501/* Hook from the front ends to apply the results of one of the preceding 502 pragmas that rename variables. */ 503 504tree 505maybe_apply_renaming_pragma (tree decl, tree asmname) 506{ 507 tree *p, t; 508 509 /* The renaming pragmas are only applied to declarations with 510 external linkage. */ 511 if ((TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL) 512 || (!TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl)) 513 || !has_c_linkage (decl)) 514 return asmname; 515 516 /* If the DECL_ASSEMBLER_NAME is already set, it does not change, 517 but we may warn about a rename that conflicts. */ 518 if (DECL_ASSEMBLER_NAME_SET_P (decl)) 519 { 520 const char *oldname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 521 oldname = targetm.strip_name_encoding (oldname); 522 523 if (asmname && strcmp (TREE_STRING_POINTER (asmname), oldname)) 524 warning (OPT_Wpragmas, "asm declaration ignored due to " 525 "conflict with previous rename"); 526 527 /* Take any pending redefine_extname off the list. */ 528 for (p = &pending_redefine_extname; (t = *p); p = &TREE_CHAIN (t)) 529 if (DECL_NAME (decl) == TREE_PURPOSE (t)) 530 { 531 /* Only warn if there is a conflict. */ 532 if (strcmp (IDENTIFIER_POINTER (TREE_VALUE (t)), oldname)) 533 warning (OPT_Wpragmas, "#pragma redefine_extname ignored due to " 534 "conflict with previous rename"); 535 536 *p = TREE_CHAIN (t); 537 break; 538 } 539 return 0; 540 } 541 542 /* Find out if we have a pending #pragma redefine_extname. */ 543 for (p = &pending_redefine_extname; (t = *p); p = &TREE_CHAIN (t)) 544 if (DECL_NAME (decl) == TREE_PURPOSE (t)) 545 { 546 tree newname = TREE_VALUE (t); 547 *p = TREE_CHAIN (t); 548 549 /* If we already have an asmname, #pragma redefine_extname is 550 ignored (with a warning if it conflicts). */ 551 if (asmname) 552 { 553 if (strcmp (TREE_STRING_POINTER (asmname), 554 IDENTIFIER_POINTER (newname)) != 0) 555 warning (OPT_Wpragmas, "#pragma redefine_extname ignored due to " 556 "conflict with __asm__ declaration"); 557 return asmname; 558 } 559 560 /* Otherwise we use what we've got; #pragma extern_prefix is 561 silently ignored. */ 562 return build_string (IDENTIFIER_LENGTH (newname), 563 IDENTIFIER_POINTER (newname)); 564 } 565 566 /* If we've got an asmname, #pragma extern_prefix is silently ignored. */ 567 if (asmname) 568 return asmname; 569 570 /* If #pragma extern_prefix is in effect, apply it. */ 571 if (pragma_extern_prefix) 572 { 573 const char *prefix = TREE_STRING_POINTER (pragma_extern_prefix); 574 size_t plen = TREE_STRING_LENGTH (pragma_extern_prefix) - 1; 575 576 const char *id = IDENTIFIER_POINTER (DECL_NAME (decl)); 577 size_t ilen = IDENTIFIER_LENGTH (DECL_NAME (decl)); 578 579 char *newname = (char *) alloca (plen + ilen + 1); 580 581 memcpy (newname, prefix, plen); 582 memcpy (newname + plen, id, ilen + 1); 583 584 return build_string (plen + ilen, newname); 585 } 586 587 /* Nada. */ 588 return 0; 589} 590 591 592#ifdef HANDLE_PRAGMA_VISIBILITY 593static void handle_pragma_visibility (cpp_reader *); 594 595typedef enum symbol_visibility visibility; 596DEF_VEC_I (visibility); 597DEF_VEC_ALLOC_I (visibility, heap); 598 599/* Sets the default visibility for symbols to something other than that 600 specified on the command line. */ 601static void 602handle_pragma_visibility (cpp_reader *dummy ATTRIBUTE_UNUSED) 603{ 604 /* Form is #pragma GCC visibility push(hidden)|pop */ 605 tree x; 606 enum cpp_ttype token; 607 enum { bad, push, pop } action = bad; 608 static VEC (visibility, heap) *visstack; 609 610 token = c_lex (&x); 611 if (token == CPP_NAME) 612 { 613 const char *op = IDENTIFIER_POINTER (x); 614 if (!strcmp (op, "push")) 615 action = push; 616 else if (!strcmp (op, "pop")) 617 action = pop; 618 } 619 if (bad == action) 620 GCC_BAD ("#pragma GCC visibility must be followed by push or pop"); 621 else 622 { 623 if (pop == action) 624 { 625 if (!VEC_length (visibility, visstack)) 626 { 627 GCC_BAD ("no matching push for %<#pragma GCC visibility pop%>"); 628 } 629 else 630 { 631 default_visibility = VEC_pop (visibility, visstack); 632 visibility_options.inpragma 633 = VEC_length (visibility, visstack) != 0; 634 } 635 } 636 else 637 { 638 if (c_lex (&x) != CPP_OPEN_PAREN) 639 GCC_BAD ("missing %<(%> after %<#pragma GCC visibility push%> - ignored"); 640 token = c_lex (&x); 641 if (token != CPP_NAME) 642 { 643 GCC_BAD ("malformed #pragma GCC visibility push"); 644 } 645 else 646 { 647 const char *str = IDENTIFIER_POINTER (x); 648 VEC_safe_push (visibility, heap, visstack, 649 default_visibility); 650 if (!strcmp (str, "default")) 651 default_visibility = VISIBILITY_DEFAULT; 652 else if (!strcmp (str, "internal")) 653 default_visibility = VISIBILITY_INTERNAL; 654 else if (!strcmp (str, "hidden")) 655 default_visibility = VISIBILITY_HIDDEN; 656 else if (!strcmp (str, "protected")) 657 default_visibility = VISIBILITY_PROTECTED; 658 else 659 { 660 GCC_BAD ("#pragma GCC visibility push() must specify default, internal, hidden or protected"); 661 } 662 visibility_options.inpragma = 1; 663 } 664 if (c_lex (&x) != CPP_CLOSE_PAREN) 665 GCC_BAD ("missing %<(%> after %<#pragma GCC visibility push%> - ignored"); 666 } 667 } 668 if (c_lex (&x) != CPP_EOF) 669 warning (OPT_Wpragmas, "junk at end of %<#pragma GCC visibility%>"); 670} 671 672#endif 673 674/* Front-end wrappers for pragma registration to avoid dragging 675 cpplib.h in almost everywhere. */ 676void 677c_register_pragma (const char *space, const char *name, 678 void (*handler) (struct cpp_reader *)) 679{ 680 cpp_register_pragma (parse_in, space, name, handler, 0); 681} 682 683void 684c_register_pragma_with_expansion (const char *space, const char *name, 685 void (*handler) (struct cpp_reader *)) 686{ 687 cpp_register_pragma (parse_in, space, name, handler, 1); 688} 689 690/* Set up front-end pragmas. */ 691void 692init_pragma (void) 693{ 694#ifdef HANDLE_PRAGMA_PACK 695#ifdef HANDLE_PRAGMA_PACK_WITH_EXPANSION 696 c_register_pragma_with_expansion (0, "pack", handle_pragma_pack); 697#else 698 c_register_pragma (0, "pack", handle_pragma_pack); 699#endif 700#endif 701#ifdef HANDLE_PRAGMA_WEAK 702 c_register_pragma (0, "weak", handle_pragma_weak); 703#endif 704#ifdef HANDLE_PRAGMA_VISIBILITY 705 c_register_pragma ("GCC", "visibility", handle_pragma_visibility); 706#endif 707 708 c_register_pragma (0, "redefine_extname", handle_pragma_redefine_extname); 709 c_register_pragma (0, "extern_prefix", handle_pragma_extern_prefix); 710 711 c_register_pragma ("GCC", "pch_preprocess", c_common_pch_pragma); 712 713#ifdef REGISTER_TARGET_PRAGMAS 714 REGISTER_TARGET_PRAGMAS (); 715#endif 716} 717 718#include "gt-c-pragma.h" 719