Subversion Repositories scarts

/* Process declarations and variables for C++ compiler.

   Copyright (C) 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.  */

/* Process declarations and symbol lookup for C++ front end.

   Also constructs types; the standard scalar types at initialization,

   and structure, union, array and enum types when they are declared.  */

/* ??? not all decl nodes are given the most useful possible

   line numbers.  For example, the CONST_DECLs for enum values.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "tree.h"

#include "rtl.h"

#include "expr.h"

#include "flags.h"

#include "cp-tree.h"

#include "decl.h"

#include "output.h"

#include "except.h"

#include "toplev.h"

#include "timevar.h"

#include "cpplib.h"

#include "target.h"

#include "c-common.h"

#include "tree-mudflap.h"

#include "cgraph.h"

#include "tree-inline.h"

#include "c-pragma.h"

#include "tree-dump.h"

#include "intl.h"

extern cpp_reader *parse_in;

/* This structure contains information about the initializations

   and/or destructions required for a particular priority level.  */

typedef struct priority_info_s {

  /* Nonzero if there have been any initializations at this priority

     throughout the translation unit.  */

  int initializations_p;

  /* Nonzero if there have been any destructions at this priority

     throughout the translation unit.  */

  int destructions_p;

} *priority_info;

static void mark_vtable_entries (tree);

static bool maybe_emit_vtables (tree);

static bool acceptable_java_type (tree);

static tree start_objects (int, int);

static void finish_objects (int, int, tree);

static tree start_static_storage_duration_function (unsigned);

static void finish_static_storage_duration_function (tree);

static priority_info get_priority_info (int);

static void do_static_initialization_or_destruction (tree, bool);

static void one_static_initialization_or_destruction (tree, tree, bool);

static void generate_ctor_or_dtor_function (bool, int, location_t *);

static int generate_ctor_and_dtor_functions_for_priority (splay_tree_node,

                                                          void *);

static tree prune_vars_needing_no_initialization (tree *);

static void write_out_vars (tree);

static void import_export_class (tree);

static tree get_guard_bits (tree);

/* A list of static class variables.  This is needed, because a

   static class variable can be declared inside the class without

   an initializer, and then initialized, statically, outside the class.  */

static GTY(()) VEC(tree,gc) *pending_statics;

/* A list of functions which were declared inline, but which we

   may need to emit outline anyway.  */

static GTY(()) VEC(tree,gc) *deferred_fns;

/* Nonzero if we're done parsing and into end-of-file activities.  */

int at_eof;

/* Functions called along with real static constructors and destructors.  */

tree static_ctors;

tree static_dtors;

/* Incorporate `const' and `volatile' qualifiers for member functions.

   FUNCTION is a TYPE_DECL or a FUNCTION_DECL.

   QUALS is a list of qualifiers.  Returns any explicit

   top-level qualifiers of the method's this pointer, anything other than

   TYPE_UNQUALIFIED will be an extension.  */

int

grok_method_quals (tree ctype, tree function, cp_cv_quals quals)

{

  tree fntype = TREE_TYPE (function);

  tree raises = TYPE_RAISES_EXCEPTIONS (fntype);

  int type_quals = TYPE_UNQUALIFIED;

  int this_quals = TYPE_UNQUALIFIED;

  type_quals = quals & ~TYPE_QUAL_RESTRICT;

  this_quals = quals & TYPE_QUAL_RESTRICT;

  ctype = cp_build_qualified_type (ctype, type_quals);

  fntype = build_method_type_directly (ctype, TREE_TYPE (fntype),

                                       (TREE_CODE (fntype) == METHOD_TYPE

                                        ? TREE_CHAIN (TYPE_ARG_TYPES (fntype))

                                        : TYPE_ARG_TYPES (fntype)));

  if (raises)

    fntype = build_exception_variant (fntype, raises);

  TREE_TYPE (function) = fntype;

  return this_quals;

}

/* Build a PARM_DECL with NAME and TYPE, and set DECL_ARG_TYPE

   appropriately.  */

tree

cp_build_parm_decl (tree name, tree type)

{

  tree parm = build_decl (PARM_DECL, name, type);

  /* DECL_ARG_TYPE is only used by the back end and the back end never

     sees templates.  */

  if (!processing_template_decl)

    DECL_ARG_TYPE (parm) = type_passed_as (type);

  return parm;

}

/* Returns a PARM_DECL for a parameter of the indicated TYPE, with the

   indicated NAME.  */

static tree

build_artificial_parm (tree name, tree type)

