* common.opt (fshow-column): Default to 0.

[pf3gnuchains/gcc-fork.git] / gcc / stor-layout.c

diff --git a/gcc/stor-layout.c b/gcc/stor-layout.c
index 2814622..23e0cf5 100644 (file)
--- a/gcc/stor-layout.c
+++ b/gcc/stor-layout.c
@@ -1,12 +1,13 @@
 /* C-compiler utilities for types and variables storage layout
    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1996, 1998,
 /* C-compiler utilities for types and variables storage layout
    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1996, 1998,

-   1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+   Free Software Foundation, Inc.

 
 This file is part of GCC.
 
 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
 
 This file is part of GCC.
 
 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
+Software Foundation; either version 3, or (at your option) any later

 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY


@@ -15,9 +16,8 @@ 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
 for more details.
 
 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.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */

 
 
 #include "config.h"
 
 
 #include "config.h"


@@ -30,6 +30,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "flags.h"
 #include "function.h"
 #include "expr.h"
 #include "flags.h"
 #include "function.h"
 #include "expr.h"

+#include "output.h"

 #include "toplev.h"
 #include "ggc.h"
 #include "target.h"
 #include "toplev.h"
 #include "ggc.h"
 #include "target.h"


@@ -186,17 +187,18 @@ mode_for_size (unsigned int size, enum mode_class class, int limit)
 /* Similar, except passed a tree node.  */
 
 enum machine_mode
 /* Similar, except passed a tree node.  */
 
 enum machine_mode

-mode_for_size_tree (tree size, enum mode_class class, int limit)
+mode_for_size_tree (const_tree size, enum mode_class class, int limit)

 {
 {

-  if (TREE_CODE (size) != INTEGER_CST
-      || TREE_OVERFLOW (size)
-      /* What we really want to say here is that the size can fit in a
-        host integer, but we know there's no way we'd find a mode for
-        this many bits, so there's no point in doing the precise test.  */
-      || compare_tree_int (size, 1000) > 0)
+  unsigned HOST_WIDE_INT uhwi;
+  unsigned int ui;
+
+  if (!host_integerp (size, 1))

     return BLKmode;
     return BLKmode;

-  else
-    return mode_for_size (tree_low_cst (size, 1), class, limit);
+  uhwi = tree_low_cst (size, 1);
+  ui = uhwi;
+  if (uhwi != ui)
+    return BLKmode;
+  return mode_for_size (ui, class, limit);

 }
 
 /* Similar, but never return BLKmode; return the narrowest mode that
 }
 
 /* Similar, but never return BLKmode; return the narrowest mode that


@@ -231,8 +233,17 @@ int_mode_for_mode (enum machine_mode mode)
     case MODE_COMPLEX_INT:
     case MODE_COMPLEX_FLOAT:
     case MODE_FLOAT:
     case MODE_COMPLEX_INT:
     case MODE_COMPLEX_FLOAT:
     case MODE_FLOAT:

+    case MODE_DECIMAL_FLOAT:

     case MODE_VECTOR_INT:
     case MODE_VECTOR_FLOAT:
     case MODE_VECTOR_INT:
     case MODE_VECTOR_FLOAT:

+    case MODE_FRACT:
+    case MODE_ACCUM:
+    case MODE_UFRACT:
+    case MODE_UACCUM:
+    case MODE_VECTOR_FRACT:
+    case MODE_VECTOR_ACCUM:
+    case MODE_VECTOR_UFRACT:
+    case MODE_VECTOR_UACCUM:

       mode = mode_for_size (GET_MODE_BITSIZE (mode), MODE_INT, 0);
       break;
 
       mode = mode_for_size (GET_MODE_BITSIZE (mode), MODE_INT, 0);
       break;
 


@@ -296,10 +307,10 @@ layout_decl (tree decl, unsigned int known_align)
 
   if (code == CONST_DECL)
     return;
 
   if (code == CONST_DECL)
     return;

-  
+

   gcc_assert (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL
              || code == TYPE_DECL ||code == FIELD_DECL);
   gcc_assert (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL
              || code == TYPE_DECL ||code == FIELD_DECL);

-  
+

   rtl = DECL_RTL_IF_SET (decl);
 
   if (type == error_mark_node)
   rtl = DECL_RTL_IF_SET (decl);
 
   if (type == error_mark_node)


@@ -336,17 +347,22 @@ layout_decl (tree decl, unsigned int known_align)
     /* For fields, it's a bit more complicated...  */
     {
       bool old_user_align = DECL_USER_ALIGN (decl);
     /* For fields, it's a bit more complicated...  */
     {
       bool old_user_align = DECL_USER_ALIGN (decl);

+      bool zero_bitfield = false;
+      bool packed_p = DECL_PACKED (decl);
+      unsigned int mfa;

 
       if (DECL_BIT_FIELD (decl))
        {
          DECL_BIT_FIELD_TYPE (decl) = type;
 
          /* A zero-length bit-field affects the alignment of the next
 
       if (DECL_BIT_FIELD (decl))
        {
          DECL_BIT_FIELD_TYPE (decl) = type;
 
          /* A zero-length bit-field affects the alignment of the next

-            field.  */
+            field.  In essence such bit-fields are not influenced by
+            any packing due to #pragma pack or attribute packed.  */

          if (integer_zerop (DECL_SIZE (decl))
          if (integer_zerop (DECL_SIZE (decl))

-             && ! DECL_PACKED (decl)

              && ! targetm.ms_bitfield_layout_p (DECL_FIELD_CONTEXT (decl)))
            {
              && ! targetm.ms_bitfield_layout_p (DECL_FIELD_CONTEXT (decl)))
            {

+             zero_bitfield = true;
+             packed_p = false;

 #ifdef PCC_BITFIELD_TYPE_MATTERS
              if (PCC_BITFIELD_TYPE_MATTERS)
                do_type_align (type, decl);
 #ifdef PCC_BITFIELD_TYPE_MATTERS
              if (PCC_BITFIELD_TYPE_MATTERS)
                do_type_align (type, decl);


@@ -390,7 +406,7 @@ layout_decl (tree decl, unsigned int known_align)
              && DECL_ALIGN (decl) >= TYPE_ALIGN (type))
            DECL_BIT_FIELD (decl) = 0;
        }
              && DECL_ALIGN (decl) >= TYPE_ALIGN (type))
            DECL_BIT_FIELD (decl) = 0;
        }

-      else if (DECL_PACKED (decl) && DECL_USER_ALIGN (decl))
+      else if (packed_p && DECL_USER_ALIGN (decl))

        /* Don't touch DECL_ALIGN.  For other packed fields, go ahead and
           round up; we'll reduce it again below.  We want packing to
           supersede USER_ALIGN inherited from the type, but defer to
        /* Don't touch DECL_ALIGN.  For other packed fields, go ahead and
           round up; we'll reduce it again below.  We want packing to
           supersede USER_ALIGN inherited from the type, but defer to


@@ -398,21 +414,14 @@ layout_decl (tree decl, unsigned int known_align)
       else
        do_type_align (type, decl);
 
       else
        do_type_align (type, decl);
 

-      /* If the field is of variable size, we can't misalign it since we
-        have no way to make a temporary to align the result.  But this
-        isn't an issue if the decl is not addressable.  Likewise if it
-        is of unknown size.
-
-        Note that do_type_align may set DECL_USER_ALIGN, so we need to
-        check old_user_align instead.  */
-      if (DECL_PACKED (decl)
-         && !old_user_align
-         && (DECL_NONADDRESSABLE_P (decl)
-             || DECL_SIZE_UNIT (decl) == 0
-             || TREE_CODE (DECL_SIZE_UNIT (decl)) == INTEGER_CST))
+      /* If the field is packed and not explicitly aligned, give it the
+        minimum alignment.  Note that do_type_align may set
+        DECL_USER_ALIGN, so we need to check old_user_align instead.  */
+      if (packed_p
+         && !old_user_align)

        DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), BITS_PER_UNIT);
 
        DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), BITS_PER_UNIT);
 

