Gcc 3.4.2 20040728.

1 files changed, 45 insertions, 44 deletions

diff --git a/contrib/gcc/c-pragma.c b/contrib/gcc/c-pragma.c
index 819e696..10c8cae 100644
--- a/contrib/gcc/c-pragma.c
+++ b/contrib/gcc/c-pragma.c
@@ -1,5 +1,5 @@
 /* Handle #pragma, system V.4 style.  Supports #pragma weak and #pragma pack.
-   Copyright (C) 1992, 1997, 1998, 1999, 2000, 2001, 2002
+   Copyright (C) 1992, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
    Free Software Foundation, Inc.
 
 This file is part of GCC.
@@ -21,6 +21,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 
 #include "config.h"
 #include "system.h"
+#include "coretypes.h"
+#include "tm.h"
 #include "rtl.h"
 #include "tree.h"
 #include "function.h"
@@ -47,7 +49,7 @@ typedef struct align_stack GTY(())
 static GTY(()) struct align_stack * alignment_stack;
 
 #ifdef HANDLE_PRAGMA_PACK
-static void handle_pragma_pack PARAMS ((cpp_reader *));
+static void handle_pragma_pack (cpp_reader *);
 
 #ifdef HANDLE_PRAGMA_PACK_PUSH_POP
 /* If we have a "global" #pragma pack(<n>) in effect when the first
@@ -59,14 +61,12 @@ static int default_alignment;
 #define SET_GLOBAL_ALIGNMENT(ALIGN) \
   (default_alignment = maximum_field_alignment = (ALIGN))
 
-static void push_alignment PARAMS ((int, tree));
-static void pop_alignment  PARAMS ((tree));
+static void push_alignment (int, tree);
+static void pop_alignment (tree);
 
 /* Push an alignment value onto the stack.  */
 static void
