Enlist the FreeBSD-CURRENT users as testers of what is to become Gcc 3.1.0.

These bits are taken from the FSF anoncvs repo on 1-Feb-2002 08:20 PST.

1 files changed, 192 insertions, 370 deletions

diff --git a/contrib/gcc/c-pragma.c b/contrib/gcc/c-pragma.c
index 5aa8d9f..f0c2b40 100644
--- a/contrib/gcc/c-pragma.c
+++ b/contrib/gcc/c-pragma.c
@@ -1,44 +1,43 @@
 /* Handle #pragma, system V.4 style.  Supports #pragma weak and #pragma pack.
-   Copyright (C) 1992, 1997, 1998, 1999 Free Software Foundation, Inc.
+   Copyright (C) 1992, 1997, 1998, 1999, 2000, 2001
+   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 "except.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 "output.h"
+#include "tm_p.h"
 
-#ifdef HANDLE_GENERIC_PRAGMAS
+#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
-/* When structure field packing is in effect, this variable is the
-   number of bits to use as the maximum alignment.  When packing is not
-   in effect, this is zero.  */
-
-extern int maximum_field_alignment;
-#endif
-
+static void handle_pragma_pack PARAMS ((cpp_reader *));
 
 #ifdef HANDLE_PRAGMA_PACK_PUSH_POP
 typedef struct align_stack
@@ -51,30 +50,25 @@ typedef struct align_stack
 
 static struct align_stack * alignment_stack = NULL;
 
-static int  push_alignment PROTO((int, tree));
-static int  pop_alignment  PROTO((tree));
+/* If we have a "global" #pragma pack(<n>) in effect when the first
+   #pragma pack(push,<n>) 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;
+#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 mark_align_stack PARAMS ((void *));
 
 /* Push an alignment value onto the stack.  */
-static int
+static void
 push_alignment (alignment, id)
      int alignment;
      tree id;
 {
-  switch (alignment)
-    {
-    case 0:
-    case 1:
-    case 2:
-    case 4:
-    case 8:
-    case 16:
-      break;
-    default:
-      warning ("\
-Alignment must be a small power of two, not %d, in #pragma pack",
-	       alignment);
-      return 0;
-    }
   
   if (alignment_stack == NULL
       || alignment_stack->alignment != alignment
@@ -84,29 +78,27 @@ Alignment must be a small power of two, not %d, in #pragma pack",
 
       entry = (align_stack *) xmalloc (sizeof (* entry));
 
-      if (entry == NULL)
-	{
-	  warning ("Out of memory pushing #pragma pack");
-	  return 0;
-	}
-
       entry->alignment  = alignment;
       entry->num_pushes = 1;
       entry->id         = id;
       entry->prev       = alignment_stack;
       
+      /* The current value of maximum_field_alignment is not necessarily 
+	 0 since there may be a #pragma pack(<n>) in effect; remember it 
+	 so that we can restore it after the final #pragma pop().  */
+      if (alignment_stack == NULL)
+	default_alignment = maximum_field_alignment;
+      
       alignment_stack = entry;
 
-      maximum_field_alignment = alignment * 8;
+      maximum_field_alignment = alignment;
     }
   else
     alignment_stack->num_pushes ++;
-
-  return 1;
 }
 
 /* Undo a push of an alignment onto the stack.  */
