Subversion Repositories scarts

/* Alias analysis for GNU C

   Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006

   Free Software Foundation, Inc.

   Contributed by John Carr (jfc@mit.edu).

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 "rtl.h"

#include "tree.h"

#include "tm_p.h"

#include "function.h"

#include "alias.h"

#include "emit-rtl.h"

#include "regs.h"

#include "hard-reg-set.h"

#include "basic-block.h"

#include "flags.h"

#include "output.h"

#include "toplev.h"

#include "cselib.h"

#include "splay-tree.h"

#include "ggc.h"

#include "langhooks.h"

#include "timevar.h"

#include "target.h"

#include "cgraph.h"

#include "varray.h"

#include "tree-pass.h"

#include "ipa-type-escape.h"

/* The aliasing API provided here solves related but different problems:

   Say there exists (in c)

   struct X {

     struct Y y1;

     struct Z z2;

   } x1, *px1,  *px2;

   struct Y y2, *py;

   struct Z z2, *pz;

   py = &px1.y1;

   px2 = &x1;

   Consider the four questions:

   Can a store to x1 interfere with px2->y1?

   Can a store to x1 interfere with px2->z2?

   (*px2).z2

   Can a store to x1 change the value pointed to by with py?

   Can a store to x1 change the value pointed to by with pz?

   The answer to these questions can be yes, yes, yes, and maybe.

   The first two questions can be answered with a simple examination

   of the type system.  If structure X contains a field of type Y then

   a store thru a pointer to an X can overwrite any field that is

   contained (recursively) in an X (unless we know that px1 != px2).

   The last two of the questions can be solved in the same way as the

   first two questions but this is too conservative.  The observation

   is that in some cases analysis we can know if which (if any) fields

   are addressed and if those addresses are used in bad ways.  This

   analysis may be language specific.  In C, arbitrary operations may

   be applied to pointers.  However, there is some indication that

   this may be too conservative for some C++ types.

   The pass ipa-type-escape does this analysis for the types whose

   instances do not escape across the compilation boundary.

   Historically in GCC, these two problems were combined and a single

   data structure was used to represent the solution to these

   problems.  We now have two similar but different data structures,

   The data structure to solve the last two question is similar to the

   first, but does not contain have the fields in it whose address are

   never taken.  For types that do escape the compilation unit, the

   data structures will have identical information.

*/

/* The alias sets assigned to MEMs assist the back-end in determining

   which MEMs can alias which other MEMs.  In general, two MEMs in

   different alias sets cannot alias each other, with one important

   exception.  Consider something like:

     struct S { int i; double d; };

   a store to an `S' can alias something of either type `int' or type

   `double'.  (However, a store to an `int' cannot alias a `double'

   and vice versa.)  We indicate this via a tree structure that looks

   like:

           struct S

            /   \

           /     \

         |/_     _\|

         int    double

   (The arrows are directed and point downwards.)

    In this situation we say the alias set for `struct S' is the

   `superset' and that those for `int' and `double' are `subsets'.

   To see whether two alias sets can point to the same memory, we must

   see if either alias set is a subset of the other. We need not trace

   past immediate descendants, however, since we propagate all

   grandchildren up one level.

   Alias set zero is implicitly a superset of all other alias sets.

   However, this is no actual entry for alias set zero.  It is an

   error to attempt to explicitly construct a subset of zero.  */

struct alias_set_entry GTY(())

{

  /* The alias set number, as stored in MEM_ALIAS_SET.  */

  HOST_WIDE_INT alias_set;

  /* The children of the alias set.  These are not just the immediate

     children, but, in fact, all descendants.  So, if we have:

       struct T { struct S s; float f; }

     continuing our example above, the children here will be all of

     `int', `double', `float', and `struct S'.  */

  splay_tree GTY((param1_is (int), param2_is (int))) children;

  /* Nonzero if would have a child of zero: this effectively makes this

     alias set the same as alias set zero.  */

  int has_zero_child;

};

typedef struct alias_set_entry *alias_set_entry;

static int rtx_equal_for_memref_p (rtx, rtx);

static rtx find_symbolic_term (rtx);

static int memrefs_conflict_p (int, rtx, int, rtx, HOST_WIDE_INT);

static void record_set (rtx, rtx, void *);

static int base_alias_check (rtx, rtx, enum machine_mode,

                             enum machine_mode);

