hotspot/src/share/vm/utilities/exceptions.cpp
author never
Sun, 25 Sep 2011 16:03:29 -0700
changeset 10565 dc90c239f4ec
parent 9321 c29711c6ae35
child 11636 3c07b54482a5
permissions -rw-r--r--
7089790: integrate bsd-port changes Reviewed-by: kvn, twisti, jrose Contributed-by: Kurt Miller <kurt@intricatesoftware.com>, Greg Lewis <glewis@eyesbeyond.com>, Jung-uk Kim <jkim@freebsd.org>, Christos Zoulas <christos@zoulas.com>, Landon Fuller <landonf@plausible.coop>, The FreeBSD Foundation <board@freebsdfoundation.org>, Michael Franz <mvfranz@gmail.com>, Roger Hoover <rhoover@apple.com>, Alexander Strange <astrange@apple.com>
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
8921
14bfe81f2a9d 7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents: 8076
diff changeset
     2
 * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    26
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    27
#include "classfile/vmSymbols.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    28
#include "compiler/compileBroker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    29
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    30
#include "runtime/init.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    31
#include "runtime/java.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    32
#include "runtime/javaCalls.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    33
#include "runtime/threadCritical.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    34
#include "utilities/events.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    35
#include "utilities/exceptions.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    36
#ifdef TARGET_OS_FAMILY_linux
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    37
# include "thread_linux.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    38
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    39
#ifdef TARGET_OS_FAMILY_solaris
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    40
# include "thread_solaris.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    41
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    42
#ifdef TARGET_OS_FAMILY_windows
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    43
# include "thread_windows.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    44
#endif
10565
dc90c239f4ec 7089790: integrate bsd-port changes
never
parents: 9321
diff changeset
    45
#ifdef TARGET_OS_FAMILY_bsd
dc90c239f4ec 7089790: integrate bsd-port changes
never
parents: 9321
diff changeset
    46
