Subversion Repositories openrisc

/* Handle exceptional things in C++.

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

   2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010

   Free Software Foundation, Inc.

   Contributed by Michael Tiemann <tiemann@cygnus.com>

   Rewritten by Mike Stump <mrs@cygnus.com>, based upon an

   initial re-implementation courtesy Tad Hunt.

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

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "tree.h"

#include "cp-tree.h"

#include "flags.h"

#include "output.h"

#include "tree-inline.h"

#include "tree-iterator.h"

#include "target.h"

#include "gimple.h"

static void push_eh_cleanup (tree);

static tree prepare_eh_type (tree);

static tree do_begin_catch (void);

static int dtor_nothrow (tree);

static tree do_end_catch (tree);

static bool decl_is_java_type (tree decl, int err);

static void initialize_handler_parm (tree, tree);

static tree do_allocate_exception (tree);

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

static int complete_ptr_ref_or_void_ptr_p (tree, tree);

static bool is_admissible_throw_operand (tree);

static int can_convert_eh (tree, tree);

/* Sets up all the global eh stuff that needs to be initialized at the

   start of compilation.  */

void

init_exception_processing (void)

{

  tree tmp;

  /* void std::terminate (); */

  push_namespace (std_identifier);

  tmp = build_function_type_list (void_type_node, NULL_TREE);

  terminate_node = build_cp_library_fn_ptr ("terminate", tmp);

  TREE_THIS_VOLATILE (terminate_node) = 1;

  TREE_NOTHROW (terminate_node) = 1;

  pop_namespace ();

  /* void __cxa_call_unexpected(void *); */

  tmp = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);

  call_unexpected_node

    = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp);

}

/* Returns an expression to be executed if an unhandled exception is

   propagated out of a cleanup region.  */

tree

cp_protect_cleanup_actions (void)

{

  /* [except.terminate]

     When the destruction of an object during stack unwinding exits

     using an exception ... void terminate(); is called.  */

  return terminate_node;

}

static tree

prepare_eh_type (tree type)

{

  if (type == NULL_TREE)

    return type;

  if (type == error_mark_node)

    return error_mark_node;

  /* peel back references, so they match.  */

  type = non_reference (type);

  /* Peel off cv qualifiers.  */

  type = TYPE_MAIN_VARIANT (type);

  /* Functions and arrays decay to pointers.  */

  type = type_decays_to (type);

  return type;

}

/* Return the type info for TYPE as used by EH machinery.  */

tree

eh_type_info (tree type)

{

  tree exp;

  if (type == NULL_TREE || type == error_mark_node)

    return type;

  if (decl_is_java_type (type, 0))

    exp = build_java_class_ref (TREE_TYPE (type));

  else

    exp = get_tinfo_decl (type);

  return exp;

}

/* Build the address of a typeinfo decl for use in the runtime

   matching field of the exception model.  */

tree

build_eh_type_type (tree type)

{

  tree exp = eh_type_info (type);

  if (!exp)

    return NULL;

  mark_used (exp);

  return convert (ptr_type_node, build_address (exp));

}

tree

build_exc_ptr (void)

{

  return build_call_n (builtin_decl_explicit (BUILT_IN_EH_POINTER),

                       1, integer_zero_node);

}

/* Declare a function NAME, returning RETURN_TYPE, taking a single

   parameter PARM_TYPE, with an empty exception specification.

   Note that the C++ ABI document does not have a throw-specifier on

   the routines declared below via this function.  The declarations

   are consistent with the actual implementations in libsupc++.  */

static tree

declare_nothrow_library_fn (tree name, tree return_type, tree parm_type)

{

  return push_library_fn (name, build_function_type_list (return_type,

                                                          parm_type,

                                                          NULL_TREE),

                          empty_except_spec);

}

/* Build up a call to __cxa_get_exception_ptr so that we can build a

   copy constructor for the thrown object.  */

static tree

do_get_exception_ptr (void)

