Virgin import of gcc from EGCS 1.1.2

1 files changed, 201 insertions, 87 deletions

diff --git a/contrib/gcc/stor-layout.c b/contrib/gcc/stor-layout.c
index e743c37..043ad28 100644
--- a/contrib/gcc/stor-layout.c
+++ b/contrib/gcc/stor-layout.c
@@ -1,5 +1,5 @@
 /* C-compiler utilities for types and variables storage layout
-   Copyright (C) 1987, 88, 92, 93, 94, 1995 Free Software Foundation, Inc.
+   Copyright (C) 1987, 88, 92-97, 1998 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -20,19 +20,22 @@ Boston, MA 02111-1307, USA.  */
 
 
 #include "config.h"
-#include <stdio.h>
+#include "system.h"
 
 #include "tree.h"
+#include "rtl.h"
 #include "flags.h"
+#include "except.h"
 #include "function.h"
+#include "expr.h"
+#include "toplev.h"
 
 #define CEIL(x,y) (((x) + (y) - 1) / (y))
 
 /* Data type for the expressions representing sizes of data types.
-   It is the first integer type laid out.
-   In C, this is int.  */
+   It is the first integer type laid out.  */
 
-tree sizetype;
+struct sizetype_tab sizetype_tab;
 
 /* An integer constant with value 0 whose type is sizetype.  */
 
@@ -50,10 +53,6 @@ int maximum_field_alignment;
    May be overridden by front-ends.  */
 int set_alignment = 0;
 
-#define GET_MODE_ALIGNMENT(MODE)   \
-  MIN (BIGGEST_ALIGNMENT, 	   \
-       MAX (1, (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT)))
-
 static enum machine_mode smallest_mode_for_size  PROTO((unsigned int,
 							enum mode_class));
 static tree layout_record	PROTO((tree));
@@ -254,13 +253,14 @@ layout_decl (decl, known_align)
       DECL_BIT_FIELD_TYPE (decl) = DECL_BIT_FIELD (decl) ? type : 0;
       if (maximum_field_alignment != 0)
 	DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), maximum_field_alignment);
-      else if (flag_pack_struct)
+      else if (DECL_PACKED (decl))
 	DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), BITS_PER_UNIT);
     }
 
   if (DECL_BIT_FIELD (decl)
       && TYPE_SIZE (type) != 0
-      && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
+      && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
+      && GET_MODE_CLASS (TYPE_MODE (type)) == MODE_INT)
     {
       register enum machine_mode xmode
 	= mode_for_size (TREE_INT_CST_LOW (DECL_SIZE (decl)), MODE_INT, 1);
@@ -277,6 +277,15 @@ layout_decl (decl, known_align)
 	}
     }
 