-      if (! DECL_USER_ALIGN (decl) && ! DECL_PACKED (decl))
+      if (! packed_p && ! DECL_USER_ALIGN (decl))

        {
          /* Some targets (i.e. i386, VMS) limit struct field alignment
             to a lower boundary than alignment of variables unless
        {
          /* Some targets (i.e. i386, VMS) limit struct field alignment
             to a lower boundary than alignment of variables unless


@@ -426,9 +435,13 @@ layout_decl (tree decl, unsigned int known_align)
 #endif
        }
 
 #endif
        }
 

+      if (zero_bitfield)
+        mfa = initial_max_fld_align * BITS_PER_UNIT;
+      else
+       mfa = maximum_field_alignment;

       /* Should this be controlled by DECL_USER_ALIGN, too?  */
       /* Should this be controlled by DECL_USER_ALIGN, too?  */

-      if (maximum_field_alignment != 0)
-       DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), maximum_field_alignment);
+      if (mfa != 0)
+       DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), mfa);

     }
 
   /* Evaluate nonconstant size only once, either now or as soon as safe.  */
     }
 
   /* Evaluate nonconstant size only once, either now or as soon as safe.  */


@@ -451,10 +464,10 @@ layout_decl (tree decl, unsigned int known_align)
          int size_as_int = TREE_INT_CST_LOW (size);
 
          if (compare_tree_int (size, size_as_int) == 0)
          int size_as_int = TREE_INT_CST_LOW (size);
 
          if (compare_tree_int (size, size_as_int) == 0)

-           warning ("%Jsize of %qD is %d bytes", decl, decl, size_as_int);
+           warning (OPT_Wlarger_than_, "size of %q+D is %d bytes", decl, size_as_int);

          else
          else

-           warning ("%Jsize of %qD is larger than %d bytes",
-                     decl, decl, larger_than_size);
+           warning (OPT_Wlarger_than_, "size of %q+D is larger than %wd bytes",
+                     decl, larger_than_size);

        }
     }
 
        }
     }
 


@@ -476,7 +489,8 @@ relayout_decl (tree decl)
 {
   DECL_SIZE (decl) = DECL_SIZE_UNIT (decl) = 0;
   DECL_MODE (decl) = VOIDmode;
 {
   DECL_SIZE (decl) = DECL_SIZE_UNIT (decl) = 0;
   DECL_MODE (decl) = VOIDmode;

-  DECL_ALIGN (decl) = 0;
+  if (!DECL_USER_ALIGN (decl))
+    DECL_ALIGN (decl) = 0;

   SET_DECL_RTL (decl, 0);
 
   layout_decl (decl, 0);
   SET_DECL_RTL (decl, 0);
 
   layout_decl (decl, 0);


@@ -517,7 +531,15 @@ start_record_layout (tree t)
 #ifdef STRUCTURE_SIZE_BOUNDARY
   /* Packed structures don't need to have minimum size.  */
   if (! TYPE_PACKED (t))
 #ifdef STRUCTURE_SIZE_BOUNDARY
   /* Packed structures don't need to have minimum size.  */
   if (! TYPE_PACKED (t))

-    rli->record_align = MAX (rli->record_align, (unsigned) STRUCTURE_SIZE_BOUNDARY);
+    {
+      unsigned tmp;
+
+      /* #pragma pack overrides STRUCTURE_SIZE_BOUNDARY.  */
+      tmp = (unsigned) STRUCTURE_SIZE_BOUNDARY;
+      if (maximum_field_alignment != 0)
+       tmp = MIN (tmp, maximum_field_alignment);
+      rli->record_align = MAX (rli->record_align, tmp);
+    }

 #endif
 
   rli->offset = size_zero_node;
 #endif
 
   rli->offset = size_zero_node;


@@ -525,6 +547,7 @@ start_record_layout (tree t)
   rli->prev_field = 0;
   rli->pending_statics = 0;
   rli->packed_maybe_necessary = 0;
   rli->prev_field = 0;
   rli->pending_statics = 0;
   rli->packed_maybe_necessary = 0;

+  rli->remaining_in_alignment = 0;

 
   return rli;
 }
 
   return rli;
 }


@@ -536,7 +559,7 @@ tree
 bit_from_pos (tree offset, tree bitpos)
 {
   return size_binop (PLUS_EXPR, bitpos,
 bit_from_pos (tree offset, tree bitpos)
 {
   return size_binop (PLUS_EXPR, bitpos,

-                    size_binop (MULT_EXPR, 
+                    size_binop (MULT_EXPR,

                                 fold_convert (bitsizetype, offset),
                                 bitsize_unit_node));
 }
                                 fold_convert (bitsizetype, offset),
                                 bitsize_unit_node));
 }


@@ -577,7 +600,7 @@ normalize_offset (tree *poffset, tree *pbitpos, unsigned int off_align)
 
       *poffset
        = size_binop (PLUS_EXPR, *poffset,
 
       *poffset
        = size_binop (PLUS_EXPR, *poffset,

-                     size_binop (MULT_EXPR, 
+                     size_binop (MULT_EXPR,

                                  fold_convert (sizetype, extra_aligns),
                                  size_int (off_align / BITS_PER_UNIT)));
 
                                  fold_convert (sizetype, extra_aligns),
                                  size_int (off_align / BITS_PER_UNIT)));
 


@@ -598,6 +621,11 @@ debug_rli (record_layout_info rli)
   fprintf (stderr, "\naligns: rec = %u, unpack = %u, off = %u\n",
           rli->record_align, rli->unpacked_align,
           rli->offset_align);
   fprintf (stderr, "\naligns: rec = %u, unpack = %u, off = %u\n",
           rli->record_align, rli->unpacked_align,
           rli->offset_align);

+
+  /* The ms_struct code is the only that uses this.  */
+  if (targetm.ms_bitfield_layout_p (rli->t))
+    fprintf (stderr, "remaining in alignment = %u\n", rli->remaining_in_alignment);
+

   if (rli->packed_maybe_necessary)
     fprintf (stderr, "packed may be necessary\n");
 
   if (rli->packed_maybe_necessary)
     fprintf (stderr, "packed may be necessary\n");
 


