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

equal deleted inserted replaced

-:d2d435372329
+:91576389a517
 assert(result_length >= length + 1, "must not be shorter");
 assert(result_length == (int)strlen(result) + 1, "must match");
 return result;
 }
-Symbol* java_lang_String::as_symbol(Handle java_string, TRAPS) {
+Symbol* java_lang_String::as_symbol(oop java_string, TRAPS) {
-oop          obj    = java_string();
+typeArrayOop value  = java_lang_String::value(java_string);
-typeArrayOop value  = java_lang_String::value(obj);
+int          length = java_lang_String::length(java_string);
-int          length = java_lang_String::length(obj);
+bool      is_latin1 = java_lang_String::is_latin1(java_string);
-bool      is_latin1 = java_lang_String::is_latin1(obj);
 if (!is_latin1) {
 jchar* base = (length == 0) ? NULL : value->char_at_addr(0);
 Symbol* sym = SymbolTable::lookup_unicode(base, length, THREAD);
 return sym;
 } else {
 fs.set_offset(real_offset);
 }
 }
 }
 }
-create_mirror(k, Handle(NULL), Handle(NULL), Handle(NULL), CHECK);
+create_mirror(k, Handle(), Handle(), Handle(), CHECK);
 }
 void java_lang_Class::initialize_mirror_fields(KlassHandle k,
 Handle mirror,
 Handle protection_domain,
 k->set_modifier_flags(computed_modifiers);
 // Class_klass has to be loaded because it is used to allocate
 // the mirror.
 if (SystemDictionary::Class_klass_loaded()) {
 // Allocate mirror (java.lang.Class instance)
-Handle mirror = InstanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK);
+oop mirror_oop = InstanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK);
+Handle mirror(THREAD, mirror_oop);
 // Setup indirection from mirror->klass
 if (!k.is_null()) {
 java_lang_Class::set_klass(mirror(), k());
 }
 java_lang_Class::set_static_oop_field_count(mirror(), mk->compute_static_oop_field_count(mirror()));
 // It might also have a component mirror.  This mirror must already exist.
 if (k->is_array_klass()) {
-Handle comp_mirror;
+oop comp_mirror;
 if (k->is_typeArray_klass()) {
 BasicType type = TypeArrayKlass::cast(k())->element_type();
 comp_mirror = Universe::java_mirror(type);
 } else {
 assert(k->is_objArray_klass(), "Must be");
 Klass* element_klass = ObjArrayKlass::cast(k())->element_klass();
 assert(element_klass != NULL, "Must have an element klass");
 comp_mirror = element_klass->java_mirror();
 }
-assert(comp_mirror.not_null(), "must have a mirror");
+assert(comp_mirror != NULL, "must have a mirror");
 // Two-way link between the array klass and its component mirror:
 // (array_klass) k -> mirror -> component_mirror -> array_klass -> k
-set_component_mirror(mirror(), comp_mirror());
+set_component_mirror(mirror(), comp_mirror);
-set_array_klass(comp_mirror(), k());
+set_array_klass(comp_mirror, k());
 } else {
 assert(k->is_instance_klass(), "Must be");
 initialize_mirror_fields(k, mirror, protection_domain, THREAD);
 if (HAS_PENDING_EXCEPTION) {
 void java_lang_Throwable::set_depth(oop throwable, int value) {
 throwable->int_field_put(depth_offset, value);
 }
-oop java_lang_Throwable::message(Handle throwable) {
+oop java_lang_Throwable::message(oop throwable) {
 return throwable->obj_field(detailMessage_offset);
 }
 // Return Symbol for detailed_message or NULL
 void java_lang_Throwable::clear_stacktrace(oop throwable) {
 set_stacktrace(throwable, NULL);
 }
-void java_lang_Throwable::print(Handle throwable, outputStream* st) {
+void java_lang_Throwable::print(oop throwable, outputStream* st) {
 ResourceMark rm;
 Klass* k = throwable->klass();
 assert(k != NULL, "just checking");
 st->print("%s", k->external_name());
 oop msg = message(throwable);
 Handle          _backtrace;
 objArrayOop     _head;
 typeArrayOop    _methods;
 typeArrayOop    _bcis;
 objArrayOop     _mirrors;
-typeArrayOop    _cprefs; // needed to insulate method name against redefinition
+typeArrayOop    _names; // needed to insulate method name against redefinition
 int             _index;
 NoSafepointVerifier _nsv;
 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,
+trace_names_offset   = java_lang_Throwable::trace_names_offset,
 trace_next_offset    = java_lang_Throwable::trace_next_offset,
 trace_size           = java_lang_Throwable::trace_size,
 trace_chunk_size     = java_lang_Throwable::trace_chunk_size
 };
 static objArrayOop get_mirrors(objArrayHandle chunk) {
 objArrayOop mirrors = objArrayOop(chunk->obj_at(trace_mirrors_offset));
 assert(mirrors != NULL, "mirror array should be initialized in backtrace");
 return mirrors;
 }
-static typeArrayOop get_cprefs(objArrayHandle chunk) {
+static typeArrayOop get_names(objArrayHandle chunk) {
-typeArrayOop cprefs = typeArrayOop(chunk->obj_at(trace_cprefs_offset));
+typeArrayOop names = typeArrayOop(chunk->obj_at(trace_names_offset));
-assert(cprefs != NULL, "cprefs array should be initialized in backtrace");
+assert(names != NULL, "names array should be initialized in backtrace");
-return cprefs;
+return names;
 }
 public:
 // constructor for new backtrace
-BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL), _mirrors(NULL), _cprefs(NULL) {
+BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL), _mirrors(NULL), _names(NULL) {
 expand(CHECK);
-_backtrace = _head;
+_backtrace = Handle(THREAD, _head);
 _index = 0;
 }
-BacktraceBuilder(objArrayHandle backtrace) {
+BacktraceBuilder(Thread* thread, objArrayHandle backtrace) {
 _methods = get_methods(backtrace);
 _bcis = get_bcis(backtrace);
 _mirrors = get_mirrors(backtrace);
-_cprefs = get_cprefs(backtrace);
+_names = get_names(backtrace);
 assert(_methods->length() == _bcis->length() &&
-_methods->length() == _mirrors->length(),
+_methods->length() == _mirrors->length() &&
+_mirrors->length() == _names->length(),
 "method and source information arrays should match");
 // head is the preallocated backtrace
-_backtrace = _head = backtrace();
+_head = backtrace();
+_backtrace = Handle(thread, _head);
 _index = 0;
 }
 void expand(TRAPS) {
 objArrayHandle old_head(THREAD, _head);
 typeArrayHandle new_bcis(THREAD, bcis);
 objArrayOop mirrors = oopFactory::new_objectArray(trace_chunk_size, CHECK);
 objArrayHandle new_mirrors(THREAD, mirrors);
-typeArrayOop cprefs = oopFactory::new_shortArray(trace_chunk_size, CHECK);
+typeArrayOop names = oopFactory::new_symbolArray(trace_chunk_size, CHECK);
-typeArrayHandle new_cprefs(THREAD, cprefs);
+typeArrayHandle new_names(THREAD, names);
 if (!old_head.is_null()) {
 old_head->obj_at_put(trace_next_offset, new_head());
 }
 new_head->obj_at_put(trace_methods_offset, new_methods());
 new_head->obj_at_put(trace_bcis_offset, new_bcis());
 new_head->obj_at_put(trace_mirrors_offset, new_mirrors());
-new_head->obj_at_put(trace_cprefs_offset, new_cprefs());
+new_head->obj_at_put(trace_names_offset, new_names());
 _head    = new_head();
 _methods = new_methods();
 _bcis = new_bcis();
 _mirrors = new_mirrors();
-_cprefs  = new_cprefs();
+_names  = new_names();
 _index = 0;
 }
 oop backtrace() {
 return _backtrace();
 method = mhandle();
 }
 _methods->short_at_put(_index, method->orig_method_idnum());
 _bcis->int_at_put(_index, Backtrace::merge_bci_and_version(bci, method->constants()->version()));
-_cprefs->short_at_put(_index, method->name_index());
+// Note:this doesn't leak symbols because the mirror in the backtrace keeps the
+// klass owning the symbols alive so their refcounts aren't decremented.
+Symbol* name = method->name();
+_names->symbol_at_put(_index, name);
 // We need to save the mirrors in the backtrace to keep the class
 // from being unloaded while we still have this stack trace.
 assert(method->method_holder()->java_mirror() != NULL, "never push null for mirror");
 _mirrors->obj_at_put(_index, method->method_holder()->java_mirror());
 struct BacktraceElement : public StackObj {
 int _method_id;
 int _bci;
 int _version;
-int _cpref;
+Symbol* _name;
 Handle _mirror;
-BacktraceElement(Handle mirror, int mid, int version, int bci, int cpref) :
+BacktraceElement(Handle mirror, int mid, int version, int bci, Symbol* name) :
-_mirror(mirror), _method_id(mid), _version(version), _bci(bci), _cpref(cpref) {}
+_mirror(mirror), _method_id(mid), _version(version), _bci(bci), _name(name) {}
 };
 class BacktraceIterator : public StackObj {
 int _index;
 objArrayHandle  _result;
 objArrayHandle  _mirrors;
 typeArrayHandle _methods;
 typeArrayHandle _bcis;
-typeArrayHandle _cprefs;
+typeArrayHandle _names;
 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));
+_names = typeArrayHandle(thread, BacktraceBuilder::get_names(_result));
 _index = 0;
 }
 }
 public:
 BacktraceIterator(objArrayHandle result, Thread* thread) {
 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));
+_names->symbol_at(_index));
 _index++;
 if (_index >= java_lang_Throwable::trace_chunk_size) {
 int next_offset = java_lang_Throwable::trace_next_offset;
 // Get next chunk
 };
 // Print stack trace element to resource allocated buffer
 static void print_stack_element_to_stream(outputStream* st, Handle mirror, int method_id,
-int version, int bci, int cpref) {
+int version, int bci, Symbol* name) {
 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);
