Subversion Repositories scarts

/* 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.

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

version.

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

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING.  If not, write to the Free

Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA

02110-1301, USA.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "tree.h"

#include "rtl.h"

#include "tm_p.h"

#include "flags.h"

#include "function.h"

#include "expr.h"

#include "output.h"

#include "toplev.h"

#include "ggc.h"

#include "target.h"

#include "langhooks.h"

#include "regs.h"

#include "params.h"

/* Data type for the expressions representing sizes of data types.

   It is the first integer type laid out.  */

tree sizetype_tab[(int) TYPE_KIND_LAST];

/* If nonzero, this is an upper limit on alignment of structure fields.

   The value is measured in bits.  */

unsigned int maximum_field_alignment = TARGET_DEFAULT_PACK_STRUCT * BITS_PER_UNIT;

/* ... and its original value in bytes, specified via -fpack-struct=<value>.  */

unsigned int initial_max_fld_align = TARGET_DEFAULT_PACK_STRUCT;

/* Nonzero if all REFERENCE_TYPEs are internal and hence should be

   allocated in Pmode, not ptr_mode.   Set only by internal_reference_types

   called only by a front end.  */

static int reference_types_internal = 0;

static void finalize_record_size (record_layout_info);

static void finalize_type_size (tree);

static void place_union_field (record_layout_info, tree);

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

static int excess_unit_span (HOST_WIDE_INT, HOST_WIDE_INT, HOST_WIDE_INT,

                             HOST_WIDE_INT, tree);

#endif

extern void debug_rli (record_layout_info);

/* SAVE_EXPRs for sizes of types and decls, waiting to be expanded.  */

static GTY(()) tree pending_sizes;

/* Show that REFERENCE_TYPES are internal and should be Pmode.  Called only

   by front end.  */

void

internal_reference_types (void)

{

  reference_types_internal = 1;

}

/* Get a list of all the objects put on the pending sizes list.  */

tree

get_pending_sizes (void)

{

  tree chain = pending_sizes;

  pending_sizes = 0;

  return chain;

}

/* Add EXPR to the pending sizes list.  */

void

put_pending_size (tree expr)

{

  /* Strip any simple arithmetic from EXPR to see if it has an underlying

     SAVE_EXPR.  */

  expr = skip_simple_arithmetic (expr);

  if (TREE_CODE (expr) == SAVE_EXPR)

    pending_sizes = tree_cons (NULL_TREE, expr, pending_sizes);

}

/* Put a chain of objects into the pending sizes list, which must be

   empty.  */

void

put_pending_sizes (tree chain)

{

  gcc_assert (!pending_sizes);

  pending_sizes = chain;

}

/* Given a size SIZE that may not be a constant, return a SAVE_EXPR

   to serve as the actual size-expression for a type or decl.  */

tree

variable_size (tree size)

{

  tree save;

  /* If the language-processor is to take responsibility for variable-sized

     items (e.g., languages which have elaboration procedures like Ada),

     just return SIZE unchanged.  Likewise for self-referential sizes and

     constant sizes.  */

  if (TREE_CONSTANT (size)

      || lang_hooks.decls.global_bindings_p () < 0

      || CONTAINS_PLACEHOLDER_P (size))

    return size;

  size = save_expr (size);

  /* If an array with a variable number of elements is declared, and

     the elements require destruction, we will emit a cleanup for the

     array.  That cleanup is run both on normal exit from the block

     and in the exception-handler for the block.  Normally, when code

     is used in both ordinary code and in an exception handler it is

     `unsaved', i.e., all SAVE_EXPRs are recalculated.  However, we do

     not wish to do that here; the array-size is the same in both

     places.  */

  save = skip_simple_arithmetic (size);

  if (cfun && cfun->x_dont_save_pending_sizes_p)

    /* The front-end doesn't want us to keep a list of the expressions

       that determine sizes for variable size objects.  Trust it.  */

    return size;

  if (lang_hooks.decls.global_bindings_p ())

    {

      if (TREE_CONSTANT (size))

        error ("type size can%'t be explicitly evaluated");

      else

        error ("variable-size type declared outside of any function");

      return size_one_node;

    }

  put_pending_size (save);

  return size;

}