+  /* Turn off DECL_BIT_FIELD if we won't need it set.  */
+  if (DECL_BIT_FIELD (decl) && TYPE_MODE (type) == BLKmode
+      && known_align % TYPE_ALIGN (type) == 0
+      && DECL_SIZE (decl) != 0
+      && (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST
+	  || (TREE_INT_CST_LOW (DECL_SIZE (decl)) % BITS_PER_UNIT) == 0)
+      && DECL_ALIGN (decl) >= TYPE_ALIGN (type))
+    DECL_BIT_FIELD (decl) = 0;
+
   /* Evaluate nonconstant size only once, either now or as soon as safe.  */
   if (DECL_SIZE (decl) != 0 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
     DECL_SIZE (decl) = variable_size (DECL_SIZE (decl));
@@ -299,11 +308,7 @@ layout_record (rec)
      tree rec;
 {
   register tree field;
-#ifdef STRUCTURE_SIZE_BOUNDARY
-  unsigned record_align = MAX (STRUCTURE_SIZE_BOUNDARY, TYPE_ALIGN (rec));
-#else
   unsigned record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
-#endif
   /* These must be laid out *after* the record is.  */
   tree pending_statics = NULL_TREE;
   /* Record size so far is CONST_SIZE + VAR_SIZE bits,
@@ -311,17 +316,22 @@ layout_record (rec)
      and VAR_SIZE is a tree expression.
      If VAR_SIZE is null, the size is just CONST_SIZE.
      Naturally we try to avoid using VAR_SIZE.  */
-  register int const_size = 0;
+ register HOST_WIDE_INT const_size = 0;
   register tree var_size = 0;
   /* Once we start using VAR_SIZE, this is the maximum alignment
      that we know VAR_SIZE has.  */
   register int var_align = BITS_PER_UNIT;
 
+#ifdef STRUCTURE_SIZE_BOUNDARY
+  /* Packed structures don't need to have minimum size.  */
+  if (! TYPE_PACKED (rec))
+    record_align = MAX (record_align, STRUCTURE_SIZE_BOUNDARY);
+#endif
 
   for (field = TYPE_FIELDS (rec); field; field = TREE_CHAIN (field))
     {
       register int known_align = var_size ? var_align : const_size;
-      register int desired_align;
+      register int desired_align = 0;
 
       /* If FIELD is static, then treat it like a separate variable,
 	 not really like a structure field.
@@ -329,7 +339,7 @@ layout_record (rec)
 	 In both cases, all we do is lay out the decl,
 	 and we do it *after* the record is laid out.  */
 
-      if (TREE_STATIC (field))
+      if (TREE_CODE (field) == VAR_DECL)
 	{
 	  pending_statics = tree_cons (NULL_TREE, field, pending_statics);
 	  continue;
@@ -352,6 +362,9 @@ layout_record (rec)
 #ifdef BIGGEST_FIELD_ALIGNMENT
       desired_align = MIN (desired_align, BIGGEST_FIELD_ALIGNMENT);
 #endif
+#ifdef ADJUST_FIELD_ALIGN
+      desired_align = ADJUST_FIELD_ALIGN (field, desired_align);
+#endif
 
       /* Record must have at least as much alignment as any field.
 	 Otherwise, the alignment of the field within the record
@@ -379,7 +392,7 @@ layout_record (rec)
 	      int type_align = TYPE_ALIGN (TREE_TYPE (field));
 	      if (maximum_field_alignment != 0)
 		type_align = MIN (type_align, maximum_field_alignment);
-	      else if (flag_pack_struct)
+	      else if (DECL_PACKED (field))
 		type_align = MIN (type_align, BITS_PER_UNIT);
 
 	      record_align = MAX (record_align, type_align);
@@ -408,7 +421,7 @@ layout_record (rec)
 	    {
 	      if (const_size > 0)
 		var_size = size_binop (PLUS_EXPR, var_size,
-				       size_int (const_size));
+				       bitsize_int (const_size, 0L));
 	      const_size = 0;
 	      var_size = round_up (var_size, desired_align);
 	      var_align = MIN (var_align, desired_align);
@@ -421,23 +434,18 @@ layout_record (rec)
 	  && TREE_TYPE (field) != error_mark_node
 	  && DECL_BIT_FIELD_TYPE (field)
 	  && !DECL_PACKED (field)
-	  /* If #pragma pack is in effect, turn off this feature.  */
 	  && maximum_field_alignment == 0
-	  && !flag_pack_struct
 	  && !integer_zerop (DECL_SIZE (field)))
 	{
 	  int type_align = TYPE_ALIGN (TREE_TYPE (field));
 	  register tree dsize = DECL_SIZE (field);
 	  int field_size = TREE_INT_CST_LOW (dsize);
 
-	  /* A bit field may not span the unit of alignment of its type.
-	     Advance to next boundary if necessary.  */
-	  /* ??? There is some uncertainty here as to what
-	     should be done if type_align is less than the width of the type.
-	     That can happen because the width exceeds BIGGEST_ALIGNMENT
-	     or because it exceeds maximum_field_alignment.  */
-	  if (const_size / type_align
-	      != (const_size + (field_size % type_align) - 1) / type_align)
+	  /* A bit field may not span more units of alignment of its type
+	     than its type itself.  Advance to next boundary if necessary.  */
+	  if (((const_size + field_size + type_align - 1) / type_align
+	       - const_size / type_align)
+	      > TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (field))) / type_align)
 	    const_size = CEIL (const_size, type_align) * type_align;
 	}
 #endif
@@ -458,11 +466,15 @@ layout_record (rec)
 
 	  if (maximum_field_alignment != 0)
 	    type_align = MIN (type_align, maximum_field_alignment);
-	  else if (flag_pack_struct)
+	  /* ??? This test is opposite the test in the containing if
+	     statement, so this code is unreachable currently.  */
+	  else if (DECL_PACKED (field))
 	    type_align = MIN (type_align, BITS_PER_UNIT);
 
 	  /* A bit field may not span the unit of alignment of its type.
 	     Advance to next boundary if necessary.  */
+	  /* ??? This code should match the code above for the
+	     PCC_BITFIELD_TYPE_MATTERS case.  */
 	  if (const_size / type_align
 	      != (const_size + field_size - 1) / type_align)
 	    const_size = CEIL (const_size, type_align) * type_align;
@@ -473,7 +485,7 @@ layout_record (rec)
 
       if (var_size && const_size)
 	DECL_FIELD_BITPOS (field)
-	  = size_binop (PLUS_EXPR, var_size, size_int (const_size));
+	  = size_binop (PLUS_EXPR, var_size, bitsize_int (const_size, 0L));
       else if (var_size)
 	DECL_FIELD_BITPOS (field) = var_size;
       else
@@ -499,8 +511,9 @@ layout_record (rec)
 	if (dsize == 0)
 	  /* Do nothing.  */;
 	else if (TREE_CODE (dsize) == INTEGER_CST
+		 && ! TREE_CONSTANT_OVERFLOW (dsize)
 		 && TREE_INT_CST_HIGH (dsize) == 0
-		 && TREE_INT_CST_LOW (dsize) + const_size > const_size)
+		 && TREE_INT_CST_LOW (dsize) + const_size >= const_size)
 	  /* Use const_size if there's no overflow.  */
 	  const_size += TREE_INT_CST_LOW (dsize);
 	else
