Subversion Repositories scarts

/* Report error messages, build initializers, and perform

   some front-end optimizations for C++ compiler.

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

   1999, 2000, 2001, 2002, 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.  */

/* This file is part of the C++ front end.

   It contains routines to build C++ expressions given their operands,

   including computing the types of the result, C and C++ specific error

   checks, and some optimization.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "tree.h"

#include "cp-tree.h"

#include "flags.h"

#include "toplev.h"

#include "output.h"

#include "diagnostic.h"

static tree

process_init_constructor (tree type, tree init);

/* Print an error message stemming from an attempt to use

   BASETYPE as a base class for TYPE.  */

tree

error_not_base_type (tree basetype, tree type)

{

  if (TREE_CODE (basetype) == FUNCTION_DECL)

    basetype = DECL_CONTEXT (basetype);

  error ("type %qT is not a base type for type %qT", basetype, type);

  return error_mark_node;

}

tree

binfo_or_else (tree base, tree type)

{

  tree binfo = lookup_base (type, base, ba_unique, NULL);

  if (binfo == error_mark_node)

    return NULL_TREE;

  else if (!binfo)

    error_not_base_type (base, type);

  return binfo;

}

/* According to ARM $7.1.6, "A `const' object may be initialized, but its

   value may not be changed thereafter.  Thus, we emit hard errors for these,

   rather than just pedwarns.  If `SOFT' is 1, then we just pedwarn.  (For

   example, conversions to references.)  */

void

readonly_error (tree arg, const char* string, int soft)

{

  const char *fmt;

  void (*fn) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);

  if (soft)

    fn = pedwarn;

  else

    fn = error;

  if (TREE_CODE (arg) == COMPONENT_REF)

    {

      if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))

        fmt = "%s of data-member %qD in read-only structure";

      else

        fmt = "%s of read-only data-member %qD";

      (*fn) (fmt, string, TREE_OPERAND (arg, 1));

    }

  else if (TREE_CODE (arg) == VAR_DECL)

    {

      if (DECL_LANG_SPECIFIC (arg)

          && DECL_IN_AGGR_P (arg)

          && !TREE_STATIC (arg))

        fmt = "%s of constant field %qD";

      else

        fmt = "%s of read-only variable %qD";

      (*fn) (fmt, string, arg);

    }

  else if (TREE_CODE (arg) == PARM_DECL)

    (*fn) ("%s of read-only parameter %qD", string, arg);

  else if (TREE_CODE (arg) == INDIRECT_REF

           && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE

           && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL

               || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))

    (*fn) ("%s of read-only reference %qD", string, TREE_OPERAND (arg, 0));

  else if (TREE_CODE (arg) == RESULT_DECL)

    (*fn) ("%s of read-only named return value %qD", string, arg);

  else if (TREE_CODE (arg) == FUNCTION_DECL)

    (*fn) ("%s of function %qD", string, arg);

  else

    (*fn) ("%s of read-only location", string);

}

/* Structure that holds information about declarations whose type was

   incomplete and we could not check whether it was abstract or not.  */

struct pending_abstract_type GTY((chain_next ("%h.next")))

{

  /* Declaration which we are checking for abstractness. It is either

     a DECL node, or an IDENTIFIER_NODE if we do not have a full

     declaration available.  */

  tree decl;

  /* Type which will be checked for abstractness.  */

  tree type;

  /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,

     because DECLs already carry locus information.  */

  location_t locus;

  /* Link to the next element in list.  */

  struct pending_abstract_type* next;

};

/* Compute the hash value of the node VAL. This function is used by the

   hash table abstract_pending_vars.  */

static hashval_t

pat_calc_hash (const void* val)

{

  const struct pending_abstract_type* pat = val;

  return (hashval_t) TYPE_UID (pat->type);

}

/* Compare node VAL1 with the type VAL2. This function is used by the

   hash table abstract_pending_vars.  */

static int

pat_compare (const void* val1, const void* val2)

{

  const struct pending_abstract_type* pat1 = val1;

  tree type2 = (tree)val2;

  return (pat1->type == type2);

}

/* Hash table that maintains pending_abstract_type nodes, for which we still

   need to check for type abstractness.  The key of the table is the type

   of the declaration.  */