static rtx find_base_value (rtx);

static int mems_in_disjoint_alias_sets_p (rtx, rtx);

static int insert_subset_children (splay_tree_node, void*);

static tree find_base_decl (tree);

static alias_set_entry get_alias_set_entry (HOST_WIDE_INT);

static rtx fixed_scalar_and_varying_struct_p (rtx, rtx, rtx, rtx,

                                              int (*) (rtx, int));

static int aliases_everything_p (rtx);

static bool nonoverlapping_component_refs_p (tree, tree);

static tree decl_for_component_ref (tree);

static rtx adjust_offset_for_component_ref (tree, rtx);

static int nonoverlapping_memrefs_p (rtx, rtx);

static int write_dependence_p (rtx, rtx, int);

static void memory_modified_1 (rtx, rtx, void *);

static void record_alias_subset (HOST_WIDE_INT, HOST_WIDE_INT);

/* Set up all info needed to perform alias analysis on memory references.  */

/* Returns the size in bytes of the mode of X.  */

#define SIZE_FOR_MODE(X) (GET_MODE_SIZE (GET_MODE (X)))

/* Returns nonzero if MEM1 and MEM2 do not alias because they are in

   different alias sets.  We ignore alias sets in functions making use

   of variable arguments because the va_arg macros on some systems are

   not legal ANSI C.  */

#define DIFFERENT_ALIAS_SETS_P(MEM1, MEM2)                      \

  mems_in_disjoint_alias_sets_p (MEM1, MEM2)

/* Cap the number of passes we make over the insns propagating alias

   information through set chains.   10 is a completely arbitrary choice.  */

#define MAX_ALIAS_LOOP_PASSES 10

/* reg_base_value[N] gives an address to which register N is related.

   If all sets after the first add or subtract to the current value

   or otherwise modify it so it does not point to a different top level

   object, reg_base_value[N] is equal to the address part of the source

   of the first set.

   A base address can be an ADDRESS, SYMBOL_REF, or LABEL_REF.  ADDRESS

   expressions represent certain special values: function arguments and

   the stack, frame, and argument pointers.

   The contents of an ADDRESS is not normally used, the mode of the

   ADDRESS determines whether the ADDRESS is a function argument or some

   other special value.  Pointer equality, not rtx_equal_p, determines whether

   two ADDRESS expressions refer to the same base address.

   The only use of the contents of an ADDRESS is for determining if the

   current function performs nonlocal memory memory references for the

   purposes of marking the function as a constant function.  */

static GTY(()) varray_type reg_base_value;

static rtx *new_reg_base_value;

/* We preserve the copy of old array around to avoid amount of garbage

   produced.  About 8% of garbage produced were attributed to this

   array.  */

static GTY((deletable)) varray_type old_reg_base_value;

/* Static hunks of RTL used by the aliasing code; these are initialized

   once per function to avoid unnecessary RTL allocations.  */

static GTY (()) rtx static_reg_base_value[FIRST_PSEUDO_REGISTER];

#define REG_BASE_VALUE(X) \

  (reg_base_value && REGNO (X) < VARRAY_SIZE (reg_base_value) \

   ? VARRAY_RTX (reg_base_value, REGNO (X)) : 0)

/* Vector of known invariant relationships between registers.  Set in

   loop unrolling.  Indexed by register number, if nonzero the value

   is an expression describing this register in terms of another.

   The length of this array is REG_BASE_VALUE_SIZE.

   Because this array contains only pseudo registers it has no effect

   after reload.  */

static GTY((length("alias_invariant_size"))) rtx *alias_invariant;

static GTY(()) unsigned int alias_invariant_size;

/* Vector indexed by N giving the initial (unchanging) value known for

   pseudo-register N.  This array is initialized in init_alias_analysis,

   and does not change until end_alias_analysis is called.  */

static GTY((length("reg_known_value_size"))) rtx *reg_known_value;

/* Indicates number of valid entries in reg_known_value.  */

static GTY(()) unsigned int reg_known_value_size;

/* Vector recording for each reg_known_value whether it is due to a

   REG_EQUIV note.  Future passes (viz., reload) may replace the

   pseudo with the equivalent expression and so we account for the

   dependences that would be introduced if that happens.

   The REG_EQUIV notes created in assign_parms may mention the arg

   pointer, and there are explicit insns in the RTL that modify the

   arg pointer.  Thus we must ensure that such insns don't get

   scheduled across each other because that would invalidate the

   REG_EQUIV notes.  One could argue that the REG_EQUIV notes are

   wrong, but solving the problem in the scheduler will likely give

   better code, so we do it here.  */

