truffle: src/share/vm/opto/doCall.cpp comparison

comparison src/share/vm/opto/doCall.cpp @ 18041:52b4284cb496

Merge with jdk8u20-b26

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Wed, 15 Oct 2014 16:02:50 +0200
parents	89152779163c dda2ae6f9557
children	7848fc12602b

comparison

equal deleted inserted replaced

-:45d7b2c7029d
+:52b4284cb496
 /*
-* Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1998, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 }
 CompileTask::print_inline_indent(depth, out);
 out->print(" \\-> TypeProfile (%d/%d counts) = ", receiver_count, site_count);
 stringStream ss;
 prof_klass->name()->print_symbol_on(&ss);
-out->print(ss.as_string());
+out->print("%s", ss.as_string());
 out->cr();
 }
 }
 CallGenerator* Compile::call_generator(ciMethod* callee, int vtable_index, bool call_does_dispatch,
 // This is the number of times we expect the call code to be used.
 float expected_uses = past_uses;
 // Try inlining a bytecoded method:
 if (!call_does_dispatch) {
-InlineTree* ilt;
+InlineTree* ilt = InlineTree::find_subtree_from_root(this->ilt(), jvms->caller(), jvms->method());
-if (UseOldInlining) {
-ilt = InlineTree::find_subtree_from_root(this->ilt(), jvms->caller(), jvms->method());
-} else {
-// Make a disembodied, stateless ILT.
-// TO DO:  When UseOldInlining is removed, copy the ILT code elsewhere.
-float site_invoke_ratio = prof_factor;
-// Note:  ilt is for the root of this parse, not the present call site.
-ilt = new InlineTree(this, jvms->method(), jvms->caller(), site_invoke_ratio, MaxInlineLevel);
-}
 WarmCallInfo scratch_ci;
-if (!UseOldInlining)
-scratch_ci.init(jvms, callee, profile, prof_factor);
 bool should_delay = false;
 WarmCallInfo* ci = ilt->ok_to_inline(callee, jvms, profile, &scratch_ci, should_delay);
 assert(ci != &scratch_ci, "do not let this pointer escape");
 bool allow_inline   = (ci != NULL && !ci->is_cold());
 bool require_inline = (allow_inline && ci->is_hot());
 }
 }
 CallGenerator* miss_cg;
 Deoptimization::DeoptReason reason = morphism == 2 ?
 Deoptimization::Reason_bimorphic :
-Deoptimization::Reason_class_check;
+(speculative_receiver_type == NULL ? Deoptimization::Reason_class_check : Deoptimization::Reason_speculate_class_check);
 if ((morphism == 1 || (morphism == 2 && next_hit_cg != NULL)) &&
 !too_many_traps(jvms->method(), jvms->bci(), reason)
 ) {
 // Generate uncommon trap for class check failure path
 // in case of monomorphic or bimorphic virtual call site.
 }
 bool Compile::should_delay_boxing_inlining(ciMethod* call_method, JVMState* jvms) {
 if (eliminate_boxing() && call_method->is_boxing_method()) {
 set_has_boxed_value(true);
-return true;
+return aggressive_unboxing();
 }
 return false;
 }
 // uncommon-trap call-sites where callee is unloaded, uninitialized or will not link
 ciKlass* speculative_receiver_type = NULL;
 if (is_virtual_or_interface) {
 Node* receiver_node             = stack(sp() - nargs);
 const TypeOopPtr* receiver_type = _gvn.type(receiver_node)->isa_oopptr();
 // call_does_dispatch and vtable_index are out-parameters.  They might be changed.
-callee = C->optimize_virtual_call(method(), bci(), klass, orig_callee, receiver_type,
+// For arrays, klass below is Object. When vtable calls are used,
-is_virtual,
+// resolving the call with Object would allow an illegal call to
+// finalize() on an array. We use holder instead: illegal calls to
+// finalize() won't be compiled as vtable calls (IC call
+// resolution will catch the illegal call) and the few legal calls
+// on array types won't be either.
+callee = C->optimize_virtual_call(method(), bci(), klass, holder, orig_callee,
+receiver_type, is_virtual,
 call_does_dispatch, vtable_index);  // out-parameters
 speculative_receiver_type = receiver_type != NULL ? receiver_type->speculative_type() : NULL;
 }
 // Note:  It's OK to try to inline a virtual call.
 }
 #endif //PRODUCT
 ciMethod* Compile::optimize_virtual_call(ciMethod* caller, int bci, ciInstanceKlass* klass,
-ciMethod* callee, const TypeOopPtr* receiver_type,
+ciKlass* holder, ciMethod* callee,
-bool is_virtual,
+const TypeOopPtr* receiver_type, bool is_virtual,
 bool& call_does_dispatch, int& vtable_index) {
 // Set default values for out-parameters.
 call_does_dispatch = true;
 vtable_index       = Method::invalid_vtable_index;
 if (optimized_virtual_method != NULL) {
 callee             = optimized_virtual_method;
 call_does_dispatch = false;
 } else if (!UseInlineCaches && is_virtual && callee->is_loaded()) {
 // We can make a vtable call at this site
-vtable_index = callee->resolve_vtable_index(caller->holder(), klass);
+vtable_index = callee->resolve_vtable_index(caller->holder(), holder);
 }
 return callee;
 }
 // Identify possible target method and inlining style
 // Attempt to improve the receiver
 bool actual_receiver_is_exact = false;
 ciInstanceKlass* actual_receiver = klass;
 if (receiver_type != NULL) {
 // Array methods are all inherited from Object, and are monomorphic.
+// finalize() call on array is not allowed.
 if (receiver_type->isa_aryptr() &&
-callee->holder() == env()->Object_klass()) {
+callee->holder() == env()->Object_klass() &&
+callee->name() != ciSymbol::finalize_method_name()) {
 return callee;
 }
 // All other interesting cases are instance klasses.
 if (!receiver_type->isa_instptr()) {

Mercurial > hg > truffle

comparison src/share/vm/opto/doCall.cpp @ 18041:52b4284cb496