Subversion Repositories scarts

/* Language-dependent node constructors for parse phase of GNU compiler.

   Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,

   1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.

   Hacked by Michael Tiemann (tiemann@cygnus.com)

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 "cp-tree.h"

#include "flags.h"

#include "real.h"

#include "rtl.h"

#include "toplev.h"

#include "insn-config.h"

#include "integrate.h"

#include "tree-inline.h"

#include "debug.h"

#include "target.h"

static tree bot_manip (tree *, int *, void *);

static tree bot_replace (tree *, int *, void *);

static tree build_cplus_array_type_1 (tree, tree);

static int list_hash_eq (const void *, const void *);

static hashval_t list_hash_pieces (tree, tree, tree);

static hashval_t list_hash (const void *);

static cp_lvalue_kind lvalue_p_1 (tree, int);

static tree build_target_expr (tree, tree);

static tree count_trees_r (tree *, int *, void *);

static tree verify_stmt_tree_r (tree *, int *, void *);

static tree find_tree_r (tree *, int *, void *);

static tree build_local_temp (tree);

static tree handle_java_interface_attribute (tree *, tree, tree, int, bool *);

static tree handle_com_interface_attribute (tree *, tree, tree, int, bool *);

static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *);

/* If REF is an lvalue, returns the kind of lvalue that REF is.

   Otherwise, returns clk_none.  If TREAT_CLASS_RVALUES_AS_LVALUES is

   nonzero, rvalues of class type are considered lvalues.  */

static cp_lvalue_kind

lvalue_p_1 (tree ref,

            int treat_class_rvalues_as_lvalues)

{

  cp_lvalue_kind op1_lvalue_kind = clk_none;

  cp_lvalue_kind op2_lvalue_kind = clk_none;

  if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)

    return clk_ordinary;

  if (ref == current_class_ptr)

    return clk_none;

  switch (TREE_CODE (ref))

    {

      /* preincrements and predecrements are valid lvals, provided

         what they refer to are valid lvals.  */

    case PREINCREMENT_EXPR:

    case PREDECREMENT_EXPR:

    case SAVE_EXPR:

    case TRY_CATCH_EXPR:

    case WITH_CLEANUP_EXPR:

    case REALPART_EXPR:

    case IMAGPART_EXPR:

      return lvalue_p_1 (TREE_OPERAND (ref, 0),

                         treat_class_rvalues_as_lvalues);

    case COMPONENT_REF:

      op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0),

                                    treat_class_rvalues_as_lvalues);

      /* Look at the member designator.  */

      if (!op1_lvalue_kind

          /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some

             situations.  */

          || TREE_CODE (TREE_OPERAND (ref, 1)) != FIELD_DECL)

        ;

      else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref, 1)))

        {

          /* Clear the ordinary bit.  If this object was a class

             rvalue we want to preserve that information.  */

          op1_lvalue_kind &= ~clk_ordinary;

          /* The lvalue is for a bitfield.  */

          op1_lvalue_kind |= clk_bitfield;

        }

      else if (DECL_PACKED (TREE_OPERAND (ref, 1)))

        op1_lvalue_kind |= clk_packed;

      return op1_lvalue_kind;

    case STRING_CST:

      return clk_ordinary;

    case CONST_DECL:

    case VAR_DECL:

      if (TREE_READONLY (ref) && ! TREE_STATIC (ref)

          && DECL_LANG_SPECIFIC (ref)

          && DECL_IN_AGGR_P (ref))

        return clk_none;

    case INDIRECT_REF:

    case ARRAY_REF:

    case PARM_DECL:

    case RESULT_DECL:

      if (TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)

        return clk_ordinary;

      break;

      /* A currently unresolved scope ref.  */

    case SCOPE_REF:

      gcc_unreachable ();

    case MAX_EXPR:

    case MIN_EXPR:

      /* Disallow <? and >? as lvalues if either argument side-effects.  */

      if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 0))

          || TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 1)))

        return clk_none;

      op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0),

                                    treat_class_rvalues_as_lvalues);

      op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1),

                                    treat_class_rvalues_as_lvalues);

      break;

    case COND_EXPR:

      op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1),

                                    treat_class_rvalues_as_lvalues);

      op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 2),

                                    treat_class_rvalues_as_lvalues);

      break;

    case MODIFY_EXPR:

      return clk_ordinary;

    case COMPOUND_EXPR:

      return lvalue_p_1 (TREE_OPERAND (ref, 1),

                         treat_class_rvalues_as_lvalues);

    case TARGET_EXPR:

      return treat_class_rvalues_as_lvalues ? clk_class : clk_none;

    case VA_ARG_EXPR:

      return (treat_class_rvalues_as_lvalues

              && CLASS_TYPE_P (TREE_TYPE (ref))

              ? clk_class : clk_none);

    case CALL_EXPR:

      /* Any class-valued call would be wrapped in a TARGET_EXPR.  */

      return clk_none;

    case FUNCTION_DECL:

      /* All functions (except non-static-member functions) are

         lvalues.  */

      return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref)

              ? clk_none : clk_ordinary);

    case NON_DEPENDENT_EXPR:

      /* We must consider NON_DEPENDENT_EXPRs to be lvalues so that

         things like "&E" where "E" is an expression with a

         non-dependent type work. It is safe to be lenient because an

         error will be issued when the template is instantiated if "E"

         is not an lvalue.  */

      return clk_ordinary;

    default:

      break;

    }

  /* If one operand is not an lvalue at all, then this expression is

     not an lvalue.  */

  if (!op1_lvalue_kind || !op2_lvalue_kind)

    return clk_none;

  /* Otherwise, it's an lvalue, and it has all the odd properties

     contributed by either operand.  */

  op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind;

  /* It's not an ordinary lvalue if it involves either a bit-field or

     a class rvalue.  */

  if ((op1_lvalue_kind & ~clk_ordinary) != clk_none)

    op1_lvalue_kind &= ~clk_ordinary;

  return op1_lvalue_kind;

}