static bool *reg_known_equiv_p;

/* True when scanning insns from the start of the rtl to the

   NOTE_INSN_FUNCTION_BEG note.  */

static bool copying_arguments;

/* The splay-tree used to store the various alias set entries.  */

static GTY ((param_is (struct alias_set_entry))) varray_type alias_sets;

/* Returns a pointer to the alias set entry for ALIAS_SET, if there is

   such an entry, or NULL otherwise.  */

static inline alias_set_entry

get_alias_set_entry (HOST_WIDE_INT alias_set)

{

  return (alias_set_entry)VARRAY_GENERIC_PTR (alias_sets, alias_set);

}

/* Returns nonzero if the alias sets for MEM1 and MEM2 are such that

   the two MEMs cannot alias each other.  */

static inline int

mems_in_disjoint_alias_sets_p (rtx mem1, rtx mem2)

{

/* Perform a basic sanity check.  Namely, that there are no alias sets

   if we're not using strict aliasing.  This helps to catch bugs

   whereby someone uses PUT_CODE, but doesn't clear MEM_ALIAS_SET, or

   where a MEM is allocated in some way other than by the use of

   gen_rtx_MEM, and the MEM_ALIAS_SET is not cleared.  If we begin to

   use alias sets to indicate that spilled registers cannot alias each

   other, we might need to remove this check.  */

  gcc_assert (flag_strict_aliasing

              || (!MEM_ALIAS_SET (mem1) && !MEM_ALIAS_SET (mem2)));

  return ! alias_sets_conflict_p (MEM_ALIAS_SET (mem1), MEM_ALIAS_SET (mem2));

}

/* Insert the NODE into the splay tree given by DATA.  Used by

   record_alias_subset via splay_tree_foreach.  */

static int

insert_subset_children (splay_tree_node node, void *data)

{

  splay_tree_insert ((splay_tree) data, node->key, node->value);

  return 0;

}

/* Return 1 if the two specified alias sets may conflict.  */

int

alias_sets_conflict_p (HOST_WIDE_INT set1, HOST_WIDE_INT set2)

{

  alias_set_entry ase;

  /* If have no alias set information for one of the operands, we have

     to assume it can alias anything.  */

  if (set1 == 0 || set2 == 0

      /* If the two alias sets are the same, they may alias.  */

      || set1 == set2)

    return 1;

  /* See if the first alias set is a subset of the second.  */

  ase = get_alias_set_entry (set1);

  if (ase != 0

      && (ase->has_zero_child

          || splay_tree_lookup (ase->children,

                                (splay_tree_key) set2)))

    return 1;

  /* Now do the same, but with the alias sets reversed.  */

  ase = get_alias_set_entry (set2);

  if (ase != 0

      && (ase->has_zero_child

          || splay_tree_lookup (ase->children,

                                (splay_tree_key) set1)))

    return 1;

  /* The two alias sets are distinct and neither one is the

     child of the other.  Therefore, they cannot alias.  */

  return 0;

}

/* Return 1 if the two specified alias sets might conflict, or if any subtype

   of these alias sets might conflict.  */

int

alias_sets_might_conflict_p (HOST_WIDE_INT set1, HOST_WIDE_INT set2)

{

  if (set1 == 0 || set2 == 0 || set1 == set2)

    return 1;

  return 0;

}

/* Return 1 if any MEM object of type T1 will always conflict (using the

   dependency routines in this file) with any MEM object of type T2.

   This is used when allocating temporary storage.  If T1 and/or T2 are

   NULL_TREE, it means we know nothing about the storage.  */

int

objects_must_conflict_p (tree t1, tree t2)

{

  HOST_WIDE_INT set1, set2;

  /* If neither has a type specified, we don't know if they'll conflict

     because we may be using them to store objects of various types, for

     example the argument and local variables areas of inlined functions.  */

  if (t1 == 0 && t2 == 0)

    return 0;

  /* If they are the same type, they must conflict.  */

  if (t1 == t2

      /* Likewise if both are volatile.  */

      || (t1 != 0 && TYPE_VOLATILE (t1) && t2 != 0 && TYPE_VOLATILE (t2)))

    return 1;

  set1 = t1 ? get_alias_set (t1) : 0;

  set2 = t2 ? get_alias_set (t2) : 0;

  /* Otherwise they conflict if they have no alias set or the same. We

     can't simply use alias_sets_conflict_p here, because we must make

     sure that every subtype of t1 will conflict with every subtype of

     t2 for which a pair of subobjects of these respective subtypes

     overlaps on the stack.  */

  return set1 == 0 || set2 == 0 || set1 == set2;

}