@@ -634,9 +662,9 @@ rli_size_so_far (record_layout_info rli)
 }
 
 /* FIELD is about to be added to RLI->T.  The alignment (in bits) of
 }
 
 /* FIELD is about to be added to RLI->T.  The alignment (in bits) of

-   the next available location is given by KNOWN_ALIGN.  Update the
-   variable alignment fields in RLI, and return the alignment to give
-   the FIELD.  */
+   the next available location within the record is given by KNOWN_ALIGN.
+   Update the variable alignment fields in RLI, and return the alignment
+   to give the FIELD.  */

 
 unsigned int
 update_alignment_for_field (record_layout_info rli, tree field,
 
 unsigned int
 update_alignment_for_field (record_layout_info rli, tree field,


@@ -650,6 +678,10 @@ update_alignment_for_field (record_layout_info rli, tree field,
   bool user_align;
   bool is_bitfield;
 
   bool user_align;
   bool is_bitfield;
 

+  /* Do not attempt to align an ERROR_MARK node */
+  if (TREE_CODE (type) == ERROR_MARK)
+    return 0;
+

   /* Lay out the field so we know what alignment it needs.  */
   layout_decl (field, known_align);
   desired_align = DECL_ALIGN (field);
   /* Lay out the field so we know what alignment it needs.  */
   layout_decl (field, known_align);
   desired_align = DECL_ALIGN (field);


@@ -662,7 +694,7 @@ update_alignment_for_field (record_layout_info rli, tree field,
   /* Record must have at least as much alignment as any field.
      Otherwise, the alignment of the field within the record is
      meaningless.  */
   /* Record must have at least as much alignment as any field.
      Otherwise, the alignment of the field within the record is
      meaningless.  */

-  if (is_bitfield && targetm.ms_bitfield_layout_p (rli->t))
+  if (targetm.ms_bitfield_layout_p (rli->t))

     {
       /* Here, the alignment of the underlying type of a bitfield can
         affect the alignment of a record; even a zero-sized field
     {
       /* Here, the alignment of the underlying type of a bitfield can
         affect the alignment of a record; even a zero-sized field


@@ -670,11 +702,12 @@ update_alignment_for_field (record_layout_info rli, tree field,
         the type, except that for zero-size bitfields this only
         applies if there was an immediately prior, nonzero-size
         bitfield.  (That's the way it is, experimentally.) */
         the type, except that for zero-size bitfields this only
         applies if there was an immediately prior, nonzero-size
         bitfield.  (That's the way it is, experimentally.) */

-      if (! integer_zerop (DECL_SIZE (field))
-         ? ! DECL_PACKED (field)
-         : (rli->prev_field
-            && DECL_BIT_FIELD_TYPE (rli->prev_field)
-            && ! integer_zerop (DECL_SIZE (rli->prev_field))))
+      if ((!is_bitfield && !DECL_PACKED (field))
+         || (!integer_zerop (DECL_SIZE (field))
+             ? !DECL_PACKED (field)
+             : (rli->prev_field
+                && DECL_BIT_FIELD_TYPE (rli->prev_field)
+                && ! integer_zerop (DECL_SIZE (rli->prev_field)))))

        {
          unsigned int type_align = TYPE_ALIGN (type);
          type_align = MAX (type_align, desired_align);
        {
          unsigned int type_align = TYPE_ALIGN (type);
          type_align = MAX (type_align, desired_align);


@@ -700,7 +733,16 @@ update_alignment_for_field (record_layout_info rli, tree field,
            type_align = ADJUST_FIELD_ALIGN (field, type_align);
 #endif
 
            type_align = ADJUST_FIELD_ALIGN (field, type_align);
 #endif
 

-         if (maximum_field_alignment != 0)
+         /* Targets might chose to handle unnamed and hence possibly
+            zero-width bitfield.  Those are not influenced by #pragmas
+            or packed attributes.  */
+         if (integer_zerop (DECL_SIZE (field)))
+           {
+             if (initial_max_fld_align)
+               type_align = MIN (type_align,
+                                 initial_max_fld_align * BITS_PER_UNIT);
+           }
+         else if (maximum_field_alignment != 0)

            type_align = MIN (type_align, maximum_field_alignment);
          else if (DECL_PACKED (field))
            type_align = MIN (type_align, BITS_PER_UNIT);
            type_align = MIN (type_align, maximum_field_alignment);
          else if (DECL_PACKED (field))
            type_align = MIN (type_align, BITS_PER_UNIT);


@@ -741,14 +783,20 @@ place_union_field (record_layout_info rli, tree field)
   DECL_FIELD_BIT_OFFSET (field) = bitsize_zero_node;
   SET_DECL_OFFSET_ALIGN (field, BIGGEST_ALIGNMENT);
 
   DECL_FIELD_BIT_OFFSET (field) = bitsize_zero_node;
   SET_DECL_OFFSET_ALIGN (field, BIGGEST_ALIGNMENT);
 

+  /* If this is an ERROR_MARK return *after* having set the
+     field at the start of the union. This helps when parsing
+     invalid fields. */
+  if (TREE_CODE (TREE_TYPE (field)) == ERROR_MARK)
+    return;
+

   /* We assume the union's size will be a multiple of a byte so we don't
      bother with BITPOS.  */
   if (TREE_CODE (rli->t) == UNION_TYPE)
     rli->offset = size_binop (MAX_EXPR, rli->offset, DECL_SIZE_UNIT (field));
   else if (TREE_CODE (rli->t) == QUAL_UNION_TYPE)
   /* We assume the union's size will be a multiple of a byte so we don't
      bother with BITPOS.  */
   if (TREE_CODE (rli->t) == UNION_TYPE)
     rli->offset = size_binop (MAX_EXPR, rli->offset, DECL_SIZE_UNIT (field));
   else if (TREE_CODE (rli->t) == QUAL_UNION_TYPE)

-    rli->offset = fold (build3 (COND_EXPR, sizetype,
-                               DECL_QUALIFIER (field),
-                               DECL_SIZE_UNIT (field), rli->offset));
+    rli->offset = fold_build3 (COND_EXPR, sizetype,
+                              DECL_QUALIFIER (field),
+                              DECL_SIZE_UNIT (field), rli->offset);

 }
 
 #if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED)
 }
 
 #if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED)


@@ -787,8 +835,7 @@ place_field (record_layout_info rli, tree field)
   /* The type of this field.  */
   tree type = TREE_TYPE (field);
 
   /* The type of this field.  */
   tree type = TREE_TYPE (field);
 

-  if (TREE_CODE (field) == ERROR_MARK || TREE_CODE (type) == ERROR_MARK)
-      return;
+  gcc_assert (TREE_CODE (field) != ERROR_MARK);

 
   /* If FIELD is static, then treat it like a separate variable, not
      really like a structure field.  If it is a FUNCTION_DECL, it's a
 
   /* If FIELD is static, then treat it like a separate variable, not
      really like a structure field.  If it is a FUNCTION_DECL, it's a


@@ -814,13 +861,23 @@ place_field (record_layout_info rli, tree field)
       return;
     }
 
       return;
     }
 

+  else if (TREE_CODE (type) == ERROR_MARK)
+    {
+      /* Place this field at the current allocation position, so we
+        maintain monotonicity.  */
+      DECL_FIELD_OFFSET (field) = rli->offset;
+      DECL_FIELD_BIT_OFFSET (field) = rli->bitpos;
+      SET_DECL_OFFSET_ALIGN (field, rli->offset_align);
+      return;
+    }
+

   /* Work out the known alignment so far.  Note that A & (-A) is the
      value of the least-significant bit in A that is one.  */
   if (! integer_zerop (rli->bitpos))
     known_align = (tree_low_cst (rli->bitpos, 1)
                   & - tree_low_cst (rli->bitpos, 1));
   else if (integer_zerop (rli->offset))
   /* Work out the known alignment so far.  Note that A & (-A) is the
      value of the least-significant bit in A that is one.  */
   if (! integer_zerop (rli->bitpos))
     known_align = (tree_low_cst (rli->bitpos, 1)
                   & - tree_low_cst (rli->bitpos, 1));
   else if (integer_zerop (rli->offset))

-    known_align = BIGGEST_ALIGNMENT;
+    known_align = 0;

   else if (host_integerp (rli->offset, 1))
     known_align = (BITS_PER_UNIT
                   * (tree_low_cst (rli->offset, 1)
   else if (host_integerp (rli->offset, 1))
     known_align = (BITS_PER_UNIT
                   * (tree_low_cst (rli->offset, 1)


@@ -829,6 +886,8 @@ place_field (record_layout_info rli, tree field)
     known_align = rli->offset_align;
 
   desired_align = update_alignment_for_field (rli, field, known_align);
     known_align = rli->offset_align;
 
   desired_align = update_alignment_for_field (rli, field, known_align);

+  if (known_align == 0)
+    known_align = MAX (BIGGEST_ALIGNMENT, rli->record_align);

 
   if (warn_packed && DECL_PACKED (field))
     {
 
   if (warn_packed && DECL_PACKED (field))
     {


@@ -837,11 +896,11 @@ place_field (record_layout_info rli, tree field)
          if (TYPE_ALIGN (type) > desired_align)
            {
              if (STRICT_ALIGNMENT)
          if (TYPE_ALIGN (type) > desired_align)
            {
              if (STRICT_ALIGNMENT)

-               warning ("%Jpacked attribute causes inefficient alignment "
-                         "for %qD", field, field);
+               warning (OPT_Wattributes, "packed attribute causes "
+                         "inefficient alignment for %q+D", field);

              else
              else

-               warning ("%Jpacked attribute is unnecessary for %qD",
-                        field, field);
+               warning (OPT_Wattributes, "packed attribute is "
+                        "unnecessary for %q+D", field);

            }
        }
       else
            }
        }
       else


@@ -849,14 +908,15 @@ place_field (record_layout_info rli, tree field)
     }
 
   /* Does this field automatically have alignment it needs by virtue
     }
 
   /* Does this field automatically have alignment it needs by virtue

-     of the fields that precede it and the record's own alignment?  */
-  if (known_align < desired_align)
+     of the fields that precede it and the record's own alignment?
+     We already align ms_struct fields, so don't re-align them.  */
+  if (known_align < desired_align
+      && !targetm.ms_bitfield_layout_p (rli->t))

     {
       /* No, we need to skip space before this field.
         Bump the cumulative size to multiple of field alignment.  */
 
     {
       /* No, we need to skip space before this field.
         Bump the cumulative size to multiple of field alignment.  */
 

-      if (warn_padded)
-       warning ("%Jpadding struct to align %qD", field, field);
+      warning (OPT_Wpadded, "padding struct to align %q+D", field);

 
       /* If the alignment is still within offset_align, just align
         the bit position.  */
 
       /* If the alignment is still within offset_align, just align
         the bit position.  */


@@ -968,17 +1028,13 @@ place_field (record_layout_info rli, tree field)
      Note: for compatibility, we use the type size, not the type alignment
      to determine alignment, since that matches the documentation */
 
      Note: for compatibility, we use the type size, not the type alignment
      to determine alignment, since that matches the documentation */
 

-  if (targetm.ms_bitfield_layout_p (rli->t)
-       && ((DECL_BIT_FIELD_TYPE (field) && ! DECL_PACKED (field))
-         || (rli->prev_field && ! DECL_PACKED (rli->prev_field))))
+  if (targetm.ms_bitfield_layout_p (rli->t))

     {
     {

-      /* At this point, either the prior or current are bitfields,
-        (possibly both), and we're dealing with MS packing.  */

       tree prev_saved = rli->prev_field;
       tree prev_saved = rli->prev_field;

+      tree prev_type = prev_saved ? DECL_BIT_FIELD_TYPE (prev_saved) : NULL;

 
 

-      /* Is the prior field a bitfield?  If so, handle "runs" of same
-        type size fields.  */
-      if (rli->prev_field /* necessarily a bitfield if it exists.  */)
+      /* This is a bitfield if it exists.  */
+      if (rli->prev_field)

        {
          /* If both are bitfields, nonzero, and the same size, this is
             the middle of a run.  Zero declared size fields are special
        {
          /* If both are bitfields, nonzero, and the same size, this is
             the middle of a run.  Zero declared size fields are special


@@ -991,27 +1047,29 @@ place_field (record_layout_info rli, tree field)
              && !integer_zerop (DECL_SIZE (rli->prev_field))
              && host_integerp (DECL_SIZE (rli->prev_field), 0)
              && host_integerp (TYPE_SIZE (type), 0)
              && !integer_zerop (DECL_SIZE (rli->prev_field))
              && host_integerp (DECL_SIZE (rli->prev_field), 0)
              && host_integerp (TYPE_SIZE (type), 0)

-             && simple_cst_equal (TYPE_SIZE (type),
-                                  TYPE_SIZE (TREE_TYPE (rli->prev_field))))
+             && simple_cst_equal (TYPE_SIZE (type), TYPE_SIZE (prev_type)))

            {
              /* We're in the middle of a run of equal type size fields; make
                 sure we realign if we run out of bits.  (Not decl size,
                 type size!) */
            {
              /* We're in the middle of a run of equal type size fields; make
                 sure we realign if we run out of bits.  (Not decl size,
                 type size!) */

-             HOST_WIDE_INT bitsize = tree_low_cst (DECL_SIZE (field), 0);
+             HOST_WIDE_INT bitsize = tree_low_cst (DECL_SIZE (field), 1);

 
              if (rli->remaining_in_alignment < bitsize)
                {
 
              if (rli->remaining_in_alignment < bitsize)
                {

+                 HOST_WIDE_INT typesize = tree_low_cst (TYPE_SIZE (type), 1);
+

                  /* out of bits; bump up to next 'word'.  */
                  /* out of bits; bump up to next 'word'.  */

-                 rli->offset = DECL_FIELD_OFFSET (rli->prev_field);

                  rli->bitpos
                  rli->bitpos

-                   = size_binop (PLUS_EXPR, TYPE_SIZE (type),
-                                 DECL_FIELD_BIT_OFFSET (rli->prev_field));
+                   = size_binop (PLUS_EXPR, rli->bitpos,
+                                 bitsize_int (rli->remaining_in_alignment));

                  rli->prev_field = field;
                  rli->prev_field = field;

-                 rli->remaining_in_alignment
-                   = tree_low_cst (TYPE_SIZE (type), 0);
+                 if (typesize < bitsize)
+                   rli->remaining_in_alignment = 0;
+                 else
+                   rli->remaining_in_alignment = typesize - bitsize;

                }
                }

-
-             rli->remaining_in_alignment -= bitsize;
+             else
+               rli->remaining_in_alignment -= bitsize;

            }
          else
            {
            }
          else
            {


@@ -1026,11 +1084,9 @@ place_field (record_layout_info rli, tree field)
 
              if (!integer_zerop (DECL_SIZE (rli->prev_field)))
                {
 
              if (!integer_zerop (DECL_SIZE (rli->prev_field)))
                {

-                 tree type_size = TYPE_SIZE (TREE_TYPE (rli->prev_field));
-

                  rli->bitpos
                  rli->bitpos

-                   = size_binop (PLUS_EXPR, type_size,
-                                 DECL_FIELD_BIT_OFFSET (rli->prev_field));
+                   = size_binop (PLUS_EXPR, rli->bitpos,
+                                 bitsize_int (rli->remaining_in_alignment));

                }
              else
                /* We "use up" size zero fields; the code below should behave
                }
              else
                /* We "use up" size zero fields; the code below should behave


@@ -1040,7 +1096,7 @@ place_field (record_layout_info rli, tree field)
              /* Cause a new bitfield to be captured, either this time (if
                 currently a bitfield) or next time we see one.  */
              if (!DECL_BIT_FIELD_TYPE(field)
              /* Cause a new bitfield to be captured, either this time (if
                 currently a bitfield) or next time we see one.  */
              if (!DECL_BIT_FIELD_TYPE(field)

-                || integer_zerop (DECL_SIZE (field)))
+                 || integer_zerop (DECL_SIZE (field)))

                rli->prev_field = NULL;
            }
 
                rli->prev_field = NULL;
            }
 


@@ -1060,9 +1116,8 @@ place_field (record_layout_info rli, tree field)
         there wasn't.  */
 
       if (!DECL_BIT_FIELD_TYPE (field)
         there wasn't.  */
 
       if (!DECL_BIT_FIELD_TYPE (field)

-         || ( prev_saved != NULL
-              ? !simple_cst_equal (TYPE_SIZE (type),
-                                   TYPE_SIZE (TREE_TYPE (prev_saved)))
+         || (prev_saved != NULL
+             ? !simple_cst_equal (TYPE_SIZE (type), TYPE_SIZE (prev_type))

              : !integer_zerop (DECL_SIZE (field)) ))
        {
          /* Never smaller than a byte for compatibility.  */
              : !integer_zerop (DECL_SIZE (field)) ))
        {
          /* Never smaller than a byte for compatibility.  */


@@ -1075,22 +1130,19 @@ place_field (record_layout_info rli, tree field)
          if (DECL_SIZE (field) != NULL
              && host_integerp (TYPE_SIZE (TREE_TYPE (field)), 0)
              && host_integerp (DECL_SIZE (field), 0))
          if (DECL_SIZE (field) != NULL
              && host_integerp (TYPE_SIZE (TREE_TYPE (field)), 0)
              && host_integerp (DECL_SIZE (field), 0))

-           rli->remaining_in_alignment
-             = tree_low_cst (TYPE_SIZE (TREE_TYPE(field)), 0)
-               - tree_low_cst (DECL_SIZE (field), 0);
+           {
+             HOST_WIDE_INT bitsize = tree_low_cst (DECL_SIZE (field), 1);
+             HOST_WIDE_INT typesize
+               = tree_low_cst (TYPE_SIZE (TREE_TYPE (field)), 1);
+
+             if (typesize < bitsize)
+               rli->remaining_in_alignment = 0;
+             else
+               rli->remaining_in_alignment = typesize - bitsize;
+           }

 
          /* Now align (conventionally) for the new type.  */
 
          /* Now align (conventionally) for the new type.  */

-         if (!DECL_PACKED(field))
-           type_align = MAX(TYPE_ALIGN (type), type_align);
-
-         if (prev_saved
-             && DECL_BIT_FIELD_TYPE (prev_saved)
-             /* If the previous bit-field is zero-sized, we've already
-                accounted for its alignment needs (or ignored it, if
-                appropriate) while placing it.  */
-             && ! integer_zerop (DECL_SIZE (prev_saved)))
-           type_align = MAX (type_align,
-                             TYPE_ALIGN (TREE_TYPE (prev_saved)));
+         type_align = TYPE_ALIGN (TREE_TYPE (field));

 
          if (maximum_field_alignment != 0)
            type_align = MIN (type_align, maximum_field_alignment);
 
          if (maximum_field_alignment != 0)
            type_align = MIN (type_align, maximum_field_alignment);


@@ -1116,20 +1168,22 @@ place_field (record_layout_info rli, tree field)
     actual_align = (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
                    & - tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1));
   else if (integer_zerop (DECL_FIELD_OFFSET (field)))
     actual_align = (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
                    & - tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1));
   else if (integer_zerop (DECL_FIELD_OFFSET (field)))

-    actual_align = BIGGEST_ALIGNMENT;
+    actual_align = MAX (BIGGEST_ALIGNMENT, rli->record_align);

   else if (host_integerp (DECL_FIELD_OFFSET (field), 1))
     actual_align = (BITS_PER_UNIT
                   * (tree_low_cst (DECL_FIELD_OFFSET (field), 1)
                      & - tree_low_cst (DECL_FIELD_OFFSET (field), 1)));
   else
     actual_align = DECL_OFFSET_ALIGN (field);
   else if (host_integerp (DECL_FIELD_OFFSET (field), 1))
     actual_align = (BITS_PER_UNIT
                   * (tree_low_cst (DECL_FIELD_OFFSET (field), 1)
                      & - tree_low_cst (DECL_FIELD_OFFSET (field), 1)));
   else
     actual_align = DECL_OFFSET_ALIGN (field);

+  /* ACTUAL_ALIGN is still the actual alignment *within the record* .
+     store / extract bit field operations will check the alignment of the
+     record against the mode of bit fields.  */

 
   if (known_align != actual_align)
     layout_decl (field, actual_align);
 
 
   if (known_align != actual_align)
     layout_decl (field, actual_align);
 

-  /* Only the MS bitfields use this.  */
-  if (rli->prev_field == NULL && DECL_BIT_FIELD_TYPE(field))
-      rli->prev_field = field;
+  if (rli->prev_field == NULL && DECL_BIT_FIELD_TYPE (field))
+    rli->prev_field = field;

 
   /* Now add size of this field to the size of the record.  If the size is
      not constant, treat the field as being a multiple of bytes and just
 
   /* Now add size of this field to the size of the record.  If the size is
      not constant, treat the field as being a multiple of bytes and just


@@ -1140,8 +1194,8 @@ place_field (record_layout_info rli, tree field)
      is printed in finish_struct.  */
   if (DECL_SIZE (field) == 0)
     /* Do nothing.  */;
      is printed in finish_struct.  */
   if (DECL_SIZE (field) == 0)
     /* Do nothing.  */;

-  else if (TREE_CODE (DECL_SIZE_UNIT (field)) != INTEGER_CST
-          || TREE_CONSTANT_OVERFLOW (DECL_SIZE_UNIT (field)))
+  else if (TREE_CODE (DECL_SIZE (field)) != INTEGER_CST
+          || TREE_OVERFLOW (DECL_SIZE (field)))

     {
       rli->offset
        = size_binop (PLUS_EXPR, rli->offset,
     {
       rli->offset
        = size_binop (PLUS_EXPR, rli->offset,


@@ -1153,6 +1207,21 @@ place_field (record_layout_info rli, tree field)
       rli->bitpos = bitsize_zero_node;
       rli->offset_align = MIN (rli->offset_align, desired_align);
     }
       rli->bitpos = bitsize_zero_node;
       rli->offset_align = MIN (rli->offset_align, desired_align);
     }

+  else if (targetm.ms_bitfield_layout_p (rli->t))
+    {
+      rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field));
+
+      /* If we ended a bitfield before the full length of the type then
+        pad the struct out to the full length of the last type.  */
+      if ((TREE_CHAIN (field) == NULL
+          || TREE_CODE (TREE_CHAIN (field)) != FIELD_DECL)
+         && DECL_BIT_FIELD_TYPE (field)
+         && !integer_zerop (DECL_SIZE (field)))
+       rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos,
+                                 bitsize_int (rli->remaining_in_alignment));
+
+      normalize_rli (rli);
+    }

   else
     {
       rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field));
   else
     {
       rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field));


@@ -1196,9 +1265,9 @@ finalize_record_size (record_layout_info rli)
   TYPE_SIZE_UNIT (rli->t)
     = round_up (unpadded_size_unit, TYPE_ALIGN_UNIT (rli->t));
 
   TYPE_SIZE_UNIT (rli->t)
     = round_up (unpadded_size_unit, TYPE_ALIGN_UNIT (rli->t));
 

-  if (warn_padded && TREE_CONSTANT (unpadded_size)
+  if (TREE_CONSTANT (unpadded_size)

       && simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0)
       && simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0)

-    warning ("padding struct size to alignment boundary");
+    warning (OPT_Wpadded, "padding struct size to alignment boundary");

 
   if (warn_packed && TREE_CODE (rli->t) == RECORD_TYPE
       && TYPE_PACKED (rli->t) && ! rli->packed_maybe_necessary
 
   if (warn_packed && TREE_CODE (rli->t) == RECORD_TYPE
       && TYPE_PACKED (rli->t) && ! rli->packed_maybe_necessary


@@ -1228,17 +1297,19 @@ finalize_record_size (record_layout_info rli)
                name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (rli->t)));
 
              if (STRICT_ALIGNMENT)
                name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (rli->t)));
 
              if (STRICT_ALIGNMENT)

-               warning ("packed attribute causes inefficient "
+               warning (OPT_Wpacked, "packed attribute causes inefficient "

                         "alignment for %qs", name);
              else
                         "alignment for %qs", name);
              else

-               warning ("packed attribute is unnecessary for %qs", name);
+               warning (OPT_Wpacked,
+                        "packed attribute is unnecessary for %qs", name);

            }
          else
            {
              if (STRICT_ALIGNMENT)
            }
          else
            {
              if (STRICT_ALIGNMENT)

-               warning ("packed attribute causes inefficient alignment");
+               warning (OPT_Wpacked,
+                        "packed attribute causes inefficient alignment");

              else
              else

-               warning ("packed attribute is unnecessary");
+               warning (OPT_Wpacked, "packed attribute is unnecessary");

            }
        }
     }
            }
        }
     }


@@ -1294,14 +1365,15 @@ compute_record_mode (tree type)
 #endif /* MEMBER_TYPE_FORCES_BLK  */
     }
 
 #endif /* MEMBER_TYPE_FORCES_BLK  */
     }
 

-  TYPE_MODE (type) = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1);
-

   /* If we only have one real field; use its mode if that mode's size
      matches the type's size.  This only applies to RECORD_TYPE.  This
      does not apply to unions.  */
   if (TREE_CODE (type) == RECORD_TYPE && mode != VOIDmode
   /* If we only have one real field; use its mode if that mode's size
      matches the type's size.  This only applies to RECORD_TYPE.  This
      does not apply to unions.  */
   if (TREE_CODE (type) == RECORD_TYPE && mode != VOIDmode

-      && GET_MODE_SIZE (mode) == GET_MODE_SIZE (TYPE_MODE (type)))
+      && host_integerp (TYPE_SIZE (type), 1)
+      && GET_MODE_BITSIZE (mode) == TREE_INT_CST_LOW (TYPE_SIZE (type)))

     TYPE_MODE (type) = mode;
     TYPE_MODE (type) = mode;

