Subversion Repositories openrisc_me

/* Functions related to invoking methods and overloaded functions.

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

   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009

   Free Software Foundation, Inc.

   Contributed by Michael Tiemann (tiemann@cygnus.com) and

   modified by Brendan Kehoe (brendan@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 3, 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 COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

/* High-level class interface.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "tree.h"

#include "cp-tree.h"

#include "output.h"

#include "flags.h"

#include "rtl.h"

#include "toplev.h"

#include "expr.h"

#include "diagnostic.h"

#include "intl.h"

#include "target.h"

#include "convert.h"

#include "langhooks.h"

/* The various kinds of conversion.  */

typedef enum conversion_kind {

  ck_identity,

  ck_lvalue,

  ck_qual,

  ck_std,

  ck_ptr,

  ck_pmem,

  ck_base,

  ck_ref_bind,

  ck_user,

  ck_ambig,

  ck_list,

  ck_aggr,

  ck_rvalue

} conversion_kind;

/* The rank of the conversion.  Order of the enumerals matters; better

   conversions should come earlier in the list.  */

typedef enum conversion_rank {

  cr_identity,

  cr_exact,

  cr_promotion,

  cr_std,

  cr_pbool,

  cr_user,

  cr_ellipsis,

  cr_bad

} conversion_rank;

/* An implicit conversion sequence, in the sense of [over.best.ics].

   The first conversion to be performed is at the end of the chain.

   That conversion is always a cr_identity conversion.  */

typedef struct conversion conversion;

struct conversion {

  /* The kind of conversion represented by this step.  */

  conversion_kind kind;

  /* The rank of this conversion.  */

  conversion_rank rank;

  BOOL_BITFIELD user_conv_p : 1;

  BOOL_BITFIELD ellipsis_p : 1;

  BOOL_BITFIELD this_p : 1;

  BOOL_BITFIELD bad_p : 1;

  /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a

     temporary should be created to hold the result of the

     conversion.  */

  BOOL_BITFIELD need_temporary_p : 1;

  /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion

     from a pointer-to-derived to pointer-to-base is being performed.  */

  BOOL_BITFIELD base_p : 1;

  /* If KIND is ck_ref_bind, true when either an lvalue reference is

     being bound to an lvalue expression or an rvalue reference is

     being bound to an rvalue expression. */

  BOOL_BITFIELD rvaluedness_matches_p: 1;

  BOOL_BITFIELD check_narrowing: 1;

  /* The type of the expression resulting from the conversion.  */

  tree type;

  union {

    /* The next conversion in the chain.  Since the conversions are

       arranged from outermost to innermost, the NEXT conversion will

       actually be performed before this conversion.  This variant is

       used only when KIND is neither ck_identity nor ck_ambig.  */

    conversion *next;

    /* The expression at the beginning of the conversion chain.  This

       variant is used only if KIND is ck_identity or ck_ambig.  */

    tree expr;

    /* The array of conversions for an initializer_list.  */

    conversion **list;

  } u;

  /* The function candidate corresponding to this conversion

     sequence.  This field is only used if KIND is ck_user.  */

  struct z_candidate *cand;

};

#define CONVERSION_RANK(NODE)                   \

  ((NODE)->bad_p ? cr_bad                       \

   : (NODE)->ellipsis_p ? cr_ellipsis           \

   : (NODE)->user_conv_p ? cr_user              \

   : (NODE)->rank)

static struct obstack conversion_obstack;

static bool conversion_obstack_initialized;

static struct z_candidate * tourney (struct z_candidate *);

static int equal_functions (tree, tree);

static int joust (struct z_candidate *, struct z_candidate *, bool);

static int compare_ics (conversion *, conversion *);

static tree build_over_call (struct z_candidate *, int, tsubst_flags_t);

static tree build_java_interface_fn_ref (tree, tree);

#define convert_like(CONV, EXPR, COMPLAIN)                      \

  convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0,             \

                     /*issue_conversion_warnings=*/true,        \

                     /*c_cast_p=*/false, (COMPLAIN))

#define convert_like_with_context(CONV, EXPR, FN, ARGNO, COMPLAIN )     \

  convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0,                   \

                     /*issue_conversion_warnings=*/true,                \

                     /*c_cast_p=*/false, (COMPLAIN))

