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

equal deleted inserted replaced

-:2e7898927798
+:979ebd346ecf
 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);
 public:
 // constructor for new backtrace
 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);
 _names = get_names(backtrace);
 assert(_methods->length() == _bcis->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);
 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();
 print_stack_element_to_stream(st, mirror, method_id, version, bci, method->name());
 }
 * 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()) {
 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
 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);
 // 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 46271	979ebd346ecf
parent 46257	3e95288ce4ca
child 46289	1904e7ec236e