+  else
+    TYPE_MODE (type) = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1);

 
   /* If structure's known alignment is less than what the scalar
      mode would need, and it matters, then stick with BLKmode.  */
 
   /* If structure's known alignment is less than what the scalar
      mode would need, and it matters, then stick with BLKmode.  */


@@ -1334,8 +1406,15 @@ finalize_type_size (tree type)
              && TREE_CODE (type) != QUAL_UNION_TYPE
              && TREE_CODE (type) != ARRAY_TYPE)))
     {
              && TREE_CODE (type) != QUAL_UNION_TYPE
              && TREE_CODE (type) != ARRAY_TYPE)))
     {

-      TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type));
-      TYPE_USER_ALIGN (type) = 0;
+      unsigned mode_align = GET_MODE_ALIGNMENT (TYPE_MODE (type));
+
+      /* Don't override a larger alignment requirement coming from a user
+        alignment of one of the fields.  */
+      if (mode_align >= TYPE_ALIGN (type))
+       {
+         TYPE_ALIGN (type) = mode_align;
+         TYPE_USER_ALIGN (type) = 0;
+       }

     }
 
   /* Do machine-dependent extra alignment.  */
     }
 
   /* Do machine-dependent extra alignment.  */


@@ -1404,6 +1483,8 @@ finalize_type_size (tree type)
 void
 finish_record_layout (record_layout_info rli, int free_p)
 {
 void
 finish_record_layout (record_layout_info rli, int free_p)
 {

+  tree variant;
+

   /* Compute the final size.  */
   finalize_record_size (rli);
 
   /* Compute the final size.  */
   finalize_record_size (rli);
 


@@ -1413,6 +1494,12 @@ finish_record_layout (record_layout_info rli, int free_p)
   /* Perform any last tweaks to the TYPE_SIZE, etc.  */
   finalize_type_size (rli->t);
 
   /* Perform any last tweaks to the TYPE_SIZE, etc.  */
   finalize_type_size (rli->t);
 

+  /* Propagate TYPE_PACKED to variants.  With C++ templates,
+     handle_packed_attribute is too early to do this.  */
+  for (variant = TYPE_NEXT_VARIANT (rli->t); variant;
+       variant = TYPE_NEXT_VARIANT (variant))
+    TYPE_PACKED (variant) = TYPE_PACKED (rli->t);
+

   /* Lay out any static members.  This is done now because their type
      may use the record's type.  */
   while (rli->pending_statics)
   /* Lay out any static members.  This is done now because their type
      may use the record's type.  */
   while (rli->pending_statics)


@@ -1500,7 +1587,6 @@ layout_type (tree type)
 
     case INTEGER_TYPE:
     case ENUMERAL_TYPE:
 
     case INTEGER_TYPE:
     case ENUMERAL_TYPE:

-    case CHAR_TYPE:

       if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
          && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0)
        TYPE_UNSIGNED (type) = 1;
       if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
          && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0)
        TYPE_UNSIGNED (type) = 1;