-Method* method = holder->method_with_orig_idnum(method_id, version);
+char* method_name = name->as_C_string();
-// The method can be NULL if the requested class version is gone
-Symbol* sym = (method != NULL) ? method->name() : holder->constants()->symbol_at(cpref);
-char* method_name = sym->as_C_string();
 buf_len += (int)strlen(method_name);
 char* source_file_name = NULL;
 Symbol* source = Backtrace::get_source_file_name(holder, version);
 if (source != NULL) {
 } else {
 sprintf(buf + (int)strlen(buf), "%s/", module_name);
 }
 }
+// The method can be NULL if the requested class version is gone
+Method* method = holder->method_with_orig_idnum(method_id, version);
 if (!version_matches(method, version)) {
 strcat(buf, "Redefined)");
 } else {
 int line_number = Backtrace::get_line_number(method, bci);
 if (line_number == -2) {
 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();
+Handle mirror (Thread::current(),  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_to_stream(st, mirror, method_id, version, bci, method->name());
-print_stack_element_to_stream(st, mirror, method_id, version, bci, cpref);
 }
 /**
 * 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().
 */
 void java_lang_Throwable::print_stack_trace(Handle throwable, outputStream* st) {
 // First, print the message.
-print(throwable, st);
+print(throwable(), st);
 st->cr();
 // Now print the stack trace.
 Thread* THREAD = Thread::current();
 while (throwable.not_null()) {
 }
 BacktraceIterator iter(result, THREAD);
 while (iter.repeat()) {
 BacktraceElement bte = iter.next(THREAD);
-print_stack_element_to_stream(st, bte._mirror, bte._method_id, bte._version, bte._bci, bte._cpref);
+print_stack_element_to_stream(st, bte._mirror, bte._method_id, bte._version, bte._bci, bte._name);
 }
 {
 // Call getCause() which doesn't necessarily return the _cause field.
 EXCEPTION_MARK;
 JavaValue cause(T_OBJECT);
 throwable = Handle();
 } else {
 throwable = Handle(THREAD, (oop) cause.get_jobject());
 if (throwable.not_null()) {
 st->print("Caused by: ");
-print(throwable, st);
+print(throwable(), st);
 st->cr();
 }
 }
 }
 }
 assert(backtrace.not_null(), "backtrace should have been preallocated");
 ResourceMark rm(THREAD);
 vframeStream st(THREAD);
-BacktraceBuilder bt(backtrace);
+BacktraceBuilder bt(THREAD, backtrace);
 // 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
 java_lang_StackTraceElement::fill_in(stack_trace_element, holder,
 method,
 bte._version,
 bte._bci,
-bte._cpref, CHECK);
+bte._name, CHECK);
 }
 }
 oop java_lang_StackTraceElement::create(const methodHandle& method, int bci, TRAPS) {
 // Allocate java.lang.StackTraceElement instance
 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);