/* T is an expression with pointer type.  Find the DECL on which this

   expression is based.  (For example, in `a[i]' this would be `a'.)

   If there is no such DECL, or a unique decl cannot be determined,

   NULL_TREE is returned.  */

static tree

find_base_decl (tree t)

{

  tree d0, d1;

  if (t == 0 || t == error_mark_node || ! POINTER_TYPE_P (TREE_TYPE (t)))

    return 0;

  /* If this is a declaration, return it.  If T is based on a restrict

     qualified decl, return that decl.  */

  if (DECL_P (t))

    {

      if (TREE_CODE (t) == VAR_DECL && DECL_BASED_ON_RESTRICT_P (t))

        t = DECL_GET_RESTRICT_BASE (t);

      return t;

    }

  /* Handle general expressions.  It would be nice to deal with

     COMPONENT_REFs here.  If we could tell that `a' and `b' were the

     same, then `a->f' and `b->f' are also the same.  */

  switch (TREE_CODE_CLASS (TREE_CODE (t)))

    {

    case tcc_unary:

      return find_base_decl (TREE_OPERAND (t, 0));

    case tcc_binary:

      /* Return 0 if found in neither or both are the same.  */

      d0 = find_base_decl (TREE_OPERAND (t, 0));

      d1 = find_base_decl (TREE_OPERAND (t, 1));

      if (d0 == d1)

        return d0;

      else if (d0 == 0)

        return d1;

      else if (d1 == 0)

        return d0;

      else

        return 0;

    default:

      return 0;

    }

}

/* Return true if all nested component references handled by

   get_inner_reference in T are such that we should use the alias set

   provided by the object at the heart of T.

   This is true for non-addressable components (which don't have their

   own alias set), as well as components of objects in alias set zero.

   This later point is a special case wherein we wish to override the

   alias set used by the component, but we don't have per-FIELD_DECL

   assignable alias sets.  */

bool

component_uses_parent_alias_set (tree t)

{

  while (1)

    {

      /* If we're at the end, it vacuously uses its own alias set.  */

      if (!handled_component_p (t))

        return false;

      switch (TREE_CODE (t))

        {

        case COMPONENT_REF:

          if (DECL_NONADDRESSABLE_P (TREE_OPERAND (t, 1)))

            return true;

          break;

        case ARRAY_REF:

        case ARRAY_RANGE_REF:

          if (TYPE_NONALIASED_COMPONENT (TREE_TYPE (TREE_OPERAND (t, 0))))

            return true;

          break;

        case REALPART_EXPR:

        case IMAGPART_EXPR:

          break;

        default:

          /* Bitfields and casts are never addressable.  */

          return true;

        }

      t = TREE_OPERAND (t, 0);

      if (get_alias_set (TREE_TYPE (t)) == 0)

        return true;

    }

}

/* Return the alias set for T, which may be either a type or an

   expression.  Call language-specific routine for help, if needed.  */

HOST_WIDE_INT

get_alias_set (tree t)