static GTY ((param_is (struct pending_abstract_type)))

htab_t abstract_pending_vars = NULL;

/* This function is called after TYPE is completed, and will check if there

   are pending declarations for which we still need to verify the abstractness

   of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE

   turned out to be incomplete.  */

void

complete_type_check_abstract (tree type)

{

  void **slot;

  struct pending_abstract_type *pat;

  location_t cur_loc = input_location;

  gcc_assert (COMPLETE_TYPE_P (type));

  if (!abstract_pending_vars)

    return;

  /* Retrieve the list of pending declarations for this type.  */

  slot = htab_find_slot_with_hash (abstract_pending_vars, type,

                                   (hashval_t)TYPE_UID (type), NO_INSERT);

  if (!slot)

    return;

  pat = (struct pending_abstract_type*)*slot;

  gcc_assert (pat);

  /* If the type is not abstract, do not do anything.  */

  if (CLASSTYPE_PURE_VIRTUALS (type))

    {

      struct pending_abstract_type *prev = 0, *next;

      /* Reverse the list to emit the errors in top-down order.  */

      for (; pat; pat = next)

        {

          next = pat->next;

          pat->next = prev;

          prev = pat;

        }

      pat = prev;

      /* Go through the list, and call abstract_virtuals_error for each

        element: it will issue a diagnostic if the type is abstract.  */

      while (pat)

        {

          gcc_assert (type == pat->type);

          /* Tweak input_location so that the diagnostic appears at the correct

            location. Notice that this is only needed if the decl is an

            IDENTIFIER_NODE.  */

          input_location = pat->locus;

          abstract_virtuals_error (pat->decl, pat->type);

          pat = pat->next;

        }

    }

  htab_clear_slot (abstract_pending_vars, slot);

  input_location = cur_loc;

}

/* If TYPE has abstract virtual functions, issue an error about trying

   to create an object of that type.  DECL is the object declared, or

   NULL_TREE if the declaration is unavailable.  Returns 1 if an error

   occurred; zero if all was well.  */

int

abstract_virtuals_error (tree decl, tree type)

{

  VEC(tree,gc) *pure;

  /* This function applies only to classes. Any other entity can never

     be abstract.  */

  if (!CLASS_TYPE_P (type))

    return 0;

  /* If the type is incomplete, we register it within a hash table,

     so that we can check again once it is completed. This makes sense

     only for objects for which we have a declaration or at least a

     name.  */

  if (!COMPLETE_TYPE_P (type))

    {

      void **slot;

      struct pending_abstract_type *pat;

      gcc_assert (!decl || DECL_P (decl)

                  || TREE_CODE (decl) == IDENTIFIER_NODE);

      if (!abstract_pending_vars)

        abstract_pending_vars = htab_create_ggc (31, &pat_calc_hash,

                                                &pat_compare, NULL);

      slot = htab_find_slot_with_hash (abstract_pending_vars, type,

                                      (hashval_t)TYPE_UID (type), INSERT);

      pat = GGC_NEW (struct pending_abstract_type);

      pat->type = type;

      pat->decl = decl;

      pat->locus = ((decl && DECL_P (decl))

                    ? DECL_SOURCE_LOCATION (decl)

                    : input_location);

      pat->next = *slot;

      *slot = pat;

      return 0;

    }

  if (!TYPE_SIZE (type))

    /* TYPE is being defined, and during that time

       CLASSTYPE_PURE_VIRTUALS holds the inline friends.  */

    return 0;

  pure = CLASSTYPE_PURE_VIRTUALS (type);

  if (!pure)

    return 0;

  if (decl)

    {

      if (TREE_CODE (decl) == RESULT_DECL)

        return 0;

      if (TREE_CODE (decl) == VAR_DECL)

        error ("cannot declare variable %q+D to be of abstract "

               "type %qT", decl, type);

      else if (TREE_CODE (decl) == PARM_DECL)

        error ("cannot declare parameter %q+D to be of abstract type %qT",

               decl, type);

      else if (TREE_CODE (decl) == FIELD_DECL)

        error ("cannot declare field %q+D to be of abstract type %qT",

               decl, type);

      else if (TREE_CODE (decl) == FUNCTION_DECL

               && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)

        error ("invalid abstract return type for member function %q+#D", decl);

      else if (TREE_CODE (decl) == FUNCTION_DECL)

        error ("invalid abstract return type for function %q+#D", decl);

      else if (TREE_CODE (decl) == IDENTIFIER_NODE)

        /* Here we do not have location information.  */

        error ("invalid abstract type %qT for %qE", type, decl);

      else

        error ("invalid abstract type for %q+D", decl);

    }

  else

    error ("cannot allocate an object of abstract type %qT", type);

  /* Only go through this once.  */

  if (VEC_length (tree, pure))

    {

      unsigned ix;

      tree fn;

      inform ("%J  because the following virtual functions are pure "

              "within %qT:", TYPE_MAIN_DECL (type), type);

      for (ix = 0; VEC_iterate (tree, pure, ix, fn); ix++)

        inform ("\t%+#D", fn);

      /* Now truncate the vector.  This leaves it non-null, so we know

         there are pure virtuals, but empty so we don't list them out

         again.  */

      VEC_truncate (tree, pure, 0);

    }

  else

    inform ("%J  since type %qT has pure virtual functions",

            TYPE_MAIN_DECL (type), type);

  return 1;

}