{

  tree fn;

  fn = get_identifier ("__cxa_get_exception_ptr");

  if (!get_global_value_if_present (fn, &fn))

    {

      /* Declare void* __cxa_get_exception_ptr (void *) throw().  */

      fn = declare_nothrow_library_fn (fn, ptr_type_node, ptr_type_node);

      if (flag_tm)

        apply_tm_attr (fn, get_identifier ("transaction_pure"));

    }

  return cp_build_function_call_nary (fn, tf_warning_or_error,

                                      build_exc_ptr (), NULL_TREE);

}

/* Build up a call to __cxa_begin_catch, to tell the runtime that the

   exception has been handled.  */

static tree

do_begin_catch (void)

{

  tree fn;

  fn = get_identifier ("__cxa_begin_catch");

  if (!get_global_value_if_present (fn, &fn))

    {

      /* Declare void* __cxa_begin_catch (void *) throw().  */

      fn = declare_nothrow_library_fn (fn, ptr_type_node, ptr_type_node);

      /* Create its transactional-memory equivalent.  */

      if (flag_tm)

        {

          tree fn2 = get_identifier ("_ITM_cxa_begin_catch");

          if (!get_global_value_if_present (fn2, &fn2))

            fn2 = declare_nothrow_library_fn (fn2, ptr_type_node,

                                              ptr_type_node);

          apply_tm_attr (fn2, get_identifier ("transaction_pure"));

          record_tm_replacement (fn, fn2);

        }

    }

  return cp_build_function_call_nary (fn, tf_warning_or_error,

                                      build_exc_ptr (), NULL_TREE);

}

/* Returns nonzero if cleaning up an exception of type TYPE (which can be

   NULL_TREE for a ... handler) will not throw an exception.  */

static int

dtor_nothrow (tree type)

{

  if (type == NULL_TREE || type == error_mark_node)

    return 0;

  if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))

    return 1;

  if (CLASSTYPE_LAZY_DESTRUCTOR (type))

    lazily_declare_fn (sfk_destructor, type);

  return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type));

}

/* Build up a call to __cxa_end_catch, to destroy the exception object

   for the current catch block if no others are currently using it.  */

static tree

do_end_catch (tree type)

{

  tree fn, cleanup;

  fn = get_identifier ("__cxa_end_catch");

  if (!get_global_value_if_present (fn, &fn))

    {

      /* Declare void __cxa_end_catch ().  */

      fn = push_void_library_fn (fn, void_list_node);

      /* This can throw if the destructor for the exception throws.  */

      TREE_NOTHROW (fn) = 0;

      /* Create its transactional-memory equivalent.  */

      if (flag_tm)

        {

          tree fn2 = get_identifier ("_ITM_cxa_end_catch");

          if (!get_global_value_if_present (fn2, &fn2))

            {

              fn2 = push_void_library_fn (fn2, void_list_node);

              TREE_NOTHROW (fn2) = 0;

            }

          apply_tm_attr (fn2, get_identifier ("transaction_pure"));

          record_tm_replacement (fn, fn2);

        }

    }

  cleanup = cp_build_function_call_vec (fn, NULL, tf_warning_or_error);

  TREE_NOTHROW (cleanup) = dtor_nothrow (type);

  return cleanup;

}

/* This routine creates the cleanup for the current exception.  */

static void

push_eh_cleanup (tree type)

{

  finish_decl_cleanup (NULL_TREE, do_end_catch (type));

}

/* Return nonzero value if DECL is a Java type suitable for catch or

   throw.  */

static bool

decl_is_java_type (tree decl, int err)

{

  bool r = (TREE_CODE (decl) == POINTER_TYPE

            && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE

            && TYPE_FOR_JAVA (TREE_TYPE (decl)));

  if (err)

    {

      if (TREE_CODE (decl) == REFERENCE_TYPE

          && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE

          && TYPE_FOR_JAVA (TREE_TYPE (decl)))

        {

          /* Can't throw a reference.  */

          error ("type %qT is disallowed in Java %<throw%> or %<catch%>",

                 decl);

        }

      if (r)

        {

          tree jthrow_node

            = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable"));

          if (jthrow_node == NULL_TREE)

            fatal_error

              ("call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined");

          jthrow_node = TREE_TYPE (TREE_TYPE (jthrow_node));

          if (! DERIVED_FROM_P (jthrow_node, TREE_TYPE (decl)))

            {

              /* Thrown object must be a Throwable.  */

              error ("type %qT is not derived from %<java::lang::Throwable%>",

                     TREE_TYPE (decl));

            }

        }

    }

  return r;

}