{

  tree parm = cp_build_parm_decl (name, type);

  DECL_ARTIFICIAL (parm) = 1;

  /* All our artificial parms are implicitly `const'; they cannot be

     assigned to.  */

  TREE_READONLY (parm) = 1;

  return parm;

}

/* Constructors for types with virtual baseclasses need an "in-charge" flag

   saying whether this constructor is responsible for initialization of

   virtual baseclasses or not.  All destructors also need this "in-charge"

   flag, which additionally determines whether or not the destructor should

   free the memory for the object.

   This function adds the "in-charge" flag to member function FN if

   appropriate.  It is called from grokclassfn and tsubst.

   FN must be either a constructor or destructor.

   The in-charge flag follows the 'this' parameter, and is followed by the

   VTT parm (if any), then the user-written parms.  */

void

maybe_retrofit_in_chrg (tree fn)

{

  tree basetype, arg_types, parms, parm, fntype;

  /* If we've already add the in-charge parameter don't do it again.  */

  if (DECL_HAS_IN_CHARGE_PARM_P (fn))

    return;

  /* When processing templates we can't know, in general, whether or

     not we're going to have virtual baseclasses.  */

  if (processing_template_decl)

    return;

  /* We don't need an in-charge parameter for constructors that don't

     have virtual bases.  */

  if (DECL_CONSTRUCTOR_P (fn)

      && !CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))

    return;

  arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));

  basetype = TREE_TYPE (TREE_VALUE (arg_types));

  arg_types = TREE_CHAIN (arg_types);

  parms = TREE_CHAIN (DECL_ARGUMENTS (fn));

  /* If this is a subobject constructor or destructor, our caller will

     pass us a pointer to our VTT.  */

  if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))

    {

      parm = build_artificial_parm (vtt_parm_identifier, vtt_parm_type);

      /* First add it to DECL_ARGUMENTS between 'this' and the real args...  */

      TREE_CHAIN (parm) = parms;

      parms = parm;

      /* ...and then to TYPE_ARG_TYPES.  */

      arg_types = hash_tree_chain (vtt_parm_type, arg_types);

      DECL_HAS_VTT_PARM_P (fn) = 1;

    }

  /* Then add the in-charge parm (before the VTT parm).  */

  parm = build_artificial_parm (in_charge_identifier, integer_type_node);

  TREE_CHAIN (parm) = parms;

  parms = parm;

  arg_types = hash_tree_chain (integer_type_node, arg_types);

  /* Insert our new parameter(s) into the list.  */

  TREE_CHAIN (DECL_ARGUMENTS (fn)) = parms;

  /* And rebuild the function type.  */

  fntype = build_method_type_directly (basetype, TREE_TYPE (TREE_TYPE (fn)),

                                       arg_types);

  if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))

    fntype = build_exception_variant (fntype,

                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)));

  TREE_TYPE (fn) = fntype;

  /* Now we've got the in-charge parameter.  */

  DECL_HAS_IN_CHARGE_PARM_P (fn) = 1;

}

/* Classes overload their constituent function names automatically.

   When a function name is declared in a record structure,

   its name is changed to it overloaded name.  Since names for

   constructors and destructors can conflict, we place a leading

   '$' for destructors.

   CNAME is the name of the class we are grokking for.

   FUNCTION is a FUNCTION_DECL.  It was created by `grokdeclarator'.

   FLAGS contains bits saying what's special about today's

   arguments.  1 == DESTRUCTOR.  2 == OPERATOR.

   If FUNCTION is a destructor, then we must add the `auto-delete' field

   as a second parameter.  There is some hair associated with the fact

   that we must "declare" this variable in the manner consistent with the

   way the rest of the arguments were declared.

   QUALS are the qualifiers for the this pointer.  */

void

grokclassfn (tree ctype, tree function, enum overload_flags flags,

             cp_cv_quals quals)

{

  tree fn_name = DECL_NAME (function);

  cp_cv_quals this_quals = TYPE_UNQUALIFIED;

  /* Even within an `extern "C"' block, members get C++ linkage.  See

     [dcl.link] for details.  */

  SET_DECL_LANGUAGE (function, lang_cplusplus);

  if (fn_name == NULL_TREE)

    {

      error ("name missing for member function");

      fn_name = get_identifier ("<anonymous>");

      DECL_NAME (function) = fn_name;

    }

  if (quals)

    this_quals = grok_method_quals (ctype, function, quals);

  if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)

    {

      /* Must add the class instance variable up front.  */

      /* Right now we just make this a pointer.  But later

         we may wish to make it special.  */

      tree type = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (function)));

      tree qual_type;

      tree parm;

      /* The `this' parameter is implicitly `const'; it cannot be

         assigned to.  */

      this_quals |= TYPE_QUAL_CONST;

      qual_type = cp_build_qualified_type (type, this_quals);

      parm = build_artificial_parm (this_identifier, qual_type);

      cp_apply_type_quals_to_decl (this_quals, parm);

      TREE_CHAIN (parm) = DECL_ARGUMENTS (function);

      DECL_ARGUMENTS (function) = parm;

    }

  DECL_CONTEXT (function) = ctype;

  if (flags == DTOR_FLAG)

    DECL_DESTRUCTOR_P (function) = 1;

  if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function))

    maybe_retrofit_in_chrg (function);

}