/* Print an error message for invalid use of an incomplete type.

   VALUE is the expression that was used (or 0 if that isn't known)

   and TYPE is the type that was invalid.  DIAG_TYPE indicates the

   type of diagnostic:  0 for an error, 1 for a warning, 2 for a

   pedwarn.  */

void

cxx_incomplete_type_diagnostic (tree value, tree type, int diag_type)

{

  int decl = 0;

  void (*p_msg) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);

  if (diag_type == 1)

    p_msg = warning0;

  else if (diag_type == 2)

    p_msg = pedwarn;

  else

    p_msg = error;

  /* Avoid duplicate error message.  */

  if (TREE_CODE (type) == ERROR_MARK)

    return;

  if (value != 0 && (TREE_CODE (value) == VAR_DECL

                     || TREE_CODE (value) == PARM_DECL

                     || TREE_CODE (value) == FIELD_DECL))

    {

      p_msg ("%q+D has incomplete type", value);

      decl = 1;

    }

 retry:

  /* We must print an error message.  Be clever about what it says.  */

  switch (TREE_CODE (type))

    {

    case RECORD_TYPE:

    case UNION_TYPE:

    case ENUMERAL_TYPE:

      if (!decl)

        p_msg ("invalid use of undefined type %q#T", type);

      if (!TYPE_TEMPLATE_INFO (type))

        p_msg ("forward declaration of %q+#T", type);

      else

        p_msg ("declaration of %q+#T", type);

      break;

    case VOID_TYPE:

      p_msg ("invalid use of %qT", type);

      break;

    case ARRAY_TYPE:

      if (TYPE_DOMAIN (type))

        {

          type = TREE_TYPE (type);

          goto retry;

        }

      p_msg ("invalid use of array with unspecified bounds");

      break;

    case OFFSET_TYPE:

    bad_member:

      p_msg ("invalid use of member (did you forget the %<&%> ?)");

      break;

    case TEMPLATE_TYPE_PARM:

      p_msg ("invalid use of template type parameter");

      break;

    case UNKNOWN_TYPE:

      if (value && TREE_CODE (value) == COMPONENT_REF)

        goto bad_member;

      else if (value && TREE_CODE (value) == ADDR_EXPR)

        p_msg ("address of overloaded function with no contextual "

               "type information");

      else if (value && TREE_CODE (value) == OVERLOAD)

        p_msg ("overloaded function with no contextual type information");

      else

        p_msg ("insufficient contextual information to determine type");

      break;

    default:

      gcc_unreachable ();

    }

}

/* Backward-compatibility interface to incomplete_type_diagnostic;

   required by ../tree.c.  */

#undef cxx_incomplete_type_error

void

cxx_incomplete_type_error (tree value, tree type)

{

  cxx_incomplete_type_diagnostic (value, type, 0);

}

/* The recursive part of split_nonconstant_init.  DEST is an lvalue

   expression to which INIT should be assigned.  INIT is a CONSTRUCTOR.  */