static tree convert_like_real (conversion *, tree, tree, int, int, bool,

                               bool, tsubst_flags_t);

static void op_error (enum tree_code, enum tree_code, tree, tree,

                      tree, bool);

static VEC(tree,gc) *resolve_args (VEC(tree,gc) *);

static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);

static void print_z_candidate (const char *, struct z_candidate *);

static void print_z_candidates (struct z_candidate *);

static tree build_this (tree);

static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);

static bool any_strictly_viable (struct z_candidate *);

static struct z_candidate *add_template_candidate

        (struct z_candidate **, tree, tree, tree, tree, const VEC(tree,gc) *,

         tree, tree, tree, int, unification_kind_t);

static struct z_candidate *add_template_candidate_real

        (struct z_candidate **, tree, tree, tree, tree, const VEC(tree,gc) *,

         tree, tree, tree, int, tree, unification_kind_t);

static struct z_candidate *add_template_conv_candidate

        (struct z_candidate **, tree, tree, tree, const VEC(tree,gc) *, tree,

         tree, tree);

static void add_builtin_candidates

        (struct z_candidate **, enum tree_code, enum tree_code,

         tree, tree *, int);

static void add_builtin_candidate

        (struct z_candidate **, enum tree_code, enum tree_code,

         tree, tree, tree, tree *, tree *, int);

static bool is_complete (tree);

static void build_builtin_candidate

        (struct z_candidate **, tree, tree, tree, tree *, tree *,

         int);

static struct z_candidate *add_conv_candidate

        (struct z_candidate **, tree, tree, tree, const VEC(tree,gc) *, tree,

         tree);

static struct z_candidate *add_function_candidate

        (struct z_candidate **, tree, tree, tree, const VEC(tree,gc) *, tree,

         tree, int);

static conversion *implicit_conversion (tree, tree, tree, bool, int);

static conversion *standard_conversion (tree, tree, tree, bool, int);

static conversion *reference_binding (tree, tree, tree, bool, int);

static conversion *build_conv (conversion_kind, tree, conversion *);

static conversion *build_list_conv (tree, tree, int);

static bool is_subseq (conversion *, conversion *);

static conversion *maybe_handle_ref_bind (conversion **);

static void maybe_handle_implicit_object (conversion **);

static struct z_candidate *add_candidate

        (struct z_candidate **, tree, tree, const VEC(tree,gc) *, size_t,

         conversion **, tree, tree, int);

static tree source_type (conversion *);

static void add_warning (struct z_candidate *, struct z_candidate *);

static bool reference_compatible_p (tree, tree);

static conversion *convert_class_to_reference (tree, tree, tree, int);

static conversion *direct_reference_binding (tree, conversion *);

static bool promoted_arithmetic_type_p (tree);

static conversion *conditional_conversion (tree, tree);

static char *name_as_c_string (tree, tree, bool *);

static tree prep_operand (tree);

static void add_candidates (tree, const VEC(tree,gc) *, tree, bool, tree, tree,

                            int, struct z_candidate **);

static conversion *merge_conversion_sequences (conversion *, conversion *);

static bool magic_varargs_p (tree);

static tree build_temp (tree, tree, int, diagnostic_t *);

/* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.

   NAME can take many forms...  */

bool

check_dtor_name (tree basetype, tree name)

{

  /* Just accept something we've already complained about.  */

  if (name == error_mark_node)

    return true;

  if (TREE_CODE (name) == TYPE_DECL)

    name = TREE_TYPE (name);

  else if (TYPE_P (name))

    /* OK */;

  else if (TREE_CODE (name) == IDENTIFIER_NODE)

    {

      if ((MAYBE_CLASS_TYPE_P (basetype)

           && name == constructor_name (basetype))

          || (TREE_CODE (basetype) == ENUMERAL_TYPE

              && name == TYPE_IDENTIFIER (basetype)))

        return true;

      else

        name = get_type_value (name);

    }

  else

    {

      /* In the case of:

         template <class T> struct S { ~S(); };

         int i;

         i.~S();

         NAME will be a class template.  */

      gcc_assert (DECL_CLASS_TEMPLATE_P (name));

      return false;

    }

  if (!name || name == error_mark_node)

    return false;

  return same_type_p (TYPE_MAIN_VARIANT (basetype), TYPE_MAIN_VARIANT (name));

}