@@ -525,7 +538,7 @@ layout_record (rec)
     {
       if (const_size)
 	var_size
-	  = size_binop (PLUS_EXPR, var_size, size_int (const_size));
+	  = size_binop (PLUS_EXPR, var_size, bitsize_int (const_size, 0L));
       TYPE_SIZE (rec) = var_size;
     }
 
@@ -536,6 +549,11 @@ layout_record (rec)
   TYPE_ALIGN (rec) = MAX (TYPE_ALIGN (rec), record_align);
 #endif
 
+  /* Record the un-rounded size in the binfo node.  But first we check
+     the size of TYPE_BINFO to make sure that BINFO_SIZE is available.  */
+  if (TYPE_BINFO (rec) && TREE_VEC_LENGTH (TYPE_BINFO (rec)) > 6)
+    TYPE_BINFO_SIZE (rec) = TYPE_SIZE (rec);
+
 #ifdef ROUND_TYPE_SIZE
   TYPE_SIZE (rec) = ROUND_TYPE_SIZE (rec, TYPE_SIZE (rec), TYPE_ALIGN (rec));
 #else
@@ -557,11 +575,7 @@ layout_union (rec)
      tree rec;
 {
   register tree field;
-#ifdef STRUCTURE_SIZE_BOUNDARY
-  unsigned union_align = STRUCTURE_SIZE_BOUNDARY;
-#else
   unsigned union_align = BITS_PER_UNIT;
-#endif
 
   /* The size of the union, based on the fields scanned so far,
      is max (CONST_SIZE, VAR_SIZE).
@@ -569,6 +583,12 @@ layout_union (rec)
   register int const_size = 0;
   register tree var_size = 0;
 
+#ifdef STRUCTURE_SIZE_BOUNDARY
+  /* Packed structures don't need to have minimum size.  */
+  if (! TYPE_PACKED (rec))
+    union_align = STRUCTURE_SIZE_BOUNDARY;
+#endif
+
   /* If this is a QUAL_UNION_TYPE, we want to process the fields in
      the reverse order in building the COND_EXPR that denotes its
      size.  We reverse them again later.  */
@@ -582,7 +602,7 @@ layout_union (rec)
 	continue;
 
       layout_decl (field, 0);
-      DECL_FIELD_BITPOS (field) = size_int (0);
+      DECL_FIELD_BITPOS (field) = bitsize_int (0L, 0L);
 
       /* Union must be at least as aligned as any field requires.  */
 
@@ -612,7 +632,7 @@ layout_union (rec)
       else if (TREE_CODE (rec) == QUAL_UNION_TYPE)
 	var_size = fold (build (COND_EXPR, sizetype, DECL_QUALIFIER (field),
 				DECL_SIZE (field),
-				var_size ? var_size : integer_zero_node));
+				var_size ? var_size : bitsize_int (0L, 0L)));
       }
 
   if (TREE_CODE (rec) == QUAL_UNION_TYPE)