/* Returns the kind of lvalue that REF is, in the sense of

   [basic.lval].  This function should really be named lvalue_p; it

   computes the C++ definition of lvalue.  */

cp_lvalue_kind

real_lvalue_p (tree ref)

{

  return lvalue_p_1 (ref,

                     /*treat_class_rvalues_as_lvalues=*/0);

}

/* This differs from real_lvalue_p in that class rvalues are

   considered lvalues.  */

int

lvalue_p (tree ref)

{

  return

    (lvalue_p_1 (ref, /*class rvalue ok*/ 1) != clk_none);

}

/* Test whether DECL is a builtin that may appear in a

   constant-expression. */

bool

builtin_valid_in_constant_expr_p (tree decl)

{

  /* At present BUILT_IN_CONSTANT_P is the only builtin we're allowing

     in constant-expressions.  We may want to add other builtins later. */

  return DECL_IS_BUILTIN_CONSTANT_P (decl);

}

/* Build a TARGET_EXPR, initializing the DECL with the VALUE.  */

static tree

build_target_expr (tree decl, tree value)

{

  tree t;

  t = build4 (TARGET_EXPR, TREE_TYPE (decl), decl, value,

              cxx_maybe_build_cleanup (decl), NULL_TREE);

  /* We always set TREE_SIDE_EFFECTS so that expand_expr does not

     ignore the TARGET_EXPR.  If there really turn out to be no

     side-effects, then the optimizer should be able to get rid of

     whatever code is generated anyhow.  */

  TREE_SIDE_EFFECTS (t) = 1;

  return t;

}

/* Return an undeclared local temporary of type TYPE for use in building a

   TARGET_EXPR.  */

static tree

build_local_temp (tree type)

{

  tree slot = build_decl (VAR_DECL, NULL_TREE, type);

  DECL_ARTIFICIAL (slot) = 1;

  DECL_IGNORED_P (slot) = 1;

  DECL_CONTEXT (slot) = current_function_decl;

  layout_decl (slot, 0);

  return slot;

}

/* INIT is a CALL_EXPR which needs info about its target.

   TYPE is the type that this initialization should appear to have.

   Build an encapsulation of the initialization to perform

   and return it so that it can be processed by language-independent

   and language-specific expression expanders.  */

tree

build_cplus_new (tree type, tree init)

{

  tree fn;

  tree slot;

  tree rval;

  int is_ctor;

  /* Make sure that we're not trying to create an instance of an

     abstract class.  */

  abstract_virtuals_error (NULL_TREE, type);

  if (TREE_CODE (init) != CALL_EXPR && TREE_CODE (init) != AGGR_INIT_EXPR)

    return convert (type, init);

  fn = TREE_OPERAND (init, 0);

  is_ctor = (TREE_CODE (fn) == ADDR_EXPR

             && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL

             && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0)));

  slot = build_local_temp (type);

  /* We split the CALL_EXPR into its function and its arguments here.

     Then, in expand_expr, we put them back together.  The reason for

     this is that this expression might be a default argument

     expression.  In that case, we need a new temporary every time the

     expression is used.  That's what break_out_target_exprs does; it

     replaces every AGGR_INIT_EXPR with a copy that uses a fresh

     temporary slot.  Then, expand_expr builds up a call-expression

     using the new slot.  */

  /* If we don't need to use a constructor to create an object of this

     type, don't mess with AGGR_INIT_EXPR.  */

  if (is_ctor || TREE_ADDRESSABLE (type))

    {

      rval = build3 (AGGR_INIT_EXPR, void_type_node, fn,

                     TREE_OPERAND (init, 1), slot);

      TREE_SIDE_EFFECTS (rval) = 1;

      AGGR_INIT_VIA_CTOR_P (rval) = is_ctor;

    }

  else

    rval = init;

  rval = build_target_expr (slot, rval);

  return rval;

}

