Subversion Repositories openrisc_me

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

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

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

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

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

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

   Free Software Foundation, Inc.

   Free Software Foundation, Inc.

   Contributed by Michael Tiemann (tiemann@cygnus.com)

   Contributed by Michael Tiemann (tiemann@cygnus.com)

This file is part of GCC.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify

GCC is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 3, or (at your option)

the Free Software Foundation; either version 3, or (at your option)

any later version.

any later version.

GCC is distributed in the hope that it will be useful,

GCC is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

along with GCC; see the file COPYING3.  If not see

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

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

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

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

   Also constructs types; the standard scalar types at initialization,

   Also constructs types; the standard scalar types at initialization,

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

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

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

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

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

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

#include "config.h"

#include "config.h"

#include "system.h"

#include "system.h"

#include "coretypes.h"

#include "coretypes.h"

#include "tm.h"

#include "tm.h"

#include "tree.h"

#include "tree.h"

#include "rtl.h"

#include "rtl.h"

#include "expr.h"

#include "expr.h"

#include "flags.h"

#include "flags.h"

#include "cp-tree.h"

#include "cp-tree.h"

#include "tree-inline.h"

#include "tree-inline.h"

#include "decl.h"

#include "decl.h"

#include "intl.h"

#include "intl.h"

#include "output.h"

#include "output.h"

#include "except.h"

#include "except.h"

#include "toplev.h"

#include "toplev.h"

#include "hashtab.h"

#include "hashtab.h"

#include "tm_p.h"

#include "tm_p.h"

#include "target.h"

#include "target.h"

#include "c-common.h"

#include "c-common.h"

#include "c-pragma.h"

#include "c-pragma.h"

#include "diagnostic.h"

#include "diagnostic.h"

#include "intl.h"

#include "intl.h"

#include "debug.h"

#include "debug.h"

#include "timevar.h"

#include "timevar.h"

#include "tree-flow.h"

#include "tree-flow.h"

#include "pointer-set.h"

#include "pointer-set.h"

#include "plugin.h"

#include "plugin.h"

static tree grokparms (tree parmlist, tree *);

static tree grokparms (tree parmlist, tree *);

static const char *redeclaration_error_message (tree, tree);

static const char *redeclaration_error_message (tree, tree);

static int decl_jump_unsafe (tree);

static int decl_jump_unsafe (tree);

static void require_complete_types_for_parms (tree);

static void require_complete_types_for_parms (tree);

static int ambi_op_p (enum tree_code);

static int ambi_op_p (enum tree_code);

static int unary_op_p (enum tree_code);

static int unary_op_p (enum tree_code);

static void push_local_name (tree);

static void push_local_name (tree);

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

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

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

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

                         int, int, tree);

                         int, int, tree);

static void record_unknown_type (tree, const char *);

static void record_unknown_type (tree, const char *);

static tree builtin_function_1 (tree, tree, bool);

static tree builtin_function_1 (tree, tree, bool);

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

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

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

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

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

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

                            int);

                            int);

static void check_for_uninitialized_const_var (tree);

static void check_for_uninitialized_const_var (tree);

static hashval_t typename_hash (const void *);

static hashval_t typename_hash (const void *);

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

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

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

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

static tree record_builtin_java_type (const char *, int);

static tree record_builtin_java_type (const char *, int);

static const char *tag_name (enum tag_types);

static const char *tag_name (enum tag_types);

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

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

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

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

static void maybe_deduce_size_from_array_init (tree, tree);

static void maybe_deduce_size_from_array_init (tree, tree);

static void layout_var_decl (tree);

static void layout_var_decl (tree);

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

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

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

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

static void save_function_data (tree);

static void save_function_data (tree);

static void check_function_type (tree, tree);

static void check_function_type (tree, tree);

static void finish_constructor_body (void);

static void finish_constructor_body (void);

static void begin_destructor_body (void);

static void begin_destructor_body (void);