# include "thread_bsd.inline.hpp"
dc90c239f4ec 7089790: integrate bsd-port changes
never
parents: 9321
diff changeset
    47
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// Implementation of ThreadShadow
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
void check_ThreadShadow() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
  const ByteSize offset1 = byte_offset_of(ThreadShadow, _pending_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  const ByteSize offset2 = Thread::pending_exception_offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  if (offset1 != offset2) fatal("ThreadShadow::_pending_exception is not positioned correctly");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
void ThreadShadow::set_pending_exception(oop exception, const char* file, int line) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  assert(exception != NULL && exception->is_oop(), "invalid exception oop");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  _pending_exception = exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  _exception_file    = file;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  _exception_line    = line;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
void ThreadShadow::clear_pending_exception() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  if (TraceClearedExceptions) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
    if (_pending_exception != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
      tty->print_cr("Thread::clear_pending_exception: cleared exception:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
      _pending_exception->print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  _pending_exception = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  _exception_file    = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  _exception_line    = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
// Implementation of Exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
bool Exceptions::special_exception(Thread* thread, const char* file, int line, Handle h_exception) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  // bootstrapping check
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  if (!Universe::is_fully_initialized()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
   vm_exit_during_initialization(h_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
   ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
6964
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    85
#ifdef ASSERT
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    86
  // Check for trying to throw stack overflow before initialization is complete
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    87
  // to prevent infinite recursion trying to initialize stack overflow without
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    88
  // adequate stack space.
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    89
  // This can happen with stress testing a large value of StackShadowPages
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    90
  if (h_exception()->klass() == SystemDictionary::StackOverflowError_klass()) {
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    91
    instanceKlass* ik = instanceKlass::cast(h_exception->klass());
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    92
    assert(ik->is_initialized(),
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    93
           "need to increase min_stack_allowed calculation");
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    94
  }
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    95
#endif // ASSERT
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    96
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  if (thread->is_VM_thread()
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
      || thread->is_Compiler_thread() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
    // We do not care what kind of exception we get for the vm-thread or a thread which
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
    // is compiling.  We just install a dummy exception object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
    thread->set_pending_exception(Universe::vm_exception(), file, line);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   108
bool Exceptions::special_exception(Thread* thread, const char* file, int line, Symbol* h_name, const char* message) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  // bootstrapping check
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  if (!Universe::is_fully_initialized()) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   111
    if (h_name == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
      // atleast an informative message.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
      vm_exit_during_initialization("Exception", message);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
      vm_exit_during_initialization(h_name, message);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  if (thread->is_VM_thread()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
      || thread->is_Compiler_thread() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
    // We do not care what kind of exception we get for the vm-thread or a thread which
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
    // is compiling.  We just install a dummy exception object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
    thread->set_pending_exception(Universe::vm_exception(), file, line);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
// This method should only be called from generated code,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
// therefore the exception oop should be in the oopmap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
void Exceptions::_throw_oop(Thread* thread, const char* file, int line, oop exception) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  assert(exception != NULL, "exception should not be NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  Handle h_exception = Handle(thread, exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  _throw(thread, file, line, h_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
4014
b59b8c387950 6889302: TraceExceptions output should include detail message
never
parents: 1
diff changeset
   138
void Exceptions::_throw(Thread* thread, const char* file, int line, Handle h_exception, const char* message) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  assert(h_exception() != NULL, "exception should not be NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  // tracing (do this up front - so it works during boot strapping)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  if (TraceExceptions) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
    ttyLocker ttyl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
    ResourceMark rm;
4014
b59b8c387950 6889302: TraceExceptions output should include detail message
never
parents: 1
diff changeset
   145
    tty->print_cr("Exception <%s>%s%s (" INTPTR_FORMAT " ) \n"
b59b8c387950 6889302: TraceExceptions output should include detail message
never
parents: 1
diff changeset
   146
                  "thrown [%s, line %d]\nfor thread " INTPTR_FORMAT,
b59b8c387950 6889302: TraceExceptions output should include detail message
never
parents: 1
diff changeset
   147
                  h_exception->print_value_string(),
b59b8c387950 6889302: TraceExceptions output should include detail message
never
parents: 1
diff changeset
   148
                  message ? ": " : "", message ? message : "",
b59b8c387950 6889302: TraceExceptions output should include detail message
never
parents: 1
diff changeset
   149
                  (address)h_exception(), file, line, thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  // for AbortVMOnException flag
6179
4846648c4b7b 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents: 5547
diff changeset
   152
  NOT_PRODUCT(Exceptions::debug_check_abort(h_exception, message));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  // Check for special boot-strapping/vm-thread handling
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  if (special_exception(thread, file, line, h_exception)) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4014
diff changeset
   157
  assert(h_exception->is_a(SystemDictionary::Throwable_klass()), "exception is not a subclass of java/lang/Throwable");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  // set the pending exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  thread->set_pending_exception(h_exception(), file, line);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  // vm log
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  Events::log("throw_exception " INTPTR_FORMAT, (address)h_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   167
void Exceptions::_throw_msg(Thread* thread, const char* file, int line, Symbol* h_name, const char* message, Handle h_loader, Handle h_protection_domain) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  // Check for special boot-strapping/vm-thread handling
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  if (special_exception(thread, file, line, h_name, message)) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  // Create and throw exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  Handle h_cause(thread, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  Handle h_exception = new_exception(thread, h_name, message, h_cause, h_loader, h_protection_domain);
4014
b59b8c387950 6889302: TraceExceptions output should include detail message
never
parents: 1
diff changeset
   173
  _throw(thread, file, line, h_exception, message);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
// Throw an exception with a message and a cause
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   177
void Exceptions::_throw_msg_cause(Thread* thread, const char* file, int line, Symbol* h_name, const char* message, Handle h_cause, Handle h_loader, Handle h_protection_domain) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  // Check for special boot-strapping/vm-thread handling
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  if (special_exception(thread, file, line, h_name, message)) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  // Create and throw exception and init cause
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  Handle h_exception = new_exception(thread, h_name, message, h_cause, h_loader, h_protection_domain);
4014
b59b8c387950 6889302: TraceExceptions output should include detail message
never
parents: 1
diff changeset
   182
  _throw(thread, file, line, h_exception, message);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
// This version already has a handle for name
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
void Exceptions::_throw_msg(Thread* thread, const char* file, int line,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   187
                            Symbol* name, const char* message) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  Handle       h_loader(thread, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  Handle       h_protection_domain(thread, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  Exceptions::_throw_msg(thread, file, line, name, message, h_loader, h_protection_domain);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
// This version already has a handle for name
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
void Exceptions::_throw_msg_cause(Thread* thread, const char* file, int line,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   195
                            Symbol* name, const char* message, Handle cause) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  Handle       h_loader(thread, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  Handle       h_protection_domain(thread, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  Exceptions::_throw_msg_cause(thread, file, line, name, message, cause, h_loader, h_protection_domain);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   201
void Exceptions::_throw_args(Thread* thread, const char* file, int line, Symbol* h_name, Symbol* h_signature, JavaCallArguments *args) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  // Check for special boot-strapping/vm-thread handling
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  if (special_exception(thread, file, line, h_name, NULL)) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  // Create and throw exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  Handle h_loader(thread, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  Handle h_prot(thread, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  Handle h_cause(thread, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  Handle exception = new_exception(thread, h_name, h_signature, args, h_cause, h_loader, h_prot);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  _throw(thread, file, line, exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
9321
c29711c6ae35 7009923: JSR 292: VM crash in JavaThread::last_frame
coleenp
parents: 8921
diff changeset
   213
void Exceptions::throw_stack_overflow_exception(Thread* THREAD, const char* file, int line, methodHandle method) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  Handle exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  if (!THREAD->has_pending_exception()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
    klassOop k = SystemDictionary::StackOverflowError_klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
    oop e = instanceKlass::cast(k)->allocate_instance(CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
    exception = Handle(THREAD, e);  // fill_in_stack trace does gc
6964
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
   219
    assert(instanceKlass::cast(k)->is_initialized(), "need to increase min_stack_allowed calculation");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
    if (StackTraceInThrowable) {
9321
c29711c6ae35 7009923: JSR 292: VM crash in JavaThread::last_frame
coleenp
parents: 8921
diff changeset
   221
      java_lang_Throwable::fill_in_stack_trace(exception, method());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
    // if prior exception, throw that one instead
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
    exception = Handle(THREAD, THREAD->pending_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  }
9321
c29711c6ae35 7009923: JSR 292: VM crash in JavaThread::last_frame
coleenp
parents: 8921
diff changeset
   227
  _throw(THREAD, file, line, exception);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   230
void Exceptions::fthrow(Thread* thread, const char* file, int line, Symbol* h_name, const char* format, ...) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  const int max_msg_size = 1024;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  va_list ap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  va_start(ap, format);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  char msg[max_msg_size];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  vsnprintf(msg, max_msg_size, format, ap);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  msg[max_msg_size-1] = '\0';
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  va_end(ap);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  _throw_msg(thread, file, line, h_name, msg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
// Creates an exception oop, calls the <init> method with the given signature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
// and returns a Handle
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
// Initializes the cause if cause non-null
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   244
Handle Exceptions::new_exception(Thread *thread, Symbol* h_name,
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   245
                                 Symbol* signature,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
                                 JavaCallArguments *args,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
                                 Handle h_cause, Handle h_loader,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
                                 Handle h_protection_domain) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  assert(Universe::is_fully_initialized(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
    "cannot be called during initialization");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  assert(thread->is_Java_thread(), "can only be called by a Java thread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  assert(!thread->has_pending_exception(), "already has exception");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  Handle h_exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  // Resolve exception klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  klassOop ik = SystemDictionary::resolve_or_fail(h_name, h_loader, h_protection_domain, true, thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  instanceKlassHandle klass (thread, ik);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  if (!thread->has_pending_exception()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
    assert(klass.not_null(), "klass must exist");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
    // We are about to create an instance - so make sure that klass is initialized
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
    klass->initialize(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
    if (!thread->has_pending_exception()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
      // Allocate new exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
      h_exception = klass->allocate_instance_handle(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
      if (!thread->has_pending_exception()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
        JavaValue result(T_VOID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
        args->set_receiver(h_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
        // Call constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
        JavaCalls::call_special(&result, klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   272
                                         vmSymbols::object_initializer_name(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
                                         signature,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
                                         args,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
                                         thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
    // Future: object initializer should take a cause argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
    if (h_cause() != NULL) {
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4014
diff changeset
   282
      assert(h_cause->is_a(SystemDictionary::Throwable_klass()),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
          "exception cause is not a subclass of java/lang/Throwable");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
      JavaValue result1(T_OBJECT);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
      JavaCallArguments args1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
      args1.set_receiver(h_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
      args1.push_oop(h_cause);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
      JavaCalls::call_virtual(&result1, klass,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   289
                                     vmSymbols::initCause_name(),
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   290
                                     vmSymbols::throwable_throwable_signature(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
                                     &args1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
                                     thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  // Check if another exception was thrown in the process, if so rethrow that one
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  if (thread->has_pending_exception()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
    h_exception = Handle(thread, thread->pending_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
    thread->clear_pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  return h_exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
// Convenience method. Calls either the <init>() or <init>(String) method when
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
// creating a new exception
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   306
Handle Exceptions::new_exception(Thread* thread, Symbol* h_name,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
                                 const char* message, Handle h_cause,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
                                 Handle h_loader,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
                                 Handle h_protection_domain,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
                                 ExceptionMsgToUtf8Mode to_utf8_safe) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  JavaCallArguments args;
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   312
  Symbol* signature = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  if (message == NULL) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   314
    signature = vmSymbols::void_method_signature();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
    // We want to allocate storage, but we can't do that if there's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
    // a pending exception, so we preserve any pending exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
    // around the allocation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
    // If we get an exception from the allocation, prefer that to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
    // the exception we are trying to build, or the pending exception.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
    // This is sort of like what PRESERVE_EXCEPTION_MARK does, except
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
    // for the preferencing and the early returns.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
    Handle incoming_exception (thread, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
    if (thread->has_pending_exception()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
      incoming_exception = Handle(thread, thread->pending_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
      thread->clear_pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
    Handle msg;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
    if (to_utf8_safe == safe_to_utf8) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
      // Make a java UTF8 string.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
      msg = java_lang_String::create_from_str(message, thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
      // Make a java string keeping the encoding scheme of the original string.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
      msg = java_lang_String::create_from_platform_dependent_str(message, thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
    if (thread->has_pending_exception()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
      Handle exception(thread, thread->pending_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
      thread->clear_pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
      return exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
    if (incoming_exception.not_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
      return incoming_exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
    args.push_oop(msg);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   345
    signature = vmSymbols::string_void_signature();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  return new_exception(thread, h_name, signature, &args, h_cause, h_loader, h_protection_domain);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
// Another convenience method that creates handles for null class loaders and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
// protection domains and null causes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
// If the last parameter 'to_utf8_mode' is safe_to_utf8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
// it means we can safely ignore the encoding scheme of the message string and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
// convert it directly to a java UTF8 string. Otherwise, we need to take the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
// encoding scheme of the string into account. One thing we should do at some
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
// point is to push this flag down to class java_lang_String since other
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
// classes may need similar functionalities.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
Handle Exceptions::new_exception(Thread* thread,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   359
                                 Symbol* name,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
                                 const char* message,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
                                 ExceptionMsgToUtf8Mode to_utf8_safe) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  Handle       h_loader(thread, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  Handle       h_prot(thread, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  Handle       h_cause(thread, NULL);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   366
  return Exceptions::new_exception(thread, name, message, h_cause, h_loader,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
                                   h_prot, to_utf8_safe);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
// Implementation of ExceptionMark
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
ExceptionMark::ExceptionMark(Thread*& thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  thread     = Thread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
  _thread    = thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  if (_thread->has_pending_exception()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
    oop exception = _thread->pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
    _thread->clear_pending_exception(); // Needed to avoid infinite recursion
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
    exception->print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
    fatal("ExceptionMark constructor expects no pending exceptions");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
ExceptionMark::~ExceptionMark() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  if (_thread->has_pending_exception()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
    Handle exception(_thread, _thread->pending_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
    _thread->clear_pending_exception(); // Needed to avoid infinite recursion
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
    if (is_init_completed()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
      exception->print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
      fatal("ExceptionMark destructor expects no pending exceptions");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
      vm_exit_during_initialization(exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
// ----------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
// caller frees value_string if necessary
6179
4846648c4b7b 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents: 5547
diff changeset
   401
void Exceptions::debug_check_abort(const char *value_string, const char* message) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
  if (AbortVMOnException != NULL && value_string != NULL &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
      strstr(value_string, AbortVMOnException)) {
6179
4846648c4b7b 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents: 5547
diff changeset
   404
    if (AbortVMOnExceptionMessage == NULL || message == NULL ||
4846648c4b7b 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents: 5547
diff changeset
   405
        strcmp(message, AbortVMOnExceptionMessage) == 0) {
4846648c4b7b 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents: 5547
diff changeset
   406
      fatal(err_msg("Saw %s, aborting", value_string));
4846648c4b7b 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents: 5547
diff changeset
   407
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
6179
4846648c4b7b 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents: 5547
diff changeset
   411
void Exceptions::debug_check_abort(Handle exception, const char* message) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
  if (AbortVMOnException != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
    ResourceMark rm;
6179
4846648c4b7b 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents: 5547
diff changeset
   414
    if (message == NULL && exception->is_a(SystemDictionary::Throwable_klass())) {
4846648c4b7b 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents: 5547
diff changeset
   415
      oop msg = java_lang_Throwable::message(exception);
4846648c4b7b 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents: 5547
diff changeset
   416
      if (msg != NULL) {
4846648c4b7b 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents: 5547
diff changeset
   417
        message = java_lang_String::as_utf8_string(msg);
4846648c4b7b 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents: 5547
diff changeset
   418
      }
4846648c4b7b 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents: 5547
diff changeset
   419
    }
4846648c4b7b 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents: 5547
diff changeset
   420
    debug_check_abort(instanceKlass::cast(exception()->klass())->external_name(), message);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
#endif