static void

split_nonconstant_init_1 (tree dest, tree init)

{

  unsigned HOST_WIDE_INT idx;

  tree field_index, value;

  tree type = TREE_TYPE (dest);

  tree inner_type = NULL;

  bool array_type_p = false;

  switch (TREE_CODE (type))

    {

    case ARRAY_TYPE:

      inner_type = TREE_TYPE (type);

      array_type_p = true;

      /* FALLTHRU */

    case RECORD_TYPE:

    case UNION_TYPE:

    case QUAL_UNION_TYPE:

      FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,

                                field_index, value)

        {

          /* The current implementation of this algorithm assumes that

             the field was set for all the elements. This is usually done

             by process_init_constructor.  */

          gcc_assert (field_index);

          if (!array_type_p)

            inner_type = TREE_TYPE (field_index);

          if (TREE_CODE (value) == CONSTRUCTOR)

            {

              tree sub;

              if (array_type_p)

                sub = build4 (ARRAY_REF, inner_type, dest, field_index,

                              NULL_TREE, NULL_TREE);

              else

                sub = build3 (COMPONENT_REF, inner_type, dest, field_index,

                              NULL_TREE);

              split_nonconstant_init_1 (sub, value);

            }

          else if (!initializer_constant_valid_p (value, inner_type))

            {

              tree code;

              tree sub;

              /* FIXME: Ordered removal is O(1) so the whole function is

                 worst-case quadratic. This could be fixed using an aside

                 bitmap to record which elements must be removed and remove

                 them all at the same time. Or by merging

                 split_non_constant_init into process_init_constructor_array,

                 that is separating constants from non-constants while building

                 the vector.  */

              VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init),

                                  idx);

              --idx;

              if (array_type_p)

                sub = build4 (ARRAY_REF, inner_type, dest, field_index,

                              NULL_TREE, NULL_TREE);

              else

                sub = build3 (COMPONENT_REF, inner_type, dest, field_index,

                              NULL_TREE);

              code = build2 (INIT_EXPR, inner_type, sub, value);

              code = build_stmt (EXPR_STMT, code);

              add_stmt (code);

              continue;

            }

        }

      break;

    case VECTOR_TYPE:

      if (!initializer_constant_valid_p (init, type))

        {

          tree code;

          tree cons = copy_node (init);

          CONSTRUCTOR_ELTS (init) = NULL;

          code = build2 (MODIFY_EXPR, type, dest, cons);

          code = build_stmt (EXPR_STMT, code);

          add_stmt (code);

        }

      break;

    default:

      gcc_unreachable ();

    }

}

/* A subroutine of store_init_value.  Splits non-constant static

   initializer INIT into a constant part and generates code to

   perform the non-constant part of the initialization to DEST.

   Returns the code for the runtime init.  */

static tree

split_nonconstant_init (tree dest, tree init)

{

  tree code;

  if (TREE_CODE (init) == CONSTRUCTOR)

    {

      code = push_stmt_list ();

      split_nonconstant_init_1 (dest, init);

      code = pop_stmt_list (code);

      DECL_INITIAL (dest) = init;

      TREE_READONLY (dest) = 0;

    }

  else

    code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);

  return code;

}

/* Perform appropriate conversions on the initial value of a variable,

   store it in the declaration DECL,

   and print any error messages that are appropriate.

   If the init is invalid, store an ERROR_MARK.

   C++: Note that INIT might be a TREE_LIST, which would mean that it is

   a base class initializer for some aggregate type, hopefully compatible

   with DECL.  If INIT is a single element, and DECL is an aggregate

   type, we silently convert INIT into a TREE_LIST, allowing a constructor

   to be called.

   If INIT is a TREE_LIST and there is no constructor, turn INIT

   into a CONSTRUCTOR and use standard initialization techniques.

   Perhaps a warning should be generated?

   Returns code to be executed if initialization could not be performed

   for static variable.  In that case, caller must emit the code.  */

tree

store_init_value (tree decl, tree init)