static void finish_destructor_body (void);

static void finish_destructor_body (void);

static tree create_array_type_for_decl (tree, tree, tree);

static tree create_array_type_for_decl (tree, tree, tree);

static tree get_atexit_node (void);

static tree get_atexit_node (void);

static tree get_dso_handle_node (void);

static tree get_dso_handle_node (void);

static tree start_cleanup_fn (void);

static tree start_cleanup_fn (void);

static void end_cleanup_fn (void);

static void end_cleanup_fn (void);

static tree cp_make_fname_decl (location_t, tree, int);

static tree cp_make_fname_decl (location_t, tree, int);

static void initialize_predefined_identifiers (void);

static void initialize_predefined_identifiers (void);

static tree check_special_function_return_type

static tree check_special_function_return_type

        (special_function_kind, tree, tree);

        (special_function_kind, tree, tree);

static tree push_cp_library_fn (enum tree_code, tree);

static tree push_cp_library_fn (enum tree_code, tree);

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

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

static void store_parm_decls (tree);

static void store_parm_decls (tree);

static void initialize_local_var (tree, tree);

static void initialize_local_var (tree, tree);

static void expand_static_init (tree, tree);

static void expand_static_init (tree, tree);

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

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

   listed here individually for documentation purposes.

   listed here individually for documentation purposes.

   C++ extensions

   C++ extensions

        tree wchar_decl_node;

        tree wchar_decl_node;

        tree vtable_entry_type;

        tree vtable_entry_type;

        tree delta_type_node;

        tree delta_type_node;

        tree __t_desc_type_node;

        tree __t_desc_type_node;

        tree class_type_node;

        tree class_type_node;

        tree unknown_type_node;

        tree unknown_type_node;

   Array type `vtable_entry_type[]'

   Array type `vtable_entry_type[]'

        tree vtbl_type_node;

        tree vtbl_type_node;

        tree vtbl_ptr_type_node;

        tree vtbl_ptr_type_node;

   Namespaces,

   Namespaces,

        tree std_node;

        tree std_node;

        tree abi_node;

        tree abi_node;

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

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

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

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

   by routines that want to abort the program.

   by routines that want to abort the program.

        tree abort_fndecl;

        tree abort_fndecl;

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

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

        tree global_delete_fndecl;

        tree global_delete_fndecl;

   Used by RTTI

   Used by RTTI

        tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;

        tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;

        tree tinfo_var_id;  */

        tree tinfo_var_id;  */

tree cp_global_trees[CPTI_MAX];

tree cp_global_trees[CPTI_MAX];

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

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

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

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

tree global_type_node;

tree global_type_node;

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

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

tree global_scope_name;

tree global_scope_name;

#define local_names cp_function_chain->x_local_names

#define local_names cp_function_chain->x_local_names

/* A list of objects which have constructors or destructors

/* A list of objects which have constructors or destructors

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

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

   the TREE_VALUE slot and the initializer is stored

   the TREE_VALUE slot and the initializer is stored

   in the TREE_PURPOSE slot.  */

   in the TREE_PURPOSE slot.  */

tree static_aggregates;

tree static_aggregates;

/* -- end of C++ */

/* -- end of C++ */

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

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

tree integer_two_node, integer_three_node;

tree integer_two_node, integer_three_node;

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

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

   defined labels can have their validity checked immediately.  */

   defined labels can have their validity checked immediately.  */

struct GTY(()) named_label_use_entry {

struct GTY(()) named_label_use_entry {

  struct named_label_use_entry *next;

  struct named_label_use_entry *next;

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

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

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

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

     but is modified as scopes are closed.  */

     but is modified as scopes are closed.  */

  struct cp_binding_level *binding_level;

  struct cp_binding_level *binding_level;

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

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

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

     skipped when jumping to the label.  */

     skipped when jumping to the label.  */

  tree names_in_scope;

  tree names_in_scope;

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

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

  location_t o_goto_locus;

