Subversion Repositories openrisc_2011-10-31

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

   Copyright (C) 1988, 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)

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/>.  */

/* 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 "tree-inline.h"

#include "decl.h"

#include "intl.h"

#include "output.h"

#include "except.h"

#include "toplev.h"

#include "hashtab.h"

#include "tm_p.h"

#include "target.h"

#include "c-common.h"

#include "c-pragma.h"

#include "diagnostic.h"

#include "intl.h"

#include "debug.h"

#include "timevar.h"

#include "tree-flow.h"

#include "pointer-set.h"

#include "plugin.h"

static tree grokparms (tree parmlist, tree *);

static const char *redeclaration_error_message (tree, tree);

static int decl_jump_unsafe (tree);

static void require_complete_types_for_parms (tree);

static int ambi_op_p (enum tree_code);

static int unary_op_p (enum tree_code);

static void push_local_name (tree);

static tree grok_reference_init (tree, tree, tree, tree *);

static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *,

                         int, int, tree);

static void record_unknown_type (tree, const char *);

static tree builtin_function_1 (tree, tree, bool);

static tree build_library_fn_1 (tree, enum tree_code, tree);

static int member_function_or_else (tree, tree, enum overload_flags);

static void bad_specifiers (tree, const char *, int, int, int, int,

                            int);

static void check_for_uninitialized_const_var (tree);

static hashval_t typename_hash (const void *);

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

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

static tree record_builtin_java_type (const char *, int);

static const char *tag_name (enum tag_types);

static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);

static int walk_namespaces_r (tree, walk_namespaces_fn, void *);

static void maybe_deduce_size_from_array_init (tree, tree);

static void layout_var_decl (tree);

static tree check_initializer (tree, tree, int, tree *);

static void make_rtl_for_nonlocal_decl (tree, tree, const char *);

static void save_function_data (tree);

static void check_function_type (tree, tree);

static void finish_constructor_body (void);

static void begin_destructor_body (void);

static void finish_destructor_body (void);

static tree create_array_type_for_decl (tree, tree, tree);

static tree get_atexit_node (void);

static tree get_dso_handle_node (void);

static tree start_cleanup_fn (void);

static void end_cleanup_fn (void);

static tree cp_make_fname_decl (location_t, tree, int);

static void initialize_predefined_identifiers (void);

static tree check_special_function_return_type

        (special_function_kind, tree, tree);

static tree push_cp_library_fn (enum tree_code, tree);

static tree build_cp_library_fn (tree, enum tree_code, tree);

static void store_parm_decls (tree);

static void initialize_local_var (tree, tree);

static void expand_static_init (tree, tree);

/* The following symbols are subsumed in the cp_global_trees array, and

   listed here individually for documentation purposes.

   C++ extensions

        tree wchar_decl_node;

        tree vtable_entry_type;

        tree delta_type_node;

        tree __t_desc_type_node;

        tree class_type_node;

        tree unknown_type_node;

   Array type `vtable_entry_type[]'

        tree vtbl_type_node;

        tree vtbl_ptr_type_node;

   Namespaces,

        tree std_node;

        tree abi_node;

   A FUNCTION_DECL which can call `abort'.  Not necessarily the

   one that the user will declare, but sufficient to be called

   by routines that want to abort the program.

        tree abort_fndecl;

   The FUNCTION_DECL for the default `::operator delete'.

        tree global_delete_fndecl;

   Used by RTTI

        tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;

        tree tinfo_var_id;  */

tree cp_global_trees[CPTI_MAX];

/* Indicates that there is a type value in some namespace, although

   that is not necessarily in scope at the moment.  */

tree global_type_node;

/* The node that holds the "name" of the global scope.  */

tree global_scope_name;

#define local_names cp_function_chain->x_local_names

/* A list of objects which have constructors or destructors

   which reside in the global scope.  The decl is stored in

   the TREE_VALUE slot and the initializer is stored

   in the TREE_PURPOSE slot.  */

tree static_aggregates;

/* -- end of C++ */

/* A node for the integer constants 2, and 3.  */

tree integer_two_node, integer_three_node;

/* Used only for jumps to as-yet undefined labels, since jumps to

   defined labels can have their validity checked immediately.  */

