jdk-sandbox: comparison hotspot/src/share/vm/oops/method.cpp

equal deleted inserted replaced

-:bd0d881cf1c5
+:df0a1573d5bd
 if (!VerifyStack && !VerifyLastFrame) {
 // verify stack calls this outside VM thread
 warning("oopmap should only be accessed by the "
 "VM, GC task or CMS threads (or during debugging)");
 InterpreterOopMap local_mask;
-InstanceKlass::cast(method_holder())->mask_for(h_this, bci, &local_mask);
+method_holder()->mask_for(h_this, bci, &local_mask);
 local_mask.print();
 }
 }
 #endif
-InstanceKlass::cast(method_holder())->mask_for(h_this, bci, mask);
+method_holder()->mask_for(h_this, bci, mask);
 return;
 }
 int Method::bci_from(address bcp) const {
 bool Method::is_final_method() const {
 // %%% Should return true for private methods also,
 // since there is no way to override them.
-return is_final() || Klass::cast(method_holder())->is_final();
+return is_final() || method_holder()->is_final();
 }
 bool Method::is_strict_method() const {
 return is_strict();
 return name() == vmSymbols::object_initializer_name() || is_static_initializer();
 }
 bool Method::has_valid_initializer_flags() const {
 return (is_static() ||
-InstanceKlass::cast(method_holder())->major_version() < 51);
+method_holder()->major_version() < 51);
 }
 bool Method::is_static_initializer() const {
 // For classfiles version 51 or greater, ensure that the clinit method is
 // static.  Non-static methods with the name "<clinit>" are not static
 bool Method::is_klass_loaded_by_klass_index(int klass_index) const {
 if( constants()->tag_at(klass_index).is_unresolved_klass() ) {
 Thread *thread = Thread::current();
 Symbol* klass_name = constants()->klass_name_at(klass_index);
-Handle loader(thread, InstanceKlass::cast(method_holder())->class_loader());
+Handle loader(thread, method_holder()->class_loader());
 Handle prot  (thread, Klass::cast(method_holder())->protection_domain());
 return SystemDictionary::find(klass_name, loader, prot, thread) != NULL;
 } else {
 return true;
 }
 if (ik->is_interface()) return false;
 // If method is an interface, we skip it - except if it
 // is a miranda method
-if (InstanceKlass::cast(method_holder())->is_interface()) {
+if (method_holder()->is_interface()) {
 // Check that method is not a miranda method
 if (ik->lookup_method(name(), signature()) == NULL) {
 // No implementation exist - so miranda method
 return false;
 }
 constantPoolHandle cp;
 {
 ConstantPool* cp_oop = ConstantPool::allocate(loader_data, cp_length, CHECK_(empty));
 cp = constantPoolHandle(THREAD, cp_oop);
 }
-cp->set_pool_holder(holder());
+cp->set_pool_holder(InstanceKlass::cast(holder()));
 cp->symbol_at_put(_imcp_invoke_name,       name);
 cp->symbol_at_put(_imcp_invoke_signature,  signature);
 cp->set_preresolution();
 // decide on access bits:  public or not?
 // Hopefully, the signature contains only well-known classes.
 // We could scan for this and return true/false, but the caller won't care.
 return false;
 }
 bool sig_is_loaded = true;
-Handle class_loader(THREAD, InstanceKlass::cast(m->method_holder())->class_loader());
+Handle class_loader(THREAD, m->method_holder()->class_loader());
-Handle protection_domain(THREAD, Klass::cast(m->method_holder())->protection_domain());
+Handle protection_domain(THREAD, m->method_holder()->protection_domain());
 ResourceMark rm(THREAD);
 Symbol*  signature = m->signature();
 for(SignatureStream ss(signature); !ss.is_done(); ss.next()) {
 if (ss.is_object()) {
 Symbol* sym = ss.as_symbol(CHECK_(false));
 }
 return sig_is_loaded;
 }
 bool Method::has_unloaded_classes_in_signature(methodHandle m, TRAPS) {
-Handle class_loader(THREAD, InstanceKlass::cast(m->method_holder())->class_loader());
+Handle class_loader(THREAD, m->method_holder()->class_loader());
-Handle protection_domain(THREAD, Klass::cast(m->method_holder())->protection_domain());
+Handle protection_domain(THREAD, m->method_holder()->protection_domain());
 ResourceMark rm(THREAD);
 Symbol*  signature = m->signature();
 for(SignatureStream ss(signature); !ss.is_done(); ss.next()) {
 if (ss.type() == T_OBJECT) {
 Symbol* name = ss.as_symbol_or_null();
 return true;
 }
 Bytecodes::Code Method::orig_bytecode_at(int bci) const {
-BreakpointInfo* bp = InstanceKlass::cast(method_holder())->breakpoints();
+BreakpointInfo* bp = method_holder()->breakpoints();
 for (; bp != NULL; bp = bp->next()) {
 if (bp->match(this, bci)) {
 return bp->orig_bytecode();
 }
 }
 return Bytecodes::_shouldnotreachhere;
 }
 void Method::set_orig_bytecode_at(int bci, Bytecodes::Code code) {
 assert(code != Bytecodes::_breakpoint, "cannot patch breakpoints this way");
-BreakpointInfo* bp = InstanceKlass::cast(method_holder())->breakpoints();
+BreakpointInfo* bp = method_holder()->breakpoints();
 for (; bp != NULL; bp = bp->next()) {
 if (bp->match(this, bci)) {
 bp->set_orig_bytecode(code);
 // and continue, in case there is more than one
 }
 }
 }
 void Method::set_breakpoint(int bci) {
-InstanceKlass* ik = InstanceKlass::cast(method_holder());
+InstanceKlass* ik = method_holder();
 BreakpointInfo *bp = new BreakpointInfo(this, bci);
 bp->set_next(ik->breakpoints());
 ik->set_breakpoints(bp);
 // do this last:
 bp->set(this);
 }
 static void clear_matches(Method* m, int bci) {
-InstanceKlass* ik = InstanceKlass::cast(m->method_holder());
+InstanceKlass* ik = m->method_holder();
 BreakpointInfo* prev_bp = NULL;
 BreakpointInfo* next_bp;
 for (BreakpointInfo* bp = ik->breakpoints(); bp != NULL; bp = next_bp) {
 next_bp = bp->next();
 // bci value of -1 is used to delete all breakpoints in method m (ex: clear_all_breakpoint).
 }
 bool Method::is_method_id(jmethodID mid) {
 Method* m = resolve_jmethod_id(mid);
 assert(m != NULL, "should be called with non-null method");
-InstanceKlass* ik = InstanceKlass::cast(m->method_holder());
+InstanceKlass* ik = m->method_holder();
 ClassLoaderData* cld = ik->class_loader_data();
 if (cld->jmethod_ids() == NULL) return false;
 return (cld->jmethod_ids()->contains((Method**)mid));
 }

changeset 14391	df0a1573d5bd
parent 14386	9ef88e958f4b
child 14488	ab48109f7d1b