  location_t o_goto_locus;

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

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

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

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

     illegally exit an OpenMP scope.  */

     illegally exit an OpenMP scope.  */

  bool in_omp_scope;

  bool in_omp_scope;

};

};

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

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

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

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

struct GTY(()) named_label_entry {

struct GTY(()) named_label_entry {

  /* The decl itself.  */

  /* The decl itself.  */

  tree label_decl;

  tree label_decl;

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

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

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

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

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

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

  struct cp_binding_level *binding_level;

  struct cp_binding_level *binding_level;

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

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

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

     be skipped when jumping to the label.  */

     be skipped when jumping to the label.  */

  tree names_in_scope;

  tree names_in_scope;

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

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

     crossed by a backward branch to the label.  */

     crossed by a backward branch to the label.  */

  tree bad_decls;

  tree bad_decls;

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

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

  struct named_label_use_entry *uses;

  struct named_label_use_entry *uses;

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

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

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

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

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

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

  bool in_try_scope;

  bool in_try_scope;

  bool in_catch_scope;

  bool in_catch_scope;

  bool in_omp_scope;

  bool in_omp_scope;

};

};

#define named_labels cp_function_chain->x_named_labels

#define named_labels cp_function_chain->x_named_labels

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

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

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

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

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

int function_depth;

int function_depth;

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

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

   encountered during its execution until it finishes.  */

   encountered during its execution until it finishes.  */

bool defer_mark_used_calls;

bool defer_mark_used_calls;

VEC(tree, gc) *deferred_mark_used_calls;

VEC(tree, gc) *deferred_mark_used_calls;

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

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

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

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

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

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

   deprecated items.  */

   deprecated items.  */

enum deprecated_states deprecated_state = DEPRECATED_NORMAL;

enum deprecated_states deprecated_state = DEPRECATED_NORMAL;

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

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

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

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

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

static GTY(()) tree incomplete_vars;

static GTY(()) tree incomplete_vars;

/* Returns the kind of template specialization we are currently

/* Returns the kind of template specialization we are currently

   processing, given that it's declaration contained N_CLASS_SCOPES

   processing, given that it's declaration contained N_CLASS_SCOPES

   explicit scope qualifications.  */

   explicit scope qualifications.  */

tmpl_spec_kind

tmpl_spec_kind

current_tmpl_spec_kind (int n_class_scopes)

current_tmpl_spec_kind (int n_class_scopes)

