jdk-sandbox: comparison hotspot/src/share/vm/classfile/javaClasses.cpp

equal deleted inserted replaced

-:c9d5a3727011
+:5c82fa70d313
 compute_offset(_vmAllowSuspension_offset, k, vmSymbols::vmAllowSuspension_name(), vmSymbols::bool_signature());
 compute_offset(_nthreads_offset,    k, vmSymbols::nthreads_name(),    vmSymbols::int_signature());
 compute_offset(_ngroups_offset,     k, vmSymbols::ngroups_name(),     vmSymbols::int_signature());
 }
+void java_lang_Throwable::compute_offsets() {
+Klass* k = SystemDictionary::Throwable_klass();
+compute_offset(depth_offset, k, vmSymbols::depth_name(), vmSymbols::int_signature());
+}
 oop java_lang_Throwable::unassigned_stacktrace() {
 InstanceKlass* ik = SystemDictionary::Throwable_klass();
 address addr = ik->static_field_addr(static_unassigned_stacktrace_offset);
 if (UseCompressedOops) {
 return oopDesc::load_decode_heap_oop((narrowOop *)addr);
 void java_lang_Throwable::set_backtrace(oop throwable, oop value) {
 throwable->release_obj_field_put(backtrace_offset, value);
 }
+int java_lang_Throwable::depth(oop throwable) {
-oop java_lang_Throwable::message(oop throwable) {
+return throwable->int_field(depth_offset);
-return throwable->obj_field(detailMessage_offset);
+}
-}
+void java_lang_Throwable::set_depth(oop throwable, int value) {
+throwable->int_field_put(depth_offset, value);
+}
 oop java_lang_Throwable::message(Handle throwable) {
 return throwable->obj_field(detailMessage_offset);
 }
 static inline bool version_matches(Method* method, int version) {
 assert(version < MAX_VERSION, "version is too big");
 return method != NULL && (method->constants()->version() == version);
 }
 // This class provides a simple wrapper over the internal structure of
 // exception backtrace to insulate users of the backtrace from needing
 // to know what it looks like.
 class BacktraceBuilder: public StackObj {
+friend class BacktraceIterator;
 private:
 Handle          _backtrace;
 objArrayOop     _head;
 typeArrayOop    _methods;
 typeArrayOop    _bcis;
 objArrayOop     _mirrors;
 typeArrayOop    _cprefs; // needed to insulate method name against redefinition
 int             _index;
 NoSafepointVerifier _nsv;
-public:
 enum {
 trace_methods_offset = java_lang_Throwable::trace_methods_offset,
 trace_bcis_offset    = java_lang_Throwable::trace_bcis_offset,
 trace_mirrors_offset = java_lang_Throwable::trace_mirrors_offset,
 trace_cprefs_offset  = java_lang_Throwable::trace_cprefs_offset,
 typeArrayOop cprefs = typeArrayOop(chunk->obj_at(trace_cprefs_offset));
 assert(cprefs != NULL, "cprefs array should be initialized in backtrace");
 return cprefs;
 }
+public:
 // constructor for new backtrace
 BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL), _mirrors(NULL), _cprefs(NULL) {
 expand(CHECK);
 _backtrace = _head;
 _index = 0;
 _index++;
 }
 };
+struct BacktraceElement : public StackObj {
+int _method_id;
+int _bci;
+int _version;
+int _cpref;
+Handle _mirror;
+BacktraceElement(Handle mirror, int mid, int version, int bci, int cpref) :
+_mirror(mirror), _method_id(mid), _version(version), _bci(bci), _cpref(cpref) {}
+};
+class BacktraceIterator : public StackObj {
+int _index;
+objArrayHandle  _result;
+objArrayHandle  _mirrors;
+typeArrayHandle _methods;
+typeArrayHandle _bcis;
+typeArrayHandle _cprefs;
+void init(objArrayHandle result, Thread* thread) {
+// Get method id, bci, version and mirror from chunk
+_result = result;
+if (_result.not_null()) {
+_methods = typeArrayHandle(thread, BacktraceBuilder::get_methods(_result));
+_bcis = typeArrayHandle(thread, BacktraceBuilder::get_bcis(_result));
+_mirrors = objArrayHandle(thread, BacktraceBuilder::get_mirrors(_result));
+_cprefs = typeArrayHandle(thread, BacktraceBuilder::get_cprefs(_result));
+_index = 0;
+}
+}
+public:
+BacktraceIterator(objArrayHandle result, Thread* thread) {
+init(result, thread);
+assert(_methods->length() == java_lang_Throwable::trace_chunk_size, "lengths don't match");
+}
+BacktraceElement next(Thread* thread) {
+BacktraceElement e (Handle(thread, _mirrors->obj_at(_index)),
+_methods->short_at(_index),
+Backtrace::version_at(_bcis->int_at(_index)),
+Backtrace::bci_at(_bcis->int_at(_index)),
+_cprefs->short_at(_index));
+_index++;
+if (_index >= java_lang_Throwable::trace_chunk_size) {
+int next_offset = java_lang_Throwable::trace_next_offset;
+// Get next chunk
+objArrayHandle result (thread, objArrayOop(_result->obj_at(next_offset)));
+init(result, thread);
+}
+return e;
+}
+bool repeat() {
+return _result.not_null() && _mirrors->obj_at(_index) != NULL;
+}
+};
 // Print stack trace element to resource allocated buffer
-char* java_lang_Throwable::print_stack_element_to_buffer(Handle mirror,
+static void print_stack_element_to_stream(outputStream* st, Handle mirror, int method_id,
-int method_id, int version, int bci, int cpref) {
+int version, int bci, int cpref) {
+ResourceMark rm;
 // Get strings and string lengths
 InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror()));
 const char* klass_name  = holder->external_name();
 int buf_len = (int)strlen(klass_name);
 sprintf(buf + (int)strlen(buf), "(nmethod " INTPTR_FORMAT ")", (intptr_t)nm);
 }
 }
 }