+fill_in(element, method->method_holder(), method, version, bci, method->name(), CHECK_0);
 return element();
 }
 void java_lang_StackTraceElement::fill_in(Handle element,
 InstanceKlass* holder, const methodHandle& method,
-int version, int bci, int cpref, TRAPS) {
+int version, int bci, Symbol* name, TRAPS) {
 assert(element->is_a(SystemDictionary::StackTraceElement_klass()), "sanity check");
 // Fill in class name
 ResourceMark rm(THREAD);
 const char* str = holder->external_name();
 oop loader_name = java_lang_ClassLoader::name(loader);
 if (loader_name != NULL)
 java_lang_StackTraceElement::set_classLoaderName(element(), loader_name);
 }
-// The method can be NULL if the requested class version is gone
-Symbol* sym = !method.is_null() ? method->name() : holder->constants()->symbol_at(cpref);
 // Fill in method name
-oop methodname = StringTable::intern(sym, CHECK);
+oop methodname = StringTable::intern(name, CHECK);
 java_lang_StackTraceElement::set_methodName(element(), methodname);
 // Fill in module name and version
 ModuleEntry* module = holder->module();
 if (module->is_named()) {
 module_version = NULL;
 }
 java_lang_StackTraceElement::set_moduleVersion(element(), module_version);
 }