-push_alignment (alignment, id)
-     int alignment;
-     tree id;
+push_alignment (int alignment, tree id)
 {
   if (alignment_stack == NULL
       || alignment_stack->alignment != alignment
@@ -74,7 +74,7 @@ push_alignment (alignment, id)
     {
       align_stack * entry;
 
-      entry = (align_stack *) ggc_alloc (sizeof (* entry));
+      entry = ggc_alloc (sizeof (* entry));
 
       entry->alignment  = alignment;
       entry->num_pushes = 1;
@@ -97,8 +97,7 @@ push_alignment (alignment, id)
 
 /* Undo a push of an alignment onto the stack.  */
 static void
-pop_alignment (id)
-     tree id;
+pop_alignment (tree id)
 {
   align_stack * entry;
       
@@ -155,8 +154,7 @@ pop_alignment (id)
    #pragma pack (pop)
    #pragma pack (pop, ID) */
 static void
-handle_pragma_pack (dummy)
-     cpp_reader *dummy ATTRIBUTE_UNUSED;
+handle_pragma_pack (cpp_reader *dummy ATTRIBUTE_UNUSED)
 {
   tree x, id = 0;
   int align = -1;
@@ -259,12 +257,11 @@ handle_pragma_pack (dummy)
 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 (tree, tree);
+static void handle_pragma_weak (cpp_reader *);
 
 static void
-apply_pragma_weak (decl, value)
-     tree decl, value;
+apply_pragma_weak (tree decl, tree value)
 {
   if (value)
     {
@@ -276,15 +273,16 @@ apply_pragma_weak (decl, value)
     }
 
   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_with_decl (decl, "applying #pragma weak `%s' after first use results in unspecified behavior");
+    warning ("%Japplying #pragma weak '%D' after first use results "
+             "in unspecified behavior", decl, decl);
 
   declare_weak (decl);
 }
 
 void
-maybe_apply_pragma_weak (decl)
-     tree decl;
+maybe_apply_pragma_weak (tree decl)
 {
   tree *p, t, id;
 
@@ -316,8 +314,7 @@ maybe_apply_pragma_weak (decl)
 
 /* #pragma weak name [= value] */
 static void
-handle_pragma_weak (dummy)
-     cpp_reader *dummy ATTRIBUTE_UNUSED;
+handle_pragma_weak (cpp_reader *dummy ATTRIBUTE_UNUSED)
 {
   tree name, value, x, decl;
   enum cpp_ttype t;
@@ -348,8 +345,7 @@ handle_pragma_weak (dummy)
 }
 #else
 void
-maybe_apply_pragma_weak (decl)
-     tree decl ATTRIBUTE_UNUSED;
+maybe_apply_pragma_weak (tree decl ATTRIBUTE_UNUSED)
 {
 }
 #endif /* HANDLE_PRAGMA_WEAK */
@@ -357,12 +353,11 @@ maybe_apply_pragma_weak (decl)
 static GTY(()) tree pending_redefine_extname;
 
 #ifdef HANDLE_PRAGMA_REDEFINE_EXTNAME
-static void handle_pragma_redefine_extname PARAMS ((cpp_reader *));
+static void handle_pragma_redefine_extname (cpp_reader *);
 
 /* #pragma redefined_extname oldname newname */
 static void
-handle_pragma_redefine_extname (dummy)
-     cpp_reader *dummy ATTRIBUTE_UNUSED;
+handle_pragma_redefine_extname (cpp_reader *dummy ATTRIBUTE_UNUSED)
 {
   tree oldname, newname, decl, x;
   enum cpp_ttype t;
@@ -382,12 +377,13 @@ handle_pragma_redefine_extname (dummy)
     warning ("junk at end of #pragma redefine_extname");
 
   decl = identifier_global_value (oldname);
-  if (decl && TREE_CODE_CLASS (TREE_CODE (decl)) == 'd')
+  if (decl && (TREE_CODE (decl) == FUNCTION_DECL
+	       || TREE_CODE (decl) == VAR_DECL))
     {
       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);
+      change_decl_assembler_name (decl, newname);
     }
   else
     add_to_renaming_pragma_list(oldname, newname);
@@ -395,8 +391,7 @@ handle_pragma_redefine_extname (dummy)
 #endif
 
 void
-add_to_renaming_pragma_list (oldname, newname)
-	tree oldname, newname;
+add_to_renaming_pragma_list (tree oldname, tree newname)
 {
   pending_redefine_extname
     = tree_cons (oldname, newname, pending_redefine_extname);
@@ -405,12 +400,11 @@ add_to_renaming_pragma_list (oldname, newname)
 static GTY(()) tree pragma_extern_prefix;
 
 #ifdef HANDLE_PRAGMA_EXTERN_PREFIX
-static void handle_pragma_extern_prefix PARAMS ((cpp_reader *));
+static void handle_pragma_extern_prefix (cpp_reader *);
 
 /* #pragma extern_prefix "prefix" */
 static void
-handle_pragma_extern_prefix (dummy)
-     cpp_reader *dummy ATTRIBUTE_UNUSED;
+handle_pragma_extern_prefix (cpp_reader *dummy ATTRIBUTE_UNUSED)
 {
   tree prefix, x;
   enum cpp_ttype t;
@@ -429,12 +423,11 @@ handle_pragma_extern_prefix (dummy)
 }
 #endif
 
-/* Hook from the front ends to apply the results of one of the preceeding
+/* Hook from the front ends to apply the results of one of the preceding
    pragmas that rename variables.  */
 
 tree
-maybe_apply_renaming_pragma (decl, asmname)
-     tree decl, asmname;
+maybe_apply_renaming_pragma (tree decl, tree asmname)
 {
   tree oldname;
 
@@ -488,26 +481,34 @@ maybe_apply_renaming_pragma (decl, asmname)
   return asmname;
 }
 
+/* Front-end wrapper 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);
+}
+
+/* Set up front-end pragmas.  */
 void
-init_pragma ()
+init_pragma (void)
 {
 #ifdef HANDLE_PRAGMA_PACK
-  cpp_register_pragma (parse_in, 0, "pack", handle_pragma_pack);
+  c_register_pragma (0, "pack", handle_pragma_pack);
 #endif
 #ifdef HANDLE_PRAGMA_WEAK
-  cpp_register_pragma (parse_in, 0, "weak", handle_pragma_weak);
+  c_register_pragma (0, "weak", handle_pragma_weak);
 #endif
 #ifdef HANDLE_PRAGMA_REDEFINE_EXTNAME
-  cpp_register_pragma (parse_in, 0, "redefine_extname",
-		       handle_pragma_redefine_extname);
+  c_register_pragma (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);
+  c_register_pragma (0, "extern_prefix", handle_pragma_extern_prefix);
 #endif
 
 #ifdef REGISTER_TARGET_PRAGMAS
-  REGISTER_TARGET_PRAGMAS (parse_in);
+  REGISTER_TARGET_PRAGMAS ();
 #endif
 }