Virgin import of the GCC 2.95.1 compilers

1 files changed, 392 insertions, 73 deletions

diff --git a/contrib/gcc/c-pragma.c b/contrib/gcc/c-pragma.c
index 3d01925..5aa8d9f 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 Free Software Foundation, Inc.
+   Copyright (C) 1992, 1997, 1998, 1999 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -29,147 +29,464 @@ Boston, MA 02111-1307, USA.  */
 #include "flags.h"
 #include "toplev.h"
 
-#ifdef HANDLE_SYSV_PRAGMA
+#ifdef HANDLE_GENERIC_PRAGMAS
 
+#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
 
-/* File used for outputting assembler code.  */
-extern FILE *asm_out_file;
 
-/* Handle one token of a pragma directive.  TOKEN is the
-   current token, and STRING is its printable form.  */
+#ifdef HANDLE_PRAGMA_PACK_PUSH_POP
+typedef struct align_stack
+{
+  int                  alignment;
+  unsigned int         num_pushes;
+  tree                 id;
+  struct align_stack * prev;
+} align_stack;
+
+static struct align_stack * alignment_stack = NULL;
+
+static int  push_alignment PROTO((int, tree));
+static int  pop_alignment  PROTO((tree));
+
+/* Push an alignment value onto the stack.  */
+static int
+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
+      || id != NULL_TREE)
+    {
+      align_stack * entry;
+
+      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;
+      
+      alignment_stack = entry;
+
+      maximum_field_alignment = alignment * 8;
+    }
+  else
+    alignment_stack->num_pushes ++;
+
+  return 1;
+}
+
+/* Undo a push of an alignment onto the stack.  */
+static int
+pop_alignment (id)
+     tree id;
+{
+  align_stack * entry;
+      
+  if (alignment_stack == NULL)
+    {
+      warning ("\
+#pragma pack (pop) encountered without matching #pragma pack (push, <n>)"
+	       );
+      return 0;
+    }
+
+  /* If we got an identifier, strip away everything above the target
+     entry so that the next step will restore the state just below it.  */
+  if (id)
+    {
+      for (entry = alignment_stack; entry; entry = entry->prev)
+	if (entry->id == id)
+	  {
+	    entry->num_pushes = 1;
+	    alignment_stack = entry;
+	    break;
+	  }
+      if (entry == NULL)
+	warning ("\
+#pragma pack(pop, %s) encountered without matching #pragma pack(push, %s, <n>)"
+		 , IDENTIFIER_POINTER (id), IDENTIFIER_POINTER (id));
+    }
+
+  if (-- alignment_stack->num_pushes == 0)
+    {
+      entry = alignment_stack->prev;
+
+      if (entry == NULL)
+	maximum_field_alignment = 0;
+      else
+	maximum_field_alignment = entry->alignment * 8;
+
+      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;
+{
+  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;
+
+  /* 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)
+    {
+      /* 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);
+	}
+    }
+
+  return;
+}
+#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)
-     char *string;
+     const char * string;
      tree token;
 {
-  static enum pragma_state state = ps_start, type;
-  static char *name;
-  static char *value;
+  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 (string == 0)
+  /* If we have reached the end of the #pragma directive then
+     determine what value we should return.  */
+  
+  if (string == NULL)
     {
-      if (type == ps_pack)
+      int ret_val = 0;
+
+      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;
+	    {
+	      maximum_field_alignment = align * 8;
+	      ret_val = 1;
+	    }
 	  else
 	    warning ("malformed `#pragma pack'");
-	}
-      else if (type == ps_weak)
-	{
+	  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)
-	    handle_pragma_weak (state, name, value);
-
+	    {
+	      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 */
 	}
 
       type = state = ps_start;
-      return;
+      id = NULL_TREE;
+      
+      return ret_val;
     }
 
+  /* If we have been given a token, but it is not an identifier,
+     or a small constant, then something has gone wrong.  */
+  if (token)
+    {
+      switch (TREE_CODE (token))
+	{
+	case IDENTIFIER_NODE:
+	  break;
+	  
+	case INTEGER_CST:
+	  if (TREE_INT_CST_HIGH (token) != 0)
+	    return 0;
+	  break;
+	  
+	default:
+	  return 0;
+	}
+    }
+      
   switch (state)
     {
     case ps_start:
-      if (token && TREE_CODE (token) == IDENTIFIER_NODE)
+      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)
 	{
-	  if (strcmp (IDENTIFIER_POINTER (token), "pack") == 0)
-	    type = state = ps_pack;
-	  else if (strcmp (IDENTIFIER_POINTER (token), "weak") == 0)
-	    type = state = ps_weak;
-	  else
-	    {
-	      type = state = ps_done;
-
-	      /* Issue a warning message if we have been asked to do so.
-		 Ignoring unknown pragmas in system header file unless          
-		 an explcit -Wunknown-pragmas has been given. */                
-	      if (warn_unknown_pragmas > 1
-		  || (warn_unknown_pragmas && ! in_system_header))
-		warning ("ignoring pragma: %s", string);
-	    }
+	  warning ("Out of memory parsing #pragma weak");
+	  state = ps_bad;
 	}
       else
-	type = state = ps_done;
-      break;
-
-    case ps_weak:
-      if (token && TREE_CODE (token) == IDENTIFIER_NODE)
 	{
-	  name = IDENTIFIER_POINTER (token);
+	  strcpy (name, string);
 	  state = ps_name;
 	}
-      else
-	state = ps_bad;
       break;
-
+      
     case ps_name:
       state = (strcmp (string, "=") ? ps_bad : ps_equals);
       break;
 
     case ps_equals:
-      if (token && TREE_CODE (token) == IDENTIFIER_NODE)
+      value = permalloc (strlen (string) + 1);
+      if (value == NULL)
 	{
-	  value = IDENTIFIER_POINTER (token);
-	  state = ps_value;
+	  warning ("Out of memory parsing #pragma weak");
+	  state = ps_bad;
 	}
       else
-	state = ps_bad;
+	{
+	  strcpy (value, string);
+	  state = ps_value;
+	}
       break;
 
     case ps_value:
       state = ps_bad;
       break;
-
+#endif /* HANDLE_PRAGMA_WEAK */
+      
+#ifdef HANDLE_PRAGMA_PACK
     case ps_pack:
-      if (strcmp (string, "(") == 0)
-	state = ps_left;
-      else
-	state = ps_bad;
+      state = (strcmp (string, "(") ? ps_bad : ps_left);
       break;
 
     case ps_left:
-      if (token && TREE_CODE (token) == INTEGER_CST
-	  && TREE_INT_CST_HIGH (token) == 0)
-	switch (TREE_INT_CST_LOW (token))
-	  {
-	  case 1:
-	  case 2:
-	  case 4:
-	    align = TREE_INT_CST_LOW (token);
-	    state = ps_align;
-	    break;
 
-	  default:
+      if (token == NULL_TREE)
+	{
+	  /* #pragma pack () resets packing rules to their
+	     defaults.  */
+	  if (strcmp (string, ")") == 0)
+	    {
+	      align = 0;
+	      state = ps_right;
+	    }
+	  else
 	    state = ps_bad;
-	  }
-      else if (! token && strcmp (string, ")") == 0)
+	}
+      else if (TREE_CODE (token) == INTEGER_CST)
+	goto handle_align;
+
+#ifdef HANDLE_PRAGMA_PACK_PUSH_POP
+      else if (TREE_CODE (token) == IDENTIFIER_NODE)
 	{
-	  align = 0;
-	  state = ps_right;
+	  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;
+	}
+      break;
+
     case ps_align:
-      if (strcmp (string, ")") == 0)
-	state = ps_right;
-      else
-	state = ps_bad;
+      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;
+
+    case ps_pushid:
+      state = (strcmp (string, ",") ? ps_bad : ps_pushcomma2);
+      break;
+
+    case ps_pushcomma:
+      if (token && TREE_CODE (token) == IDENTIFIER_NODE)
+	{
+	  id = token;
+	  state = ps_pushid;
+	  break;
+	}
+
+      /* else fall through */
+    case ps_pushcomma2:
+      if (token && TREE_CODE (token) == INTEGER_CST)
+	goto handle_align;
+      else
+	state = ps_bad;
+      break;
 
+    case ps_pop:
+      if (strcmp (string, ",") == 0)
+	state = ps_popcomma;
+      else
+	state = (strcmp (string, ")") ? ps_bad : ps_right);
+      break;
+
+    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;
@@ -177,5 +494,7 @@ handle_pragma_token (string, token)
     default:
       abort ();
     }
+
+  return 1;
 }
-#endif /* HANDLE_SYSV_PRAGMA */
+#endif /* HANDLE_GENERIC_PRAGMAS */