/* Build a TARGET_EXPR using INIT to initialize a new temporary of the

   indicated TYPE.  */

tree

build_target_expr_with_type (tree init, tree type)

{

  tree slot;

  gcc_assert (!VOID_TYPE_P (type));

  if (TREE_CODE (init) == TARGET_EXPR)

    return init;

  else if (CLASS_TYPE_P (type) && !TYPE_HAS_TRIVIAL_INIT_REF (type)

           && TREE_CODE (init) != COND_EXPR

           && TREE_CODE (init) != CONSTRUCTOR

           && TREE_CODE (init) != VA_ARG_EXPR)

    /* We need to build up a copy constructor call.  COND_EXPR is a special

       case because we already have copies on the arms and we don't want

       another one here.  A CONSTRUCTOR is aggregate initialization, which

       is handled separately.  A VA_ARG_EXPR is magic creation of an

       aggregate; there's no additional work to be done.  */

    return force_rvalue (init);

  slot = build_local_temp (type);

  return build_target_expr (slot, init);

}

/* Like the above function, but without the checking.  This function should

   only be used by code which is deliberately trying to subvert the type

   system, such as call_builtin_trap.  */

tree

force_target_expr (tree type, tree init)

{

  tree slot;

  gcc_assert (!VOID_TYPE_P (type));

  slot = build_local_temp (type);

  return build_target_expr (slot, init);

}

/* Like build_target_expr_with_type, but use the type of INIT.  */

tree

get_target_expr (tree init)

{

  return build_target_expr_with_type (init, TREE_TYPE (init));

}

/* EXPR is being used in an rvalue context.  Return a version of EXPR

   that is marked as an rvalue.  */

tree

rvalue (tree expr)

{

  tree type;

  if (real_lvalue_p (expr))

    {

      type = TREE_TYPE (expr);

      /* [basic.lval]

         Non-class rvalues always have cv-unqualified types.  */

      if (!CLASS_TYPE_P (type))

        type = TYPE_MAIN_VARIANT (type);

      expr = build1 (NON_LVALUE_EXPR, type, expr);

    }

  return expr;

}

static tree

build_cplus_array_type_1 (tree elt_type, tree index_type)

{

  tree t;

  if (elt_type == error_mark_node || index_type == error_mark_node)

    return error_mark_node;

  if (dependent_type_p (elt_type)

      || (index_type

          && value_dependent_expression_p (TYPE_MAX_VALUE (index_type))))

    {

      t = make_node (ARRAY_TYPE);

      TREE_TYPE (t) = elt_type;

      TYPE_DOMAIN (t) = index_type;

    }

  else

    t = build_array_type (elt_type, index_type);

  /* Push these needs up so that initialization takes place

     more easily.  */

  TYPE_NEEDS_CONSTRUCTING (t)

    = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));

  TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)

    = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));

  return t;

}

tree

build_cplus_array_type (tree elt_type, tree index_type)

{

  tree t;

  int type_quals = cp_type_quals (elt_type);

  if (type_quals != TYPE_UNQUALIFIED)

    elt_type = cp_build_qualified_type (elt_type, TYPE_UNQUALIFIED);

  t = build_cplus_array_type_1 (elt_type, index_type);

  if (type_quals != TYPE_UNQUALIFIED)

    t = cp_build_qualified_type (t, type_quals);

  return t;

}

/* Make a variant of TYPE, qualified with the TYPE_QUALS.  Handles

   arrays correctly.  In particular, if TYPE is an array of T's, and

   TYPE_QUALS is non-empty, returns an array of qualified T's.

   FLAGS determines how to deal with illformed qualifications. If

   tf_ignore_bad_quals is set, then bad qualifications are dropped

   (this is permitted if TYPE was introduced via a typedef or template

   type parameter). If bad qualifications are dropped and tf_warning

   is set, then a warning is issued for non-const qualifications.  If

   tf_ignore_bad_quals is not set and tf_error is not set, we

   return error_mark_node. Otherwise, we issue an error, and ignore

   the qualifications.

   Qualification of a reference type is valid when the reference came

   via a typedef or template type argument. [dcl.ref] No such

   dispensation is provided for qualifying a function type.  [dcl.fct]

   DR 295 queries this and the proposed resolution brings it into line

   with qualifying a reference.  We implement the DR.  We also behave

   in a similar manner for restricting non-pointer types.  */