{

{

  int n_template_parm_scopes = 0;

  int n_template_parm_scopes = 0;

  int seen_specialization_p = 0;

  int seen_specialization_p = 0;

  int innermost_specialization_p = 0;

  int innermost_specialization_p = 0;

  struct cp_binding_level *b;

  struct cp_binding_level *b;

  /* Scan through the template parameter scopes.  */

  /* Scan through the template parameter scopes.  */

  for (b = current_binding_level;

  for (b = current_binding_level;

       b->kind == sk_template_parms;

       b->kind == sk_template_parms;

       b = b->level_chain)

       b = b->level_chain)

    {

    {

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

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

         then something is wrong.  That corresponds to a declaration

         then something is wrong.  That corresponds to a declaration

         like:

         like:

            template <class T> template <> ...

            template <class T> template <> ...

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

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

         specialization of a class member template if the enclosing

         specialization of a class member template if the enclosing

         class templates are not explicitly specialized as well.  */

         class templates are not explicitly specialized as well.  */

      if (b->explicit_spec_p)

      if (b->explicit_spec_p)

        {

        {

          if (n_template_parm_scopes == 0)

          if (n_template_parm_scopes == 0)

            innermost_specialization_p = 1;

            innermost_specialization_p = 1;

          else

          else

            seen_specialization_p = 1;

            seen_specialization_p = 1;

        }

        }

      else if (seen_specialization_p == 1)

      else if (seen_specialization_p == 1)

        return tsk_invalid_member_spec;

        return tsk_invalid_member_spec;

      ++n_template_parm_scopes;

      ++n_template_parm_scopes;

    }

    }

  /* Handle explicit instantiations.  */

  /* Handle explicit instantiations.  */

  if (processing_explicit_instantiation)

  if (processing_explicit_instantiation)

    {

    {

      if (n_template_parm_scopes != 0)

      if (n_template_parm_scopes != 0)

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

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

           instantiation.  For example:

           instantiation.  For example:

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

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

           This is erroneous.  */

           This is erroneous.  */

        return tsk_invalid_expl_inst;

        return tsk_invalid_expl_inst;

      else

      else

        return tsk_expl_inst;

        return tsk_expl_inst;

    }

    }

  if (n_template_parm_scopes < n_class_scopes)

  if (n_template_parm_scopes < n_class_scopes)

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

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

       specialized classes present.  For example:

       specialized classes present.  For example:

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

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

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

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

       parameters for each class.  */

       parameters for each class.  */

    return tsk_insufficient_parms;

    return tsk_insufficient_parms;

  else if (n_template_parm_scopes == n_class_scopes)

  else if (n_template_parm_scopes == n_class_scopes)

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

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

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

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

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

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

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

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

       corresponding to the `f'.  */

       corresponding to the `f'.  */

    return tsk_none;

    return tsk_none;

  else if (n_template_parm_scopes > n_class_scopes + 1)

  else if (n_template_parm_scopes > n_class_scopes + 1)

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

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

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

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

       There need to be more enclosing classes.  */

       There need to be more enclosing classes.  */

    return tsk_excessive_parms;

    return tsk_excessive_parms;

  else

  else

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

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

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

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

       This is a specialization if the innermost level was a

       This is a specialization if the innermost level was a

       specialization; otherwise it's just a definition of the

       specialization; otherwise it's just a definition of the

       template.  */

       template.  */

    return innermost_specialization_p ? tsk_expl_spec : tsk_template;

    return innermost_specialization_p ? tsk_expl_spec : tsk_template;

}

}

/* Exit the current scope.  */

/* Exit the current scope.  */

void

void

finish_scope (void)

finish_scope (void)

{

{

  poplevel (0, 0, 0);

  poplevel (0, 0, 0);

}

}

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

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

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

static void

static void

pop_label (tree label, tree old_value)

pop_label (tree label, tree old_value)

{

{

  if (!processing_template_decl)

  if (!processing_template_decl)

    {

    {

      if (DECL_INITIAL (label) == NULL_TREE)

      if (DECL_INITIAL (label) == NULL_TREE)

        {

        {

          location_t location;

          location_t location;

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

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

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

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

          /* Avoid crashing later.  */

          /* Avoid crashing later.  */

          define_label (location, DECL_NAME (label));

          define_label (location, DECL_NAME (label));

        }

        }

      else

      else

        warn_for_unused_label (label);

        warn_for_unused_label (label);

    }

    }

  SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);

  SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);

}

}

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

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

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

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

   function.  */

   function.  */

static int

static int

pop_labels_1 (void **slot, void *data)

pop_labels_1 (void **slot, void *data)

{

{

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

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

  tree block = (tree) data;

  tree block = (tree) data;

  pop_label (ent->label_decl, NULL_TREE);

  pop_label (ent->label_decl, NULL_TREE);

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

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

     so debugger can see them.  */

     so debugger can see them.  */

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

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

  BLOCK_VARS (block) = ent->label_decl;

  BLOCK_VARS (block) = ent->label_decl;

  htab_clear_slot (named_labels, slot);

  htab_clear_slot (named_labels, slot);

  return 1;

  return 1;

}

}

static void

static void

pop_labels (tree block)

pop_labels (tree block)

{

{

  if (named_labels)

  if (named_labels)

    {

    {

      htab_traverse (named_labels, pop_labels_1, block);

      htab_traverse (named_labels, pop_labels_1, block);

      named_labels = NULL;

      named_labels = NULL;

    }

    }

}

}

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

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