#ifndef MAX_FIXED_MODE_SIZE

#define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode)

#endif

/* Return the machine mode to use for a nonscalar of SIZE bits.  The

   mode must be in class CLASS, and have exactly that many value bits;

   it may have padding as well.  If LIMIT is nonzero, modes of wider

   than MAX_FIXED_MODE_SIZE will not be used.  */

enum machine_mode

mode_for_size (unsigned int size, enum mode_class class, int limit)

{

  enum machine_mode mode;

  if (limit && size > MAX_FIXED_MODE_SIZE)

    return BLKmode;

  /* Get the first mode which has this size, in the specified class.  */

  for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode;

       mode = GET_MODE_WIDER_MODE (mode))

    if (GET_MODE_PRECISION (mode) == size)

      return mode;

  return BLKmode;

}

/* Similar, except passed a tree node.  */

enum machine_mode

mode_for_size_tree (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)

    return BLKmode;

  else

    return mode_for_size (tree_low_cst (size, 1), class, limit);

}

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

   contains at least the requested number of value bits.  */

enum machine_mode

smallest_mode_for_size (unsigned int size, enum mode_class class)

{

  enum machine_mode mode;

  /* Get the first mode which has at least this size, in the

     specified class.  */

  for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode;

       mode = GET_MODE_WIDER_MODE (mode))

    if (GET_MODE_PRECISION (mode) >= size)

      return mode;

  gcc_unreachable ();

}

/* Find an integer mode of the exact same size, or BLKmode on failure.  */

enum machine_mode

int_mode_for_mode (enum machine_mode mode)

{

  switch (GET_MODE_CLASS (mode))

    {

    case MODE_INT:

    case MODE_PARTIAL_INT:

      break;

    case MODE_COMPLEX_INT:

    case MODE_COMPLEX_FLOAT:

    case MODE_FLOAT:

    case MODE_VECTOR_INT:

    case MODE_VECTOR_FLOAT:

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

      break;

    case MODE_RANDOM:

      if (mode == BLKmode)

        break;

      /* ... fall through ...  */

    case MODE_CC:

    default:

      gcc_unreachable ();

    }

  return mode;

}

/* Return the alignment of MODE. This will be bounded by 1 and

   BIGGEST_ALIGNMENT.  */

unsigned int

get_mode_alignment (enum machine_mode mode)

{

  return MIN (BIGGEST_ALIGNMENT, MAX (1, mode_base_align[mode]*BITS_PER_UNIT));

}

/* Subroutine of layout_decl: Force alignment required for the data type.

   But if the decl itself wants greater alignment, don't override that.  */

static inline void

do_type_align (tree type, tree decl)

{

  if (TYPE_ALIGN (type) > DECL_ALIGN (decl))

    {

      DECL_ALIGN (decl) = TYPE_ALIGN (type);

      if (TREE_CODE (decl) == FIELD_DECL)

        DECL_USER_ALIGN (decl) = TYPE_USER_ALIGN (type);

    }

}

/* Set the size, mode and alignment of a ..._DECL node.

   TYPE_DECL does need this for C++.

   Note that LABEL_DECL and CONST_DECL nodes do not need this,

   and FUNCTION_DECL nodes have them set up in a special (and simple) way.

   Don't call layout_decl for them.

   KNOWN_ALIGN is the amount of alignment we can assume this

   decl has with no special effort.  It is relevant only for FIELD_DECLs

   and depends on the previous fields.

   All that matters about KNOWN_ALIGN is which powers of 2 divide it.

   If KNOWN_ALIGN is 0, it means, "as much alignment as you like":

   the record will be aligned to suit.  */

void

layout_decl (tree decl, unsigned int known_align)