{

  HOST_WIDE_INT set;

  /* If we're not doing any alias analysis, just assume everything

     aliases everything else.  Also return 0 if this or its type is

     an error.  */

  if (! flag_strict_aliasing || t == error_mark_node

      || (! TYPE_P (t)

          && (TREE_TYPE (t) == 0 || TREE_TYPE (t) == error_mark_node)))

    return 0;

  /* We can be passed either an expression or a type.  This and the

     language-specific routine may make mutually-recursive calls to each other

     to figure out what to do.  At each juncture, we see if this is a tree

     that the language may need to handle specially.  First handle things that

     aren't types.  */

  if (! TYPE_P (t))

    {

      tree inner = t;

      /* Remove any nops, then give the language a chance to do

         something with this tree before we look at it.  */

      STRIP_NOPS (t);

      set = lang_hooks.get_alias_set (t);

      if (set != -1)

        return set;

      /* First see if the actual object referenced is an INDIRECT_REF from a

         restrict-qualified pointer or a "void *".  */

      while (handled_component_p (inner))

        {

          inner = TREE_OPERAND (inner, 0);

          STRIP_NOPS (inner);

        }

      /* Check for accesses through restrict-qualified pointers.  */

      if (INDIRECT_REF_P (inner))

        {

          tree decl = find_base_decl (TREE_OPERAND (inner, 0));

          if (decl && DECL_POINTER_ALIAS_SET_KNOWN_P (decl))

            {

              /* If we haven't computed the actual alias set, do it now.  */

              if (DECL_POINTER_ALIAS_SET (decl) == -2)

                {

                  tree pointed_to_type = TREE_TYPE (TREE_TYPE (decl));

                  /* No two restricted pointers can point at the same thing.

                     However, a restricted pointer can point at the same thing

                     as an unrestricted pointer, if that unrestricted pointer

                     is based on the restricted pointer.  So, we make the

                     alias set for the restricted pointer a subset of the

                     alias set for the type pointed to by the type of the

                     decl.  */

                  HOST_WIDE_INT pointed_to_alias_set

                    = get_alias_set (pointed_to_type);

                  if (pointed_to_alias_set == 0)

                    /* It's not legal to make a subset of alias set zero.  */

                    DECL_POINTER_ALIAS_SET (decl) = 0;

                  else if (AGGREGATE_TYPE_P (pointed_to_type))

                    /* For an aggregate, we must treat the restricted

                       pointer the same as an ordinary pointer.  If we

                       were to make the type pointed to by the

                       restricted pointer a subset of the pointed-to

                       type, then we would believe that other subsets

                       of the pointed-to type (such as fields of that

                       type) do not conflict with the type pointed to

                       by the restricted pointer.  */

                    DECL_POINTER_ALIAS_SET (decl)

                      = pointed_to_alias_set;

                  else

                    {

                      DECL_POINTER_ALIAS_SET (decl) = new_alias_set ();

                      record_alias_subset (pointed_to_alias_set,

                                           DECL_POINTER_ALIAS_SET (decl));

                    }

                }

              /* We use the alias set indicated in the declaration.  */

              return DECL_POINTER_ALIAS_SET (decl);

            }

          /* If we have an INDIRECT_REF via a void pointer, we don't

             know anything about what that might alias.  Likewise if the

             pointer is marked that way.  */

          else if (TREE_CODE (TREE_TYPE (inner)) == VOID_TYPE

                   || (TYPE_REF_CAN_ALIAS_ALL

                       (TREE_TYPE (TREE_OPERAND (inner, 0)))))

            return 0;

        }

      /* Otherwise, pick up the outermost object that we could have a pointer

         to, processing conversions as above.  */

      while (component_uses_parent_alias_set (t))

        {

          t = TREE_OPERAND (t, 0);

          STRIP_NOPS (t);

        }

      /* If we've already determined the alias set for a decl, just return

         it.  This is necessary for C++ anonymous unions, whose component

         variables don't look like union members (boo!).  */

      if (TREE_CODE (t) == VAR_DECL

          && DECL_RTL_SET_P (t) && MEM_P (DECL_RTL (t)))

        return MEM_ALIAS_SET (DECL_RTL (t));

      /* Now all we care about is the type.  */

      t = TREE_TYPE (t);

    }

  /* Variant qualifiers don't affect the alias set, so get the main

     variant. If this is a type with a known alias set, return it.  */

  t = TYPE_MAIN_VARIANT (t);

  if (TYPE_ALIAS_SET_KNOWN_P (t))

    return TYPE_ALIAS_SET (t);

  /* See if the language has special handling for this type.  */

  set = lang_hooks.get_alias_set (t);

  if (set != -1)

    return set;

  /* There are no objects of FUNCTION_TYPE, so there's no point in

     using up an alias set for them.  (There are, of course, pointers

     and references to functions, but that's different.)  */

  else if (TREE_CODE (t) == FUNCTION_TYPE)

    set = 0;

  /* Unless the language specifies otherwise, let vector types alias

     their components.  This avoids some nasty type punning issues in

     normal usage.  And indeed lets vectors be treated more like an

     array slice.  */

  else if (TREE_CODE (t) == VECTOR_TYPE)

    set = get_alias_set (TREE_TYPE (t));

  else

    /* Otherwise make a new alias set for this type.  */

    set = new_alias_set ();

  TYPE_ALIAS_SET (t) = set;

  /* If this is an aggregate type, we must record any component aliasing

     information.  */

  if (AGGREGATE_TYPE_P (t) || TREE_CODE (t) == COMPLEX_TYPE)

    record_component_aliases (t);

  return set;

}