static void

static void

pop_local_label (tree label, tree old_value)

pop_local_label (tree label, tree old_value)

{

{

  struct named_label_entry dummy;

  struct named_label_entry dummy;

  void **slot;

  void **slot;

  pop_label (label, old_value);

  pop_label (label, old_value);

  dummy.label_decl = label;

  dummy.label_decl = label;

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

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

  htab_clear_slot (named_labels, slot);

  htab_clear_slot (named_labels, slot);

}

}

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

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

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

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

void *

void *

objc_get_current_scope (void)

objc_get_current_scope (void)

{

{

  return current_binding_level;

  return current_binding_level;

}

}

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

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

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

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

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

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

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

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

   shall be thusly marked.  */

   shall be thusly marked.  */

void

void

objc_mark_locals_volatile (void *enclosing_blk)

objc_mark_locals_volatile (void *enclosing_blk)

{

{

  struct cp_binding_level *scope;

  struct cp_binding_level *scope;

  for (scope = current_binding_level;

  for (scope = current_binding_level;

       scope && scope != enclosing_blk;

       scope && scope != enclosing_blk;

       scope = scope->level_chain)

       scope = scope->level_chain)

    {

    {

      tree decl;

      tree decl;

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

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

        objc_volatilize_decl (decl);

        objc_volatilize_decl (decl);

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

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

      if (scope->kind == sk_function_parms)

      if (scope->kind == sk_function_parms)

        break;

        break;

    }

    }

}

}

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

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

static int

static int

poplevel_named_label_1 (void **slot, void *data)

poplevel_named_label_1 (void **slot, void *data)

{

{

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

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

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

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

  struct cp_binding_level *obl = bl->level_chain;

  struct cp_binding_level *obl = bl->level_chain;

  if (ent->binding_level == bl)

  if (ent->binding_level == bl)

    {

    {

      tree decl;

      tree decl;

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

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

        if (decl_jump_unsafe (decl))

        if (decl_jump_unsafe (decl))

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

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

      ent->binding_level = obl;

      ent->binding_level = obl;

      ent->names_in_scope = obl->names;

      ent->names_in_scope = obl->names;

      switch (bl->kind)

      switch (bl->kind)

        {

        {

        case sk_try:

        case sk_try:

          ent->in_try_scope = true;

          ent->in_try_scope = true;

          break;

          break;

        case sk_catch:

        case sk_catch:

          ent->in_catch_scope = true;

          ent->in_catch_scope = true;

          break;

          break;

        case sk_omp:

        case sk_omp:

          ent->in_omp_scope = true;

          ent->in_omp_scope = true;

          break;

          break;

        default:

        default:

          break;

          break;

        }

        }

    }

    }

  else if (ent->uses)

  else if (ent->uses)

    {

    {

      struct named_label_use_entry *use;

      struct named_label_use_entry *use;

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

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

        if (use->binding_level == bl)

        if (use->binding_level == bl)

          {

          {

            use->binding_level = obl;

            use->binding_level = obl;

            use->names_in_scope = obl->names;

            use->names_in_scope = obl->names;

            if (bl->kind == sk_omp)

            if (bl->kind == sk_omp)

              use->in_omp_scope = true;

              use->in_omp_scope = true;

          }

          }

    }

    }

  return 1;

  return 1;

}

}

/* Exit a binding level.

/* Exit a binding level.

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

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

   that were in effect when this level was entered.

   that were in effect when this level was entered.

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

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

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

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

   to record its declarations and subblocks for symbol table output.

   to record its declarations and subblocks for symbol table output.

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

   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

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

   label names.

   label names.

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

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

   them into the BLOCK.  */

   them into the BLOCK.  */

tree

tree

poplevel (int keep, int reverse, int functionbody)

poplevel (int keep, int reverse, int functionbody)