-static int
+static void
 pop_alignment (id)
      tree id;
 {
@@ -117,7 +109,7 @@ pop_alignment (id)
       warning ("\
 #pragma pack (pop) encountered without matching #pragma pack (push, <n>)"
 	       );
-      return 0;
+      return;
     }
 
   /* If we got an identifier, strip away everything above the target
@@ -142,359 +134,189 @@ pop_alignment (id)
       entry = alignment_stack->prev;
 
       if (entry == NULL)
-	maximum_field_alignment = 0;
+	maximum_field_alignment = default_alignment;
       else
-	maximum_field_alignment = entry->alignment * 8;
+	maximum_field_alignment = entry->alignment;
 
       free (alignment_stack);
 
       alignment_stack = entry;
     }
-
-  return 1;
 }
 
-/* Generate 'packed' and 'aligned' attributes for decls whilst a
-   #pragma pack(push... is in effect.  */
-void
-insert_pack_attributes (node, attributes, prefix)
-     tree node;
-     tree * attributes;
-     tree * prefix;
+static void
+mark_align_stack (p)
+    void *p;
 {
-  tree a;
-  int field_alignment;
-
-  /* If we are not packing, then there is nothing to do.  */
-  if (maximum_field_alignment == 0
-      || alignment_stack == NULL)
-    return;
-
-  /* We are only interested in fields.  */
-  if (TREE_CODE_CLASS (TREE_CODE (node)) != 'd'
-      || TREE_CODE (node) != FIELD_DECL)
-    return;
-  
-  field_alignment = TYPE_ALIGN (TREE_TYPE (node));
-  if (field_alignment <= 0 || field_alignment > maximum_field_alignment)
-    field_alignment = maximum_field_alignment;
+  align_stack *a = *(align_stack **) p;
 
-  /* Add a 'packed' attribute.  */
-  * attributes = tree_cons (get_identifier ("packed"), NULL, * attributes);
-  
-  /* If the alignment is > 8 then add an alignment attribute as well.  */
-  if (field_alignment > 8)
+  while (a)
     {
-      /* If the aligned attribute is already present then do not override it.  */
-      for (a = * attributes; a; a = TREE_CHAIN (a))
-	{
-	  tree name = TREE_PURPOSE (a);
-	  if (strcmp (IDENTIFIER_POINTER (name), "aligned") == 0)
-	    break;
-	}
-      
-      if (a == NULL)
-	for (a = * prefix; a; a = TREE_CHAIN (a))
-	  {
-	    tree name = TREE_PURPOSE (a);
-	    if (strcmp (IDENTIFIER_POINTER (name), "aligned") == 0)
-	      break;
-	  }
-  
-      if (a == NULL)
-	{
-	  * attributes = tree_cons
-	      (get_identifier ("aligned"),
-	       tree_cons (NULL,
-			  build_int_2 (field_alignment / 8, 0),
-			  NULL),
-	       * attributes);
-	}
+      ggc_mark_tree (a->id);
+      a = a->prev;
     }
-
-  return;
 }
+#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")
+#define pop_alignment(ID) \
+    GCC_BAD("#pragma pack(pop[, id], <n>) is not supported on this target")
 #endif /* HANDLE_PRAGMA_PACK_PUSH_POP */