/* Create an ARRAY_REF, checking for the user doing things backwards

   along the way.  */

tree

grok_array_decl (tree array_expr, tree index_exp)

{

  tree type;

  tree expr;

  tree orig_array_expr = array_expr;

  tree orig_index_exp = index_exp;

  if (error_operand_p (array_expr) || error_operand_p (index_exp))

    return error_mark_node;

  if (processing_template_decl)

    {

      if (type_dependent_expression_p (array_expr)

          || type_dependent_expression_p (index_exp))

        return build_min_nt (ARRAY_REF, array_expr, index_exp,

                             NULL_TREE, NULL_TREE);

      array_expr = build_non_dependent_expr (array_expr);

      index_exp = build_non_dependent_expr (index_exp);

    }

  type = TREE_TYPE (array_expr);

  gcc_assert (type);

  type = non_reference (type);

  /* If they have an `operator[]', use that.  */

  if (IS_AGGR_TYPE (type) || IS_AGGR_TYPE (TREE_TYPE (index_exp)))

    expr = build_new_op (ARRAY_REF, LOOKUP_NORMAL,

                         array_expr, index_exp, NULL_TREE,

                         /*overloaded_p=*/NULL);

  else

    {

      tree p1, p2, i1, i2;

      /* Otherwise, create an ARRAY_REF for a pointer or array type.

         It is a little-known fact that, if `a' is an array and `i' is

         an int, you can write `i[a]', which means the same thing as

         `a[i]'.  */

      if (TREE_CODE (type) == ARRAY_TYPE)

        p1 = array_expr;

      else

        p1 = build_expr_type_conversion (WANT_POINTER, array_expr, false);

      if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE)

        p2 = index_exp;

      else

        p2 = build_expr_type_conversion (WANT_POINTER, index_exp, false);

      i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr,

                                       false);

      i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp,

                                       false);

      if ((p1 && i2) && (i1 && p2))

        error ("ambiguous conversion for array subscript");

      if (p1 && i2)

        array_expr = p1, index_exp = i2;

      else if (i1 && p2)

        array_expr = p2, index_exp = i1;

      else

        {

          error ("invalid types %<%T[%T]%> for array subscript",

                 type, TREE_TYPE (index_exp));

          return error_mark_node;

        }

      if (array_expr == error_mark_node || index_exp == error_mark_node)

        error ("ambiguous conversion for array subscript");

      expr = build_array_ref (array_expr, index_exp);

    }

  if (processing_template_decl && expr != error_mark_node)

    return build_min_non_dep (ARRAY_REF, expr, orig_array_expr, orig_index_exp,

                              NULL_TREE, NULL_TREE);

  return expr;

}

/* Given the cast expression EXP, checking out its validity.   Either return

   an error_mark_node if there was an unavoidable error, return a cast to

   void for trying to delete a pointer w/ the value 0, or return the

   call to delete.  If DOING_VEC is true, we handle things differently

   for doing an array delete.

   Implements ARM $5.3.4.  This is called from the parser.  */

tree

delete_sanity (tree exp, tree size, bool doing_vec, int use_global_delete)

{

  tree t, type;

  if (exp == error_mark_node)

    return exp;

  if (processing_template_decl)

    {

      t = build_min (DELETE_EXPR, void_type_node, exp, size);

      DELETE_EXPR_USE_GLOBAL (t) = use_global_delete;

      DELETE_EXPR_USE_VEC (t) = doing_vec;

      TREE_SIDE_EFFECTS (t) = 1;

      return t;

    }

  /* An array can't have been allocated by new, so complain.  */

  if (TREE_CODE (exp) == VAR_DECL

      && TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)

    warning (0, "deleting array %q#D", exp);

  t = build_expr_type_conversion (WANT_POINTER, exp, true);

  if (t == NULL_TREE || t == error_mark_node)

    {

      error ("type %q#T argument given to %<delete%>, expected pointer",

             TREE_TYPE (exp));

      return error_mark_node;

    }

  type = TREE_TYPE (t);

  /* As of Valley Forge, you can delete a pointer to const.  */

  /* You can't delete functions.  */

  if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)

    {

      error ("cannot delete a function.  Only pointer-to-objects are "

             "valid arguments to %<delete%>");

      return error_mark_node;

    }

  /* Deleting ptr to void is undefined behavior [expr.delete/3].  */

  if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)

    {

      warning (0, "deleting %qT is undefined", type);

      doing_vec = 0;

    }

  /* Deleting a pointer with the value zero is valid and has no effect.  */

  if (integer_zerop (t))

    return build1 (NOP_EXPR, void_type_node, t);

  if (doing_vec)

    return build_vec_delete (t, /*maxindex=*/NULL_TREE,

                             sfk_deleting_destructor,

                             use_global_delete);

  else

    return build_delete (type, t, sfk_deleting_destructor,

                         LOOKUP_NORMAL, use_global_delete);

}