{

  tree value, type;

  /* If variable's type was invalidly declared, just ignore it.  */

  type = TREE_TYPE (decl);

  if (TREE_CODE (type) == ERROR_MARK)

    return NULL_TREE;

  if (IS_AGGR_TYPE (type))

    {

      gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type)

                  || TREE_CODE (init) == CONSTRUCTOR);

      if (TREE_CODE (init) == TREE_LIST)

        {

          error ("constructor syntax used, but no constructor declared "

                 "for type %qT", type);

          init = build_constructor_from_list (NULL_TREE, nreverse (init));

        }

    }

  else if (TREE_CODE (init) == TREE_LIST

           && TREE_TYPE (init) != unknown_type_node)

    {

      if (TREE_CODE (decl) == RESULT_DECL)

        init = build_x_compound_expr_from_list (init,

                                                "return value initializer");

      else if (TREE_CODE (init) == TREE_LIST

               && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)

        {

          error ("cannot initialize arrays using this syntax");

          return NULL_TREE;

        }

      else

        /* We get here with code like `int a (2);' */

        init = build_x_compound_expr_from_list (init, "initializer");

    }

  /* End of special C++ code.  */

  /* Digest the specified initializer into an expression.  */

  value = digest_init (type, init);

  /* If the initializer is not a constant, fill in DECL_INITIAL with

     the bits that are constant, and then return an expression that

     will perform the dynamic initialization.  */

  if (value != error_mark_node

      && (TREE_SIDE_EFFECTS (value)

           || ! initializer_constant_valid_p (value, TREE_TYPE (value))))

    return split_nonconstant_init (decl, value);

  /* If the value is a constant, just put it in DECL_INITIAL.  If DECL

     is an automatic variable, the middle end will turn this into a

     dynamic initialization later.  */

  DECL_INITIAL (decl) = value;

  return NULL_TREE;

}

/* Process the initializer INIT for a variable of type TYPE, emitting

   diagnostics for invalid initializers and converting the initializer as

   appropriate.

   For aggregate types, it assumes that reshape_init has already run, thus the

   initializer will have the right shape (brace elision has been undone).  */

tree

digest_init (tree type, tree init)

{

  enum tree_code code = TREE_CODE (type);

  if (init == error_mark_node)

    return error_mark_node;

  gcc_assert (init);

  /* We must strip the outermost array type when completing the type,

     because the its bounds might be incomplete at the moment.  */

  if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE

                              ? TREE_TYPE (type) : type, NULL_TREE))

    return error_mark_node;

  /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue

     (g++.old-deja/g++.law/casts2.C).  */

  if (TREE_CODE (init) == NON_LVALUE_EXPR)

    init = TREE_OPERAND (init, 0);

  /* Initialization of an array of chars from a string constant. The initializer

     can be optionally enclosed in braces, but reshape_init has already removed

     them if they were present.  */

  if (code == ARRAY_TYPE)

    {

      tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));

      if (char_type_p (typ1)

          /*&& init */

          && TREE_CODE (init) == STRING_CST)

        {

          tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));

          if (char_type != char_type_node

              && TYPE_PRECISION (typ1) == BITS_PER_UNIT)

            {

              error ("char-array initialized from wide string");

              return error_mark_node;

            }

          if (char_type == char_type_node

              && TYPE_PRECISION (typ1) != BITS_PER_UNIT)

            {

              error ("int-array initialized from non-wide string");

              return error_mark_node;

            }

          TREE_TYPE (init) = type;

          if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type)))

            {

              int size = TREE_INT_CST_LOW (TYPE_SIZE (type));

              size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;

              /* In C it is ok to subtract 1 from the length of the string

                 because it's ok to ignore the terminating null char that is

                 counted in the length of the constant, but in C++ this would

                 be invalid.  */

              if (size < TREE_STRING_LENGTH (init))

                pedwarn ("initializer-string for array of chars is too long");

            }

          return init;

        }

    }

  /* Handle scalar types (including conversions) and references.  */

  if (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE)

    return convert_for_initialization (0, type, init, LOOKUP_NORMAL,

                                       "initialization", NULL_TREE, 0);

  /* Come here only for aggregates: records, arrays, unions, complex numbers

     and vectors.  */

  gcc_assert (TREE_CODE (type) == ARRAY_TYPE

              || TREE_CODE (type) == VECTOR_TYPE

              || TREE_CODE (type) == RECORD_TYPE