/* We want the address of a function or method.  We avoid creating a

   pointer-to-member function.  */

tree

build_addr_func (tree function)

{

  tree type = TREE_TYPE (function);

  /* We have to do these by hand to avoid real pointer to member

     functions.  */

  if (TREE_CODE (type) == METHOD_TYPE)

    {

      if (TREE_CODE (function) == OFFSET_REF)

        {

          tree object = build_address (TREE_OPERAND (function, 0));

          return get_member_function_from_ptrfunc (&object,

                                                   TREE_OPERAND (function, 1));

        }

      function = build_address (function);

    }

  else

    function = decay_conversion (function);

  return function;

}

/* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or

   POINTER_TYPE to those.  Note, pointer to member function types

   (TYPE_PTRMEMFUNC_P) must be handled by our callers.  There are

   two variants.  build_call_a is the primitive taking an array of

   arguments, while build_call_n is a wrapper that handles varargs.  */

tree

build_call_n (tree function, int n, ...)

{

  if (n == 0)

    return build_call_a (function, 0, NULL);

  else

    {

      tree *argarray = (tree *) alloca (n * sizeof (tree));

      va_list ap;

      int i;

      va_start (ap, n);

      for (i = 0; i < n; i++)

        argarray[i] = va_arg (ap, tree);

      va_end (ap);

      return build_call_a (function, n, argarray);

    }

}

tree

build_call_a (tree function, int n, tree *argarray)

{

  int is_constructor = 0;

  int nothrow;

  tree decl;

  tree result_type;

  tree fntype;

  int i;

  function = build_addr_func (function);

  gcc_assert (TYPE_PTR_P (TREE_TYPE (function)));

  fntype = TREE_TYPE (TREE_TYPE (function));

  gcc_assert (TREE_CODE (fntype) == FUNCTION_TYPE

              || TREE_CODE (fntype) == METHOD_TYPE);

  result_type = TREE_TYPE (fntype);

  /* An rvalue has no cv-qualifiers.  */

  if (SCALAR_TYPE_P (result_type) || VOID_TYPE_P (result_type))

    result_type = cv_unqualified (result_type);

  if (TREE_CODE (function) == ADDR_EXPR

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

    {

      decl = TREE_OPERAND (function, 0);

      if (!TREE_USED (decl))

        {

          /* We invoke build_call directly for several library

             functions.  These may have been declared normally if

             we're building libgcc, so we can't just check

             DECL_ARTIFICIAL.  */

          gcc_assert (DECL_ARTIFICIAL (decl)

                      || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)),

                                   "__", 2));

          mark_used (decl);

        }

    }

  else

    decl = NULL_TREE;

  /* We check both the decl and the type; a function may be known not to

     throw without being declared throw().  */

  nothrow = ((decl && TREE_NOTHROW (decl))

             || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));

  if (decl && TREE_THIS_VOLATILE (decl) && cfun && cp_function_chain)

    current_function_returns_abnormally = 1;

  if (decl && TREE_DEPRECATED (decl))

    warn_deprecated_use (decl, NULL_TREE);

  require_complete_eh_spec_types (fntype, decl);

  if (decl && DECL_CONSTRUCTOR_P (decl))

    is_constructor = 1;

  /* Don't pass empty class objects by value.  This is useful

     for tags in STL, which are used to control overload resolution.

     We don't need to handle other cases of copying empty classes.  */

  if (! decl || ! DECL_BUILT_IN (decl))

    for (i = 0; i < n; i++)

      if (is_empty_class (TREE_TYPE (argarray[i]))

          && ! TREE_ADDRESSABLE (TREE_TYPE (argarray[i])))

        {

          tree t = build0 (EMPTY_CLASS_EXPR, TREE_TYPE (argarray[i]));

          argarray[i] = build2 (COMPOUND_EXPR, TREE_TYPE (t),

                                argarray[i], t);

        }

  function = build_call_array_loc (input_location,

                                   result_type, function, n, argarray);

  TREE_HAS_CONSTRUCTOR (function) = is_constructor;

  TREE_NOTHROW (function) = nothrow;

  return function;

}

