X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fc-pragma.c;h=df9e1bf3c3403b97de4b8d88261791a6f4930f00;hb=b0d8e49cb34af0a14e5e21c23a7933d482c5d3ec;hp=8503f3cacca41362ea1cb52f1b6e9b13f6220964;hpb=c9906f1e70916bbd20e66e9d92618dafc8dc67c8;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/c-pragma.c b/gcc/c-pragma.c index 8503f3cacca..df9e1bf3c34 100644 --- a/gcc/c-pragma.c +++ b/gcc/c-pragma.c @@ -1,56 +1,42 @@ /* Handle #pragma, system V.4 style. Supports #pragma weak and #pragma pack. - Copyright (C) 1992, 1997, 1998, 1999, 2000 Free Software Foundation, Inc. + Copyright (C) 1992, 1997, 1998, 1999, 2000, 2001, 2002 + Free Software Foundation, Inc. -This file is part of GNU CC. +This file is part of GCC. -GNU CC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) -any later version. +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 2, or (at your option) any later +version. -GNU CC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. You should have received a copy of the GNU General Public License -along with GNU CC; see the file COPYING. If not, write to -the Free Software Foundation, 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ +along with GCC; see the file COPYING. If not, write to the Free +Software Foundation, 59 Temple Place - Suite 330, Boston, MA +02111-1307, USA. */ #include "config.h" #include "system.h" #include "rtl.h" #include "tree.h" #include "function.h" -#include "defaults.h" #include "cpplib.h" #include "c-pragma.h" #include "flags.h" #include "toplev.h" #include "ggc.h" -#include "c-lex.h" +#include "c-common.h" +#include "output.h" #include "tm_p.h" -#if USE_CPPLIB -extern cpp_reader parse_in; -#else -struct pragma_entry; -static struct pragma_entry *pragmas; - -void cpp_register_pragma PARAMS ((cpp_reader *, const char *, const char *, - void (*) PARAMS ((cpp_reader *)) )); -void cpp_register_pragma_space PARAMS ((cpp_reader *, const char *)); -#endif - -#define BAD(msgid) do { warning (msgid); return; } while (0) -#define BAD2(msgid, arg) do { warning (msgid, arg); return; } while (0) +#define GCC_BAD(msgid) do { warning (msgid); return; } while (0) +#define GCC_BAD2(msgid, arg) do { warning (msgid, arg); return; } while (0) -#ifdef HANDLE_PRAGMA_PACK -static void handle_pragma_pack PARAMS ((cpp_reader *)); - -#ifdef HANDLE_PRAGMA_PACK_PUSH_POP -typedef struct align_stack +typedef struct align_stack GTY(()) { int alignment; unsigned int num_pushes; @@ -58,20 +44,23 @@ typedef struct align_stack struct align_stack * prev; } align_stack; -static struct align_stack * alignment_stack = NULL; +static GTY(()) struct align_stack * alignment_stack; -/* If we have a "global" #pragma pack() if effect when the first - #pragma push(pack,) is encountered, this stores the the value of +#ifdef HANDLE_PRAGMA_PACK +static void handle_pragma_pack PARAMS ((cpp_reader *)); + +#ifdef HANDLE_PRAGMA_PACK_PUSH_POP +/* If we have a "global" #pragma pack() in effect when the first + #pragma pack(push,) is encountered, this stores the value of maximum_field_alignment in effect. When the final pop_alignment() happens, we restore the value to this, not to a value of 0 for - maximum_field_alignment. Value is in bits. */ -static int default_alignment; + maximum_field_alignment. Value is in bits. */ +static int default_alignment; #define SET_GLOBAL_ALIGNMENT(ALIGN) \ -(default_alignment = maximum_field_alignment = (ALIGN)) + (default_alignment = maximum_field_alignment = (ALIGN)) static void push_alignment PARAMS ((int, tree)); static void pop_alignment PARAMS ((tree)); -static void mark_align_stack PARAMS ((void *)); /* Push an alignment value onto the stack. */ static void @@ -79,14 +68,13 @@ push_alignment (alignment, id) int alignment; tree id; { - if (alignment_stack == NULL || alignment_stack->alignment != alignment || id != NULL_TREE) { align_stack * entry; - entry = (align_stack *) xmalloc (sizeof (* entry)); + entry = (align_stack *) ggc_alloc (sizeof (* entry)); entry->alignment = alignment; entry->num_pushes = 1; @@ -95,7 +83,7 @@ push_alignment (alignment, id) /* The current value of maximum_field_alignment is not necessarily 0 since there may be a #pragma pack() in effect; remember it - so that we can restore it after the final #pragma pop(). */ + so that we can restore it after the final #pragma pop(). */ if (alignment_stack == NULL) default_alignment = maximum_field_alignment; @@ -148,30 +136,15 @@ pop_alignment (id) else maximum_field_alignment = entry->alignment; - free (alignment_stack); - alignment_stack = entry; } } - -static void -mark_align_stack (p) - void *p; -{ - align_stack *a = *(align_stack **) p; - - while (a) - { - ggc_mark_tree (a->id); - a = a->prev; - } -} #else /* not HANDLE_PRAGMA_PACK_PUSH_POP */ #define SET_GLOBAL_ALIGNMENT(ALIGN) (maximum_field_alignment = (ALIGN)) #define push_alignment(ID, N) \ - BAD("#pragma pack(push[, id], ) is not supported on this target") + GCC_BAD("#pragma pack(push[, id], ) is not supported on this target") #define pop_alignment(ID) \ - BAD("#pragma pack(pop[, id], ) is not supported on this target") + GCC_BAD("#pragma pack(pop[, id], ) is not supported on this target") #endif /* HANDLE_PRAGMA_PACK_PUSH_POP */ /* #pragma pack () @@ -186,12 +159,12 @@ handle_pragma_pack (dummy) cpp_reader *dummy ATTRIBUTE_UNUSED; { tree x, id = 0; - int align; + int align = -1; enum cpp_ttype token; enum { set, push, pop } action; if (c_lex (&x) != CPP_OPEN_PAREN) - BAD ("missing '(' after '#pragma pack' - ignored"); + GCC_BAD ("missing '(' after '#pragma pack' - ignored"); token = c_lex (&x); if (token == CPP_CLOSE_PAREN) @@ -204,57 +177,75 @@ handle_pragma_pack (dummy) align = TREE_INT_CST_LOW (x); action = set; if (c_lex (&x) != CPP_CLOSE_PAREN) - BAD ("malformed '#pragma pack' - ignored"); + GCC_BAD ("malformed '#pragma pack' - ignored"); } else if (token == CPP_NAME) { +#define GCC_BAD_ACTION do { if (action == push) \ + GCC_BAD ("malformed '#pragma pack(push[, id], )' - ignored"); \ + else \ + GCC_BAD ("malformed '#pragma pack(pop[, id])' - ignored"); \ + } while (0) + const char *op = IDENTIFIER_POINTER (x); if (!strcmp (op, "push")) action = push; else if (!strcmp (op, "pop")) action = pop; else - BAD2 ("unknown action '%s' for '#pragma pack' - ignored", op); - - if (c_lex (&x) != CPP_COMMA) - BAD2 ("malformed '#pragma pack(%s[, id], )' - ignored", op); + GCC_BAD2 ("unknown action '%s' for '#pragma pack' - ignored", op); token = c_lex (&x); - if (token == CPP_NAME) + if (token != CPP_COMMA && action == push) + GCC_BAD_ACTION; + + if (token == CPP_COMMA) { - id = x; - if (c_lex (&x) != CPP_COMMA) - BAD2 ("malformed '#pragma pack(%s[, id], )' - ignored", op); token = c_lex (&x); - } + if (token == CPP_NAME) + { + id = x; + if (action == push && c_lex (&x) != CPP_COMMA) + GCC_BAD_ACTION; + token = c_lex (&x); + } - if (token == CPP_NUMBER) - align = TREE_INT_CST_LOW (x); - else - BAD2 ("malformed '#pragma pack(%s[, id], )' - ignored", op); + if (action == push) + { + if (token == CPP_NUMBER) + { + align = TREE_INT_CST_LOW (x); + token = c_lex (&x); + } + else + GCC_BAD_ACTION; + } + } - if (c_lex (&x) != CPP_CLOSE_PAREN) - BAD ("malformed '#pragma pack' - ignored"); + if (token != CPP_CLOSE_PAREN) + GCC_BAD_ACTION; +#undef GCC_BAD_ACTION } else - BAD ("malformed '#pragma pack' - ignored"); + GCC_BAD ("malformed '#pragma pack' - ignored"); if (c_lex (&x) != CPP_EOF) warning ("junk at end of '#pragma pack'"); - switch (align) - { - case 0: - case 1: - case 2: - case 4: - case 8: - case 16: - align *= BITS_PER_UNIT; - break; - default: - BAD2 ("alignment must be a small power of two, not %d", align); - } + if (action != pop) + switch (align) + { + case 0: + case 1: + case 2: + case 4: + case 8: + case 16: + align *= BITS_PER_UNIT; + break; + default: + GCC_BAD2 ("alignment must be a small power of two, not %d", align); + } switch (action) { @@ -265,193 +256,247 @@ handle_pragma_pack (dummy) } #endif /* HANDLE_PRAGMA_PACK */ +static GTY(()) tree pending_weaks; + #ifdef HANDLE_PRAGMA_WEAK +static void apply_pragma_weak PARAMS ((tree, tree)); static void handle_pragma_weak PARAMS ((cpp_reader *)); +static void +apply_pragma_weak (decl, value) + tree decl, value; +{ + if (value) + { + value = build_string (IDENTIFIER_LENGTH (value), + IDENTIFIER_POINTER (value)); + decl_attributes (&decl, build_tree_list (get_identifier ("alias"), + build_tree_list (NULL, value)), + 0); + } + + if (SUPPORTS_WEAK && DECL_EXTERNAL (decl) && TREE_USED (decl) + && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))) + warning_with_decl (decl, "applying #pragma weak `%s' after first use results in unspecified behavior"); + + declare_weak (decl); +} + +void +maybe_apply_pragma_weak (decl) + tree decl; +{ + tree *p, t, id; + + /* 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)))) + id = DECL_ASSEMBLER_NAME (decl); + else + return; + + for (p = &pending_weaks; (t = *p) ; p = &TREE_CHAIN (t)) + if (id == TREE_PURPOSE (t)) + { + apply_pragma_weak (decl, TREE_VALUE (t)); + *p = TREE_CHAIN (t); + break; + } +} + /* #pragma weak name [= value] */ static void handle_pragma_weak (dummy) cpp_reader *dummy ATTRIBUTE_UNUSED; { - tree name, value, x; + tree name, value, x, decl; enum cpp_ttype t; value = 0; if (c_lex (&name) != CPP_NAME) - BAD ("malformed #pragma weak, ignored"); + GCC_BAD ("malformed #pragma weak, ignored"); t = c_lex (&x); if (t == CPP_EQ) { if (c_lex (&value) != CPP_NAME) - BAD ("malformed #pragma weak, ignored"); + GCC_BAD ("malformed #pragma weak, ignored"); t = c_lex (&x); } if (t != CPP_EOF) warning ("junk at end of #pragma weak"); - add_weak (IDENTIFIER_POINTER (name), value ? IDENTIFIER_POINTER (value) : 0); + decl = identifier_global_value (name); + if (decl && TREE_CODE_CLASS (TREE_CODE (decl)) == 'd') + { + apply_pragma_weak (decl, value); + if (value) + assemble_alias (decl, value); + } + else + pending_weaks = tree_cons (name, value, pending_weaks); } -#endif - -#if !USE_CPPLIB -/* Glue version of cpplib's pragma registration and dispatch system. */ -struct pragma_entry +#else +void +maybe_apply_pragma_weak (decl) + tree decl ATTRIBUTE_UNUSED; { - struct pragma_entry *next; - const char *name; - size_t len; - int isnspace; - union { - void (*handler) PARAMS ((cpp_reader *)); - struct pragma_entry *space; - } u; -}; +} +#endif /* HANDLE_PRAGMA_WEAK */ -void -cpp_register_pragma_space (pfile, space) - cpp_reader *pfile ATTRIBUTE_UNUSED; - const char *space; +static GTY(()) tree pending_redefine_extname; + +#ifdef HANDLE_PRAGMA_REDEFINE_EXTNAME +static void handle_pragma_redefine_extname PARAMS ((cpp_reader *)); + +/* #pragma redefined_extname oldname newname */ +static void +handle_pragma_redefine_extname (dummy) + cpp_reader *dummy ATTRIBUTE_UNUSED; { - struct pragma_entry *new; - const struct pragma_entry *p = pragmas; - size_t len = strlen (space); + tree oldname, newname, decl, x; + enum cpp_ttype t; - while (p) + if (c_lex (&oldname) != CPP_NAME) { - if (p->isnspace && p->len == len && !memcmp (p->name, space, len)) - return; - p = p->next; + warning ("malformed #pragma redefine_extname, ignored"); + return; } + if (c_lex (&newname) != CPP_NAME) + { + warning ("malformed #pragma redefine_extname, ignored"); + return; + } + t = c_lex (&x); + if (t != CPP_EOF) + warning ("junk at end of #pragma redefine_extname"); - new = (struct pragma_entry *) xmalloc (sizeof (struct pragma_entry)); - new->name = space; - new->len = len; - new->isnspace = 1; - new->u.space = 0; - - new->next = pragmas; - pragmas = new; + decl = identifier_global_value (oldname); + if (decl && TREE_CODE_CLASS (TREE_CODE (decl)) == 'd') + { + if (DECL_ASSEMBLER_NAME_SET_P (decl) + && DECL_ASSEMBLER_NAME (decl) != newname) + warning ("#pragma redefine_extname conflicts with declaration"); + SET_DECL_ASSEMBLER_NAME (decl, newname); + } + else + pending_redefine_extname + = tree_cons (oldname, newname, pending_redefine_extname); } +#endif -void -cpp_register_pragma (pfile, space, name, handler) - cpp_reader *pfile ATTRIBUTE_UNUSED; - const char *space; - const char *name; - void (*handler) PARAMS ((cpp_reader *)); +static GTY(()) tree pragma_extern_prefix; + +#ifdef HANDLE_PRAGMA_EXTERN_PREFIX +static void handle_pragma_extern_prefix PARAMS ((cpp_reader *)); + +/* #pragma extern_prefix "prefix" */ +static void +handle_pragma_extern_prefix (dummy) + cpp_reader *dummy ATTRIBUTE_UNUSED; { - struct pragma_entry **x, *new; - size_t len; + tree prefix, x; + enum cpp_ttype t; - x = &pragmas; - if (space) + if (c_lex (&prefix) != CPP_STRING) { - struct pragma_entry *p = pragmas; - len = strlen (space); - while (p) - { - if (p->isnspace && p->len == len && !memcmp (p->name, space, len)) - { - x = &p->u.space; - goto found; - } - p = p->next; - } - abort (); + warning ("malformed #pragma extern_prefix, ignored"); + return; } + t = c_lex (&x); + if (t != CPP_EOF) + warning ("junk at end of #pragma extern_prefix"); - found: - new = (struct pragma_entry *) xmalloc (sizeof (struct pragma_entry)); - new->name = name; - new->len = strlen (name); - new->isnspace = 0; - new->u.handler = handler; - - new->next = *x; - *x = new; + /* Note that the length includes the null terminator. */ + pragma_extern_prefix = (TREE_STRING_LENGTH (prefix) > 1 ? prefix : NULL); } +#endif -/* Called from process_directive() for #pragma lines. */ -void -dispatch_pragma () -{ - enum cpp_ttype t; - tree x; - const struct pragma_entry *p; - const char *name, *space = 0; - size_t len; - - p = pragmas; +/* Hook from the front ends to apply the results of one of the preceeding + pragmas that rename variables. */ - new_space: - t = c_lex (&x); - if (t == CPP_EOF) - return; +tree +maybe_apply_renaming_pragma (decl, asmname) + tree decl, 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 + return asmname; - if (t != CPP_NAME) + /* If the name begins with a *, that's a sign of an asmname attached to + a previous declaration. */ + if (IDENTIFIER_POINTER (oldname)[0] == '*') { - warning ("malformed #pragma directive"); - return; + const char *oldasmname = IDENTIFIER_POINTER (oldname) + 1; + if (asmname && strcmp (TREE_STRING_POINTER (asmname), oldasmname) != 0) + warning ("asm declaration conficts with previous rename"); + asmname = build_string (strlen (oldasmname), oldasmname); } - name = IDENTIFIER_POINTER (x); - len = IDENTIFIER_LENGTH (x); - while (p) - { - if (strlen (p->name) == len && !memcmp (p->name, name, len)) +#ifdef HANDLE_PRAGMA_REDEFINE_EXTNAME + { + tree *p, t; + + for (p = &pending_redefine_extname; (t = *p) ; p = &TREE_CHAIN (t)) + if (oldname == TREE_PURPOSE (t)) { - if (p->isnspace) - { - space = p->name; - p = p->u.space; - goto new_space; - } - else - { - (*p->u.handler) (0); - return; - } + const char *newname = IDENTIFIER_POINTER (TREE_VALUE (t)); + + if (asmname && strcmp (TREE_STRING_POINTER (asmname), newname) != 0) + warning ("#pragma redefine_extname conflicts with declaration"); + *p = TREE_CHAIN (t); + + return build_string (strlen (newname), newname); } - p = p->next; - } + } +#endif - /* Issue a warning message if we have been asked to do so. Ignore - unknown pragmas in system headers unless an explicit - -Wunknown-pragmas has been given. */ - if (warn_unknown_pragmas > in_system_header) +#ifdef HANDLE_PRAGMA_EXTERN_PREFIX + if (pragma_extern_prefix && !asmname) { - if (space) - warning ("ignoring #pragma %s %s", space, name); - else - warning ("ignoring #pragma %s", name); + char *x = concat (TREE_STRING_POINTER (pragma_extern_prefix), + IDENTIFIER_POINTER (oldname), NULL); + asmname = build_string (strlen (x), x); + free (x); + return asmname; } -} - #endif + return asmname; +} + void init_pragma () { - cpp_reader *pfile ATTRIBUTE_UNUSED; -#if !USE_CPPLIB - pfile = 0; -#else - pfile = &parse_in; -#endif - #ifdef HANDLE_PRAGMA_PACK - cpp_register_pragma (pfile, 0, "pack", handle_pragma_pack); + cpp_register_pragma (parse_in, 0, "pack", handle_pragma_pack); #endif #ifdef HANDLE_PRAGMA_WEAK - cpp_register_pragma (pfile, 0, "weak", handle_pragma_weak); + cpp_register_pragma (parse_in, 0, "weak", handle_pragma_weak); #endif -#ifdef REGISTER_TARGET_PRAGMAS - REGISTER_TARGET_PRAGMAS (pfile); +#ifdef HANDLE_PRAGMA_REDEFINE_EXTNAME + cpp_register_pragma (parse_in, 0, "redefine_extname", + handle_pragma_redefine_extname); +#endif +#ifdef HANDLE_PRAGMA_EXTERN_PREFIX + cpp_register_pragma (parse_in, 0, "extern_prefix", + handle_pragma_extern_prefix); #endif -#ifdef HANDLE_PRAGMA_PACK_PUSH_POP - ggc_add_root (&alignment_stack, 1, sizeof(alignment_stack), - mark_align_stack); +#ifdef REGISTER_TARGET_PRAGMAS + REGISTER_TARGET_PRAGMAS (parse_in); #endif } + +#include "gt-c-pragma.h"