-return buf;
-}
-void java_lang_Throwable::print_stack_element(outputStream *st, Handle mirror,
-int method_id, int version, int bci, int cpref) {
-ResourceMark rm;
-char* buf = print_stack_element_to_buffer(mirror, method_id, version, bci, cpref);
 st->print_cr("%s", buf);
 }
 void java_lang_Throwable::print_stack_element(outputStream *st, const methodHandle& method, int bci) {
 Handle mirror = method->method_holder()->java_mirror();
 int method_id = method->orig_method_idnum();
 int version = method->constants()->version();
 int cpref = method->name_index();
-print_stack_element(st, mirror, method_id, version, bci, cpref);
+print_stack_element_to_stream(st, mirror, method_id, version, bci, cpref);
-}
-const char* java_lang_Throwable::no_stack_trace_message() {
-return "\t<<no stack trace available>>";
 }
 /**
 * Print the throwable message and its stack trace plus all causes by walking the
 * cause chain.  The output looks the same as of Throwable.printStackTrace().
 // Now print the stack trace.
 Thread* THREAD = Thread::current();
 while (throwable.not_null()) {
 objArrayHandle result (THREAD, objArrayOop(backtrace(throwable())));
 if (result.is_null()) {
-st->print_raw_cr(no_stack_trace_message());
+st->print_raw_cr("\t<<no stack trace available>>");
 return;
 }
+BacktraceIterator iter(result, THREAD);
-while (result.not_null()) {
-// Get method id, bci, version and mirror from chunk
+while (iter.repeat()) {
-typeArrayHandle methods (THREAD, BacktraceBuilder::get_methods(result));
+BacktraceElement bte = iter.next(THREAD);
-typeArrayHandle bcis (THREAD, BacktraceBuilder::get_bcis(result));
+print_stack_element_to_stream(st, bte._mirror, bte._method_id, bte._version, bte._bci, bte._cpref);
-objArrayHandle mirrors (THREAD, BacktraceBuilder::get_mirrors(result));
+}
-typeArrayHandle cprefs (THREAD, BacktraceBuilder::get_cprefs(result));
-int length = methods()->length();
-for (int index = 0; index < length; index++) {
-Handle mirror(THREAD, mirrors->obj_at(index));
-// NULL mirror means end of stack trace
-if (mirror.is_null()) goto handle_cause;
-int method = methods->short_at(index);
-int version = Backtrace::version_at(bcis->int_at(index));
-int bci = Backtrace::bci_at(bcis->int_at(index));
-int cpref = cprefs->short_at(index);
-print_stack_element(st, mirror, method, version, bci, cpref);
-}
-result = objArrayHandle(THREAD, objArrayOop(result->obj_at(trace_next_offset)));
-}
-handle_cause:
 {
+// Call getCause() which doesn't necessarily return the _cause field.
 EXCEPTION_MARK;
 JavaValue cause(T_OBJECT);
 JavaCalls::call_virtual(&cause,
 throwable,
 KlassHandle(THREAD, throwable->klass()),
 // This is unnecessary in 1.7+ but harmless
 clear_stacktrace(throwable());
 int max_depth = MaxJavaStackTraceDepth;
 JavaThread* thread = (JavaThread*)THREAD;
 BacktraceBuilder bt(CHECK);
 // If there is no Java frame just return the method that was being called
 // with bci 0
 if (!thread->has_last_Java_frame()) {
 if (max_depth >= 1 && method() != NULL) {
 bt.push(method(), 0, CHECK);
+log_info(stacktrace)("%s, %d", throwable->klass()->external_name(), 1);
+set_depth(throwable(), 1);
 set_backtrace(throwable(), bt.backtrace());
 }
 return;
 }
 }
 bt.push(method, bci, CHECK);
 total_count++;
 }
+log_info(stacktrace)("%s, %d", throwable->klass()->external_name(), total_count);
 // Put completed stack trace into throwable object
 set_backtrace(throwable(), bt.backtrace());
+set_depth(throwable(), total_count);
 }
 void java_lang_Throwable::fill_in_stack_trace(Handle throwable, const methodHandle& method) {
 // No-op if stack trace is disabled
 if (!StackTraceInThrowable) {
 // Unlike fill_in_stack_trace we do not skip fillInStackTrace or throwable init
 // methods as preallocated errors aren't created by "java" code.
 // fill in as much stack trace as possible
-typeArrayOop methods = BacktraceBuilder::get_methods(backtrace);
-int max_chunks = MIN2(methods->length(), (int)MaxJavaStackTraceDepth);
 int chunk_count = 0;
 for (;!st.at_end(); st.next()) {
 bt.push(st.method(), st.bci(), CHECK);
 chunk_count++;
 // Bail-out for deep stacks
-if (chunk_count >= max_chunks) break;
+if (chunk_count >= trace_chunk_size) break;
 }
+set_depth(throwable(), chunk_count);
+log_info(stacktrace)("%s, %d", throwable->klass()->external_name(), chunk_count);
 // We support the Throwable immutability protocol defined for Java 7.
 java_lang_Throwable::set_stacktrace(throwable(), java_lang_Throwable::unassigned_stacktrace());
 assert(java_lang_Throwable::unassigned_stacktrace() != NULL, "not initialized");
 }
+void java_lang_Throwable::get_stack_trace_elements(Handle throwable,
-int java_lang_Throwable::get_stack_trace_depth(oop throwable, TRAPS) {
+objArrayHandle stack_trace_array_h, TRAPS) {
-if (throwable == NULL) {
-THROW_0(vmSymbols::java_lang_NullPointerException());
+if (throwable.is_null() || stack_trace_array_h.is_null()) {
-}
+THROW(vmSymbols::java_lang_NullPointerException());
-objArrayOop chunk = objArrayOop(backtrace(throwable));
+}
-int depth = 0;
-if (chunk != NULL) {
+assert(stack_trace_array_h->is_objArray(), "Stack trace array should be an array of StackTraceElenent");
-// Iterate over chunks and count full ones
-while (true) {
+if (stack_trace_array_h->length() != depth(throwable())) {
-objArrayOop next = objArrayOop(chunk->obj_at(trace_next_offset));
+THROW(vmSymbols::java_lang_IndexOutOfBoundsException());
-if (next == NULL) break;
+}
-depth += trace_chunk_size;
-chunk = next;
+objArrayHandle result(THREAD, objArrayOop(backtrace(throwable())));
-}
+BacktraceIterator iter(result, THREAD);
-assert(chunk != NULL && chunk->obj_at(trace_next_offset) == NULL, "sanity check");
-// Count element in remaining partial chunk.  NULL value for mirror
+int index = 0;
-// marks the end of the stack trace elements that are saved.
+while (iter.repeat()) {
-objArrayOop mirrors = BacktraceBuilder::get_mirrors(chunk);
+BacktraceElement bte = iter.next(THREAD);
-assert(mirrors != NULL, "sanity check");
-for (int i = 0; i < mirrors->length(); i++) {
+Handle stack_trace_element(THREAD, stack_trace_array_h->obj_at(index++));
-if (mirrors->obj_at(i) == NULL) break;
-depth++;
+if (stack_trace_element.is_null()) {
-}
+THROW(vmSymbols::java_lang_NullPointerException());
 }
-return depth;
-}
+InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(bte._mirror()));
+methodHandle method (THREAD, holder->method_with_orig_idnum(bte._method_id, bte._version));
-oop java_lang_Throwable::get_stack_trace_element(oop throwable, int index, TRAPS) {
+java_lang_StackTraceElement::fill_in(stack_trace_element, holder,
-if (throwable == NULL) {
+method,
-THROW_0(vmSymbols::java_lang_NullPointerException());
+bte._version,
-}
+bte._bci,
-if (index < 0) {
+bte._cpref, CHECK);
-THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
+}
 }
-// Compute how many chunks to skip and index into actual chunk
-objArrayOop chunk = objArrayOop(backtrace(throwable));
+oop java_lang_StackTraceElement::create(const methodHandle& method, int bci, TRAPS) {
-int skip_chunks = index / trace_chunk_size;
-int chunk_index = index % trace_chunk_size;
-while (chunk != NULL && skip_chunks > 0) {
-chunk = objArrayOop(chunk->obj_at(trace_next_offset));
-skip_chunks--;
-}
-if (chunk == NULL) {
-THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
-}
-// Get method id, bci, version, mirror and cpref from chunk
-typeArrayOop methods = BacktraceBuilder::get_methods(chunk);
-typeArrayOop bcis = BacktraceBuilder::get_bcis(chunk);
-objArrayOop mirrors = BacktraceBuilder::get_mirrors(chunk);
-typeArrayOop cprefs = BacktraceBuilder::get_cprefs(chunk);
-assert(methods != NULL && bcis != NULL && mirrors != NULL, "sanity check");
-int method = methods->short_at(chunk_index);
-int version = Backtrace::version_at(bcis->int_at(chunk_index));
-int bci = Backtrace::bci_at(bcis->int_at(chunk_index));
-int cpref = cprefs->short_at(chunk_index);
-Handle mirror(THREAD, mirrors->obj_at(chunk_index));
-// Chunk can be partial full
-if (mirror.is_null()) {
-THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
-}
-oop element = java_lang_StackTraceElement::create(mirror, method, version, bci, cpref, CHECK_0);
-return element;
-}
-oop java_lang_StackTraceElement::create(Handle mirror, int method_id,
-int version, int bci, int cpref, TRAPS) {
 // Allocate java.lang.StackTraceElement instance
 Klass* k = SystemDictionary::StackTraceElement_klass();
 assert(k != NULL, "must be loaded in 1.4+");
 instanceKlassHandle ik (THREAD, k);
 if (ik->should_be_initialized()) {
 ik->initialize(CHECK_0);
 }
 Handle element = ik->allocate_instance_handle(CHECK_0);
+int cpref = method->name_index();
+int version = method->constants()->version();
+fill_in(element, method->method_holder(), method, version, bci, cpref, CHECK_0);
+return element();
+}
+void java_lang_StackTraceElement::fill_in(Handle element,
+InstanceKlass* holder, const methodHandle& method,
+int version, int bci, int cpref, TRAPS) {
+assert(element->is_a(SystemDictionary::StackTraceElement_klass()), "sanity check");
 // Fill in class name
 ResourceMark rm(THREAD);
-InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror()));
 const char* str = holder->external_name();
-oop classname = StringTable::intern((char*) str, CHECK_0);
+oop classname = StringTable::intern((char*) str, CHECK);
 java_lang_StackTraceElement::set_declaringClass(element(), classname);
-Method* method = holder->method_with_orig_idnum(method_id, version);
 // The method can be NULL if the requested class version is gone
-Symbol* sym = (method != NULL) ? method->name() : holder->constants()->symbol_at(cpref);
+Symbol* sym = !method.is_null() ? method->name() : holder->constants()->symbol_at(cpref);
 // Fill in method name
-oop methodname = StringTable::intern(sym, CHECK_0);
+oop methodname = StringTable::intern(sym, CHECK);
 java_lang_StackTraceElement::set_methodName(element(), methodname);
-if (!version_matches(method, version)) {
+if (!version_matches(method(), version)) {
 // The method was redefined, accurate line number information isn't available
 java_lang_StackTraceElement::set_fileName(element(), NULL);
 java_lang_StackTraceElement::set_lineNumber(element(), -1);
 } else {
 // Fill in source file name and line number.
 Symbol* source = Backtrace::get_source_file_name(holder, version);
 if (ShowHiddenFrames && source == NULL)
 source = vmSymbols::unknown_class_name();
-oop filename = StringTable::intern(source, CHECK_0);
+oop filename = StringTable::intern(source, CHECK);
 java_lang_StackTraceElement::set_fileName(element(), filename);
 int line_number = Backtrace::get_line_number(method, bci);
 java_lang_StackTraceElement::set_lineNumber(element(), line_number);
 }
-return element();
-}
-oop java_lang_StackTraceElement::create(const methodHandle& method, int bci, TRAPS) {
-Handle mirror (THREAD, method->method_holder()->java_mirror());
-int method_id = method->orig_method_idnum();
-int cpref = method->name_index();
-return create(mirror, method_id, method->constants()->version(), bci, cpref, THREAD);
 }
 Method* java_lang_StackFrameInfo::get_method(Handle stackFrame, InstanceKlass* holder, TRAPS) {
 if (MemberNameInStackFrame) {
 Handle mname(THREAD, stackFrame->obj_field(_memberName_offset));
 int java_lang_Class::_init_lock_offset;
 int java_lang_Class::_signers_offset;
 GrowableArray<Klass*>* java_lang_Class::_fixup_mirror_list = NULL;
 int java_lang_Throwable::backtrace_offset;
 int java_lang_Throwable::detailMessage_offset;
-int java_lang_Throwable::cause_offset;
 int java_lang_Throwable::stackTrace_offset;
+int java_lang_Throwable::depth_offset;
 int java_lang_Throwable::static_unassigned_stacktrace_offset;
 int java_lang_reflect_AccessibleObject::override_offset;
 int java_lang_reflect_Method::clazz_offset;
 int java_lang_reflect_Method::name_offset;
 int java_lang_reflect_Method::returnType_offset;
 const int header = instanceOopDesc::base_offset_in_bytes();
 // Throwable Class
 java_lang_Throwable::backtrace_offset  = java_lang_Throwable::hc_backtrace_offset  * x + header;
 java_lang_Throwable::detailMessage_offset = java_lang_Throwable::hc_detailMessage_offset * x + header;
-java_lang_Throwable::cause_offset      = java_lang_Throwable::hc_cause_offset      * x + header;
 java_lang_Throwable::stackTrace_offset = java_lang_Throwable::hc_stackTrace_offset * x + header;
 java_lang_Throwable::static_unassigned_stacktrace_offset = java_lang_Throwable::hc_static_unassigned_stacktrace_offset *  x;
 // java_lang_boxing_object
 java_lang_boxing_object::value_offset = java_lang_boxing_object::hc_value_offset + header;
 // Compute non-hard-coded field offsets of all the classes in this file
 void JavaClasses::compute_offsets() {
 // java_lang_Class::compute_offsets was called earlier in bootstrap
 java_lang_ClassLoader::compute_offsets();
+java_lang_Throwable::compute_offsets();
 java_lang_Thread::compute_offsets();
 java_lang_ThreadGroup::compute_offsets();
 java_lang_invoke_MethodHandle::compute_offsets();
 java_lang_invoke_DirectMethodHandle::compute_offsets();
 java_lang_invoke_MemberName::compute_offsets();
 // java.lang.Throwable
 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, backtrace, "Ljava/lang/Object;");
 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, detailMessage, "Ljava/lang/String;");
-CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, cause, "Ljava/lang/Throwable;");
 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, stackTrace, "[Ljava/lang/StackTraceElement;");
+CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, depth, "I");
 // Boxed primitive objects (java_lang_boxing_object)
 CHECK_OFFSET("java/lang/Boolean",   java_lang_boxing_object, value, "Z");
 CHECK_OFFSET("java/lang/Character", java_lang_boxing_object, value, "C");

changeset 37064	5c82fa70d313
parent 35918	1e48ea715a0b
child 37082	1a8577705228