/* Build something of the form ptr->method (args)

   or object.method (args).  This can also build

   calls to constructors, and find friends.

   Member functions always take their class variable

   as a pointer.

   INSTANCE is a class instance.

   NAME is the name of the method desired, usually an IDENTIFIER_NODE.

   PARMS help to figure out what that NAME really refers to.

   BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE

   down to the real instance type to use for access checking.  We need this

   information to get protected accesses correct.

   FLAGS is the logical disjunction of zero or more LOOKUP_

   flags.  See cp-tree.h for more info.

   If this is all OK, calls build_function_call with the resolved

   member function.

   This function must also handle being called to perform

   initialization, promotion/coercion of arguments, and

   instantiation of default parameters.

   Note that NAME may refer to an instance variable name.  If

   `operator()()' is defined for the type of that field, then we return

   that result.  */

/* New overloading code.  */

typedef struct z_candidate z_candidate;

typedef struct candidate_warning candidate_warning;

struct candidate_warning {

  z_candidate *loser;

  candidate_warning *next;

};

struct z_candidate {

  /* The FUNCTION_DECL that will be called if this candidate is

     selected by overload resolution.  */

  tree fn;

  /* If not NULL_TREE, the first argument to use when calling this

     function.  */

  tree first_arg;

  /* The rest of the arguments to use when calling this function.  If

     there are no further arguments this may be NULL or it may be an

     empty vector.  */

  const VEC(tree,gc) *args;

  /* The implicit conversion sequences for each of the arguments to

     FN.  */

  conversion **convs;

  /* The number of implicit conversion sequences.  */

  size_t num_convs;

  /* If FN is a user-defined conversion, the standard conversion

     sequence from the type returned by FN to the desired destination

     type.  */

  conversion *second_conv;

  int viable;

  /* If FN is a member function, the binfo indicating the path used to

     qualify the name of FN at the call site.  This path is used to

     determine whether or not FN is accessible if it is selected by

     overload resolution.  The DECL_CONTEXT of FN will always be a

     (possibly improper) base of this binfo.  */

  tree access_path;

  /* If FN is a non-static member function, the binfo indicating the

     subobject to which the `this' pointer should be converted if FN

     is selected by overload resolution.  The type pointed to the by

     the `this' pointer must correspond to the most derived class

     indicated by the CONVERSION_PATH.  */

  tree conversion_path;

  tree template_decl;

  tree explicit_targs;

  candidate_warning *warnings;

  z_candidate *next;

};

/* Returns true iff T is a null pointer constant in the sense of

   [conv.ptr].  */

bool

null_ptr_cst_p (tree t)

{

  /* [conv.ptr]

     A null pointer constant is an integral constant expression

     (_expr.const_) rvalue of integer type that evaluates to zero.  */

  t = integral_constant_value (t);

  if (t == null_node)

    return true;

  if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t))

    {

      STRIP_NOPS (t);

      if (!TREE_OVERFLOW (t))

        return true;

    }

  return false;

}

/* Returns nonzero if PARMLIST consists of only default parms and/or

   ellipsis.  */

bool

sufficient_parms_p (const_tree parmlist)

{

  for (; parmlist && parmlist != void_list_node;

       parmlist = TREE_CHAIN (parmlist))

    if (!TREE_PURPOSE (parmlist))

      return false;

  return true;

}

/* Allocate N bytes of memory from the conversion obstack.  The memory

   is zeroed before being returned.  */

static void *

conversion_obstack_alloc (size_t n)

{

  void *p;

  if (!conversion_obstack_initialized)

    {

      gcc_obstack_init (&conversion_obstack);

      conversion_obstack_initialized = true;

    }

  p = obstack_alloc (&conversion_obstack, n);

  memset (p, 0, n);

  return p;

}

/* Dynamically allocate a conversion.  */

static conversion *

alloc_conversion (conversion_kind kind)

{

  conversion *c;

  c = (conversion *) conversion_obstack_alloc (sizeof (conversion));

  c->kind = kind;

  return c;

}

#ifdef ENABLE_CHECKING

/* Make sure that all memory on the conversion obstack has been

   freed.  */

void

validate_conversion_obstack (void)

{

  if (conversion_obstack_initialized)

    gcc_assert ((obstack_next_free (&conversion_obstack)

                 == obstack_base (&conversion_obstack)));

}