@@ -1517,6 +1603,12 @@ layout_type (tree type)
       TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
       break;
 
       TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
       break;
 

+   case FIXED_POINT_TYPE:
+     /* TYPE_MODE (type) has been set already.  */
+     TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
+     TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
+     break;
+

     case COMPLEX_TYPE:
       TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TREE_TYPE (type));
       TYPE_MODE (type)
     case COMPLEX_TYPE:
       TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TREE_TYPE (type));
       TYPE_MODE (type)


@@ -1531,7 +1623,6 @@ layout_type (tree type)
     case VECTOR_TYPE:
       {
        int nunits = TYPE_VECTOR_SUBPARTS (type);
     case VECTOR_TYPE:
       {
        int nunits = TYPE_VECTOR_SUBPARTS (type);

-       tree nunits_tree = build_int_cst (NULL_TREE, nunits);

        tree innertype = TREE_TYPE (type);
 
        gcc_assert (!(nunits & (nunits - 1)));
        tree innertype = TREE_TYPE (type);
 
        gcc_assert (!(nunits & (nunits - 1)));


@@ -1543,8 +1634,16 @@ layout_type (tree type)
            enum machine_mode mode;
 
            /* First, look for a supported vector type.  */
            enum machine_mode mode;
 
            /* First, look for a supported vector type.  */

-           if (GET_MODE_CLASS (innermode) == MODE_FLOAT)
+           if (SCALAR_FLOAT_MODE_P (innermode))

              mode = MIN_MODE_VECTOR_FLOAT;
              mode = MIN_MODE_VECTOR_FLOAT;

+           else if (SCALAR_FRACT_MODE_P (innermode))
+             mode = MIN_MODE_VECTOR_FRACT;
+           else if (SCALAR_UFRACT_MODE_P (innermode))
+             mode = MIN_MODE_VECTOR_UFRACT;
+           else if (SCALAR_ACCUM_MODE_P (innermode))
+             mode = MIN_MODE_VECTOR_ACCUM;
+           else if (SCALAR_UACCUM_MODE_P (innermode))
+             mode = MIN_MODE_VECTOR_UACCUM;

            else
              mode = MIN_MODE_VECTOR_INT;
 
            else
              mode = MIN_MODE_VECTOR_INT;
 


@@ -1566,12 +1665,13 @@ layout_type (tree type)
              TYPE_MODE (type) = mode;
          }
 
              TYPE_MODE (type) = mode;
          }
 

