src/hotspot/share/utilities/exceptions.cpp
author mr
Tue, 29 Oct 2019 13:52:04 -0700
changeset 58850 f4290bf1cc21
parent 58177 4932dce35882
child 59056 15936b142f86
permissions -rw-r--r--
8233137: runtime/ErrorHandling/VeryEarlyAssertTest.java fails after 8232080 Reviewed-by: stuefe, iignatyev, mchung
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
53745
a535ba736cab 8218004: Clean up terminology for shared methods within the JVM for indy and condy support
lfoltan
parents: 50516
diff changeset
     2
 * Copyright (c) 1998, 2019, 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"
35216
71c463a17b3b 8141211: Convert TraceExceptions to Unified Logging
rprotacio
parents: 33602
diff changeset
    29
#include "logging/log.hpp"
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46329
diff changeset
    30
#include "logging/logStream.hpp"
37248
11a660dbbb8e 8132524: Missing includes to resourceArea.hpp
jprovino
parents: 37242
diff changeset
    31
#include "memory/resourceArea.hpp"
54786
ebf733a324d4 8223624: Cleanup includes of universe.hpp
stefank
parents: 53874
diff changeset
    32
#include "memory/universe.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    33
#include "oops/oop.inline.hpp"
49480
d7df2dd501ce 8199809: Don't include frame.inline.hpp and other.inline.hpp from .hpp files
coleenp
parents: 49177
diff changeset
    34
#include "runtime/handles.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    35
#include "runtime/init.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    36
#include "runtime/java.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    37
#include "runtime/javaCalls.hpp"
49177
eebf559c9e0d 8196882: VS2017 Hotspot Defined vsnprintf Function Causes C2084 Already Defined Compilation Error
kbarrett
parents: 48826
diff changeset
    38
#include "runtime/os.hpp"
14583
d70ee55535f4 8003935: Simplify the needed includes for using Thread::current()
stefank
parents: 13728
diff changeset
    39
#include "runtime/thread.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    40
#include "runtime/threadCritical.hpp"
50516
77f9fece2f19 8204477: Count linkage errors and print in Exceptions::print_exception_counts_on_error
goetz
parents: 50217
diff changeset
    41
#include "runtime/atomic.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    42
#include "utilities/events.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6964
diff changeset
    43