tree

cp_build_qualified_type_real (tree type,

                              int type_quals,

                              tsubst_flags_t complain)

{

  tree result;

  int bad_quals = TYPE_UNQUALIFIED;

  if (type == error_mark_node)

    return type;

  if (type_quals == cp_type_quals (type))

    return type;

  if (TREE_CODE (type) == ARRAY_TYPE)

    {

      /* In C++, the qualification really applies to the array element

         type.  Obtain the appropriately qualified element type.  */

      tree t;

      tree element_type

        = cp_build_qualified_type_real (TREE_TYPE (type),

                                        type_quals,

                                        complain);

      if (element_type == error_mark_node)

        return error_mark_node;

      /* See if we already have an identically qualified type.  */

      for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))

        if (cp_type_quals (t) == type_quals

            && TYPE_NAME (t) == TYPE_NAME (type)

            && TYPE_CONTEXT (t) == TYPE_CONTEXT (type))

          break;

      if (!t)

        {

          /* Make a new array type, just like the old one, but with the

             appropriately qualified element type.  */

          t = build_variant_type_copy (type);

          TREE_TYPE (t) = element_type;

        }

      /* Even if we already had this variant, we update

         TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case

         they changed since the variant was originally created.

         This seems hokey; if there is some way to use a previous

         variant *without* coming through here,

         TYPE_NEEDS_CONSTRUCTING will never be updated.  */

      TYPE_NEEDS_CONSTRUCTING (t)

        = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));

      TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)

        = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));

      return t;

    }

  else if (TYPE_PTRMEMFUNC_P (type))

    {

      /* For a pointer-to-member type, we can't just return a

         cv-qualified version of the RECORD_TYPE.  If we do, we

         haven't changed the field that contains the actual pointer to

         a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong.  */

      tree t;

      t = TYPE_PTRMEMFUNC_FN_TYPE (type);

      t = cp_build_qualified_type_real (t, type_quals, complain);

      return build_ptrmemfunc_type (t);

    }

  /* A reference or method type shall not be cv qualified.

     [dcl.ref], [dct.fct]  */

  if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)

      && (TREE_CODE (type) == REFERENCE_TYPE

          || TREE_CODE (type) == METHOD_TYPE))

    {

      bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);

      type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);

    }

  /* A restrict-qualified type must be a pointer (or reference)

     to object or incomplete type, or a function type. */

  if ((type_quals & TYPE_QUAL_RESTRICT)

      && TREE_CODE (type) != TEMPLATE_TYPE_PARM

      && TREE_CODE (type) != TYPENAME_TYPE

      && TREE_CODE (type) != FUNCTION_TYPE

      && !POINTER_TYPE_P (type))

    {

      bad_quals |= TYPE_QUAL_RESTRICT;

      type_quals &= ~TYPE_QUAL_RESTRICT;

    }

  if (bad_quals == TYPE_UNQUALIFIED)

    /*OK*/;

  else if (!(complain & (tf_error | tf_ignore_bad_quals)))

    return error_mark_node;

  else

    {

      if (complain & tf_ignore_bad_quals)

        /* We're not going to warn about constifying things that can't

           be constified.  */

        bad_quals &= ~TYPE_QUAL_CONST;

      if (bad_quals)

        {

          tree bad_type = build_qualified_type (ptr_type_node, bad_quals);

          if (!(complain & tf_ignore_bad_quals))

            error ("%qV qualifiers cannot be applied to %qT",

                   bad_type, type);

        }

    }

  /* Retrieve (or create) the appropriately qualified variant.  */

  result = build_qualified_type (type, type_quals);

  /* If this was a pointer-to-method type, and we just made a copy,

     then we need to unshare the record that holds the cached

     pointer-to-member-function type, because these will be distinct

     between the unqualified and qualified types.  */

  if (result != type

      && TREE_CODE (type) == POINTER_TYPE

      && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)

    TYPE_LANG_SPECIFIC (result) = NULL;

  return result;

}

/* Returns the canonical version of TYPE.  In other words, if TYPE is

   a typedef, returns the underlying type.  The cv-qualification of

   the type returned matches the type input; they will always be

   compatible types.  */