@@ -620,13 +640,13 @@ layout_union (rec)
 
   /* Determine the ultimate size of the union (in bytes).  */
   if (NULL == var_size)
-    TYPE_SIZE (rec) = size_int (CEIL (const_size, BITS_PER_UNIT)
-				* BITS_PER_UNIT);
+    TYPE_SIZE (rec) = bitsize_int (CEIL (const_size, BITS_PER_UNIT)
+				   * BITS_PER_UNIT, 0L);
   else if (const_size == 0)
     TYPE_SIZE (rec) = var_size;
   else
     TYPE_SIZE (rec) = size_binop (MAX_EXPR, var_size,
-				  round_up (size_int (const_size),
+				  round_up (bitsize_int (const_size, 0L),
 					    BITS_PER_UNIT));
 
   /* Determine the desired alignment.  */
@@ -685,20 +705,28 @@ layout_type (type)
 	 of the language-specific code.  */
       abort ();
 
+    case BOOLEAN_TYPE:  /* Used for Java, Pascal, and Chill. */
+      if (TYPE_PRECISION (type) == 0)
+	TYPE_PRECISION (type) = 1; /* default to one byte/boolean. */
+      /* ... fall through ... */
+
     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)
 	TREE_UNSIGNED (type) = 1;
 
       TYPE_MODE (type) = smallest_mode_for_size (TYPE_PRECISION (type),
 						 MODE_INT);
-      TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
+      TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)), 0L);
+      TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
       break;
 
     case REAL_TYPE:
       TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0);
-      TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
+      TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)), 0L);
+      TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
       break;
 
     case COMPLEX_TYPE:
@@ -708,30 +736,35 @@ layout_type (type)
 			 (TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE
 			  ? MODE_COMPLEX_INT : MODE_COMPLEX_FLOAT),
 			 0);
-      TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
+      TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)), 0L);
+      TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
       break;
 
     case VOID_TYPE:
       TYPE_SIZE (type) = size_zero_node;
+      TYPE_SIZE_UNIT (type) = size_zero_node;
       TYPE_ALIGN (type) = 1;
       TYPE_MODE (type) = VOIDmode;
       break;
 
     case OFFSET_TYPE:
-      TYPE_SIZE (type) = size_int (POINTER_SIZE);
+      TYPE_SIZE (type) = bitsize_int (POINTER_SIZE, 0L);
+      TYPE_SIZE_UNIT (type) = size_int (POINTER_SIZE / BITS_PER_UNIT);
       TYPE_MODE (type) = ptr_mode;
       break;
 
     case FUNCTION_TYPE:
     case METHOD_TYPE:
       TYPE_MODE (type) = mode_for_size (2 * POINTER_SIZE, MODE_INT, 0);