/* Return a brand-new alias set.  */

static GTY(()) HOST_WIDE_INT last_alias_set;

HOST_WIDE_INT

new_alias_set (void)

{

  if (flag_strict_aliasing)

    {

      if (!alias_sets)

        VARRAY_GENERIC_PTR_INIT (alias_sets, 10, "alias sets");

      else

        VARRAY_GROW (alias_sets, last_alias_set + 2);

      return ++last_alias_set;

    }

  else

    return 0;

}

/* Indicate that things in SUBSET can alias things in SUPERSET, but that

   not everything that aliases SUPERSET also aliases SUBSET.  For example,

   in C, a store to an `int' can alias a load of a structure containing an

   `int', and vice versa.  But it can't alias a load of a 'double' member

   of the same structure.  Here, the structure would be the SUPERSET and

   `int' the SUBSET.  This relationship is also described in the comment at

   the beginning of this file.

   This function should be called only once per SUPERSET/SUBSET pair.

   It is illegal for SUPERSET to be zero; everything is implicitly a

   subset of alias set zero.  */

static void

record_alias_subset (HOST_WIDE_INT superset, HOST_WIDE_INT subset)

{

  alias_set_entry superset_entry;

  alias_set_entry subset_entry;

  /* It is possible in complex type situations for both sets to be the same,

     in which case we can ignore this operation.  */

  if (superset == subset)

    return;

  gcc_assert (superset);

  superset_entry = get_alias_set_entry (superset);

  if (superset_entry == 0)

    {

      /* Create an entry for the SUPERSET, so that we have a place to

         attach the SUBSET.  */

      superset_entry = ggc_alloc (sizeof (struct alias_set_entry));

      superset_entry->alias_set = superset;

      superset_entry->children

        = splay_tree_new_ggc (splay_tree_compare_ints);

      superset_entry->has_zero_child = 0;

      VARRAY_GENERIC_PTR (alias_sets, superset) = superset_entry;

    }

  if (subset == 0)

    superset_entry->has_zero_child = 1;

  else

    {

      subset_entry = get_alias_set_entry (subset);

      /* If there is an entry for the subset, enter all of its children

         (if they are not already present) as children of the SUPERSET.  */

      if (subset_entry)

        {

          if (subset_entry->has_zero_child)

            superset_entry->has_zero_child = 1;

          splay_tree_foreach (subset_entry->children, insert_subset_children,

                              superset_entry->children);

        }

      /* Enter the SUBSET itself as a child of the SUPERSET.  */

      splay_tree_insert (superset_entry->children,

                         (splay_tree_key) subset, 0);

    }

}

/* Record that component types of TYPE, if any, are part of that type for

   aliasing purposes.  For record types, we only record component types

   for fields that are marked addressable.  For array types, we always

   record the component types, so the front end should not call this

   function if the individual component aren't addressable.  */

void

record_component_aliases (tree type)

{

  HOST_WIDE_INT superset = get_alias_set (type);

  tree field;

  if (superset == 0)

    return;

  switch (TREE_CODE (type))

    {

    case ARRAY_TYPE:

      if (! TYPE_NONALIASED_COMPONENT (type))

        record_alias_subset (superset, get_alias_set (TREE_TYPE (type)));

      break;

    case RECORD_TYPE:

    case UNION_TYPE:

    case QUAL_UNION_TYPE:

      /* Recursively record aliases for the base classes, if there are any.  */

      if (TYPE_BINFO (type))

        {

          int i;

          tree binfo, base_binfo;

          for (binfo = TYPE_BINFO (type), i = 0;

               BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)

            record_alias_subset (superset,

                                 get_alias_set (BINFO_TYPE (base_binfo)));

        }

      for (field = TYPE_FIELDS (type); field != 0; field = TREE_CHAIN (field))

        if (TREE_CODE (field) == FIELD_DECL && ! DECL_NONADDRESSABLE_P (field))

          record_alias_subset (superset, get_alias_set (TREE_TYPE (field)));