{

  tree type = TREE_TYPE (decl);

  enum tree_code code = TREE_CODE (decl);

  rtx rtl = NULL_RTX;

  if (code == CONST_DECL)

    return;

  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)

    type = void_type_node;

  /* Usually the size and mode come from the data type without change,

     however, the front-end may set the explicit width of the field, so its

     size may not be the same as the size of its type.  This happens with

     bitfields, of course (an `int' bitfield may be only 2 bits, say), but it

     also happens with other fields.  For example, the C++ front-end creates

     zero-sized fields corresponding to empty base classes, and depends on

     layout_type setting DECL_FIELD_BITPOS correctly for the field.  Set the

     size in bytes from the size in bits.  If we have already set the mode,

     don't set it again since we can be called twice for FIELD_DECLs.  */

  DECL_UNSIGNED (decl) = TYPE_UNSIGNED (type);

  if (DECL_MODE (decl) == VOIDmode)

    DECL_MODE (decl) = TYPE_MODE (type);

  if (DECL_SIZE (decl) == 0)

    {

      DECL_SIZE (decl) = TYPE_SIZE (type);

      DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (type);

    }

  else if (DECL_SIZE_UNIT (decl) == 0)

    DECL_SIZE_UNIT (decl)

      = fold_convert (sizetype, size_binop (CEIL_DIV_EXPR, DECL_SIZE (decl),

                                            bitsize_unit_node));

  if (code != FIELD_DECL)

    /* For non-fields, update the alignment from the type.  */

    do_type_align (type, decl);

  else

    /* For fields, it's a bit more complicated...  */

    {

      bool old_user_align = DECL_USER_ALIGN (decl);

      bool zero_bitfield = false;

      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

             field.  */

          if (integer_zerop (DECL_SIZE (decl))

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

            {

              zero_bitfield = true;

#ifdef PCC_BITFIELD_TYPE_MATTERS

              if (PCC_BITFIELD_TYPE_MATTERS)

                do_type_align (type, decl);

              else

#endif

                {

#ifdef EMPTY_FIELD_BOUNDARY

                  if (EMPTY_FIELD_BOUNDARY > DECL_ALIGN (decl))

                    {

                      DECL_ALIGN (decl) = EMPTY_FIELD_BOUNDARY;

                      DECL_USER_ALIGN (decl) = 0;

                    }

#endif

                }

            }

          /* See if we can use an ordinary integer mode for a bit-field.

             Conditions are: a fixed size that is correct for another mode

             and occupying a complete byte or bytes on proper boundary.  */

          if (TYPE_SIZE (type) != 0

              && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST

              && GET_MODE_CLASS (TYPE_MODE (type)) == MODE_INT)

            {

              enum machine_mode xmode

                = mode_for_size_tree (DECL_SIZE (decl), MODE_INT, 1);

              if (xmode != BLKmode

                  && (known_align == 0

                      || known_align >= GET_MODE_ALIGNMENT (xmode)))

                {

                  DECL_ALIGN (decl) = MAX (GET_MODE_ALIGNMENT (xmode),

                                           DECL_ALIGN (decl));

                  DECL_MODE (decl) = xmode;

                  DECL_BIT_FIELD (decl) = 0;

                }

            }

          /* Turn off DECL_BIT_FIELD if we won't need it set.  */

          if (TYPE_MODE (type) == BLKmode && DECL_MODE (decl) == BLKmode

              && known_align >= TYPE_ALIGN (type)

              && DECL_ALIGN (decl) >= TYPE_ALIGN (type))

            DECL_BIT_FIELD (decl) = 0;

        }

      else if (DECL_PACKED (decl) && 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

           alignment explicitly specified on the field 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

          && !zero_bitfield

          && (DECL_NONADDRESSABLE_P (decl)

              || DECL_SIZE_UNIT (decl) == 0

              || TREE_CODE (DECL_SIZE_UNIT (decl)) == INTEGER_CST))

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

      if (! DECL_USER_ALIGN (decl) && (! DECL_PACKED (decl) || zero_bitfield))

        {

          /* Some targets (i.e. i386, VMS) limit struct field alignment

             to a lower boundary than alignment of variables unless

             it was overridden by attribute aligned.  */

#ifdef BIGGEST_FIELD_ALIGNMENT

          DECL_ALIGN (decl)

            = MIN (DECL_ALIGN (decl), (unsigned) BIGGEST_FIELD_ALIGNMENT);

#endif

#ifdef ADJUST_FIELD_ALIGN

          DECL_ALIGN (decl) = ADJUST_FIELD_ALIGN (decl, DECL_ALIGN (decl));

#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?  */

      if (mfa != 0)

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

    }

  /* 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));

  if (DECL_SIZE_UNIT (decl) != 0

      && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST)

    DECL_SIZE_UNIT (decl) = variable_size (DECL_SIZE_UNIT (decl));

  /* If requested, warn about definitions of large data objects.  */

  if (warn_larger_than

      && (code == VAR_DECL || code == PARM_DECL)

      && ! DECL_EXTERNAL (decl))

    {

      tree size = DECL_SIZE_UNIT (decl);

      if (size != 0 && TREE_CODE (size) == INTEGER_CST

          && compare_tree_int (size, larger_than_size) > 0)

        {

          int size_as_int = TREE_INT_CST_LOW (size);

          if (compare_tree_int (size, size_as_int) == 0)

            warning (0, "size of %q+D is %d bytes", decl, size_as_int);

          else

            warning (0, "size of %q+D is larger than %wd bytes",

                     decl, larger_than_size);

        }

    }

  /* If the RTL was already set, update its mode and mem attributes.  */

  if (rtl)

    {

      PUT_MODE (rtl, DECL_MODE (decl));

      SET_DECL_RTL (decl, 0);

      set_mem_attributes (rtl, decl, 1);

      SET_DECL_RTL (decl, rtl);

    }

}