-      TYPE_SIZE (type) = size_int (2 * POINTER_SIZE);
+      TYPE_SIZE (type) = bitsize_int (2 * POINTER_SIZE, 0);
+      TYPE_SIZE_UNIT (type) = size_int ((2 * POINTER_SIZE) / BITS_PER_UNIT);
       break;
 
     case POINTER_TYPE:
     case REFERENCE_TYPE:
       TYPE_MODE (type) = ptr_mode;
-      TYPE_SIZE (type) = size_int (POINTER_SIZE);
+      TYPE_SIZE (type) = bitsize_int (POINTER_SIZE, 0L);
+      TYPE_SIZE_UNIT (type) = size_int (POINTER_SIZE / BITS_PER_UNIT);
       TREE_UNSIGNED (type) = 1;
       TYPE_PRECISION (type) = POINTER_SIZE;
       break;
@@ -767,8 +800,11 @@ layout_type (type)
 					 lb, 0))
 	      ub = TREE_OPERAND (ub, 0);
 
+	    /* The initial subtraction should happen in the original type so
+	       that (possible) negative values are handled appropriately.  */
 	    length = size_binop (PLUS_EXPR, size_one_node,
-				 size_binop (MINUS_EXPR, ub, lb));
+				 fold (build (MINUS_EXPR, TREE_TYPE (lb),
+					      ub, lb)));
 
 	    /* If neither bound is a constant and sizetype is signed, make
 	       sure the size is never negative.  We should really do this
@@ -779,8 +815,19 @@ layout_type (type)
 		&& TREE_CODE (TYPE_MAX_VALUE (index)) != INTEGER_CST)
 	      length = size_binop (MAX_EXPR, length, size_zero_node);
 
-	    TYPE_SIZE (type) = size_binop (MULT_EXPR, length,
-					   TYPE_SIZE (element));
+	    TYPE_SIZE (type) = size_binop (MULT_EXPR, TYPE_SIZE (element),
+					   length);
+
+	    /* If we know the size of the element, calculate the total
+	       size directly, rather than do some division thing below.
+	       This optimization helps Fortran assumed-size arrays
+	       (where the size of the array is determined at runtime)
+	       substantially.  */
+	    if (TYPE_SIZE_UNIT (element) != 0)
+	      {
+	        TYPE_SIZE_UNIT (type)
+		  = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (element), length);
+	      }
 	  }
 
 	/* Now round the alignment and size,
@@ -795,8 +842,15 @@ layout_type (type)
 
 #ifdef ROUND_TYPE_SIZE
 	if (TYPE_SIZE (type) != 0)
-	  TYPE_SIZE (type)
-	    = ROUND_TYPE_SIZE (type, TYPE_SIZE (type), TYPE_ALIGN (type));
+	  {
+	    tree tmp;
+	    tmp = ROUND_TYPE_SIZE (type, TYPE_SIZE (type), TYPE_ALIGN (type));
+	    /* If the rounding changed the size of the type, remove any
+	       pre-calculated TYPE_SIZE_UNIT.  */
+	    if (simple_cst_equal (TYPE_SIZE (type), tmp) != 1)
+	      TYPE_SIZE_UNIT (type) = NULL;
+	    TYPE_SIZE (type) = tmp;
+	  }
 #endif
 
 	TYPE_MODE (type) = BLKmode;
@@ -828,6 +882,8 @@ layout_type (type)
       if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
 	{
 	  tree field;
+	  enum machine_mode mode = VOIDmode;
+
 	  /* A record which has any BLKmode members must itself be BLKmode;
 	     it can't go in a register.
 	     Unless the member is BLKmode only because it isn't aligned.  */
@@ -853,13 +909,23 @@ layout_type (type)
 		  != ((TREE_INT_CST_LOW (DECL_SIZE (field)) + bitpos - 1)
 		      / BITS_PER_WORD)
 		  /* But there is no problem if the field is entire words.  */
-		  && TREE_INT_CST_LOW (DECL_SIZE (field)) % BITS_PER_WORD == 0)
+		  && TREE_INT_CST_LOW (DECL_SIZE (field)) % BITS_PER_WORD != 0)
 		goto record_lose;