-if (!version_matches(method(), version)) {
+if (method() == NULL || !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.
 return method;
 }
 void java_lang_StackFrameInfo::set_method_and_bci(Handle stackFrame, const methodHandle& method, int bci) {
 // set Method* or mid/cpref
-oop mname = stackFrame->obj_field(_memberName_offset);
+Handle mname(Thread::current(), stackFrame->obj_field(_memberName_offset));
 InstanceKlass* ik = method->method_holder();
 CallInfo info(method(), ik);
 MethodHandles::init_method_MemberName(mname, info);
 // set bci
 java_lang_StackFrameInfo::set_bci(stackFrame(), bci);
 InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(k()));
 Method* method = java_lang_StackFrameInfo::get_method(stackFrame, holder, CHECK);
 short version = stackFrame->short_field(_version_offset);
 short bci = stackFrame->short_field(_bci_offset);
-int cpref = method->name_index();
+Symbol* name = method->name();
-java_lang_StackTraceElement::fill_in(stack_trace_element, holder, method, version, bci, cpref, CHECK);
+java_lang_StackTraceElement::fill_in(stack_trace_element, holder, method, version, bci, name, CHECK);
 }
 void java_lang_StackFrameInfo::compute_offsets() {
 Klass* k = SystemDictionary::StackFrameInfo_klass();
 compute_offset(_declaringClass_offset, k, vmSymbols::declaringClass_name(),  vmSymbols::class_signature());
 // Check the hard-coded field offsets of all the classes in this file
 void JavaClasses::check_offsets() {
 bool valid = true;
-HandleMark hm;
 #define CHECK_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
 valid &= check_offset(klass_name, cpp_klass_name :: field_name ## _offset, #field_name, field_sig)
 #define CHECK_LONG_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \

changeset 46327	91576389a517
parent 43929	9a572e758c9b
parent 46289	1904e7ec236e
child 46329	53ccc37bda19