struct GTY(()) named_label_use_entry {

  struct named_label_use_entry *next;

  /* The binding level to which this entry is *currently* attached.

     This is initially the binding level in which the goto appeared,

     but is modified as scopes are closed.  */

  struct cp_binding_level *binding_level;

  /* The head of the names list that was current when the goto appeared,

     or the inner scope popped.  These are the decls that will *not* be

     skipped when jumping to the label.  */

  tree names_in_scope;

  /* The location of the goto, for error reporting.  */

  location_t o_goto_locus;

  /* True if an OpenMP structured block scope has been closed since

     the goto appeared.  This means that the branch from the label will

     illegally exit an OpenMP scope.  */

  bool in_omp_scope;

};

/* A list of all LABEL_DECLs in the function that have names.  Here so

   we can clear out their names' definitions at the end of the

   function, and so we can check the validity of jumps to these labels.  */

struct GTY(()) named_label_entry {

  /* The decl itself.  */

  tree label_decl;

  /* The binding level to which the label is *currently* attached.

     This is initially set to the binding level in which the label

     is defined, but is modified as scopes are closed.  */

  struct cp_binding_level *binding_level;

  /* The head of the names list that was current when the label was

     defined, or the inner scope popped.  These are the decls that will

     be skipped when jumping to the label.  */

  tree names_in_scope;

  /* A tree list of all decls from all binding levels that would be

     crossed by a backward branch to the label.  */

  tree bad_decls;

  /* A list of uses of the label, before the label is defined.  */

  struct named_label_use_entry *uses;

  /* The following bits are set after the label is defined, and are

     updated as scopes are popped.  They indicate that a backward jump

     to the label will illegally enter a scope of the given flavor.  */

  bool in_try_scope;

  bool in_catch_scope;

  bool in_omp_scope;

};

#define named_labels cp_function_chain->x_named_labels

/* The number of function bodies which we are currently processing.

   (Zero if we are at namespace scope, one inside the body of a

   function, two inside the body of a function in a local class, etc.)  */

int function_depth;

/* To avoid unwanted recursion, finish_function defers all mark_used calls

   encountered during its execution until it finishes.  */

bool defer_mark_used_calls;

VEC(tree, gc) *deferred_mark_used_calls;

/* States indicating how grokdeclarator() should handle declspecs marked

   with __attribute__((deprecated)).  An object declared as

   __attribute__((deprecated)) suppresses warnings of uses of other

   deprecated items.  */

enum deprecated_states deprecated_state = DEPRECATED_NORMAL;

/* A TREE_LIST of VAR_DECLs.  The TREE_PURPOSE is a RECORD_TYPE or

   UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type.  At the

   time the VAR_DECL was declared, the type was incomplete.  */

static GTY(()) tree incomplete_vars;

/* Returns the kind of template specialization we are currently

   processing, given that it's declaration contained N_CLASS_SCOPES

   explicit scope qualifications.  */

tmpl_spec_kind

current_tmpl_spec_kind (int n_class_scopes)