/* Select the personality routine to be used for exception handling,

   or issue an error if we need two different ones in the same

   translation unit.

   ??? At present DECL_FUNCTION_PERSONALITY is set via

   LANG_HOOKS_EH_PERSONALITY.  Should it be done here instead?  */

void

choose_personality_routine (enum languages lang)

{

  static enum {

    chose_none,

    chose_cpp,

    chose_java,

    gave_error

  } state;

  switch (state)

    {

    case gave_error:

      return;

    case chose_cpp:

      if (lang != lang_cplusplus)

        goto give_error;

      return;

    case chose_java:

      if (lang != lang_java)

        goto give_error;

      return;

    case chose_none:

      ; /* Proceed to language selection.  */

    }

  switch (lang)

    {

    case lang_cplusplus:

      state = chose_cpp;

      break;

    case lang_java:

      state = chose_java;

      terminate_node = builtin_decl_explicit (BUILT_IN_ABORT);

      pragma_java_exceptions = true;

      break;

    default:

      gcc_unreachable ();

    }

  return;

 give_error:

  error ("mixing C++ and Java catches in a single translation unit");

  state = gave_error;

}

/* Wrap EXPR in a MUST_NOT_THROW_EXPR expressing that EXPR must

   not throw any exceptions if COND is true.  A condition of

   NULL_TREE is treated as 'true'.  */

tree

build_must_not_throw_expr (tree body, tree cond)

{

  tree type = body ? TREE_TYPE (body) : void_type_node;

  if (cond && !value_dependent_expression_p (cond))

    {

      cond = cxx_constant_value (cond);

      if (integer_zerop (cond))

        return body;

      else if (integer_onep (cond))

        cond = NULL_TREE;

    }

  return build2 (MUST_NOT_THROW_EXPR, type, body, cond);

}

/* Initialize the catch parameter DECL.  */

static void

initialize_handler_parm (tree decl, tree exp)

{

  tree init;

  tree init_type;

  /* Make sure we mark the catch param as used, otherwise we'll get a

     warning about an unused ((anonymous)).  */

  TREE_USED (decl) = 1;

  DECL_READ_P (decl) = 1;

  /* Figure out the type that the initializer is.  Pointers are returned

     adjusted by value from __cxa_begin_catch.  Others are returned by

     reference.  */

  init_type = TREE_TYPE (decl);

  if (!POINTER_TYPE_P (init_type))

    init_type = build_reference_type (init_type);

  choose_personality_routine (decl_is_java_type (init_type, 0)

                              ? lang_java : lang_cplusplus);

  /* Since pointers are passed by value, initialize a reference to

     pointer catch parm with the address of the temporary.  */

  if (TREE_CODE (init_type) == REFERENCE_TYPE

      && TYPE_PTR_P (TREE_TYPE (init_type)))

    exp = cp_build_addr_expr (exp, tf_warning_or_error);

  exp = ocp_convert (init_type, exp, CONV_IMPLICIT|CONV_FORCE_TEMP, 0);

  init = convert_from_reference (exp);

  /* If the constructor for the catch parm exits via an exception, we

     must call terminate.  See eh23.C.  */

  if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))

    {

      /* Generate the copy constructor call directly so we can wrap it.

         See also expand_default_init.  */

      init = ocp_convert (TREE_TYPE (decl), init,

                          CONV_IMPLICIT|CONV_FORCE_TEMP, 0);

      /* Force cleanups now to avoid nesting problems with the

         MUST_NOT_THROW_EXPR.  */

      init = fold_build_cleanup_point_expr (TREE_TYPE (init), init);

      init = build_must_not_throw_expr (init, NULL_TREE);

    }

  decl = pushdecl (decl);

  start_decl_1 (decl, true);

  cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,

                  LOOKUP_ONLYCONVERTING|DIRECT_BIND);

}

