X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fc-pragma.c;h=0bf2f1231bc22589fb629cd06f91674fa0cefa68;hb=5d4b6e9c06cae8242813f303f804f31222500c65;hp=c9e15056e78f0b3c2a29545476499c45cfa0db39;hpb=a8349c62da4e62b8ab039f14ee293e6a24c56026;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/c-pragma.c b/gcc/c-pragma.c index c9e15056e78..0bf2f1231bc 100644 --- a/gcc/c-pragma.c +++ b/gcc/c-pragma.c @@ -34,6 +34,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "c-common.h" #include "output.h" #include "tm_p.h" +#include "target.h" #define GCC_BAD(msgid) do { warning (msgid); return; } while (0) #define GCC_BAD2(msgid, arg) do { warning (msgid, arg); return; } while (0) @@ -154,7 +155,7 @@ pop_alignment (tree id) #pragma pack (pop) #pragma pack (pop, ID) */ static void -handle_pragma_pack (cpp_reader *dummy ATTRIBUTE_UNUSED) +handle_pragma_pack (cpp_reader * ARG_UNUSED (dummy)) { tree x, id = 0; int align = -1; @@ -314,7 +315,7 @@ maybe_apply_pragma_weak (tree decl) /* #pragma weak name [= value] */ static void -handle_pragma_weak (cpp_reader *dummy ATTRIBUTE_UNUSED) +handle_pragma_weak (cpp_reader * ARG_UNUSED (dummy)) { tree name, value, x, decl; enum cpp_ttype t; @@ -345,82 +346,135 @@ handle_pragma_weak (cpp_reader *dummy ATTRIBUTE_UNUSED) } #else void -maybe_apply_pragma_weak (tree decl ATTRIBUTE_UNUSED) +maybe_apply_pragma_weak (tree ARG_UNUSED (decl)) { } #endif /* HANDLE_PRAGMA_WEAK */ +/* GCC supports two #pragma directives for renaming the external + symbol associated with a declaration (DECL_ASSEMBLER_NAME), for + compatibility with the Solaris and Tru64 system headers. GCC also + has its own notation for this, __asm__("name") annotations. + + Corner cases of these features and their interaction: + + 1) Both pragmas silently apply only to declarations with external + linkage (that is, TREE_PUBLIC || DECL_EXTERNAL). Asm labels + do not have this restriction. + + 2) In C++, both #pragmas silently apply only to extern "C" declarations. + Asm labels do not have this restriction. + + 3) If any of the three ways of changing DECL_ASSEMBLER_NAME is + applied to a decl whose DECL_ASSEMBLER_NAME is already set, and the + new name is different, a warning issues and the name does not change. + + 4) The "source name" for #pragma redefine_extname is the DECL_NAME, + *not* the DECL_ASSEMBLER_NAME. + + 5) If #pragma extern_prefix is in effect and a declaration occurs + with an __asm__ name, the #pragma extern_prefix is silently + ignored for that declaration. + + 6) If #pragma extern_prefix and #pragma redefine_extname apply to + the same declaration, whichever triggered first wins, and a warning + is issued. (We would like to have #pragma redefine_extname always + win, but it can appear either before or after the declaration, and + if it appears afterward, we have no way of knowing whether a modified + DECL_ASSEMBLER_NAME is due to #pragma extern_prefix.) */ + static GTY(()) tree pending_redefine_extname; -#ifdef HANDLE_PRAGMA_REDEFINE_EXTNAME static void handle_pragma_redefine_extname (cpp_reader *); -/* #pragma redefined_extname oldname newname */ +/* #pragma redefine_extname oldname newname */ static void -handle_pragma_redefine_extname (cpp_reader *dummy ATTRIBUTE_UNUSED) +handle_pragma_redefine_extname (cpp_reader * ARG_UNUSED (dummy)) { tree oldname, newname, decl, x; enum cpp_ttype t; if (c_lex (&oldname) != CPP_NAME) - { - warning ("malformed #pragma redefine_extname, ignored"); - return; - } + GCC_BAD ("malformed #pragma redefine_extname, ignored"); if (c_lex (&newname) != CPP_NAME) - { - warning ("malformed #pragma redefine_extname, ignored"); - return; - } + GCC_BAD ("malformed #pragma redefine_extname, ignored"); t = c_lex (&x); if (t != CPP_EOF) warning ("junk at end of #pragma redefine_extname"); + if (!flag_mudflap && !targetm.handle_pragma_redefine_extname) + { + if (warn_unknown_pragmas > in_system_header) + warning ("#pragma redefine_extname not supported on this target"); + return; + } + decl = identifier_global_value (oldname); - if (decl && TREE_CODE_CLASS (TREE_CODE (decl)) == 'd') + if (decl + && (TREE_PUBLIC (decl) || DECL_EXTERNAL (decl)) + && (TREE_CODE (decl) == FUNCTION_DECL + || TREE_CODE (decl) == VAR_DECL) + && has_c_linkage (decl)) { - if (DECL_ASSEMBLER_NAME_SET_P (decl) - && DECL_ASSEMBLER_NAME (decl) != newname) - warning ("#pragma redefine_extname conflicts with declaration"); - change_decl_assembler_name (decl, newname); + if (DECL_ASSEMBLER_NAME_SET_P (decl)) + { + const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); + name = targetm.strip_name_encoding (name); + + if (strcmp (name, IDENTIFIER_POINTER (newname))) + warning ("#pragma redefine_extname ignored due to conflict with " + "previous rename"); + } + else + change_decl_assembler_name (decl, newname); } else - add_to_renaming_pragma_list(oldname, newname); + /* We have to add this to the rename list even if there's already + a global value that doesn't meet the above criteria, because in + C++ "struct foo {...};" puts "foo" in the current namespace but + does *not* conflict with a subsequent declaration of a function + or variable foo. See g++.dg/other/pragma-re-2.C. */ + add_to_renaming_pragma_list (oldname, newname); } -#endif +/* This is called from here and from ia64.c. */ void add_to_renaming_pragma_list (tree oldname, tree newname) { + tree previous = purpose_member (oldname, pending_redefine_extname); + if (previous) + { + if (TREE_VALUE (previous) != newname) + warning ("#pragma redefine_extname ignored due to conflict with " + "previous #pragma redefine_extname"); + return; + } + pending_redefine_extname = tree_cons (oldname, newname, pending_redefine_extname); } static GTY(()) tree pragma_extern_prefix; -#ifdef HANDLE_PRAGMA_EXTERN_PREFIX -static void handle_pragma_extern_prefix (cpp_reader *); - /* #pragma extern_prefix "prefix" */ static void -handle_pragma_extern_prefix (cpp_reader *dummy ATTRIBUTE_UNUSED) +handle_pragma_extern_prefix (cpp_reader * ARG_UNUSED (dummy)) { tree prefix, x; enum cpp_ttype t; if (c_lex (&prefix) != CPP_STRING) - { - warning ("malformed #pragma extern_prefix, ignored"); - return; - } + GCC_BAD ("malformed #pragma extern_prefix, ignored"); t = c_lex (&x); if (t != CPP_EOF) warning ("junk at end of #pragma extern_prefix"); - /* Note that the length includes the null terminator. */ - pragma_extern_prefix = (TREE_STRING_LENGTH (prefix) > 1 ? prefix : NULL); + if (targetm.handle_pragma_extern_prefix) + /* Note that the length includes the null terminator. */ + pragma_extern_prefix = (TREE_STRING_LENGTH (prefix) > 1 ? prefix : NULL); + else if (warn_unknown_pragmas > in_system_header) + warning ("#pragma extern_prefix not supported on this target"); } -#endif /* Hook from the front ends to apply the results of one of the preceding pragmas that rename variables. */ @@ -428,58 +482,170 @@ handle_pragma_extern_prefix (cpp_reader *dummy ATTRIBUTE_UNUSED) tree maybe_apply_renaming_pragma (tree decl, tree asmname) { - tree oldname; - - /* Copied from the check in set_decl_assembler_name. */ - if (TREE_CODE (decl) == FUNCTION_DECL - || (TREE_CODE (decl) == VAR_DECL - && (TREE_STATIC (decl) - || DECL_EXTERNAL (decl) - || TREE_PUBLIC (decl)))) - oldname = DECL_ASSEMBLER_NAME (decl); - else + tree *p, t; + + /* The renaming pragmas are only applied to declarations with + external linkage. */ + if ((TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL) + || (!TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl)) + || !has_c_linkage (decl)) return asmname; - /* If the name begins with a *, that's a sign of an asmname attached to - a previous declaration. */ - if (IDENTIFIER_POINTER (oldname)[0] == '*') + /* If the DECL_ASSEMBLER_NAME is already set, it does not change, + but we may warn about a rename that conflicts. */ + if (DECL_ASSEMBLER_NAME_SET_P (decl)) { - const char *oldasmname = IDENTIFIER_POINTER (oldname) + 1; - if (asmname && strcmp (TREE_STRING_POINTER (asmname), oldasmname) != 0) - warning ("asm declaration conflicts with previous rename"); - asmname = build_string (strlen (oldasmname), oldasmname); + const char *oldname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); + oldname = targetm.strip_name_encoding (oldname); + + if (asmname && strcmp (TREE_STRING_POINTER (asmname), oldname)) + warning ("asm declaration ignored due to " + "conflict with previous rename"); + + /* Take any pending redefine_extname off the list. */ + for (p = &pending_redefine_extname; (t = *p); p = &TREE_CHAIN (t)) + if (DECL_NAME (decl) == TREE_PURPOSE (t)) + { + /* Only warn if there is a conflict. */ + if (strcmp (IDENTIFIER_POINTER (TREE_VALUE (t)), oldname)) + warning ("#pragma redefine_extname ignored due to " + "conflict with previous rename"); + + *p = TREE_CHAIN (t); + break; + } + return 0; } - { - tree *p, t; + /* Find out if we have a pending #pragma redefine_extname. */ + for (p = &pending_redefine_extname; (t = *p); p = &TREE_CHAIN (t)) + if (DECL_NAME (decl) == TREE_PURPOSE (t)) + { + tree newname = TREE_VALUE (t); + *p = TREE_CHAIN (t); - for (p = &pending_redefine_extname; (t = *p) ; p = &TREE_CHAIN (t)) - if (oldname == TREE_PURPOSE (t)) - { - const char *newname = IDENTIFIER_POINTER (TREE_VALUE (t)); + /* If we already have an asmname, #pragma redefine_extname is + ignored (with a warning if it conflicts). */ + if (asmname) + { + if (strcmp (TREE_STRING_POINTER (asmname), + IDENTIFIER_POINTER (newname)) != 0) + warning ("#pragma redefine_extname ignored due to " + "conflict with __asm__ declaration"); + return asmname; + } - if (asmname && strcmp (TREE_STRING_POINTER (asmname), newname) != 0) - warning ("#pragma redefine_extname conflicts with declaration"); - *p = TREE_CHAIN (t); + /* Otherwise we use what we've got; #pragma extern_prefix is + silently ignored. */ + return build_string (IDENTIFIER_LENGTH (newname), + IDENTIFIER_POINTER (newname)); + } - return build_string (strlen (newname), newname); - } - } + /* If we've got an asmname, #pragma extern_prefix is silently ignored. */ + if (asmname) + return asmname; -#ifdef HANDLE_PRAGMA_EXTERN_PREFIX - if (pragma_extern_prefix && !asmname) + /* If #pragma extern_prefix is in effect, apply it. */ + if (pragma_extern_prefix) { - char *x = concat (TREE_STRING_POINTER (pragma_extern_prefix), - IDENTIFIER_POINTER (oldname), NULL); - asmname = build_string (strlen (x), x); - free (x); - return asmname; + const char *prefix = TREE_STRING_POINTER (pragma_extern_prefix); + size_t plen = TREE_STRING_LENGTH (pragma_extern_prefix) - 1; + + const char *id = IDENTIFIER_POINTER (DECL_NAME (decl)); + size_t ilen = IDENTIFIER_LENGTH (DECL_NAME (decl)); + + char *newname = (char *) alloca (plen + ilen + 1); + + memcpy (newname, prefix, plen); + memcpy (newname + plen, id, ilen + 1); + + return build_string (plen + ilen, newname); } -#endif - return asmname; + /* Nada. */ + return 0; +} + + +#ifdef HANDLE_PRAGMA_VISIBILITY +static void handle_pragma_visibility (cpp_reader *); + +/* Sets the default visibility for symbols to something other than that + specified on the command line. */ +static void +handle_pragma_visibility (cpp_reader *dummy ATTRIBUTE_UNUSED) +{ /* Form is #pragma GCC visibility push(hidden)|pop */ + static int visstack [16], visidx; + tree x; + enum cpp_ttype token; + enum { bad, push, pop } action = bad; + + token = c_lex (&x); + if (token == CPP_NAME) + { + const char *op = IDENTIFIER_POINTER (x); + if (!strcmp (op, "push")) + action = push; + else if (!strcmp (op, "pop")) + action = pop; + } + if (bad == action) + GCC_BAD ("#pragma GCC visibility must be followed by push or pop"); + else + { + if (pop == action) + { + if (!visidx) + { + GCC_BAD ("No matching push for '#pragma GCC visibility pop'"); + } + else + { + default_visibility = visstack[--visidx]; + visibility_options.inpragma = (visidx>0); + } + } + else + { + if (c_lex (&x) != CPP_OPEN_PAREN) + GCC_BAD ("missing '(' after '#pragma GCC visibility push' - ignored"); + token = c_lex (&x); + if (token != CPP_NAME) + { + GCC_BAD ("malformed #pragma GCC visibility push"); + } + else if (visidx >= 16) + { + GCC_BAD ("No more than sixteen #pragma GCC visibility pushes allowed at once"); + } + else + { + const char *str = IDENTIFIER_POINTER (x); + visstack[visidx++] = default_visibility; + if (!strcmp (str, "default")) + default_visibility = VISIBILITY_DEFAULT; + else if (!strcmp (str, "internal")) + default_visibility = VISIBILITY_INTERNAL; + else if (!strcmp (str, "hidden")) + default_visibility = VISIBILITY_HIDDEN; + else if (!strcmp (str, "protected")) + default_visibility = VISIBILITY_PROTECTED; + else + { + GCC_BAD ("#pragma GCC visibility push() must specify default, internal, hidden or protected"); + } + visibility_options.inpragma = 1; + } + if (c_lex (&x) != CPP_CLOSE_PAREN) + GCC_BAD ("missing '(' after '#pragma GCC visibility push' - ignored"); + } + } + if (c_lex (&x) != CPP_EOF) + warning ("junk at end of '#pragma GCC visibility'"); } +#endif + /* Front-end wrapper for pragma registration to avoid dragging cpplib.h in almost everywhere. */ void @@ -499,12 +665,14 @@ init_pragma (void) #ifdef HANDLE_PRAGMA_WEAK c_register_pragma (0, "weak", handle_pragma_weak); #endif -#ifdef HANDLE_PRAGMA_REDEFINE_EXTNAME - c_register_pragma (0, "redefine_extname", handle_pragma_redefine_extname); +#ifdef HANDLE_PRAGMA_VISIBILITY + c_register_pragma ("GCC", "visibility", handle_pragma_visibility); #endif -#ifdef HANDLE_PRAGMA_EXTERN_PREFIX + + c_register_pragma (0, "redefine_extname", handle_pragma_redefine_extname); c_register_pragma (0, "extern_prefix", handle_pragma_extern_prefix); -#endif + + c_register_pragma ("GCC", "pch_preprocess", c_common_pch_pragma); #ifdef REGISTER_TARGET_PRAGMAS REGISTER_TARGET_PRAGMAS ();