{

  int n_template_parm_scopes = 0;

  int seen_specialization_p = 0;

  int innermost_specialization_p = 0;

  struct cp_binding_level *b;

  /* Scan through the template parameter scopes.  */

  for (b = current_binding_level;

       b->kind == sk_template_parms;

       b = b->level_chain)

    {

      /* If we see a specialization scope inside a parameter scope,

         then something is wrong.  That corresponds to a declaration

         like:

            template <class T> template <> ...

         which is always invalid since [temp.expl.spec] forbids the

         specialization of a class member template if the enclosing

         class templates are not explicitly specialized as well.  */

      if (b->explicit_spec_p)

        {

          if (n_template_parm_scopes == 0)

            innermost_specialization_p = 1;

          else

            seen_specialization_p = 1;

        }

      else if (seen_specialization_p == 1)

        return tsk_invalid_member_spec;

      ++n_template_parm_scopes;

    }

  /* Handle explicit instantiations.  */

  if (processing_explicit_instantiation)

    {

      if (n_template_parm_scopes != 0)

        /* We've seen a template parameter list during an explicit

           instantiation.  For example:

             template <class T> template void f(int);

           This is erroneous.  */

        return tsk_invalid_expl_inst;

      else

        return tsk_expl_inst;

    }

  if (n_template_parm_scopes < n_class_scopes)

    /* We've not seen enough template headers to match all the

       specialized classes present.  For example:

         template <class T> void R<T>::S<T>::f(int);

       This is invalid; there needs to be one set of template

       parameters for each class.  */

    return tsk_insufficient_parms;

  else if (n_template_parm_scopes == n_class_scopes)

    /* We're processing a non-template declaration (even though it may

       be a member of a template class.)  For example:

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

       The `class T' matches the `S<T>', leaving no template headers

       corresponding to the `f'.  */

    return tsk_none;

  else if (n_template_parm_scopes > n_class_scopes + 1)

    /* We've got too many template headers.  For example:

         template <> template <class T> void f (T);

       There need to be more enclosing classes.  */

    return tsk_excessive_parms;

  else

    /* This must be a template.  It's of the form:

         template <class T> template <class U> void S<T>::f(U);

       This is a specialization if the innermost level was a

       specialization; otherwise it's just a definition of the

       template.  */

    return innermost_specialization_p ? tsk_expl_spec : tsk_template;

}

/* Exit the current scope.  */

void

finish_scope (void)

{

  poplevel (0, 0, 0);

}

/* When a label goes out of scope, check to see if that label was used

   in a valid manner, and issue any appropriate warnings or errors.  */

static void

pop_label (tree label, tree old_value)

{

  if (!processing_template_decl)

    {

      if (DECL_INITIAL (label) == NULL_TREE)

        {

          location_t location;

          error ("label %q+D used but not defined", label);

          location = input_location; /* FIXME want (input_filename, (line)0) */

          /* Avoid crashing later.  */

          define_label (location, DECL_NAME (label));

        }

      else

        warn_for_unused_label (label);

    }

  SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);

}

/* At the end of a function, all labels declared within the function

   go out of scope.  BLOCK is the top-level block for the

   function.  */

static int

pop_labels_1 (void **slot, void *data)

{

  struct named_label_entry *ent = (struct named_label_entry *) *slot;

  tree block = (tree) data;

  pop_label (ent->label_decl, NULL_TREE);

  /* Put the labels into the "variables" of the top-level block,

     so debugger can see them.  */

  TREE_CHAIN (ent->label_decl) = BLOCK_VARS (block);

  BLOCK_VARS (block) = ent->label_decl;

  htab_clear_slot (named_labels, slot);

  return 1;

}

static void

pop_labels (tree block)

{

  if (named_labels)

    {

      htab_traverse (named_labels, pop_labels_1, block);

      named_labels = NULL;

    }

}

/* At the end of a block with local labels, restore the outer definition.  */

static void

pop_local_label (tree label, tree old_value)

{

  struct named_label_entry dummy;

  void **slot;

  pop_label (label, old_value);

  dummy.label_decl = label;

  slot = htab_find_slot (named_labels, &dummy, NO_INSERT);

  htab_clear_slot (named_labels, slot);

}

/* The following two routines are used to interface to Objective-C++.

   The binding level is purposely treated as an opaque type.  */

void *

objc_get_current_scope (void)

{

  return current_binding_level;

}

/* The following routine is used by the NeXT-style SJLJ exceptions;

   variables get marked 'volatile' so as to not be clobbered by

   _setjmp()/_longjmp() calls.  All variables in the current scope,

   as well as parent scopes up to (but not including) ENCLOSING_BLK

   shall be thusly marked.  */

void

objc_mark_locals_volatile (void *enclosing_blk)

{

  struct cp_binding_level *scope;

  for (scope = current_binding_level;

       scope && scope != enclosing_blk;

       scope = scope->level_chain)

    {

      tree decl;

      for (decl = scope->names; decl; decl = TREE_CHAIN (decl))

        objc_volatilize_decl (decl);

      /* Do not climb up past the current function.  */

      if (scope->kind == sk_function_parms)

        break;

    }

}

/* Update data for defined and undefined labels when leaving a scope.  */

static int

poplevel_named_label_1 (void **slot, void *data)