/* Report an error if the indicated template declaration is not the

   sort of thing that should be a member template.  */

void

check_member_template (tree tmpl)

{

  tree decl;

  gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);

  decl = DECL_TEMPLATE_RESULT (tmpl);

  if (TREE_CODE (decl) == FUNCTION_DECL

      || (TREE_CODE (decl) == TYPE_DECL

          && IS_AGGR_TYPE (TREE_TYPE (decl))))

    {

      if (current_function_decl)

        /* 14.5.2.2 [temp.mem]

           A local class shall not have member templates.  */

        error ("invalid declaration of member template %q#D in local class",

               decl);

      if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))

        {

          /* 14.5.2.3 [temp.mem]

             A member function template shall not be virtual.  */

          error

            ("invalid use of %<virtual%> in template declaration of %q#D",

             decl);

          DECL_VIRTUAL_P (decl) = 0;

        }

      /* The debug-information generating code doesn't know what to do

         with member templates.  */

      DECL_IGNORED_P (tmpl) = 1;

    }

  else

    error ("template declaration of %q#D", decl);

}

/* Return true iff TYPE is a valid Java parameter or return type.  */

static bool

acceptable_java_type (tree type)

{

  if (TREE_CODE (type) == VOID_TYPE || TYPE_FOR_JAVA (type))

    return 1;

  if (TREE_CODE (type) == POINTER_TYPE || TREE_CODE (type) == REFERENCE_TYPE)

    {

      type = TREE_TYPE (type);

      if (TREE_CODE (type) == RECORD_TYPE)

        {

          tree args;  int i;

          if (! TYPE_FOR_JAVA (type))

            return false;

          if (! CLASSTYPE_TEMPLATE_INFO (type))

            return true;

          args = CLASSTYPE_TI_ARGS (type);

          i = TREE_VEC_LENGTH (args);

          while (--i >= 0)

            {

              type = TREE_VEC_ELT (args, i);

              if (TREE_CODE (type) == POINTER_TYPE)

                type = TREE_TYPE (type);

              if (! TYPE_FOR_JAVA (type))

                return false;

            }

          return true;

        }

    }

  return false;

}

/* For a METHOD in a Java class CTYPE, return true if

   the parameter and return types are valid Java types.

   Otherwise, print appropriate error messages, and return false.  */

bool

check_java_method (tree method)

{

  bool jerr = false;

  tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));

  tree ret_type = TREE_TYPE (TREE_TYPE (method));

  if (!acceptable_java_type (ret_type))

    {

      error ("Java method %qD has non-Java return type %qT",

             method, ret_type);

      jerr = true;

    }

  arg_types = TREE_CHAIN (arg_types);

  if (DECL_HAS_IN_CHARGE_PARM_P (method))

    arg_types = TREE_CHAIN (arg_types);

  if (DECL_HAS_VTT_PARM_P (method))

    arg_types = TREE_CHAIN (arg_types);

  for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types))

    {

      tree type = TREE_VALUE (arg_types);

      if (!acceptable_java_type (type))

        {

          error ("Java method %qD has non-Java parameter type %qT",

                 method, type);

          jerr = true;

        }

    }

  return !jerr;

}

/* Sanity check: report error if this function FUNCTION is not

   really a member of the class (CTYPE) it is supposed to belong to.

   TEMPLATE_PARMS is used to specify the template parameters of a member

   template passed as FUNCTION_DECL. If the member template is passed as a

   TEMPLATE_DECL, it can be NULL since the parameters can be extracted

   from the declaration. If the function is not a function template, it

   must be NULL.

   It returns the original declaration for the function, or NULL_TREE

   if no declaration was found (and an error was emitted).  */

tree

check_classfn (tree ctype, tree function, tree template_parms)