+       TYPE_SATURATING (type) = TYPE_SATURATING (TREE_TYPE (type));

         TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TREE_TYPE (type));
        TYPE_SIZE_UNIT (type) = int_const_binop (MULT_EXPR,
                                                 TYPE_SIZE_UNIT (innertype),
         TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TREE_TYPE (type));
        TYPE_SIZE_UNIT (type) = int_const_binop (MULT_EXPR,
                                                 TYPE_SIZE_UNIT (innertype),

-                                                nunits_tree, 0);
+                                                size_int (nunits), 0);

        TYPE_SIZE (type) = int_const_binop (MULT_EXPR, TYPE_SIZE (innertype),
        TYPE_SIZE (type) = int_const_binop (MULT_EXPR, TYPE_SIZE (innertype),

-                                           nunits_tree, 0);
+                                           bitsize_int (nunits), 0);

 
        /* Always naturally align vectors.  This prevents ABI changes
           depending on whether or not native vector modes are supported.  */
 
        /* Always naturally align vectors.  This prevents ABI changes
           depending on whether or not native vector modes are supported.  */


@@ -1641,9 +1741,9 @@ layout_type (tree type)
               that (possible) negative values are handled appropriately.  */
            length = size_binop (PLUS_EXPR, size_one_node,
                                 fold_convert (sizetype,
               that (possible) negative values are handled appropriately.  */
            length = size_binop (PLUS_EXPR, size_one_node,
                                 fold_convert (sizetype,

-                                              fold (build2 (MINUS_EXPR,
-                                                            TREE_TYPE (lb),
-                                                            ub, lb))));
+                                              fold_build2 (MINUS_EXPR,
+                                                           TREE_TYPE (lb),
+                                                           ub, lb)));

 
            /* Special handling for arrays of bits (for Chill).  */
            element_size = TYPE_SIZE (element);
 
            /* Special handling for arrays of bits (for Chill).  */
            element_size = TYPE_SIZE (element);