{

  struct named_label_entry *ent = (struct named_label_entry *) *slot;

  struct cp_binding_level *bl = (struct cp_binding_level *) data;

  struct cp_binding_level *obl = bl->level_chain;

  if (ent->binding_level == bl)

    {

      tree decl;

      for (decl = ent->names_in_scope; decl; decl = TREE_CHAIN (decl))

        if (decl_jump_unsafe (decl))

          ent->bad_decls = tree_cons (NULL, decl, ent->bad_decls);

      ent->binding_level = obl;

      ent->names_in_scope = obl->names;

      switch (bl->kind)

        {

        case sk_try:

          ent->in_try_scope = true;

          break;

        case sk_catch:

          ent->in_catch_scope = true;

          break;

        case sk_omp:

          ent->in_omp_scope = true;

          break;

        default:

          break;

        }

    }

  else if (ent->uses)

    {

      struct named_label_use_entry *use;

      for (use = ent->uses; use ; use = use->next)

        if (use->binding_level == bl)

          {

            use->binding_level = obl;

            use->names_in_scope = obl->names;

            if (bl->kind == sk_omp)

              use->in_omp_scope = true;

          }

    }

  return 1;

}

/* Exit a binding level.

   Pop the level off, and restore the state of the identifier-decl mappings

   that were in effect when this level was entered.

   If KEEP == 1, this level had explicit declarations, so

   and create a "block" (a BLOCK node) for the level

   to record its declarations and subblocks for symbol table output.

   If FUNCTIONBODY is nonzero, this level is the body of a function,

   so create a block as if KEEP were set and also clear out all

   label names.

   If REVERSE is nonzero, reverse the order of decls before putting

   them into the BLOCK.  */

tree

poplevel (int keep, int reverse, int functionbody)