/* Given a VAR_DECL, PARM_DECL or RESULT_DECL, clears the results of

   a previous call to layout_decl and calls it again.  */

void

relayout_decl (tree decl)

{

  DECL_SIZE (decl) = DECL_SIZE_UNIT (decl) = 0;

  DECL_MODE (decl) = VOIDmode;

  DECL_ALIGN (decl) = 0;

  SET_DECL_RTL (decl, 0);

  layout_decl (decl, 0);

}

/* Hook for a front-end function that can modify the record layout as needed

   immediately before it is finalized.  */

static void (*lang_adjust_rli) (record_layout_info) = 0;

void

set_lang_adjust_rli (void (*f) (record_layout_info))

{

  lang_adjust_rli = f;

}

/* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or

   QUAL_UNION_TYPE.  Return a pointer to a struct record_layout_info which

   is to be passed to all other layout functions for this record.  It is the

   responsibility of the caller to call `free' for the storage returned.

   Note that garbage collection is not permitted until we finish laying

   out the record.  */

record_layout_info

start_record_layout (tree t)

{

  record_layout_info rli = xmalloc (sizeof (struct record_layout_info_s));

  rli->t = t;

  /* If the type has a minimum specified alignment (via an attribute

     declaration, for example) use it -- otherwise, start with a

     one-byte alignment.  */

  rli->record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (t));

  rli->unpacked_align = rli->record_align;

  rli->offset_align = MAX (rli->record_align, BIGGEST_ALIGNMENT);

#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);

#endif

  rli->offset = size_zero_node;

  rli->bitpos = bitsize_zero_node;

  rli->prev_field = 0;

  rli->pending_statics = 0;

  rli->packed_maybe_necessary = 0;

  return rli;

}

/* These four routines perform computations that convert between

   the offset/bitpos forms and byte and bit offsets.  */

tree

bit_from_pos (tree offset, tree bitpos)

{

  return size_binop (PLUS_EXPR, bitpos,

                     size_binop (MULT_EXPR,

                                 fold_convert (bitsizetype, offset),

                                 bitsize_unit_node));

}

tree

byte_from_pos (tree offset, tree bitpos)

{

  return size_binop (PLUS_EXPR, offset,

                     fold_convert (sizetype,

                                   size_binop (TRUNC_DIV_EXPR, bitpos,

                                               bitsize_unit_node)));

}

void

pos_from_bit (tree *poffset, tree *pbitpos, unsigned int off_align,

              tree pos)