@@ -1672,7 +1772,7 @@ layout_type (tree type)
              length = size_binop (MAX_EXPR, length, size_zero_node);
 
            TYPE_SIZE (type) = size_binop (MULT_EXPR, element_size,
              length = size_binop (MAX_EXPR, length, size_zero_node);
 
            TYPE_SIZE (type) = size_binop (MULT_EXPR, element_size,

-                                          fold_convert (bitsizetype, 
+                                          fold_convert (bitsizetype,

                                                         length));
 
            /* If we know the size of the element, calculate the total
                                                         length));
 
            /* If we know the size of the element, calculate the total


@@ -1697,6 +1797,11 @@ layout_type (tree type)
 #else
        TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT);
 #endif
 #else
        TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT);
 #endif

+       if (!TYPE_SIZE (element))
+         /* We don't know the size of the underlying element type, so
+            our alignment calculations will be wrong, forcing us to
+            fall back on structural equality. */
+         SET_TYPE_STRUCTURAL_EQUALITY (type);

        TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (element);
        TYPE_MODE (type) = BLKmode;
        if (TYPE_SIZE (type) != 0
        TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (element);
        TYPE_MODE (type) = BLKmode;
        if (TYPE_SIZE (type) != 0


@@ -1718,13 +1823,23 @@ layout_type (tree type)
 
            if (TYPE_MODE (type) != BLKmode
                && STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT
 
            if (TYPE_MODE (type) != BLKmode
                && STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT

-               && TYPE_ALIGN (type) < GET_MODE_ALIGNMENT (TYPE_MODE (type))
-               && TYPE_MODE (type) != BLKmode)
+               && TYPE_ALIGN (type) < GET_MODE_ALIGNMENT (TYPE_MODE (type)))

              {
                TYPE_NO_FORCE_BLK (type) = 1;
                TYPE_MODE (type) = BLKmode;
              }
          }
              {
                TYPE_NO_FORCE_BLK (type) = 1;
                TYPE_MODE (type) = BLKmode;
              }
          }

+       /* When the element size is constant, check that it is at least as
+          large as the element alignment.  */
+       if (TYPE_SIZE_UNIT (element)
+           && TREE_CODE (TYPE_SIZE_UNIT (element)) == INTEGER_CST
+           /* If TYPE_SIZE_UNIT overflowed, then it is certainly larger than
+              TYPE_ALIGN_UNIT.  */
+           && !TREE_OVERFLOW (TYPE_SIZE_UNIT (element))
+           && !integer_zerop (TYPE_SIZE_UNIT (element))
+           && compare_tree_int (TYPE_SIZE_UNIT (element),
+                                TYPE_ALIGN_UNIT (element)) < 0)
+         error ("alignment of array elements is greater than element size");

        break;
       }
 
        break;
       }
 


@@ -1759,14 +1874,6 @@ layout_type (tree type)
       }
       break;
 
       }
       break;
 

-    case FILE_TYPE:
-      /* The size may vary in different languages, so the language front end
-        should fill in the size.  */
-      TYPE_ALIGN (type) = BIGGEST_ALIGNMENT;
-      TYPE_USER_ALIGN (type) = 0;
-      TYPE_MODE  (type) = BLKmode;
-      break;
-

     default:
       gcc_unreachable ();
     }
     default:
       gcc_unreachable ();
     }


@@ -1779,13 +1886,10 @@ layout_type (tree type)
       && TREE_CODE (type) != QUAL_UNION_TYPE)
     finalize_type_size (type);
 
       && TREE_CODE (type) != QUAL_UNION_TYPE)
     finalize_type_size (type);
 

-  /* If an alias set has been set for this aggregate when it was incomplete,
-     force it into alias set 0.
-     This is too conservative, but we cannot call record_component_aliases
-     here because some frontends still change the aggregates after
-     layout_type.  */
-  if (AGGREGATE_TYPE_P (type) && TYPE_ALIAS_SET_KNOWN_P (type))
-    TYPE_ALIAS_SET (type) = 0;
+  /* We should never see alias sets on incomplete aggregates.  And we
+     should not call layout_type on not incomplete aggregates.  */
+  if (AGGREGATE_TYPE_P (type))
+    gcc_assert (!TYPE_ALIAS_SET_KNOWN_P (type));

 }
 \f
 /* Create and return a type for signed integers of PRECISION bits.  */
 }
 \f
 /* Create and return a type for signed integers of PRECISION bits.  */


@@ -1814,6 +1918,58 @@ make_unsigned_type (int precision)
   return type;
 }
 \f
   return type;
 }
 \f

+/* Create and return a type for fract of PRECISION bits, UNSIGNEDP,
+   and SATP.  */
+
+tree
+make_fract_type (int precision, int unsignedp, int satp)
+{
+  tree type = make_node (FIXED_POINT_TYPE);
+
+  TYPE_PRECISION (type) = precision;
+
+  if (satp)
+    TYPE_SATURATING (type) = 1;
+
+  /* Lay out the type: set its alignment, size, etc.  */
+  if (unsignedp)
+    {
+      TYPE_UNSIGNED (type) = 1;
+      TYPE_MODE (type) = mode_for_size (precision, MODE_UFRACT, 0);
+    }
+  else
+    TYPE_MODE (type) = mode_for_size (precision, MODE_FRACT, 0);
+  layout_type (type);
+
+  return type;
+}
+
+/* Create and return a type for accum of PRECISION bits, UNSIGNEDP,
+   and SATP.  */
+
+tree
+make_accum_type (int precision, int unsignedp, int satp)
+{
+  tree type = make_node (FIXED_POINT_TYPE);
+
+  TYPE_PRECISION (type) = precision;
+
+  if (satp)
+    TYPE_SATURATING (type) = 1;
+
+  /* Lay out the type: set its alignment, size, etc.  */
+  if (unsignedp)
+    {
+      TYPE_UNSIGNED (type) = 1;
+      TYPE_MODE (type) = mode_for_size (precision, MODE_UACCUM, 0);
+    }
+  else
+    TYPE_MODE (type) = mode_for_size (precision, MODE_ACCUM, 0);
+  layout_type (type);
+
+  return type;
+}
+

 /* Initialize sizetype and bitsizetype to a reasonable and temporary
    value to enable integer types to be created.  */
 
 /* Initialize sizetype and bitsizetype to a reasonable and temporary
    value to enable integer types to be created.  */
 