{

  tree link;

  /* The chain of decls was accumulated in reverse order.

     Put it into forward order, just for cleanliness.  */

  tree decls;

  tree subblocks;

  tree block;

  tree decl;

  int leaving_for_scope;

  scope_kind kind;

  timevar_push (TV_NAME_LOOKUP);

 restart:

  block = NULL_TREE;

  gcc_assert (current_binding_level->kind != sk_class);

  if (current_binding_level->kind == sk_cleanup)

    functionbody = 0;

  subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;

  gcc_assert (!VEC_length(cp_class_binding,

                          current_binding_level->class_shadowed));

  /* We used to use KEEP == 2 to indicate that the new block should go

     at the beginning of the list of blocks at this binding level,

     rather than the end.  This hack is no longer used.  */

  gcc_assert (keep == 0 || keep == 1);

  if (current_binding_level->keep)

    keep = 1;

  /* Any uses of undefined labels, and any defined labels, now operate

     under constraints of next binding contour.  */

  if (cfun && !functionbody && named_labels)

    htab_traverse (named_labels, poplevel_named_label_1,

                   current_binding_level);

  /* Get the decls in the order they were written.

     Usually current_binding_level->names is in reverse order.

     But parameter decls were previously put in forward order.  */

  if (reverse)

    current_binding_level->names

      = decls = nreverse (current_binding_level->names);

  else

    decls = current_binding_level->names;

  /* If there were any declarations or structure tags in that level,

     or if this level is a function body,

     create a BLOCK to record them for the life of this function.  */

  block = NULL_TREE;

  if (keep == 1 || functionbody)

    block = make_node (BLOCK);

  if (block != NULL_TREE)

    {

      BLOCK_VARS (block) = decls;

      BLOCK_SUBBLOCKS (block) = subblocks;

    }

  /* In each subblock, record that this is its superior.  */

  if (keep >= 0)

    for (link = subblocks; link; link = BLOCK_CHAIN (link))

      BLOCK_SUPERCONTEXT (link) = block;

  /* We still support the old for-scope rules, whereby the variables

     in a for-init statement were in scope after the for-statement

     ended.  We only use the new rules if flag_new_for_scope is

     nonzero.  */

  leaving_for_scope

    = current_binding_level->kind == sk_for && flag_new_for_scope == 1;

  /* Before we remove the declarations first check for unused variables.  */

  if (warn_unused_variable

      && !processing_template_decl)

    for (decl = getdecls (); decl; decl = TREE_CHAIN (decl))

      if (TREE_CODE (decl) == VAR_DECL

          && ! TREE_USED (decl)

          && ! DECL_IN_SYSTEM_HEADER (decl)

          && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))

        warning (OPT_Wunused_variable, "unused variable %q+D", decl);

  /* Remove declarations for all the DECLs in this level.  */

  for (link = decls; link; link = TREE_CHAIN (link))

    {

      if (leaving_for_scope && TREE_CODE (link) == VAR_DECL

          && DECL_NAME (link))

        {

          tree name = DECL_NAME (link);

          cxx_binding *ob;

          tree ns_binding;

          ob = outer_binding (name,

                              IDENTIFIER_BINDING (name),

                              /*class_p=*/true);

          if (!ob)

            ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);

          else

            ns_binding = NULL_TREE;

          if (ob && ob->scope == current_binding_level->level_chain)

            /* We have something like:

                 int i;

                 for (int i; ;);

               and we are leaving the `for' scope.  There's no reason to

               keep the binding of the inner `i' in this case.  */

            pop_binding (name, link);

          else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))

                   || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))

            /* Here, we have something like:

                 typedef int I;

                 void f () {

                   for (int I; ;);

                 }

               We must pop the for-scope binding so we know what's a

               type and what isn't.  */

            pop_binding (name, link);

          else

            {

              /* Mark this VAR_DECL as dead so that we can tell we left it

                 there only for backward compatibility.  */

              DECL_DEAD_FOR_LOCAL (link) = 1;

              /* Keep track of what should have happened when we

                 popped the binding.  */

              if (ob && ob->value)

                {

                  SET_DECL_SHADOWED_FOR_VAR (link, ob->value);

                  DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;

                }

              /* Add it to the list of dead variables in the next

                 outermost binding to that we can remove these when we

                 leave that binding.  */

              current_binding_level->level_chain->dead_vars_from_for

                = tree_cons (NULL_TREE, link,

                             current_binding_level->level_chain->

                             dead_vars_from_for);

              /* Although we don't pop the cxx_binding, we do clear

                 its SCOPE since the scope is going away now.  */

              IDENTIFIER_BINDING (name)->scope

                = current_binding_level->level_chain;

            }

        }

      else

        {

          tree name;

          /* Remove the binding.  */

          decl = link;

          if (TREE_CODE (decl) == TREE_LIST)

            decl = TREE_VALUE (decl);

          name = decl;

          if (TREE_CODE (name) == OVERLOAD)

            name = OVL_FUNCTION (name);

          gcc_assert (DECL_P (name));

          pop_binding (DECL_NAME (name), decl);

        }

    }

  /* Remove declarations for any `for' variables from inner scopes

     that we kept around.  */

  for (link = current_binding_level->dead_vars_from_for;

       link; link = TREE_CHAIN (link))

    pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));

  /* Restore the IDENTIFIER_TYPE_VALUEs.  */

  for (link = current_binding_level->type_shadowed;

       link; link = TREE_CHAIN (link))

    SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));

  /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */

  for (link = current_binding_level->shadowed_labels;

       link;

       link = TREE_CHAIN (link))

    pop_local_label (TREE_VALUE (link), TREE_PURPOSE (link));

  /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs

     list if a `using' declaration put them there.  The debugging

     back ends won't understand OVERLOAD, so we remove them here.

     Because the BLOCK_VARS are (temporarily) shared with

     CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have

     popped all the bindings.  */

  if (block)

    {

      tree* d;

      for (d = &BLOCK_VARS (block); *d; )

        {

          if (TREE_CODE (*d) == TREE_LIST)

            *d = TREE_CHAIN (*d);

          else

            d = &TREE_CHAIN (*d);

        }

    }

  /* If the level being exited is the top level of a function,

     check over all the labels.  */

  if (functionbody)

    {

      /* Since this is the top level block of a function, the vars are

         the function's parameters.  Don't leave them in the BLOCK

         because they are found in the FUNCTION_DECL instead.  */

      BLOCK_VARS (block) = 0;

      pop_labels (block);

    }

  kind = current_binding_level->kind;

  if (kind == sk_cleanup)

    {

      tree stmt;