+
+	      /* If this field is the whole struct, remember its mode so
+		 that, say, we can put a double in a class into a DF
+		 register instead of forcing it to live in the stack.  */
+	      if (simple_cst_equal (TYPE_SIZE (type), DECL_SIZE (field)))
+		mode = DECL_MODE (field);
 	    }
 
-	  TYPE_MODE (type)
-	    = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)),
-			     MODE_INT, 1);
+	  if (mode != VOIDmode)
+	    /* We only have one real field; use its mode.  */
+	    TYPE_MODE (type) = mode;
+	  else
+	    TYPE_MODE (type)
+	      = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)),
+			       MODE_INT, 1);
 
 	  /* If structure's known alignment is less than
 	     what the scalar mode would need, and it matters,
@@ -922,25 +988,7 @@ layout_type (type)
 	}
       break;
 
-    /* Pascal and Chill types */
-    case BOOLEAN_TYPE:		 /* store one byte/boolean for now. */
-      TYPE_MODE (type) = QImode;
-      TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
-      TYPE_PRECISION (type) = 1;
-      TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type));
-      if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
-	  && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0)
- 	TREE_UNSIGNED (type) = 1;
-      break;
-
-    case CHAR_TYPE:
-      TYPE_MODE (type) = QImode;
-      TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
-      TYPE_PRECISION (type) = GET_MODE_BITSIZE (TYPE_MODE (type));
-      TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type));
-      break;
-
-    case SET_TYPE:
+    case SET_TYPE:  /* Used by Chill and Pascal. */
       if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST
 	  || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST)
 	abort();
@@ -950,16 +998,17 @@ layout_type (type)
 #define SET_WORD_SIZE BITS_PER_WORD
 #endif
 	  int alignment = set_alignment ? set_alignment : SET_WORD_SIZE;
-	  int size_in_bits =
-	    TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
-	      - TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1;
+	  int size_in_bits
+	    = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
+	       - TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1);
 	  int rounded_size
 	    = ((size_in_bits + alignment - 1) / alignment) * alignment;
 	  if (rounded_size > alignment)
 	    TYPE_MODE (type) = BLKmode;
 	  else
 	    TYPE_MODE (type) = mode_for_size (alignment, MODE_INT, 1);
-	  TYPE_SIZE (type) = size_int (rounded_size);
+	  TYPE_SIZE (type) = bitsize_int (rounded_size, 0L);
+	  TYPE_SIZE_UNIT (type) = size_int (rounded_size / BITS_PER_UNIT);
 	  TYPE_ALIGN (type) = alignment;
 	  TYPE_PRECISION (type) = size_in_bits;
 	}
@@ -992,6 +1041,19 @@ layout_type (type)
   if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
     TYPE_SIZE (type) = variable_size (TYPE_SIZE (type));
 
+  /* If we failed to find a simple way to calculate the unit size
+     of the type above, find it by division.  */
+  if (TYPE_SIZE_UNIT (type) == 0 && TYPE_SIZE (type) != 0)
+    {
+      TYPE_SIZE_UNIT (type) = size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (type),
+				          size_int (BITS_PER_UNIT));
+    }
+
+  /* Once again evaluate only once, either now or as soon as safe.  */
+  if (TYPE_SIZE_UNIT (type) != 0
+      && TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST)
+    TYPE_SIZE_UNIT (type) = variable_size (TYPE_SIZE_UNIT (type));
+
   /* Also layout any other variants of the type.  */
   if (TYPE_NEXT_VARIANT (type)
       || type != TYPE_MAIN_VARIANT (type))
@@ -999,6 +1061,7 @@ layout_type (type)
       tree variant;
       /* Record layout info of this variant.  */
       tree size = TYPE_SIZE (type);