{

  int ix;

  bool is_template;

  if (DECL_USE_TEMPLATE (function)

      && !(TREE_CODE (function) == TEMPLATE_DECL

           && DECL_TEMPLATE_SPECIALIZATION (function))

      && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (function)))

    /* Since this is a specialization of a member template,

       we're not going to find the declaration in the class.

       For example, in:

         struct S { template <typename T> void f(T); };

         template <> void S::f(int);

       we're not going to find `S::f(int)', but there's no

       reason we should, either.  We let our callers know we didn't

       find the method, but we don't complain.  */

    return NULL_TREE;

  /* Basic sanity check: for a template function, the template parameters

     either were not passed, or they are the same of DECL_TEMPLATE_PARMS.  */

  if (TREE_CODE (function) == TEMPLATE_DECL)

    {

      gcc_assert (!template_parms

                  || comp_template_parms (template_parms,

                                          DECL_TEMPLATE_PARMS (function)));

      template_parms = DECL_TEMPLATE_PARMS (function);

    }

  /* OK, is this a definition of a member template?  */

  is_template = (template_parms != NULL_TREE);

  ix = class_method_index_for_fn (complete_type (ctype), function);

  if (ix >= 0)

    {

      VEC(tree,gc) *methods = CLASSTYPE_METHOD_VEC (ctype);

      tree fndecls, fndecl = 0;

      bool is_conv_op;

      tree pushed_scope;

      const char *format = NULL;

      pushed_scope = push_scope (ctype);

      for (fndecls = VEC_index (tree, methods, ix);

           fndecls; fndecls = OVL_NEXT (fndecls))

        {

          tree p1, p2;

          fndecl = OVL_CURRENT (fndecls);

          p1 = TYPE_ARG_TYPES (TREE_TYPE (function));

          p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl));

          /* We cannot simply call decls_match because this doesn't

             work for static member functions that are pretending to

             be methods, and because the name may have been changed by

             asm("new_name").  */

           /* Get rid of the this parameter on functions that become

              static.  */

          if (DECL_STATIC_FUNCTION_P (fndecl)

              && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)

            p1 = TREE_CHAIN (p1);

          /* A member template definition only matches a member template

             declaration.  */

          if (is_template != (TREE_CODE (fndecl) == TEMPLATE_DECL))

            continue;

          if (same_type_p (TREE_TYPE (TREE_TYPE (function)),

                           TREE_TYPE (TREE_TYPE (fndecl)))

              && compparms (p1, p2)

              && (!is_template

                  || comp_template_parms (template_parms,

                                          DECL_TEMPLATE_PARMS (fndecl)))

              && (DECL_TEMPLATE_SPECIALIZATION (function)

                  == DECL_TEMPLATE_SPECIALIZATION (fndecl))

              && (!DECL_TEMPLATE_SPECIALIZATION (function)

                  || (DECL_TI_TEMPLATE (function)

                      == DECL_TI_TEMPLATE (fndecl))))

            break;

        }

      if (pushed_scope)

        pop_scope (pushed_scope);

      if (fndecls)

        return OVL_CURRENT (fndecls);

      error ("prototype for %q#D does not match any in class %qT",

             function, ctype);

      is_conv_op = DECL_CONV_FN_P (fndecl);

      if (is_conv_op)

        ix = CLASSTYPE_FIRST_CONVERSION_SLOT;

      fndecls = VEC_index (tree, methods, ix);

      while (fndecls)

        {

          fndecl = OVL_CURRENT (fndecls);

          fndecls = OVL_NEXT (fndecls);

          if (!fndecls && is_conv_op)

            {

              if (VEC_length (tree, methods) > (size_t) ++ix)

                {

                  fndecls = VEC_index (tree, methods, ix);

                  if (!DECL_CONV_FN_P (OVL_CURRENT (fndecls)))

                    {

                      fndecls = NULL_TREE;

                      is_conv_op = false;

                    }

                }

              else

                is_conv_op = false;

            }

          if (format)

            format = "                %+#D";

          else if (fndecls)

            format = N_("candidates are: %+#D");

          else

            format = N_("candidate is: %+#D");

          error (format, fndecl);

        }

    }

  else if (!COMPLETE_TYPE_P (ctype))

    cxx_incomplete_type_error (function, ctype);

  else

    error ("no %q#D member function declared in class %qT",

           function, ctype);

  /* If we did not find the method in the class, add it to avoid

     spurious errors (unless the CTYPE is not yet defined, in which

     case we'll only confuse ourselves when the function is declared

     properly within the class.  */

  if (COMPLETE_TYPE_P (ctype))