@@ -1821,20 +1977,19 @@ void
 initialize_sizetypes (bool signed_p)
 {
   tree t = make_node (INTEGER_TYPE);
 initialize_sizetypes (bool signed_p)
 {
   tree t = make_node (INTEGER_TYPE);

+  int precision = GET_MODE_BITSIZE (SImode);

 
   TYPE_MODE (t) = SImode;
   TYPE_ALIGN (t) = GET_MODE_ALIGNMENT (SImode);
   TYPE_USER_ALIGN (t) = 0;
   TYPE_IS_SIZETYPE (t) = 1;
   TYPE_UNSIGNED (t) = !signed_p;
 
   TYPE_MODE (t) = SImode;
   TYPE_ALIGN (t) = GET_MODE_ALIGNMENT (SImode);
   TYPE_USER_ALIGN (t) = 0;
   TYPE_IS_SIZETYPE (t) = 1;
   TYPE_UNSIGNED (t) = !signed_p;

-  TYPE_SIZE (t) = build_int_cst (t, GET_MODE_BITSIZE (SImode));
+  TYPE_SIZE (t) = build_int_cst (t, precision);

   TYPE_SIZE_UNIT (t) = build_int_cst (t, GET_MODE_SIZE (SImode));
   TYPE_SIZE_UNIT (t) = build_int_cst (t, GET_MODE_SIZE (SImode));

-  TYPE_PRECISION (t) = GET_MODE_BITSIZE (SImode);
-  TYPE_MIN_VALUE (t) = build_int_cst (t, 0);
+  TYPE_PRECISION (t) = precision;

 
 

-  /* 1000 avoids problems with possible overflow and is certainly
-     larger than any size value we'd want to be storing.  */
-  TYPE_MAX_VALUE (t) = build_int_cst (t, 1000);
+  /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE.  */
+  set_min_and_max_values_for_integral_type (t, precision, !signed_p);

 
   sizetype = t;
   bitsizetype = build_distinct_type_copy (t);
 
   sizetype = t;
   bitsizetype = build_distinct_type_copy (t);


@@ -1854,7 +2009,8 @@ set_sizetype (tree type)
      calculating signed sizes / offsets in bits.  However, when
      cross-compiling from a 32 bit to a 64 bit host, we are limited to 64 bit
      precision.  */
      calculating signed sizes / offsets in bits.  However, when
      cross-compiling from a 32 bit to a 64 bit host, we are limited to 64 bit
      precision.  */

-  int precision = MIN (oprecision + BITS_PER_UNIT_LOG + 1,
+  int precision = MIN (MIN (oprecision + BITS_PER_UNIT_LOG + 1,
+                           MAX_FIXED_MODE_SIZE),

                       2 * HOST_BITS_PER_WIDE_INT);
   tree t;
 
                       2 * HOST_BITS_PER_WIDE_INT);
   tree t;
 


@@ -1868,11 +2024,11 @@ set_sizetype (tree type)
   TREE_TYPE (TYPE_CACHED_VALUES (t)) = type;
   TYPE_UID (t) = TYPE_UID (sizetype);
   TYPE_IS_SIZETYPE (t) = 1;
   TREE_TYPE (TYPE_CACHED_VALUES (t)) = type;
   TYPE_UID (t) = TYPE_UID (sizetype);
   TYPE_IS_SIZETYPE (t) = 1;

-  
+

   /* Replace our original stub sizetype.  */
   memcpy (sizetype, t, tree_size (sizetype));
   TYPE_MAIN_VARIANT (sizetype) = sizetype;
   /* Replace our original stub sizetype.  */
   memcpy (sizetype, t, tree_size (sizetype));
   TYPE_MAIN_VARIANT (sizetype) = sizetype;

-  
+

   t = make_node (INTEGER_TYPE);
   TYPE_NAME (t) = get_identifier ("bit_size_type");
   /* We do want to use bitsizetype's cache, as we will be replacing that
   t = make_node (INTEGER_TYPE);
   TYPE_NAME (t) = get_identifier ("bit_size_type");
   /* We do want to use bitsizetype's cache, as we will be replacing that


@@ -1882,9 +2038,11 @@ set_sizetype (tree type)
   TYPE_PRECISION (t) = precision;
   TYPE_UID (t) = TYPE_UID (bitsizetype);
   TYPE_IS_SIZETYPE (t) = 1;
   TYPE_PRECISION (t) = precision;
   TYPE_UID (t) = TYPE_UID (bitsizetype);
   TYPE_IS_SIZETYPE (t) = 1;

+

   /* Replace our original stub bitsizetype.  */
   memcpy (bitsizetype, t, tree_size (bitsizetype));
   /* Replace our original stub bitsizetype.  */
   memcpy (bitsizetype, t, tree_size (bitsizetype));

-  
+  TYPE_MAIN_VARIANT (bitsizetype) = bitsizetype;
+

   if (TYPE_UNSIGNED (type))
     {
       fixup_unsigned_type (bitsizetype);
   if (TYPE_UNSIGNED (type))
     {
       fixup_unsigned_type (bitsizetype);


@@ -1899,10 +2057,26 @@ set_sizetype (tree type)
       ssizetype = sizetype;
       sbitsizetype = bitsizetype;
     }
       ssizetype = sizetype;
       sbitsizetype = bitsizetype;
     }

+
+  /* If SIZETYPE is unsigned, we need to fix TYPE_MAX_VALUE so that
+     it is sign extended in a way consistent with force_fit_type.  */
+  if (TYPE_UNSIGNED (type))
+    {
+      tree orig_max, new_max;
+
+      orig_max = TYPE_MAX_VALUE (sizetype);
+
+      /* Build a new node with the same values, but a different type.
+        Sign extend it to ensure consistency.  */
+      new_max = build_int_cst_wide_type (sizetype,
+                                        TREE_INT_CST_LOW (orig_max),
+                                        TREE_INT_CST_HIGH (orig_max));
+      TYPE_MAX_VALUE (sizetype) = new_max;
+    }

 }
 \f
 }
 \f

-/* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE,
-   BOOLEAN_TYPE, or CHAR_TYPE.  Set TYPE_MIN_VALUE and TYPE_MAX_VALUE
+/* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE
+   or BOOLEAN_TYPE.  Set TYPE_MIN_VALUE and TYPE_MAX_VALUE

    for TYPE, based on the PRECISION and whether or not the TYPE
    IS_UNSIGNED.  PRECISION need not correspond to a width supported
    natively by the hardware; for example, on a machine with 8-bit,
    for TYPE, based on the PRECISION and whether or not the TYPE
    IS_UNSIGNED.  PRECISION need not correspond to a width supported
    natively by the hardware; for example, on a machine with 8-bit,


@@ -2010,13 +2184,17 @@ fixup_unsigned_type (tree type)
    If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
    larger than LARGEST_MODE (usually SImode).
 
    If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
    larger than LARGEST_MODE (usually SImode).
 

-   If no mode meets all these conditions, we return VOIDmode.  Otherwise, if
-   VOLATILEP is true or SLOW_BYTE_ACCESS is false, we return the smallest
-   mode meeting these conditions.
+   If no mode meets all these conditions, we return VOIDmode.
+
+   If VOLATILEP is false and SLOW_BYTE_ACCESS is false, we return the
+   smallest mode meeting these conditions.
+
+   If VOLATILEP is false and SLOW_BYTE_ACCESS is true, we return the
+   largest mode (but a mode no wider than UNITS_PER_WORD) that meets
+   all the conditions.

 
 

-   Otherwise (VOLATILEP is false and SLOW_BYTE_ACCESS is true), we return
-   the largest mode (but a mode no wider than UNITS_PER_WORD) that meets
-   all the conditions.  */
+   If VOLATILEP is true the narrow_volatile_bitfields target hook is used to
+   decide which of the above modes should be used.  */

 
 enum machine_mode
 get_best_mode (int bitsize, int bitpos, unsigned int align,
 
 enum machine_mode
 get_best_mode (int bitsize, int bitpos, unsigned int align,


@@ -2046,7 +2224,8 @@ get_best_mode (int bitsize, int bitpos, unsigned int align,
       || (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode)))
     return VOIDmode;
 
       || (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode)))
     return VOIDmode;
 

-  if (SLOW_BYTE_ACCESS && ! volatilep)
+  if ((SLOW_BYTE_ACCESS && ! volatilep)
+      || (volatilep && !targetm.narrow_volatile_bitfield ()))

     {
       enum machine_mode wide_mode = VOIDmode, tmode;
 
     {
       enum machine_mode wide_mode = VOIDmode, tmode;