#include "utilities/exceptions.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
// Implementation of ThreadShadow
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
void check_ThreadShadow() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
  const ByteSize offset1 = byte_offset_of(ThreadShadow, _pending_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
  const ByteSize offset2 = Thread::pending_exception_offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
  if (offset1 != offset2) fatal("ThreadShadow::_pending_exception is not positioned correctly");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
void ThreadShadow::set_pending_exception(oop exception, const char* file, int line) {
46968
9119841280f4 8160399: is_oop_or_null involves undefined behavior
coleenp
parents: 46701
diff changeset
    54
  assert(exception != NULL && oopDesc::is_oop(exception), "invalid exception oop");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  _pending_exception = exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  _exception_file    = file;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  _exception_line    = line;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
void ThreadShadow::clear_pending_exception() {
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46329
diff changeset
    61
  LogTarget(Debug, exceptions) lt;
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46329
diff changeset
    62
  if (_pending_exception != NULL && lt.is_enabled()) {
37110
0c468eab5c66 8150085: Convert TraceClearedExceptions to Unified Loggin
rprotacio
parents: 35477
diff changeset
    63
    ResourceMark rm;
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46329
diff changeset
    64
    LogStream ls(lt);
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46329
diff changeset
    65
    ls.print("Thread::clear_pending_exception: cleared exception:");
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46329
diff changeset
    66
    _pending_exception->print_on(&ls);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  _pending_exception = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  _exception_file    = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  _exception_line    = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
// Implementation of Exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
bool Exceptions::special_exception(Thread* thread, const char* file, int line, Handle h_exception) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  // bootstrapping check
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  if (!Universe::is_fully_initialized()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
   vm_exit_during_initialization(h_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
   ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
6964
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    81
#ifdef ASSERT
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    82
  // 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
    83
  // 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
    84
  // adequate stack space.
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    85
  // 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
    86
  if (h_exception()->klass() == SystemDictionary::StackOverflowError_klass()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
    87
    InstanceKlass* ik = InstanceKlass::cast(h_exception->klass());
6964
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    88
    assert(ik->is_initialized(),
41070
496463b4e206 8140520: segfault on solaris-amd64 with "-XX:VMThreadStackSize=1" option
rdurbin
parents: 37248
diff changeset
    89
           "need to increase java_thread_min_stack_allowed calculation");
6964
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    90
  }
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    91
#endif // ASSERT
6e45ffa3bccf 6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents: 6179
diff changeset
    92
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  if (thread->is_VM_thread()
47103
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46968
diff changeset
    94
      || !thread->can_call_java()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
    // 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
    96
    // is compiling.  We just install a dummy exception object
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
    thread->set_pending_exception(Universe::vm_exception(), file, line);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   104
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
   105
  // bootstrapping check
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  if (!Universe::is_fully_initialized()) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   107
    if (h_name == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
      // atleast an informative message.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
      vm_exit_during_initialization("Exception", message);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
      vm_exit_during_initialization(h_name, message);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  if (thread->is_VM_thread()
47103
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46968
diff changeset
   117
      || !thread->can_call_java()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
    // 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
   119
    // is compiling.  We just install a dummy exception object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
    thread->set_pending_exception(Universe::vm_exception(), file, line);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
// This method should only be called from generated code,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
// therefore the exception oop should be in the oopmap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
void Exceptions::_throw_oop(Thread* thread, const char* file, int line, oop exception) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  assert(exception != NULL, "exception should not be NULL");
46271
979ebd346ecf 8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents: 41070
diff changeset
   130
  Handle h_exception(thread, exception);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  _throw(thread, file, line, h_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
4014
b59b8c387950 6889302: TraceExceptions output should include detail message
never
parents: 1
diff changeset
   134
void Exceptions::_throw(Thread* thread, const char* file, int line, Handle h_exception, const char* message) {
53874
b2fb6f782d84 8153413: Exceptions::_throw always logs exceptions, penalizing performance
coleenp
parents: 53745
diff changeset
   135
  ResourceMark rm(thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  assert(h_exception() != NULL, "exception should not be NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  // tracing (do this up front - so it works during boot strapping)
53874
b2fb6f782d84 8153413: Exceptions::_throw always logs exceptions, penalizing performance
coleenp
parents: 53745
diff changeset
   139
  // Note, the print_value_string() argument is not called unless logging is enabled!
35216
71c463a17b3b 8141211: Convert TraceExceptions to Unified Logging
rprotacio
parents: 33602
diff changeset
   140
  log_info(exceptions)("Exception <%s%s%s> (" INTPTR_FORMAT ") \n"
71c463a17b3b 8141211: Convert TraceExceptions to Unified Logging
rprotacio
parents: 33602
diff changeset
   141
                       "thrown [%s, line %d]\nfor thread " INTPTR_FORMAT,
71c463a17b3b 8141211: Convert TraceExceptions to Unified Logging
rprotacio
parents: 33602
diff changeset
   142
                       h_exception->print_value_string(),
71c463a17b3b 8141211: Convert TraceExceptions to Unified Logging
rprotacio
parents: 33602
diff changeset
   143
                       message ? ": " : "", message ? message : "",
71c463a17b3b 8141211: Convert TraceExceptions to Unified Logging
rprotacio
parents: 33602
diff changeset
   144
                       p2i(h_exception()), file, line, p2i(thread));
53874
b2fb6f782d84 8153413: Exceptions::_throw always logs exceptions, penalizing performance
coleenp
parents: 53745
diff changeset
   145
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  // for AbortVMOnException flag
33208
5ec6ffa63c57 8136577: Make AbortVMOnException available in product builds
poonam
parents: 33148
diff changeset
   147
  Exceptions::debug_check_abort(h_exception, message);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  // Check for special boot-strapping/vm-thread handling
19158
9c755bf7cae5 8021301: better event messages
anoll
parents: 14583
diff changeset
   150
  if (special_exception(thread, file, line, h_exception)) {
9c755bf7cae5 8021301: better event messages
anoll
parents: 14583
diff changeset
   151
    return;
9c755bf7cae5 8021301: better event messages
anoll
parents: 14583
diff changeset
   152
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
31335
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   154
  if (h_exception->is_a(SystemDictionary::OutOfMemoryError_klass())) {
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   155
    count_out_of_memory_exceptions(h_exception);
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   156
  }
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   157
50516
77f9fece2f19 8204477: Count linkage errors and print in Exceptions::print_exception_counts_on_error
goetz
parents: 50217
diff changeset
   158
  if (h_exception->is_a(SystemDictionary::LinkageError_klass())) {
77f9fece2f19 8204477: Count linkage errors and print in Exceptions::print_exception_counts_on_error
goetz
parents: 50217
diff changeset
   159
    Atomic::inc(&_linkage_errors);
77f9fece2f19 8204477: Count linkage errors and print in Exceptions::print_exception_counts_on_error
goetz
parents: 50217
diff changeset
   160
  }
77f9fece2f19 8204477: Count linkage errors and print in Exceptions::print_exception_counts_on_error
goetz
parents: 50217
diff changeset
   161
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4014
diff changeset
   162
  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
   163
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  // set the pending exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  thread->set_pending_exception(h_exception(), file, line);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  // vm log
53874
b2fb6f782d84 8153413: Exceptions::_throw always logs exceptions, penalizing performance
coleenp
parents: 53745
diff changeset
   168
  Events::log_exception(thread, h_exception, message, file, line);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   172
void Exceptions::_throw_msg(Thread* thread, const char* file, int line, Symbol* name, const char* message,
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   173
                            Handle h_loader, Handle h_protection_domain) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  // Check for special boot-strapping/vm-thread handling
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   175
  if (special_exception(thread, file, line, name, message)) return;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  // Create and throw exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  Handle h_cause(thread, NULL);
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   178
  Handle h_exception = new_exception(thread, name, message, h_cause, h_loader, h_protection_domain);
4014
b59b8c387950 6889302: TraceExceptions output should include detail message
never
parents: 1
diff changeset
   179
  _throw(thread, file, line, h_exception, message);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   182
void Exceptions::_throw_msg_cause(Thread* thread, const char* file, int line, Symbol* name, const char* message, Handle h_cause,
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   183
                                  Handle h_loader, Handle h_protection_domain) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  // Check for special boot-strapping/vm-thread handling
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   185
  if (special_exception(thread, file, line, name, message)) return;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  // Create and throw exception and init cause
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   187
  Handle h_exception = new_exception(thread, name, message, h_cause, h_loader, h_protection_domain);
4014
b59b8c387950 6889302: TraceExceptions output should include detail message
never
parents: 1
diff changeset
   188
  _throw(thread, file, line, h_exception, message);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   191
void Exceptions::_throw_cause(Thread* thread, const char* file, int line, Symbol* name, Handle h_cause,
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   192
                              Handle h_loader, Handle h_protection_domain) {
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   193
  // Check for special boot-strapping/vm-thread handling
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   194
  if (special_exception(thread, file, line, h_cause)) return;
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   195
  // Create and throw exception
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   196
  Handle h_exception = new_exception(thread, name, h_cause, h_loader, h_protection_domain);
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   197
  _throw(thread, file, line, h_exception, NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   200
void Exceptions::_throw_args(Thread* thread, const char* file, int line, Symbol* name, Symbol* signature, JavaCallArguments *args) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  // Check for special boot-strapping/vm-thread handling
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   202
  if (special_exception(thread, file, line, name, NULL)) return;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  // Create and throw exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  Handle h_loader(thread, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  Handle h_prot(thread, NULL);
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   206
  Handle exception = new_exception(thread, name, signature, args, h_loader, h_prot);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  _throw(thread, file, line, exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   211
// Methods for default parameters.
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   212
// NOTE: These must be here (and not in the header file) because of include circularities.
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   213
void Exceptions::_throw_msg_cause(Thread* thread, const char* file, int line, Symbol* name, const char* message, Handle h_cause) {
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   214
  _throw_msg_cause(thread, file, line, name, message, h_cause, Handle(thread, NULL), Handle(thread, NULL));
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   215
}
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   216
void Exceptions::_throw_msg(Thread* thread, const char* file, int line, Symbol* name, const char* message) {
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   217
  _throw_msg(thread, file, line, name, message, Handle(thread, NULL), Handle(thread, NULL));
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   218
}
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   219
void Exceptions::_throw_cause(Thread* thread, const char* file, int line, Symbol* name, Handle h_cause) {
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   220
  _throw_cause(thread, file, line, name, h_cause, Handle(thread, NULL), Handle(thread, NULL));
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   221
}
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   222
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   223
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 33230
diff changeset
   224
void Exceptions::throw_stack_overflow_exception(Thread* THREAD, const char* file, int line, const methodHandle& method) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  Handle exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  if (!THREAD->has_pending_exception()) {
47689
54b78d6243c5 8189794: Assert in InstanceKlass::cast called from Exceptions::new_exceptions
coleenp
parents: 47216
diff changeset
   227
    InstanceKlass* k = SystemDictionary::StackOverflowError_klass();
54b78d6243c5 8189794: Assert in InstanceKlass::cast called from Exceptions::new_exceptions
coleenp
parents: 47216
diff changeset
   228
    oop e = k->allocate_instance(CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
    exception = Handle(THREAD, e);  // fill_in_stack trace does gc
47689
54b78d6243c5 8189794: Assert in InstanceKlass::cast called from Exceptions::new_exceptions
coleenp
parents: 47216
diff changeset
   230
    assert(k->is_initialized(), "need to increase java_thread_min_stack_allowed calculation");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
    if (StackTraceInThrowable) {
9321
c29711c6ae35 7009923: JSR 292: VM crash in JavaThread::last_frame
coleenp
parents: 8921
diff changeset
   232
      java_lang_Throwable::fill_in_stack_trace(exception, method());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
    }
31335
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   234
    // Increment counter for hs_err file reporting
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   235
    Atomic::inc(&Exceptions::_stack_overflow_errors);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
    // if prior exception, throw that one instead
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
    exception = Handle(THREAD, THREAD->pending_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  }
9321
c29711c6ae35 7009923: JSR 292: VM crash in JavaThread::last_frame
coleenp
parents: 8921
diff changeset
   240
  _throw(THREAD, file, line, exception);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   243
void Exceptions::fthrow(Thread* thread, const char* file, int line, Symbol* h_name, const char* format, ...) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  const int max_msg_size = 1024;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  va_list ap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  va_start(ap, format);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
  char msg[max_msg_size];
49177
eebf559c9e0d 8196882: VS2017 Hotspot Defined vsnprintf Function Causes C2084 Already Defined Compilation Error
kbarrett
parents: 48826
diff changeset
   248
  os::vsnprintf(msg, max_msg_size, format, ap);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  va_end(ap);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  _throw_msg(thread, file, line, h_name, msg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 22234
diff changeset
   253
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
// Creates an exception oop, calls the <init> method with the given signature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
// and returns a Handle
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   256
Handle Exceptions::new_exception(Thread *thread, Symbol* name,
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   257
                                 Symbol* signature, JavaCallArguments *args,
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   258
                                 Handle h_loader, Handle h_protection_domain) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  assert(Universe::is_fully_initialized(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
    "cannot be called during initialization");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  assert(thread->is_Java_thread(), "can only be called by a Java thread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  assert(!thread->has_pending_exception(), "already has exception");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  Handle h_exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
47689
54b78d6243c5 8189794: Assert in InstanceKlass::cast called from Exceptions::new_exceptions
coleenp
parents: 47216
diff changeset
   266
  // Resolve exception klass, and check for pending exception below.
54b78d6243c5 8189794: Assert in InstanceKlass::cast called from Exceptions::new_exceptions
coleenp
parents: 47216
diff changeset
   267
  Klass* klass = SystemDictionary::resolve_or_fail(name, h_loader, h_protection_domain, true, thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  if (!thread->has_pending_exception()) {
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46271
diff changeset
   270
    assert(klass != NULL, "klass must exist");
50217
843fc56f4686 8203381: Replace InstanceKlass::allocate_instance_handle with JavaCalls::construct_new_instance
iklam
parents: 49658
diff changeset
   271
    h_exception = JavaCalls::construct_new_instance(InstanceKlass::cast(klass),
47689
54b78d6243c5 8189794: Assert in InstanceKlass::cast called from Exceptions::new_exceptions
coleenp
parents: 47216
diff changeset
   272
                                signature,
54b78d6243c5 8189794: Assert in InstanceKlass::cast called from Exceptions::new_exceptions
coleenp
parents: 47216
diff changeset
   273
                                args,
54b78d6243c5 8189794: Assert in InstanceKlass::cast called from Exceptions::new_exceptions
coleenp
parents: 47216
diff changeset
   274
                                thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  // Check if another exception was thrown in the process, if so rethrow that one
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  if (thread->has_pending_exception()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
    h_exception = Handle(thread, thread->pending_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
    thread->clear_pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  return h_exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   285
// Creates an exception oop, calls the <init> method with the given signature.
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   286
// and returns a Handle
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   287
// Initializes the cause if cause non-null
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   288
Handle Exceptions::new_exception(Thread *thread, Symbol* name,
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   289
                                 Symbol* signature, JavaCallArguments *args,
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   290
                                 Handle h_cause,
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   291
                                 Handle h_loader, Handle h_protection_domain) {
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   292
  Handle h_exception = new_exception(thread, name, signature, args, h_loader, h_protection_domain);
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   293
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   294
  // Future: object initializer should take a cause argument
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   295
  if (h_cause.not_null()) {
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   296
    assert(h_cause->is_a(SystemDictionary::Throwable_klass()),
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   297
        "exception cause is not a subclass of java/lang/Throwable");
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   298
    JavaValue result1(T_OBJECT);
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   299
    JavaCallArguments args1;
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   300
    args1.set_receiver(h_exception);
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   301
    args1.push_oop(h_cause);
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   302
    JavaCalls::call_virtual(&result1, h_exception->klass(),
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   303
                                      vmSymbols::initCause_name(),
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   304
                                      vmSymbols::throwable_throwable_signature(),
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   305
                                      &args1,
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   306
                                      thread);
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   307
  }
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   308
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   309
  // Check if another exception was thrown in the process, if so rethrow that one
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   310
  if (thread->has_pending_exception()) {
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   311
    h_exception = Handle(thread, thread->pending_exception());
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   312
    thread->clear_pending_exception();
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   313
  }
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   314
  return h_exception;
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   315
}
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   316
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   317
// Convenience method. Calls either the <init>() or <init>(Throwable) method when
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   318
// creating a new exception
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   319
Handle Exceptions::new_exception(Thread* thread, Symbol* name,
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   320
                                 Handle h_cause,
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   321
                                 Handle h_loader, Handle h_protection_domain,
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   322
                                 ExceptionMsgToUtf8Mode to_utf8_safe) {
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   323
  JavaCallArguments args;
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   324
  Symbol* signature = NULL;
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   325
  if (h_cause.is_null()) {
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   326
    signature = vmSymbols::void_method_signature();
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   327
  } else {
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   328
    signature = vmSymbols::throwable_void_signature();
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   329
    args.push_oop(h_cause);
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   330
  }
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   331
  return new_exception(thread, name, signature, &args, h_loader, h_protection_domain);
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   332
}
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   333
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
// Convenience method. Calls either the <init>() or <init>(String) method when
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
// creating a new exception
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   336
Handle Exceptions::new_exception(Thread* thread, Symbol* name,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
                                 const char* message, Handle h_cause,
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   338
                                 Handle h_loader, Handle h_protection_domain,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
                                 ExceptionMsgToUtf8Mode to_utf8_safe) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  JavaCallArguments args;
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   341
  Symbol* signature = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  if (message == NULL) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   343
    signature = vmSymbols::void_method_signature();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
    // We want to allocate storage, but we can't do that if there's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
    // a pending exception, so we preserve any pending exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
    // around the allocation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
    // If we get an exception from the allocation, prefer that to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
    // the exception we are trying to build, or the pending exception.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
    // This is sort of like what PRESERVE_EXCEPTION_MARK does, except
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
    // for the preferencing and the early returns.
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   352
    Handle incoming_exception(thread, NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
    if (thread->has_pending_exception()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
      incoming_exception = Handle(thread, thread->pending_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
      thread->clear_pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
    Handle msg;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
    if (to_utf8_safe == safe_to_utf8) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
      // Make a java UTF8 string.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
      msg = java_lang_String::create_from_str(message, thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
      // Make a java string keeping the encoding scheme of the original string.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
      msg = java_lang_String::create_from_platform_dependent_str(message, thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
    if (thread->has_pending_exception()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
      Handle exception(thread, thread->pending_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
      thread->clear_pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
      return exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
    if (incoming_exception.not_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
      return incoming_exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
    args.push_oop(msg);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   374
    signature = vmSymbols::string_void_signature();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  }
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   376
  return new_exception(thread, name, signature, &args, h_cause, h_loader, h_protection_domain);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
// Another convenience method that creates handles for null class loaders and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
// protection domains and null causes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
// If the last parameter 'to_utf8_mode' is safe_to_utf8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
// it means we can safely ignore the encoding scheme of the message string and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
// convert it directly to a java UTF8 string. Otherwise, we need to take the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
// encoding scheme of the string into account. One thing we should do at some
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
// point is to push this flag down to class java_lang_String since other
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
// classes may need similar functionalities.
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 11636
diff changeset
   387
Handle Exceptions::new_exception(Thread* thread, Symbol* name,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
                                 const char* message,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
                                 ExceptionMsgToUtf8Mode to_utf8_safe) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  Handle       h_loader(thread, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  Handle       h_prot(thread, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  Handle       h_cause(thread, NULL);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   394
  return Exceptions::new_exception(thread, name, message, h_cause, h_loader,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
                                   h_prot, to_utf8_safe);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
48826
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   398
// invokedynamic uses wrap_dynamic_exception for:
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   399
//    - bootstrap method resolution
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   400
//    - post call to MethodHandleNatives::linkCallSite
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   401
// dynamically computed constant uses wrap_dynamic_exception for:
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   402
//    - bootstrap method resolution
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   403
//    - post call to MethodHandleNatives::linkDynamicConstant
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   404
void Exceptions::wrap_dynamic_exception(Thread* THREAD) {
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   405
  if (THREAD->has_pending_exception()) {
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   406
    oop exception = THREAD->pending_exception();
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   407
    // See the "Linking Exceptions" section for the invokedynamic instruction
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   408
    // in JVMS 6.5.
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   409
    if (exception->is_a(SystemDictionary::Error_klass())) {
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   410
      // Pass through an Error, including BootstrapMethodError, any other form
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   411
      // of linkage error, or say ThreadDeath/OutOfMemoryError
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   412
      if (TraceMethodHandles) {
53745
a535ba736cab 8218004: Clean up terminology for shared methods within the JVM for indy and condy support
lfoltan
parents: 50516
diff changeset
   413
        tty->print_cr("bootstrap method invocation wraps BSME around " INTPTR_FORMAT, p2i((void *)exception));
48826
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   414
        exception->print();
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   415
      }
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   416
      return;
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   417
    }
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   418
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   419
    // Otherwise wrap the exception in a BootstrapMethodError
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   420
    if (TraceMethodHandles) {
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   421
      tty->print_cr("[constant/invoke]dynamic throws BSME for " INTPTR_FORMAT, p2i((void *)exception));
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   422
      exception->print();
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   423
    }
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   424
    Handle nested_exception(THREAD, exception);
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   425
    THREAD->clear_pending_exception();
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   426
    THROW_CAUSE(vmSymbols::java_lang_BootstrapMethodError(), nested_exception)
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   427
  }
c4d9d1b08e2e 8186209: Tool support for ConstantDynamic
psandoz
parents: 47689
diff changeset
   428
}
31335
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   429
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   430
// Exception counting for hs_err file
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   431
volatile int Exceptions::_stack_overflow_errors = 0;
50516
77f9fece2f19 8204477: Count linkage errors and print in Exceptions::print_exception_counts_on_error
goetz
parents: 50217
diff changeset
   432
volatile int Exceptions::_linkage_errors = 0;
31335
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   433
volatile int Exceptions::_out_of_memory_error_java_heap_errors = 0;
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   434
volatile int Exceptions::_out_of_memory_error_metaspace_errors = 0;
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   435
volatile int Exceptions::_out_of_memory_error_class_metaspace_errors = 0;
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   436
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   437
void Exceptions::count_out_of_memory_exceptions(Handle exception) {
58177
4932dce35882 8230841: Remove oopDesc::equals()
pliden
parents: 54973
diff changeset
   438
  if (exception() == Universe::out_of_memory_error_metaspace()) {
31335
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   439
     Atomic::inc(&_out_of_memory_error_metaspace_errors);
58177
4932dce35882 8230841: Remove oopDesc::equals()
pliden
parents: 54973
diff changeset
   440
  } else if (exception() == Universe::out_of_memory_error_class_metaspace()) {
31335
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   441
     Atomic::inc(&_out_of_memory_error_class_metaspace_errors);
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   442
  } else {
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   443
     // everything else reported as java heap OOM
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   444
     Atomic::inc(&_out_of_memory_error_java_heap_errors);
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   445
  }
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   446
}
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   447
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   448
void print_oom_count(outputStream* st, const char *err, int count) {
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   449
  if (count > 0) {
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   450
    st->print_cr("OutOfMemoryError %s=%d", err, count);
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   451
  }
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   452
}
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   453
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   454
bool Exceptions::has_exception_counts() {
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   455
  return (_stack_overflow_errors + _out_of_memory_error_java_heap_errors +
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   456
         _out_of_memory_error_metaspace_errors + _out_of_memory_error_class_metaspace_errors) > 0;
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   457
}
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   458
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   459
void Exceptions::print_exception_counts_on_error(outputStream* st) {
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   460
  print_oom_count(st, "java_heap_errors", _out_of_memory_error_java_heap_errors);
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   461
  print_oom_count(st, "metaspace_errors", _out_of_memory_error_metaspace_errors);
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   462
  print_oom_count(st, "class_metaspace_errors", _out_of_memory_error_class_metaspace_errors);
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   463
  if (_stack_overflow_errors > 0) {
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   464
    st->print_cr("StackOverflowErrors=%d", _stack_overflow_errors);
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   465
  }
50516
77f9fece2f19 8204477: Count linkage errors and print in Exceptions::print_exception_counts_on_error
goetz
parents: 50217
diff changeset
   466
  if (_linkage_errors > 0) {
77f9fece2f19 8204477: Count linkage errors and print in Exceptions::print_exception_counts_on_error
goetz
parents: 50217
diff changeset
   467
    st->print_cr("LinkageErrors=%d", _linkage_errors);
77f9fece2f19 8204477: Count linkage errors and print in Exceptions::print_exception_counts_on_error
goetz
parents: 50217
diff changeset
   468
  }
31335
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   469
}
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 26135
diff changeset
   470
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
// Implementation of ExceptionMark
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
ExceptionMark::ExceptionMark(Thread*& thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
  thread     = Thread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
  _thread    = thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
  if (_thread->has_pending_exception()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
    oop exception = _thread->pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
    _thread->clear_pending_exception(); // Needed to avoid infinite recursion
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
    exception->print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
    fatal("ExceptionMark constructor expects no pending exceptions");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
ExceptionMark::~ExceptionMark() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  if (_thread->has_pending_exception()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
    Handle exception(_thread, _thread->pending_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
    _thread->clear_pending_exception(); // Needed to avoid infinite recursion
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
    if (is_init_completed()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
      exception->print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
      fatal("ExceptionMark destructor expects no pending exceptions");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
      vm_exit_during_initialization(exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
// ----------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
// 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
   501
void Exceptions::debug_check_abort(const char *value_string, const char* message) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  if (AbortVMOnException != NULL && value_string != NULL &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
      strstr(value_string, AbortVMOnException)) {
33208
5ec6ffa63c57 8136577: Make AbortVMOnException available in product builds
poonam
parents: 33148
diff changeset
   504
    if (AbortVMOnExceptionMessage == NULL || (message != NULL &&
5ec6ffa63c57 8136577: Make AbortVMOnException available in product builds
poonam
parents: 33148
diff changeset
   505
        strstr(message, AbortVMOnExceptionMessage))) {
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31337
diff changeset
   506
      fatal("Saw %s, aborting", value_string);
6179
4846648c4b7b 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents: 5547
diff changeset
   507
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
6179
4846648c4b7b 6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents: 5547
diff changeset
   511
void Exceptions::debug_check_abort(Handle exception, const char* message) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  if (AbortVMOnException != NULL) {
33208
5ec6ffa63c57 8136577: Make AbortVMOnException available in product builds
poonam
parents: 33148
diff changeset
   513
    debug_check_abort_helper(exception, message);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
}
33208
5ec6ffa63c57 8136577: Make AbortVMOnException available in product builds
poonam
parents: 33148
diff changeset
   516
5ec6ffa63c57 8136577: Make AbortVMOnException available in product builds
poonam
parents: 33148
diff changeset
   517
void Exceptions::debug_check_abort_helper(Handle exception, const char* message) {
5ec6ffa63c57 8136577: Make AbortVMOnException available in product builds
poonam
parents: 33148
diff changeset
   518
  ResourceMark rm;
5ec6ffa63c57 8136577: Make AbortVMOnException available in product builds
poonam
parents: 33148
diff changeset
   519
  if (message == NULL && exception->is_a(SystemDictionary::Throwable_klass())) {
46271
979ebd346ecf 8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents: 41070
diff changeset
   520
    oop msg = java_lang_Throwable::message(exception());
33208
5ec6ffa63c57 8136577: Make AbortVMOnException available in product builds
poonam
parents: 33148
diff changeset
   521
    if (msg != NULL) {
5ec6ffa63c57 8136577: Make AbortVMOnException available in product builds
poonam
parents: 33148
diff changeset
   522
      message = java_lang_String::as_utf8_string(msg);
5ec6ffa63c57 8136577: Make AbortVMOnException available in product builds
poonam
parents: 33148
diff changeset
   523
    }
5ec6ffa63c57 8136577: Make AbortVMOnException available in product builds
poonam
parents: 33148
diff changeset
   524
  }
33602
16053580a684 8139163: InstanceKlass::cast passes through NULL
coleenp
parents: 33593
diff changeset
   525
  debug_check_abort(exception()->klass()->external_name(), message);
33208
5ec6ffa63c57 8136577: Make AbortVMOnException available in product builds
poonam
parents: 33148
diff changeset
   526
}
35477
7a00b08d27bc 8144953: runtime/CommandLine/TraceExceptionsTest.java fails when exception is thrown in compiled code
rprotacio
parents: 35216
diff changeset
   527
7a00b08d27bc 8144953: runtime/CommandLine/TraceExceptionsTest.java fails when exception is thrown in compiled code
rprotacio
parents: 35216
diff changeset
   528
// for logging exceptions
54973
0927d8c7296f 8224487: outputStream should not be copyable
stuefe
parents: 54786
diff changeset
   529
void Exceptions::log_exception(Handle exception, const char* message) {
35477
7a00b08d27bc 8144953: runtime/CommandLine/TraceExceptionsTest.java fails when exception is thrown in compiled code
rprotacio
parents: 35216
diff changeset
   530
  ResourceMark rm;
54973
0927d8c7296f 8224487: outputStream should not be copyable
stuefe
parents: 54786
diff changeset
   531
  Symbol* detail_message = java_lang_Throwable::detail_message(exception());
0927d8c7296f 8224487: outputStream should not be copyable
stuefe
parents: 54786
diff changeset
   532
  if (detail_message != NULL) {
37190
09d719d466a6 8146947: Remove PrintOopAddress rather than converting to UL
rprotacio
parents: 37110
diff changeset
   533
    log_info(exceptions)("Exception <%s: %s>\n thrown in %s",
35477
7a00b08d27bc 8144953: runtime/CommandLine/TraceExceptionsTest.java fails when exception is thrown in compiled code
rprotacio
parents: 35216
diff changeset
   534
                         exception->print_value_string(),
54973
0927d8c7296f 8224487: outputStream should not be copyable
stuefe
parents: 54786
diff changeset
   535
                         detail_message->as_C_string(),
0927d8c7296f 8224487: outputStream should not be copyable
stuefe
parents: 54786
diff changeset
   536
                         message);
35477
7a00b08d27bc 8144953: runtime/CommandLine/TraceExceptionsTest.java fails when exception is thrown in compiled code
rprotacio
parents: 35216
diff changeset
   537
  } else {
37190
09d719d466a6 8146947: Remove PrintOopAddress rather than converting to UL
rprotacio
parents: 37110
diff changeset
   538
    log_info(exceptions)("Exception <%s>\n thrown in %s",
35477
7a00b08d27bc 8144953: runtime/CommandLine/TraceExceptionsTest.java fails when exception is thrown in compiled code
rprotacio
parents: 35216
diff changeset
   539
                         exception->print_value_string(),
54973
0927d8c7296f 8224487: outputStream should not be copyable
stuefe
parents: 54786
diff changeset
   540
                         message);
35477
7a00b08d27bc 8144953: runtime/CommandLine/TraceExceptionsTest.java fails when exception is thrown in compiled code
rprotacio
parents: 35216
diff changeset
   541
  }
7a00b08d27bc 8144953: runtime/CommandLine/TraceExceptionsTest.java fails when exception is thrown in compiled code
rprotacio
parents: 35216
diff changeset
   542
}