tree

canonical_type_variant (tree t)

{

  return cp_build_qualified_type (TYPE_MAIN_VARIANT (t), cp_type_quals (t));

}

/* Makes a copy of BINFO and TYPE, which is to be inherited into a

   graph dominated by T.  If BINFO is NULL, TYPE is a dependent base,

   and we do a shallow copy.  If BINFO is non-NULL, we do a deep copy.

   VIRT indicates whether TYPE is inherited virtually or not.

   IGO_PREV points at the previous binfo of the inheritance graph

   order chain.  The newly copied binfo's TREE_CHAIN forms this

   ordering.

   The CLASSTYPE_VBASECLASSES vector of T is constructed in the

   correct order. That is in the order the bases themselves should be

   constructed in.

   The BINFO_INHERITANCE of a virtual base class points to the binfo

   of the most derived type. ??? We could probably change this so that

   BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence

   remove a field.  They currently can only differ for primary virtual

   virtual bases.  */

tree

copy_binfo (tree binfo, tree type, tree t, tree *igo_prev, int virt)

{

  tree new_binfo;

  if (virt)

    {

      /* See if we've already made this virtual base.  */

      new_binfo = binfo_for_vbase (type, t);

      if (new_binfo)

        return new_binfo;

    }

  new_binfo = make_tree_binfo (binfo ? BINFO_N_BASE_BINFOS (binfo) : 0);

  BINFO_TYPE (new_binfo) = type;

  /* Chain it into the inheritance graph.  */

  TREE_CHAIN (*igo_prev) = new_binfo;

  *igo_prev = new_binfo;

  if (binfo)

    {

      int ix;

      tree base_binfo;

      gcc_assert (!BINFO_DEPENDENT_BASE_P (binfo));

      gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type));

      BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo);

      BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo);

      /* We do not need to copy the accesses, as they are read only.  */

      BINFO_BASE_ACCESSES (new_binfo) = BINFO_BASE_ACCESSES (binfo);

      /* Recursively copy base binfos of BINFO.  */

      for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)

        {

          tree new_base_binfo;

          gcc_assert (!BINFO_DEPENDENT_BASE_P (base_binfo));

          new_base_binfo = copy_binfo (base_binfo, BINFO_TYPE (base_binfo),

                                       t, igo_prev,

                                       BINFO_VIRTUAL_P (base_binfo));

          if (!BINFO_INHERITANCE_CHAIN (new_base_binfo))

            BINFO_INHERITANCE_CHAIN (new_base_binfo) = new_binfo;

          BINFO_BASE_APPEND (new_binfo, new_base_binfo);

        }

    }

  else

    BINFO_DEPENDENT_BASE_P (new_binfo) = 1;

  if (virt)

    {

      /* Push it onto the list after any virtual bases it contains

         will have been pushed.  */

      VEC_quick_push (tree, CLASSTYPE_VBASECLASSES (t), new_binfo);

      BINFO_VIRTUAL_P (new_binfo) = 1;

      BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t);

    }

  return new_binfo;

}

/* Hashing of lists so that we don't make duplicates.

   The entry point is `list_hash_canon'.  */

/* Now here is the hash table.  When recording a list, it is added

   to the slot whose index is the hash code mod the table size.

   Note that the hash table is used for several kinds of lists.

   While all these live in the same table, they are completely independent,

   and the hash code is computed differently for each of these.  */

static GTY ((param_is (union tree_node))) htab_t list_hash_table;

struct list_proxy

{

  tree purpose;

  tree value;

  tree chain;

};

/* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy

   for a node we are thinking about adding).  */

static int

list_hash_eq (const void* entry, const void* data)

{

  tree t = (tree) entry;

  struct list_proxy *proxy = (struct list_proxy *) data;

  return (TREE_VALUE (t) == proxy->value

          && TREE_PURPOSE (t) == proxy->purpose

          && TREE_CHAIN (t) == proxy->chain);

}

/* Compute a hash code for a list (chain of TREE_LIST nodes

   with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the

   TREE_COMMON slots), by adding the hash codes of the individual entries.  */

static hashval_t

list_hash_pieces (tree purpose, tree value, tree chain)

{

  hashval_t hashcode = 0;

  if (chain)

    hashcode += TREE_HASH (chain);

  if (value)

    hashcode += TREE_HASH (value);

  else

    hashcode += 1007;

  if (purpose)

    hashcode += TREE_HASH (purpose);

  else

    hashcode += 1009;

  return hashcode;

}

/* Hash an already existing TREE_LIST.  */

static hashval_t

list_hash (const void* p)