#endif /* ENABLE_CHECKING */

/* Dynamically allocate an array of N conversions.  */

static conversion **

alloc_conversions (size_t n)

{

  return (conversion **) conversion_obstack_alloc (n * sizeof (conversion *));

}

static conversion *

build_conv (conversion_kind code, tree type, conversion *from)

{

  conversion *t;

  conversion_rank rank = CONVERSION_RANK (from);

  /* Note that the caller is responsible for filling in t->cand for

     user-defined conversions.  */

  t = alloc_conversion (code);

  t->type = type;

  t->u.next = from;

  switch (code)

    {

    case ck_ptr:

    case ck_pmem:

    case ck_base:

    case ck_std:

      if (rank < cr_std)

        rank = cr_std;

      break;

    case ck_qual:

      if (rank < cr_exact)

        rank = cr_exact;

      break;

    default:

      break;

    }

  t->rank = rank;

  t->user_conv_p = (code == ck_user || from->user_conv_p);

  t->bad_p = from->bad_p;

  t->base_p = false;

  return t;

}

/* Represent a conversion from CTOR, a braced-init-list, to TYPE, a

   specialization of std::initializer_list<T>, if such a conversion is

   possible.  */

static conversion *

build_list_conv (tree type, tree ctor, int flags)

{

  tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type), 0);

  unsigned len = CONSTRUCTOR_NELTS (ctor);

  conversion **subconvs = alloc_conversions (len);

  conversion *t;

  unsigned i;

  tree val;

  /* Within a list-initialization we can have more user-defined

     conversions.  */

  flags &= ~LOOKUP_NO_CONVERSION;

  /* But no narrowing conversions.  */

  flags |= LOOKUP_NO_NARROWING;

  FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)

    {

      conversion *sub

        = implicit_conversion (elttype, TREE_TYPE (val), val,

                               false, flags);

      if (sub == NULL)

        return NULL;

      subconvs[i] = sub;

    }

  t = alloc_conversion (ck_list);

  t->type = type;

  t->u.list = subconvs;

  t->rank = cr_exact;

  for (i = 0; i < len; ++i)

    {

      conversion *sub = subconvs[i];

      if (sub->rank > t->rank)

        t->rank = sub->rank;

      if (sub->user_conv_p)

        t->user_conv_p = true;

      if (sub->bad_p)

        t->bad_p = true;

    }

  return t;

}

/* Represent a conversion from CTOR, a braced-init-list, to TYPE, an

   aggregate class, if such a conversion is possible.  */

static conversion *

build_aggr_conv (tree type, tree ctor, int flags)

{

  unsigned HOST_WIDE_INT i = 0;

  conversion *c;

  tree field = next_initializable_field (TYPE_FIELDS (type));

  for (; field; field = next_initializable_field (TREE_CHAIN (field)))

    {

      if (i < CONSTRUCTOR_NELTS (ctor))

        {

          constructor_elt *ce = CONSTRUCTOR_ELT (ctor, i);

          if (!can_convert_arg (TREE_TYPE (field), TREE_TYPE (ce->value),

                                ce->value, flags))

            return NULL;

          ++i;

          if (TREE_CODE (type) == UNION_TYPE)

            break;

        }

      else if (build_value_init (TREE_TYPE (field)) == error_mark_node)

        return NULL;

    }

  if (i < CONSTRUCTOR_NELTS (ctor))

    return NULL;

  c = alloc_conversion (ck_aggr);

  c->type = type;

  c->rank = cr_exact;

  c->user_conv_p = true;

  c->u.next = NULL;

  return c;

}

/* Build a representation of the identity conversion from EXPR to

   itself.  The TYPE should match the type of EXPR, if EXPR is non-NULL.  */

static conversion *

build_identity_conv (tree type, tree expr)

{

  conversion *c;

  c = alloc_conversion (ck_identity);

  c->type = type;

  c->u.expr = expr;

  return c;

}

/* Converting from EXPR to TYPE was ambiguous in the sense that there

   were multiple user-defined conversions to accomplish the job.

   Build a conversion that indicates that ambiguity.  */

static conversion *

build_ambiguous_conv (tree type, tree expr)

{

  conversion *c;

  c = alloc_conversion (ck_ambig);

  c->type = type;

  c->u.expr = expr;