-
-/* Handle one token of a pragma directive.  TOKEN is the current token, and
-   STRING is its printable form.  Some front ends do not support generating
-   tokens, and will only pass in a STRING.  Also some front ends will reuse
-   the buffer containing STRING, so it must be copied to a local buffer if
-   it needs to be preserved.
-
-   If STRING is non-NULL, then the return value will be ignored, and there
-   will be futher calls to handle_pragma_token() in order to handle the rest of
-   the line containing the #pragma directive.  If STRING is NULL, the entire
-   line has now been presented to handle_pragma_token() and the return value
-   should be zero if the pragma flawed in some way, or if the pragma was not
-   recognised, and non-zero if it was successfully handled.  */
-
-int
-handle_pragma_token (string, token)
-     const char * string;
-     tree token;
+
+/* #pragma pack ()
+   #pragma pack (N)
+   
+   #pragma pack (push, N)
+   #pragma pack (push, ID, N)
+   #pragma pack (pop)
+   #pragma pack (pop, ID) */
+static void
+handle_pragma_pack (dummy)
+     cpp_reader *dummy ATTRIBUTE_UNUSED;
 {
-  static enum pragma_state state = ps_start;
-  static enum pragma_state type;
-  static char * name;
-  static char * value;
-  static int align;
-  static tree id;
-
-  /* If we have reached the end of the #pragma directive then
-     determine what value we should return.  */
-  
-  if (string == NULL)
-    {
-      int ret_val = 0;
+  tree x, id = 0;
+  int align = -1;
+  enum cpp_ttype token;
+  enum { set, push, pop } action;
 
-      switch (type)
-	{
-	default:
-	  abort ();
-	  break;
-
-	case ps_done:
-	  /* The pragma was not recognised.  */
-	  break;
-	  
-#ifdef HANDLE_PRAGMA_PACK	  
-	case ps_pack:
-	  if (state == ps_right)
-	    {
-	      maximum_field_alignment = align * 8;
-	      ret_val = 1;
-	    }
-	  else
-	    warning ("malformed `#pragma pack'");
-	  break;
-#endif /* HANDLE_PRAGMA_PACK */
-	  
-#ifdef HANDLE_PRAGMA_PACK_PUSH_POP
-	case ps_push:
-	  if (state == ps_right)
-	    ret_val = push_alignment (align, id);
-	  else
-	    warning ("malformed '#pragma pack(push[,id],<n>)'");
-	  break;
-	  
-	case ps_pop:
-	  if (state == ps_right)
-	    ret_val = pop_alignment (id);
-	  else
-	    warning ("malformed '#pragma pack(pop[,id])'");
-	  break;
-#endif /* HANDLE_PRAGMA_PACK_PUSH_POP */
-	  
-#ifdef HANDLE_PRAGMA_WEAK
-	case ps_weak:
-	  if (HANDLE_PRAGMA_WEAK)
-	    {
-	      if (state == ps_name)
-		ret_val = add_weak (name, NULL);
-	      else if (state == ps_value)
-		ret_val = add_weak (name, value);
-	      else
-		warning ("malformed `#pragma weak'");
-	    }
-	  else
-	    ret_val = 1; /* Ignore the pragma.  */
-	  break;
-#endif /* HANDLE_PRAGMA_WEAK */
-	}
+  if (c_lex (&x) != CPP_OPEN_PAREN)
+    GCC_BAD ("missing '(' after '#pragma pack' - ignored");
 
-      type = state = ps_start;
-      id = NULL_TREE;
-      
-      return ret_val;
+  token = c_lex (&x);
+  if (token == CPP_CLOSE_PAREN)
+    {
+      action = set;
+      align = 0;
     }
-
-  /* If we have been given a token, but it is not an identifier,
-     or a small constant, then something has gone wrong.  */
-  if (token)
+  else if (token == CPP_NUMBER)
     {
-      switch (TREE_CODE (token))
-	{
-	case IDENTIFIER_NODE:
-	  break;
-	  
-	case INTEGER_CST:
-	  if (TREE_INT_CST_HIGH (token) != 0)
-	    return 0;
-	  break;
-	  
-	default:
-	  return 0;
-	}
+      align = TREE_INT_CST_LOW (x);
+      action = set;
+      if (c_lex (&x) != CPP_CLOSE_PAREN)
+	GCC_BAD ("malformed '#pragma pack' - ignored");
     }
-      
-  switch (state)
+  else if (token == CPP_NAME)
     {
-    case ps_start:
-      type = state = ps_done;
-#ifdef HANDLE_PRAGMA_PACK
-      if (strcmp (string, "pack") == 0)
-	type = state = ps_pack;
-#endif
-#ifdef HANDLE_PRAGMA_WEAK
-      if (strcmp (string, "weak") == 0)
-	type = state = ps_weak;
-#endif	  
-      break;
-      
-#ifdef HANDLE_PRAGMA_WEAK
-    case ps_weak:
-      name = permalloc (strlen (string) + 1);
-      if (name == NULL)
-	{
-	  warning ("Out of memory parsing #pragma weak");
-	  state = ps_bad;
-	}
+#define GCC_BAD_ACTION do { if (action == push) \
+	  GCC_BAD ("malformed '#pragma pack(push[, id], <n>)' - 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
-	{
-	  strcpy (name, string);
-	  state = ps_name;
-	}
-      break;
-      
-    case ps_name:
-      state = (strcmp (string, "=") ? ps_bad : ps_equals);
-      break;
-
-    case ps_equals:
-      value = permalloc (strlen (string) + 1);
-      if (value == NULL)
-	{
-	  warning ("Out of memory parsing #pragma weak");
-	  state = ps_bad;
-	}
-      else
-	{
-	  strcpy (value, string);
-	  state = ps_value;
-	}
-      break;
+	GCC_BAD2 ("unknown action '%s' for '#pragma pack' - ignored", op);
 
-    case ps_value:
-      state = ps_bad;
-      break;
-#endif /* HANDLE_PRAGMA_WEAK */
-      
-#ifdef HANDLE_PRAGMA_PACK
-    case ps_pack:
-      state = (strcmp (string, "(") ? ps_bad : ps_left);
-      break;
+      token = c_lex (&x);
+      if (token != CPP_COMMA && action == push)
+	GCC_BAD_ACTION;
 
-    case ps_left:
-
-      if (token == NULL_TREE)
+      if (token == CPP_COMMA)
 	{
-	  /* #pragma pack () resets packing rules to their
-	     defaults.  */
-	  if (strcmp (string, ")") == 0)
+	  token = c_lex (&x);
+	  if (token == CPP_NAME)
 	    {
-	      align = 0;
-	      state = ps_right;
+	      id = x;
+	      if (action == push && c_lex (&x) != CPP_COMMA)
+		GCC_BAD_ACTION;
+	      token = c_lex (&x);
 	    }
-	  else
-	    state = ps_bad;
-	}
-      else if (TREE_CODE (token) == INTEGER_CST)
-	goto handle_align;
 
-#ifdef HANDLE_PRAGMA_PACK_PUSH_POP
-      else if (TREE_CODE (token) == IDENTIFIER_NODE)
-	{
-	  if (strcmp (string, "push") == 0)
-	    type = state = ps_push;
-	  else if (strcmp (string, "pop") == 0)
-	    type = state = ps_pop;
-	  else
-	    state = ps_bad;
-	}
-#endif
-      else
-	state = ps_bad;
-      break;
-
-    handle_align:
-      align = TREE_INT_CST_LOW (token);
-      switch (align)
-	{
-	case 1:
-	case 2:
-	case 4:
-	case 8:
-	case 16:
-	  state = ps_align;
-	  break;
-
-	default:
-	  state = ps_bad;
-	  break;
+	  if (action == push)
+	    {
+	      if (token == CPP_NUMBER)
+		{
+		  align = TREE_INT_CST_LOW (x);
+		  token = c_lex (&x);
+		}
+	      else
+		GCC_BAD_ACTION;
+	    }
 	}
-      break;
 
-    case ps_align:
-      state = (strcmp (string, ")") ? ps_bad : ps_right);
-      break;
-
-    case ps_right:
-      state = ps_bad;
-      break;
-#endif /* HANDLE_PRAGMA_PACK */
-
-#ifdef HANDLE_PRAGMA_PACK_PUSH_POP
-    case ps_push:
-      state = (strcmp (string, ",") ? ps_bad : ps_pushcomma);
-      break;
+      if (token != CPP_CLOSE_PAREN)
+	GCC_BAD_ACTION;
+#undef GCC_BAD_ACTION
+    }
+  else
+    GCC_BAD ("malformed '#pragma pack' - ignored");
+
+  if (c_lex (&x) != CPP_EOF)
+    warning ("junk at end of '#pragma pack'");
+
+  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)
+    {
+    case set:   SET_GLOBAL_ALIGNMENT (align);  break;
+    case push:  push_alignment (align, id);    break;
+    case pop:   pop_alignment (id);            break;
+    }
+}
+#endif  /* HANDLE_PRAGMA_PACK */
 
-    case ps_pushid:
-      state = (strcmp (string, ",") ? ps_bad : ps_pushcomma2);
-      break;
+#ifdef HANDLE_PRAGMA_WEAK
+static void handle_pragma_weak PARAMS ((cpp_reader *));
 
-    case ps_pushcomma:
-      if (token && TREE_CODE (token) == IDENTIFIER_NODE)
-	{
-	  id = token;
-	  state = ps_pushid;
-	  break;
-	}
+/* #pragma weak name [= value] */
+static void
+handle_pragma_weak (dummy)
+     cpp_reader *dummy ATTRIBUTE_UNUSED;
+{
+  tree name, value, x;
+  enum cpp_ttype t;
 
-      /* else fall through */
-    case ps_pushcomma2:
-      if (token && TREE_CODE (token) == INTEGER_CST)
-	goto handle_align;
-      else
-	state = ps_bad;
-      break;
+  value = 0;
 
-    case ps_pop:
-      if (strcmp (string, ",") == 0)
-	state = ps_popcomma;
-      else
-	state = (strcmp (string, ")") ? ps_bad : ps_right);
-      break;
+  if (c_lex (&name) != CPP_NAME)
+    GCC_BAD ("malformed #pragma weak, ignored");
+  t = c_lex (&x);
+  if (t == CPP_EQ)
+    {
+      if (c_lex (&value) != CPP_NAME)
+	GCC_BAD ("malformed #pragma weak, ignored");
+      t = c_lex (&x);
+    }
+  if (t != CPP_EOF)
+    warning ("junk at end of #pragma weak");
 
-    case ps_popcomma:
-      if (token && TREE_CODE (token) == IDENTIFIER_NODE)
-	{
-	  id = token;
-	  state = ps_align;
-	}
-      else
-	state = ps_bad;
-      break;
-#endif /* HANDLE_PRAGMA_PACK_PUSH_POP */
-      
-    case ps_bad:
-    case ps_done:
-      break;
+  add_weak (IDENTIFIER_POINTER (name), value ? IDENTIFIER_POINTER (value) : 0);
+}
+#endif
 
-    default:
-      abort ();
-    }
+void
+init_pragma ()
+{
+#ifdef HANDLE_PRAGMA_PACK
+  cpp_register_pragma (parse_in, 0, "pack", handle_pragma_pack);
+#endif
+#ifdef HANDLE_PRAGMA_WEAK
+  cpp_register_pragma (parse_in, 0, "weak", handle_pragma_weak);
+#endif
+#ifdef REGISTER_TARGET_PRAGMAS
+  REGISTER_TARGET_PRAGMAS (parse_in);
+#endif
 
-  return 1;
+#ifdef HANDLE_PRAGMA_PACK_PUSH_POP
+  ggc_add_root (&alignment_stack, 1, sizeof(alignment_stack),
+		mark_align_stack);
+#endif
 }
-#endif /* HANDLE_GENERIC_PRAGMAS */