+      tree size_unit = TYPE_SIZE_UNIT (type);
       int align = TYPE_ALIGN (type);
       enum machine_mode mode = TYPE_MODE (type);
 
@@ -1008,6 +1071,7 @@ layout_type (type)
 	   variant = TYPE_NEXT_VARIANT (variant))
 	{
 	  TYPE_SIZE (variant) = size;
+	  TYPE_SIZE_UNIT (variant) = size_unit;
 	  TYPE_ALIGN (variant) = align;
 	  TYPE_MODE (variant) = mode;
 	}
@@ -1053,9 +1117,7 @@ make_signed_type (precision)
      is the type for size values.  */
 
   if (sizetype == 0)
-    {
-      sizetype = type;
-    }
+    set_sizetype (type);
 
   /* Lay out the type: set its alignment, size, etc.  */
 
@@ -1079,13 +1141,65 @@ make_unsigned_type (precision)
 
   if (sizetype == 0)
     {
-      sizetype = type;
+      TREE_UNSIGNED (type) = 1;
+      set_sizetype (type);
     }
 
   fixup_unsigned_type (type);
   return type;
 }
 
+/* Set sizetype to TYPE, and initialize *sizetype accordingly.
+   Also update the type of any standard type's sizes made so far.  */
+
+void
+set_sizetype (type)
+     tree type;
+{
+  int oprecision = TYPE_PRECISION (type), precision;
+
+  sizetype = type;
+
+  /* The *bitsizetype types use a precision that avoids overflows when
+     calculating signed sizes / offsets in bits.
+
+     We are allocating bitsizetype once and change it in place when
+     we decide later that we want to change it.  This way, we avoid the
+     hassle of changing all the TYPE_SIZE (TREE_TYPE (sometype))
+     individually in each front end.  */
+  if (! bitsizetype)
+    bitsizetype = make_node (INTEGER_TYPE);
+  if (TYPE_NAME (sizetype) && ! TYPE_NAME (bitsizetype))
+    TYPE_NAME (bitsizetype) = TYPE_NAME (sizetype);
+
+  precision = oprecision + BITS_PER_UNIT_LOG + 1;
+  /* However, when cross-compiling from a 32 bit to a 64 bit host,
+     we are limited to 64 bit precision.  */
+  if (precision > 2 * HOST_BITS_PER_WIDE_INT)
+    precision = 2 * HOST_BITS_PER_WIDE_INT;
+  TYPE_PRECISION (bitsizetype) = precision;
+  if (TREE_UNSIGNED (type))
+    fixup_unsigned_type (bitsizetype);
+  else
+    fixup_signed_type (bitsizetype);
+  layout_type (bitsizetype);
+
+  if (TREE_UNSIGNED (type))
+    {
+      usizetype = sizetype;
+      ubitsizetype = bitsizetype;
+      ssizetype = make_signed_type (oprecision);
+      sbitsizetype = make_signed_type (precision);
+    }
+  else
+    {
+      ssizetype = sizetype;
+      sbitsizetype = bitsizetype;
+      usizetype = make_unsigned_type (oprecision);
+      ubitsizetype = make_unsigned_type (precision);
+    }
+}
+
 /* Set the extreme values of TYPE based on its precision in bits,
    then lay it out.  Used when make_signed_type won't do
    because the tree code is not INTEGER_TYPE.
@@ -1170,14 +1284,14 @@ get_best_mode (bitsize, bitpos, align, largest_mode, volatilep)
      int volatilep;
 {
   enum machine_mode mode;
-  int unit;
+  int unit = 0;
 
   /* Find the narrowest integer mode that contains the bit field.  */
   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
        mode = GET_MODE_WIDER_MODE (mode))
     {
       unit = GET_MODE_BITSIZE (mode);
-      if (bitpos / unit == (bitpos + bitsize - 1) / unit)
+      if ((bitpos % unit) + bitsize <= unit)
 	break;
     }