/* Handle #pragma, system V.4 style. Supports #pragma weak and #pragma pack.
- Copyright (C) 1992, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
+ Copyright (C) 1992, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
Free Software Foundation, Inc.
This file is part of GCC.
You should have received a copy of the GNU General Public License
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. */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA. */
#include "config.h"
#include "system.h"
#include "c-common.h"
#include "output.h"
#include "tm_p.h"
+#include "vec.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)
+#define GCC_BAD(gmsgid) do { warning (0, gmsgid); return; } while (0)
+#define GCC_BAD2(gmsgid, arg) \
+ do { warning (0, gmsgid, arg); return; } while (0)
typedef struct align_stack GTY(())
{
align_stack * entry;
if (alignment_stack == NULL)
- GCC_BAD("#pragma pack (pop) encountered without matching #pragma pack (push)");
+ GCC_BAD ("#pragma pack (pop) encountered without matching #pragma pack (push)");
/* If we got an identifier, strip away everything above the target
entry so that the next step will restore the state just below it. */
break;
}
if (entry == NULL)
- warning ("\
+ warning (0, "\
#pragma pack(pop, %s) encountered without matching #pragma pack(push, %s)"
, IDENTIFIER_POINTER (id), IDENTIFIER_POINTER (id));
}
#else /* not HANDLE_PRAGMA_PACK_PUSH_POP */
#define SET_GLOBAL_ALIGNMENT(ALIGN) (maximum_field_alignment = (ALIGN))
#define push_alignment(ID, N) \
- GCC_BAD("#pragma pack(push[, id], <n>) is not supported on this target")
+ GCC_BAD ("#pragma pack(push[, id], <n>) is not supported on this target")
#define pop_alignment(ID) \
- GCC_BAD("#pragma pack(pop[, id], <n>) is not supported on this target")
+ GCC_BAD ("#pragma pack(pop[, id], <n>) is not supported on this target")
#endif /* HANDLE_PRAGMA_PACK_PUSH_POP */
/* #pragma pack ()
enum { set, push, pop } action;
if (c_lex (&x) != CPP_OPEN_PAREN)
- GCC_BAD ("missing '(' after '#pragma pack' - ignored");
+ GCC_BAD ("missing %<(%> after %<#pragma pack%> - ignored");
token = c_lex (&x);
if (token == CPP_CLOSE_PAREN)
align = TREE_INT_CST_LOW (x);
action = set;
if (c_lex (&x) != CPP_CLOSE_PAREN)
- GCC_BAD ("malformed '#pragma pack' - ignored");
+ GCC_BAD ("malformed %<#pragma pack%> - ignored");
}
else if (token == CPP_NAME)
{
#define GCC_BAD_ACTION do { if (action != pop) \
- GCC_BAD ("malformed '#pragma pack(push[, id][, <n>])' - ignored"); \
+ GCC_BAD ("malformed %<#pragma pack(push[, id][, <n>])%> - ignored"); \
else \
- GCC_BAD ("malformed '#pragma pack(pop[, id])' - ignored"); \
+ GCC_BAD ("malformed %<#pragma pack(pop[, id])%> - ignored"); \
} while (0)
const char *op = IDENTIFIER_POINTER (x);
else if (!strcmp (op, "pop"))
action = pop;
else
- GCC_BAD2 ("unknown action '%s' for '#pragma pack' - ignored", op);
+ GCC_BAD2 ("unknown action %qs for %<#pragma pack%> - ignored", op);
while ((token = c_lex (&x)) == CPP_COMMA)
{
#undef GCC_BAD_ACTION
}
else
- GCC_BAD ("malformed '#pragma pack' - ignored");
+ GCC_BAD ("malformed %<#pragma pack%> - ignored");
if (c_lex (&x) != CPP_EOF)
- warning ("junk at end of '#pragma pack'");
+ warning (0, "junk at end of %<#pragma pack%>");
if (flag_pack_struct)
GCC_BAD ("#pragma pack has no effect with -fpack-struct - ignored");
if (SUPPORTS_WEAK && DECL_EXTERNAL (decl) && TREE_USED (decl)
&& !DECL_WEAK (decl) /* Don't complain about a redundant #pragma. */
&& TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
- warning ("%Japplying #pragma weak '%D' after first use results "
- "in unspecified behavior", decl, decl);
+ warning (0, "applying #pragma weak %q+D after first use results "
+ "in unspecified behavior", decl);
declare_weak (decl);
}
return;
/* If it's not a function or a variable, it can't be weak.
FIXME: what kinds of things are visible outside this file but
- aren't functions or variables? Should this be an abort() instead? */
+ aren't functions or variables? Should this be an assert instead? */
if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
return;
}
}
+/* Process all "#pragma weak A = B" directives where we have not seen
+ a decl for A. */
+void
+maybe_apply_pending_pragma_weaks (void)
+{
+ tree *p, t, alias_id, id, decl, *next;
+
+ for (p = &pending_weaks; (t = *p) ; p = next)
+ {
+ next = &TREE_CHAIN (t);
+ alias_id = TREE_PURPOSE (t);
+ id = TREE_VALUE (t);
+
+ if (TREE_VALUE (t) == NULL)
+ continue;
+
+ decl = build_decl (FUNCTION_DECL, alias_id, default_function_type);
+
+ DECL_ARTIFICIAL (decl) = 1;
+ TREE_PUBLIC (decl) = 1;
+ DECL_EXTERNAL (decl) = 1;
+ DECL_WEAK (decl) = 1;
+
+ assemble_alias (decl, id);
+ }
+}
+
/* #pragma weak name [= value] */
static void
handle_pragma_weak (cpp_reader * ARG_UNUSED (dummy))
t = c_lex (&x);
}
if (t != CPP_EOF)
- warning ("junk at end of #pragma weak");
+ warning (0, "junk at end of #pragma weak");
decl = identifier_global_value (name);
- if (decl && TREE_CODE_CLASS (TREE_CODE (decl)) == 'd')
+ if (decl && DECL_P (decl))
{
apply_pragma_weak (decl, value);
if (value)
maybe_apply_pragma_weak (tree ARG_UNUSED (decl))
{
}
+
+void
+maybe_apply_pending_pragma_weaks (void)
+{
+}
#endif /* HANDLE_PRAGMA_WEAK */
/* GCC supports two #pragma directives for renaming the external
GCC_BAD ("malformed #pragma redefine_extname, ignored");
t = c_lex (&x);
if (t != CPP_EOF)
- warning ("junk at end of #pragma redefine_extname");
+ warning (0, "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");
+ warning (OPT_Wunknown_pragmas,
+ "#pragma redefine_extname not supported on this target");
return;
}
name = targetm.strip_name_encoding (name);
if (strcmp (name, IDENTIFIER_POINTER (newname)))
- warning ("#pragma redefine_extname ignored due to conflict with "
+ warning (0, "#pragma redefine_extname ignored due to conflict with "
"previous rename");
}
else
if (previous)
{
if (TREE_VALUE (previous) != newname)
- warning ("#pragma redefine_extname ignored due to conflict with "
+ warning (0, "#pragma redefine_extname ignored due to conflict with "
"previous #pragma redefine_extname");
return;
}
GCC_BAD ("malformed #pragma extern_prefix, ignored");
t = c_lex (&x);
if (t != CPP_EOF)
- warning ("junk at end of #pragma extern_prefix");
+ warning (0, "junk at end of #pragma extern_prefix");
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");
+ warning (OPT_Wunknown_pragmas,
+ "#pragma extern_prefix not supported on this target");
}
/* Hook from the front ends to apply the results of one of the preceding
oldname = targetm.strip_name_encoding (oldname);
if (asmname && strcmp (TREE_STRING_POINTER (asmname), oldname))
- warning ("asm declaration ignored due to "
+ warning (0, "asm declaration ignored due to "
"conflict with previous rename");
/* Take any pending redefine_extname off the list. */
{
/* Only warn if there is a conflict. */
if (strcmp (IDENTIFIER_POINTER (TREE_VALUE (t)), oldname))
- warning ("#pragma redefine_extname ignored due to "
+ warning (0, "#pragma redefine_extname ignored due to "
"conflict with previous rename");
*p = TREE_CHAIN (t);
{
if (strcmp (TREE_STRING_POINTER (asmname),
IDENTIFIER_POINTER (newname)) != 0)
- warning ("#pragma redefine_extname ignored due to "
+ warning (0, "#pragma redefine_extname ignored due to "
"conflict with __asm__ declaration");
return asmname;
}
#ifdef HANDLE_PRAGMA_VISIBILITY
static void handle_pragma_visibility (cpp_reader *);
+typedef enum symbol_visibility visibility;
+DEF_VEC_I (visibility);
+DEF_VEC_ALLOC_I (visibility, heap);
+
/* 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;
+{
+ /* Form is #pragma GCC visibility push(hidden)|pop */
tree x;
enum cpp_ttype token;
enum { bad, push, pop } action = bad;
+ static VEC (visibility, heap) *visstack;
token = c_lex (&x);
if (token == CPP_NAME)
{
if (pop == action)
{
- if (!visidx)
+ if (!VEC_length (visibility, visstack))
{
- GCC_BAD ("No matching push for '#pragma GCC visibility pop'");
+ GCC_BAD ("No matching push for %<#pragma GCC visibility pop%>");
}
else
{
- default_visibility = visstack[--visidx];
- visibility_options.inpragma = (visidx>0);
+ default_visibility = VEC_pop (visibility, visstack);
+ visibility_options.inpragma
+ = VEC_length (visibility, visstack) != 0;
}
}
else
{
if (c_lex (&x) != CPP_OPEN_PAREN)
- GCC_BAD ("missing '(' after '#pragma GCC visibility push' - ignored");
+ 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;
+ VEC_safe_push (visibility, heap, visstack,
+ default_visibility);
if (!strcmp (str, "default"))
default_visibility = VISIBILITY_DEFAULT;
else if (!strcmp (str, "internal"))
visibility_options.inpragma = 1;
}
if (c_lex (&x) != CPP_CLOSE_PAREN)
- GCC_BAD ("missing '(' after '#pragma GCC visibility push' - ignored");
+ GCC_BAD ("missing %<(%> after %<#pragma GCC visibility push%> - ignored");
}
}
if (c_lex (&x) != CPP_EOF)
- warning ("junk at end of '#pragma GCC visibility'");
+ warning (0, "junk at end of %<#pragma GCC visibility%>");
}
#endif
-/* Front-end wrapper for pragma registration to avoid dragging
+/* Front-end wrappers for pragma registration to avoid dragging
cpplib.h in almost everywhere. */
void
c_register_pragma (const char *space, const char *name,
void (*handler) (struct cpp_reader *))
{
- cpp_register_pragma (parse_in, space, name, handler);
+ cpp_register_pragma (parse_in, space, name, handler, 0);
+}
+
+void
+c_register_pragma_with_expansion (const char *space, const char *name,
+ void (*handler) (struct cpp_reader *))
+{
+ cpp_register_pragma (parse_in, space, name, handler, 1);
}
/* Set up front-end pragmas. */
init_pragma (void)
{
#ifdef HANDLE_PRAGMA_PACK
+#ifdef HANDLE_PRAGMA_PACK_WITH_EXPANSION
+ c_register_pragma_with_expansion (0, "pack", handle_pragma_pack);
+#else
c_register_pragma (0, "pack", handle_pragma_pack);
#endif
+#endif
#ifdef HANDLE_PRAGMA_WEAK
c_register_pragma (0, "weak", handle_pragma_weak);
#endif
OSDN Git Service