/* Routine to see if exception handling is turned on.

   DO_WARN is nonzero if we want to inform the user that exception

   handling is turned off.

   This is used to ensure that -fexceptions has been specified if the

   compiler tries to use any exception-specific functions.  */

static inline int

doing_eh (void)

{

  if (! flag_exceptions)

    {

      static int warned = 0;

      if (! warned)

        {

          error ("exception handling disabled, use -fexceptions to enable");

          warned = 1;

        }

      return 0;

    }

  return 1;

}

/* Call this to start a catch block.  DECL is the catch parameter.  */

tree

expand_start_catch_block (tree decl)

{

  tree exp;

  tree type, init;

  if (! doing_eh ())

    return NULL_TREE;

  /* Make sure this declaration is reasonable.  */

  if (decl && !complete_ptr_ref_or_void_ptr_p (TREE_TYPE (decl), NULL_TREE))

    decl = error_mark_node;

  if (decl)

    type = prepare_eh_type (TREE_TYPE (decl));

  else

    type = NULL_TREE;

  if (decl && decl_is_java_type (type, 1))

    {

      /* Java only passes object via pointer and doesn't require

         adjusting.  The java object is immediately before the

         generic exception header.  */

      exp = build_exc_ptr ();

      exp = build1 (NOP_EXPR, build_pointer_type (type), exp);

      exp = fold_build_pointer_plus (exp,

                    fold_build1_loc (input_location,

                                     NEGATE_EXPR, sizetype,

                                     TYPE_SIZE_UNIT (TREE_TYPE (exp))));

      exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error);

      initialize_handler_parm (decl, exp);

      return type;

    }

  /* Call __cxa_end_catch at the end of processing the exception.  */

  push_eh_cleanup (type);

  init = do_begin_catch ();

  /* If there's no decl at all, then all we need to do is make sure

     to tell the runtime that we've begun handling the exception.  */

  if (decl == NULL || decl == error_mark_node || init == error_mark_node)

    finish_expr_stmt (init);

  /* If the C++ object needs constructing, we need to do that before

     calling __cxa_begin_catch, so that std::uncaught_exception gets

     the right value during the copy constructor.  */

  else if (flag_use_cxa_get_exception_ptr

           && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))

    {

      exp = do_get_exception_ptr ();

      initialize_handler_parm (decl, exp);

      finish_expr_stmt (init);

    }

  /* Otherwise the type uses a bitwise copy, and we don't have to worry

     about the value of std::uncaught_exception and therefore can do the

     copy with the return value of __cxa_end_catch instead.  */

  else

    {

      tree init_type = type;

      /* Pointers are passed by values, everything else by reference.  */

      if (!TYPE_PTR_P (type))

        init_type = build_pointer_type (type);

      if (init_type != TREE_TYPE (init))

        init = build1 (NOP_EXPR, init_type, init);

      exp = create_temporary_var (init_type);

      DECL_REGISTER (exp) = 1;

      cp_finish_decl (exp, init, /*init_const_expr=*/false,

                      NULL_TREE, LOOKUP_ONLYCONVERTING);

      initialize_handler_parm (decl, exp);

    }

  return type;

}

/* Call this to end a catch block.  Its responsible for emitting the

   code to handle jumping back to the correct place, and for emitting

   the label to jump to if this catch block didn't match.  */

void

expand_end_catch_block (void)

{

  if (! doing_eh ())

    return;

  /* The exception being handled is rethrown if control reaches the end of

     a handler of the function-try-block of a constructor or destructor.  */

  if (in_function_try_handler

      && (DECL_CONSTRUCTOR_P (current_function_decl)

          || DECL_DESTRUCTOR_P (current_function_decl)))

    finish_expr_stmt (build_throw (NULL_TREE));

}

tree

begin_eh_spec_block (void)

{

  tree r;

  location_t spec_location = DECL_SOURCE_LOCATION (current_function_decl);

  /* A noexcept specification (or throw() with -fnothrow-opt) is a

     MUST_NOT_THROW_EXPR.  */

  if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl)))

    {

      r = build_stmt (spec_location, MUST_NOT_THROW_EXPR,

                      NULL_TREE, NULL_TREE);

      TREE_SIDE_EFFECTS (r) = 1;

    }

  else

    r = build_stmt (spec_location, EH_SPEC_BLOCK, NULL_TREE, NULL_TREE);

  add_stmt (r);

  TREE_OPERAND (r, 0) = push_stmt_list ();

  return r;

}

