truffle: src/share/vm/utilities/exceptions.cpp comparison

comparison src/share/vm/utilities/exceptions.cpp @ 6275:957c266d8bc5

Merge with http://hg.openjdk.java.net/hsx/hsx24/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Tue, 21 Aug 2012 10:39:19 +0200
parents	1b8d02e10ee8 93c71eb28866
children	e522a00b91aa

comparison

equal deleted inserted replaced

-:fd8832ae511d
+:957c266d8bc5
 // vm log
 Events::log_exception(thread, "Threw " INTPTR_FORMAT " at %s:%d", (address)h_exception(), file, line);
 }
-void Exceptions::_throw_msg(Thread* thread, const char* file, int line, Symbol* h_name, const char* message, Handle h_loader, Handle h_protection_domain) {
+void Exceptions::_throw_msg(Thread* thread, const char* file, int line, Symbol* name, const char* message,
+Handle h_loader, Handle h_protection_domain) {
 // Check for special boot-strapping/vm-thread handling
-if (special_exception(thread, file, line, h_name, message)) return;
+if (special_exception(thread, file, line, name, message)) return;
 // Create and throw exception
 Handle h_cause(thread, NULL);
-Handle h_exception = new_exception(thread, h_name, message, h_cause, h_loader, h_protection_domain);
+Handle h_exception = new_exception(thread, name, message, h_cause, h_loader, h_protection_domain);
 _throw(thread, file, line, h_exception, message);
 }
-// Throw an exception with a message and a cause
+void Exceptions::_throw_msg_cause(Thread* thread, const char* file, int line, Symbol* name, const char* message, Handle h_cause,
-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) {
+Handle h_loader, Handle h_protection_domain) {
 // Check for special boot-strapping/vm-thread handling
-if (special_exception(thread, file, line, h_name, message)) return;
+if (special_exception(thread, file, line, name, message)) return;
 // Create and throw exception and init cause
-Handle h_exception = new_exception(thread, h_name, message, h_cause, h_loader, h_protection_domain);
+Handle h_exception = new_exception(thread, name, message, h_cause, h_loader, h_protection_domain);
 _throw(thread, file, line, h_exception, message);
 }
-// This version already has a handle for name
+void Exceptions::_throw_cause(Thread* thread, const char* file, int line, Symbol* name, Handle h_cause,
-void Exceptions::_throw_msg(Thread* thread, const char* file, int line,
+Handle h_loader, Handle h_protection_domain) {
-Symbol* name, const char* message) {
-Handle       h_loader(thread, NULL);
-Handle       h_protection_domain(thread, NULL);
-Exceptions::_throw_msg(thread, file, line, name, message, h_loader, h_protection_domain);
-}
-// This version already has a handle for name
-void Exceptions::_throw_msg_cause(Thread* thread, const char* file, int line,
-Symbol* name, const char* message, Handle cause) {
-Handle       h_loader(thread, NULL);
-Handle       h_protection_domain(thread, NULL);
-Exceptions::_throw_msg_cause(thread, file, line, name, message, cause, h_loader, h_protection_domain);
-}
-void Exceptions::_throw_args(Thread* thread, const char* file, int line, Symbol* h_name, Symbol* h_signature, JavaCallArguments *args) {
 // Check for special boot-strapping/vm-thread handling
-if (special_exception(thread, file, line, h_name, NULL)) return;
+if (special_exception(thread, file, line, h_cause)) return;
+// Create and throw exception
+Handle h_exception = new_exception(thread, name, h_cause, h_loader, h_protection_domain);
+_throw(thread, file, line, h_exception, NULL);
+}
+void Exceptions::_throw_args(Thread* thread, const char* file, int line, Symbol* name, Symbol* signature, JavaCallArguments *args) {
+// Check for special boot-strapping/vm-thread handling
+if (special_exception(thread, file, line, name, NULL)) return;
 // Create and throw exception
 Handle h_loader(thread, NULL);
 Handle h_prot(thread, NULL);
-Handle h_cause(thread, NULL);
+Handle exception = new_exception(thread, name, signature, args, h_loader, h_prot);
-Handle exception = new_exception(thread, h_name, h_signature, args, h_cause, h_loader, h_prot);
 _throw(thread, file, line, exception);
+}
+// Methods for default parameters.
+// NOTE: These must be here (and not in the header file) because of include circularities.
+void Exceptions::_throw_msg_cause(Thread* thread, const char* file, int line, Symbol* name, const char* message, Handle h_cause) {
+_throw_msg_cause(thread, file, line, name, message, h_cause, Handle(thread, NULL), Handle(thread, NULL));
+}
+void Exceptions::_throw_msg(Thread* thread, const char* file, int line, Symbol* name, const char* message) {
+_throw_msg(thread, file, line, name, message, Handle(thread, NULL), Handle(thread, NULL));
+}
+void Exceptions::_throw_cause(Thread* thread, const char* file, int line, Symbol* name, Handle h_cause) {
+_throw_cause(thread, file, line, name, h_cause, Handle(thread, NULL), Handle(thread, NULL));
 }
 void Exceptions::throw_stack_overflow_exception(Thread* THREAD, const char* file, int line, methodHandle method) {
 Handle exception;
 _throw_msg(thread, file, line, h_name, msg);
 }
 // Creates an exception oop, calls the <init> method with the given signature.
 // and returns a Handle
-// Initializes the cause if cause non-null
+Handle Exceptions::new_exception(Thread *thread, Symbol* name,
-Handle Exceptions::new_exception(Thread *thread, Symbol* h_name,
+Symbol* signature, JavaCallArguments *args,
-Symbol* signature,
+Handle h_loader, Handle h_protection_domain) {
-JavaCallArguments *args,
-Handle h_cause, Handle h_loader,
-Handle h_protection_domain) {
 assert(Universe::is_fully_initialized(),
 "cannot be called during initialization");
 assert(thread->is_Java_thread(), "can only be called by a Java thread");
 assert(!thread->has_pending_exception(), "already has exception");
 Handle h_exception;
 // Resolve exception klass
-klassOop ik = SystemDictionary::resolve_or_fail(h_name, h_loader, h_protection_domain, true, thread);
+klassOop ik = SystemDictionary::resolve_or_fail(name, h_loader, h_protection_domain, true, thread);
-instanceKlassHandle klass (thread, ik);
+instanceKlassHandle klass(thread, ik);
 if (!thread->has_pending_exception()) {
 assert(klass.not_null(), "klass must exist");
 // We are about to create an instance - so make sure that klass is initialized
 klass->initialize(thread);
 JavaCalls::call_special(&result, klass,
 vmSymbols::object_initializer_name(),
 signature,
 args,
 thread);
 }
-}
-// Future: object initializer should take a cause argument
-if (h_cause() != NULL) {
-assert(h_cause->is_a(SystemDictionary::Throwable_klass()),
-"exception cause is not a subclass of java/lang/Throwable");
-JavaValue result1(T_OBJECT);
-JavaCallArguments args1;
-args1.set_receiver(h_exception);
-args1.push_oop(h_cause);
-JavaCalls::call_virtual(&result1, klass,
-vmSymbols::initCause_name(),
-vmSymbols::throwable_throwable_signature(),
-&args1,
-thread);
 }
 }
 // Check if another exception was thrown in the process, if so rethrow that one
 if (thread->has_pending_exception()) {
 thread->clear_pending_exception();
 }
 return h_exception;
 }
+// Creates an exception oop, calls the <init> method with the given signature.
+// and returns a Handle
+// Initializes the cause if cause non-null
+Handle Exceptions::new_exception(Thread *thread, Symbol* name,
+Symbol* signature, JavaCallArguments *args,
+Handle h_cause,
+Handle h_loader, Handle h_protection_domain) {
+Handle h_exception = new_exception(thread, name, signature, args, h_loader, h_protection_domain);
+// Future: object initializer should take a cause argument
+if (h_cause.not_null()) {
+assert(h_cause->is_a(SystemDictionary::Throwable_klass()),
+"exception cause is not a subclass of java/lang/Throwable");
+JavaValue result1(T_OBJECT);
+JavaCallArguments args1;
+args1.set_receiver(h_exception);
+args1.push_oop(h_cause);
+JavaCalls::call_virtual(&result1, h_exception->klass(),
+vmSymbols::initCause_name(),
+vmSymbols::throwable_throwable_signature(),
+&args1,
+thread);
+}
+// Check if another exception was thrown in the process, if so rethrow that one
+if (thread->has_pending_exception()) {
+h_exception = Handle(thread, thread->pending_exception());
+thread->clear_pending_exception();
+}
+return h_exception;
+}
+// Convenience method. Calls either the <init>() or <init>(Throwable) method when
+// creating a new exception
+Handle Exceptions::new_exception(Thread* thread, Symbol* name,
+Handle h_cause,
+Handle h_loader, Handle h_protection_domain,
+ExceptionMsgToUtf8Mode to_utf8_safe) {
+JavaCallArguments args;
+Symbol* signature = NULL;
+if (h_cause.is_null()) {
+signature = vmSymbols::void_method_signature();
+} else {
+signature = vmSymbols::throwable_void_signature();
+args.push_oop(h_cause);
+}
+return new_exception(thread, name, signature, &args, h_loader, h_protection_domain);
+}
 // Convenience method. Calls either the <init>() or <init>(String) method when
 // creating a new exception
-Handle Exceptions::new_exception(Thread* thread, Symbol* h_name,
+Handle Exceptions::new_exception(Thread* thread, Symbol* name,
 const char* message, Handle h_cause,
-Handle h_loader,
+Handle h_loader, Handle h_protection_domain,
-Handle h_protection_domain,
 ExceptionMsgToUtf8Mode to_utf8_safe) {
 JavaCallArguments args;
 Symbol* signature = NULL;
 if (message == NULL) {
 signature = vmSymbols::void_method_signature();
 // around the allocation.
 // If we get an exception from the allocation, prefer that to
 // the exception we are trying to build, or the pending exception.
 // This is sort of like what PRESERVE_EXCEPTION_MARK does, except
 // for the preferencing and the early returns.
-Handle incoming_exception (thread, NULL);
+Handle incoming_exception(thread, NULL);
 if (thread->has_pending_exception()) {
 incoming_exception = Handle(thread, thread->pending_exception());
 thread->clear_pending_exception();
 }
 Handle msg;
 return incoming_exception;
 }
 args.push_oop(msg);
 signature = vmSymbols::string_void_signature();
 }
-return new_exception(thread, h_name, signature, &args, h_cause, h_loader, h_protection_domain);
+return new_exception(thread, name, signature, &args, h_cause, h_loader, h_protection_domain);
 }
 // Another convenience method that creates handles for null class loaders and
 // protection domains and null causes.
 // If the last parameter 'to_utf8_mode' is safe_to_utf8,
 // it means we can safely ignore the encoding scheme of the message string and
 // convert it directly to a java UTF8 string. Otherwise, we need to take the
 // encoding scheme of the string into account. One thing we should do at some
 // point is to push this flag down to class java_lang_String since other
 // classes may need similar functionalities.
-Handle Exceptions::new_exception(Thread* thread,
+Handle Exceptions::new_exception(Thread* thread, Symbol* name,
-Symbol* name,
 const char* message,
 ExceptionMsgToUtf8Mode to_utf8_safe) {
 Handle       h_loader(thread, NULL);
 Handle       h_prot(thread, NULL);

Mercurial > hg > truffle

comparison src/share/vm/utilities/exceptions.cpp @ 6275:957c266d8bc5