{

{

  tree link;

  tree link;

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

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

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

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

  tree decls;

  tree decls;

  tree subblocks;

  tree subblocks;

  tree block;

  tree block;

  tree decl;

  tree decl;

  int leaving_for_scope;

  int leaving_for_scope;

  scope_kind kind;

  scope_kind kind;

  timevar_push (TV_NAME_LOOKUP);

  timevar_push (TV_NAME_LOOKUP);

 restart:

 restart:

  block = NULL_TREE;

  block = NULL_TREE;

  gcc_assert (current_binding_level->kind != sk_class);

  gcc_assert (current_binding_level->kind != sk_class);

  if (current_binding_level->kind == sk_cleanup)

  if (current_binding_level->kind == sk_cleanup)

    functionbody = 0;

    functionbody = 0;

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

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

  gcc_assert (!VEC_length(cp_class_binding,

  gcc_assert (!VEC_length(cp_class_binding,

                          current_binding_level->class_shadowed));

                          current_binding_level->class_shadowed));

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

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

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

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

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

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

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

  if (current_binding_level->keep)

  if (current_binding_level->keep)

    keep = 1;

    keep = 1;

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

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

     under constraints of next binding contour.  */

     under constraints of next binding contour.  */

  if (cfun && !functionbody && named_labels)

  if (cfun && !functionbody && named_labels)

    htab_traverse (named_labels, poplevel_named_label_1,

    htab_traverse (named_labels, poplevel_named_label_1,

                   current_binding_level);

                   current_binding_level);

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

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

     Usually current_binding_level->names is in reverse order.

     Usually current_binding_level->names is in reverse order.

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

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

  if (reverse)

  if (reverse)

    current_binding_level->names

    current_binding_level->names

      = decls = nreverse (current_binding_level->names);

      = decls = nreverse (current_binding_level->names);

  else

  else

    decls = current_binding_level->names;

    decls = current_binding_level->names;

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

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

     or if this level is a function body,

     or if this level is a function body,

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

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

  block = NULL_TREE;

  block = NULL_TREE;

  if (keep == 1 || functionbody)

  if (keep == 1 || functionbody)

    block = make_node (BLOCK);

    block = make_node (BLOCK);

  if (block != NULL_TREE)

  if (block != NULL_TREE)

    {

    {

      BLOCK_VARS (block) = decls;

      BLOCK_VARS (block) = decls;

      BLOCK_SUBBLOCKS (block) = subblocks;

      BLOCK_SUBBLOCKS (block) = subblocks;

    }

    }

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

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

  if (keep >= 0)

  if (keep >= 0)

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

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

      BLOCK_SUPERCONTEXT (link) = block;

      BLOCK_SUPERCONTEXT (link) = block;

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

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

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

     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

     ended.  We only use the new rules if flag_new_for_scope is

     nonzero.  */

     nonzero.  */

  leaving_for_scope

  leaving_for_scope

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

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

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

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

  if (warn_unused_variable

  if (warn_unused_variable

      && !processing_template_decl)

      && !processing_template_decl)

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

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

      if (TREE_CODE (decl) == VAR_DECL

      if (TREE_CODE (decl) == VAR_DECL

          && ! TREE_USED (decl)

          && ! TREE_USED (decl)

          && ! DECL_IN_SYSTEM_HEADER (decl)

          && ! DECL_IN_SYSTEM_HEADER (decl)

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

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

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

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

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

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

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

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

    {

    {

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

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

          && DECL_NAME (link))

          && DECL_NAME (link))

        {

        {

          tree name = DECL_NAME (link);

          tree name = DECL_NAME (link);

          cxx_binding *ob;

          cxx_binding *ob;

          tree ns_binding;

          tree ns_binding;

          ob = outer_binding (name,

          ob = outer_binding (name,

                              IDENTIFIER_BINDING (name),

                              IDENTIFIER_BINDING (name),

                              /*class_p=*/true);

                              /*class_p=*/true);

          if (!ob)

          if (!ob)