{

  *poffset = size_binop (MULT_EXPR,

                         fold_convert (sizetype,

                                       size_binop (FLOOR_DIV_EXPR, pos,

                                                   bitsize_int (off_align))),

                         size_int (off_align / BITS_PER_UNIT));

  *pbitpos = size_binop (FLOOR_MOD_EXPR, pos, bitsize_int (off_align));

}

/* Given a pointer to bit and byte offsets and an offset alignment,

   normalize the offsets so they are within the alignment.  */

void

normalize_offset (tree *poffset, tree *pbitpos, unsigned int off_align)

{

  /* If the bit position is now larger than it should be, adjust it

     downwards.  */

  if (compare_tree_int (*pbitpos, off_align) >= 0)

    {

      tree extra_aligns = size_binop (FLOOR_DIV_EXPR, *pbitpos,

                                      bitsize_int (off_align));

      *poffset

        = size_binop (PLUS_EXPR, *poffset,

                      size_binop (MULT_EXPR,

                                  fold_convert (sizetype, extra_aligns),

                                  size_int (off_align / BITS_PER_UNIT)));

      *pbitpos

        = size_binop (FLOOR_MOD_EXPR, *pbitpos, bitsize_int (off_align));

    }

}

/* Print debugging information about the information in RLI.  */

void

debug_rli (record_layout_info rli)

{

  print_node_brief (stderr, "type", rli->t, 0);

  print_node_brief (stderr, "\noffset", rli->offset, 0);

  print_node_brief (stderr, " bitpos", rli->bitpos, 0);

  fprintf (stderr, "\naligns: rec = %u, unpack = %u, off = %u\n",

           rli->record_align, rli->unpacked_align,

           rli->offset_align);

  if (rli->packed_maybe_necessary)

    fprintf (stderr, "packed may be necessary\n");

  if (rli->pending_statics)

    {

      fprintf (stderr, "pending statics:\n");

      debug_tree (rli->pending_statics);

    }

}

/* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and

   BITPOS if necessary to keep BITPOS below OFFSET_ALIGN.  */

void

normalize_rli (record_layout_info rli)

{

  normalize_offset (&rli->offset, &rli->bitpos, rli->offset_align);

}

/* Returns the size in bytes allocated so far.  */

tree

rli_size_unit_so_far (record_layout_info rli)

{

  return byte_from_pos (rli->offset, rli->bitpos);

}

/* Returns the size in bits allocated so far.  */

tree

rli_size_so_far (record_layout_info rli)

{

  return bit_from_pos (rli->offset, rli->bitpos);

}

/* FIELD is about to be added to RLI->T.  The alignment (in bits) of

   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 known_align)

{

  /* The alignment required for FIELD.  */

  unsigned int desired_align;

  /* The type of this field.  */

  tree type = TREE_TYPE (field);

  /* True if the field was explicitly aligned by the user.  */

  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);

  user_align = DECL_USER_ALIGN (field);

  is_bitfield = (type != error_mark_node

                 && DECL_BIT_FIELD_TYPE (field)

                 && ! integer_zerop (TYPE_SIZE (type)));

  /* 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))

    {

      /* Here, the alignment of the underlying type of a bitfield can

         affect the alignment of a record; even a zero-sized field

         can do this.  The alignment should be to the alignment of

         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))))

        {

          unsigned int type_align = TYPE_ALIGN (type);

          type_align = MAX (type_align, desired_align);

          if (maximum_field_alignment != 0)

            type_align = MIN (type_align, maximum_field_alignment);

          rli->record_align = MAX (rli->record_align, type_align);

          rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type));

          /* If we start a new run, make sure we start it properly aligned.  */

          if ((!rli->prev_field

               || integer_zerop (DECL_SIZE (field))

               || 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)))

               || (rli->remaining_in_alignment

                   < tree_low_cst (DECL_SIZE (field), 0)))

              && desired_align < type_align)

            desired_align = type_align;

        }

    }

#ifdef PCC_BITFIELD_TYPE_MATTERS

  else if (is_bitfield && PCC_BITFIELD_TYPE_MATTERS)

    {