void

finish_eh_spec_block (tree raw_raises, tree eh_spec_block)

{

  tree raises;

  TREE_OPERAND (eh_spec_block, 0)

    = pop_stmt_list (TREE_OPERAND (eh_spec_block, 0));

  if (TREE_CODE (eh_spec_block) == MUST_NOT_THROW_EXPR)

    return;

  /* Strip cv quals, etc, from the specification types.  */

  for (raises = NULL_TREE;

       raw_raises && TREE_VALUE (raw_raises);

       raw_raises = TREE_CHAIN (raw_raises))

    {

      tree type = prepare_eh_type (TREE_VALUE (raw_raises));

      tree tinfo = eh_type_info (type);

      mark_used (tinfo);

      raises = tree_cons (NULL_TREE, type, raises);

    }

  EH_SPEC_RAISES (eh_spec_block) = raises;

}

/* Return a pointer to a buffer for an exception object of type TYPE.  */

static tree

do_allocate_exception (tree type)

{

  tree fn;

  fn = get_identifier ("__cxa_allocate_exception");

  if (!get_global_value_if_present (fn, &fn))

    {

      /* Declare void *__cxa_allocate_exception(size_t) throw().  */

      fn = declare_nothrow_library_fn (fn, ptr_type_node, size_type_node);

      if (flag_tm)

        {

          tree fn2 = get_identifier ("_ITM_cxa_allocate_exception");

          if (!get_global_value_if_present (fn2, &fn2))

            fn2 = declare_nothrow_library_fn (fn2, ptr_type_node,

                                              size_type_node);

          apply_tm_attr (fn2, get_identifier ("transaction_pure"));

          record_tm_replacement (fn, fn2);

        }

    }

  return cp_build_function_call_nary (fn, tf_warning_or_error,

                                      size_in_bytes (type), NULL_TREE);

}

/* Call __cxa_free_exception from a cleanup.  This is never invoked

   directly, but see the comment for stabilize_throw_expr.  */

static tree

do_free_exception (tree ptr)

{

  tree fn;

  fn = get_identifier ("__cxa_free_exception");

  if (!get_global_value_if_present (fn, &fn))

    {

      /* Declare void __cxa_free_exception (void *) throw().  */

      fn = declare_nothrow_library_fn (fn, void_type_node, ptr_type_node);

    }

  return cp_build_function_call_nary (fn, tf_warning_or_error, ptr, NULL_TREE);

}

/* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.

   Called from build_throw via walk_tree_without_duplicates.  */

static tree

wrap_cleanups_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,

                 void *data ATTRIBUTE_UNUSED)

{

  tree exp = *tp;

  tree cleanup;

  /* Don't walk into types.  */

  if (TYPE_P (exp))

    {

      *walk_subtrees = 0;

      return NULL_TREE;

    }

  if (TREE_CODE (exp) != TARGET_EXPR)

    return NULL_TREE;

  cleanup = TARGET_EXPR_CLEANUP (exp);

  if (cleanup)

    {

      cleanup = build2 (MUST_NOT_THROW_EXPR, void_type_node, cleanup,

                        NULL_TREE);

      TARGET_EXPR_CLEANUP (exp) = cleanup;

    }

  /* Keep iterating.  */

  return NULL_TREE;

}

/* Build a throw expression.  */

tree

build_throw (tree exp)

{

  tree fn;

  if (exp == error_mark_node)

    return exp;

  if (processing_template_decl)

    {

      if (cfun)

        current_function_returns_abnormally = 1;

      exp = build_min (THROW_EXPR, void_type_node, exp);

      SET_EXPR_LOCATION (exp, input_location);

      return exp;

    }

  if (exp == null_node)

    warning (0, "throwing NULL, which has integral, not pointer type");

  if (exp != NULL_TREE)

    {

      if (!is_admissible_throw_operand (exp))

        return error_mark_node;