truffle: src/share/vm/opto/library

comparison src/share/vm/opto/library_call.cpp @ 12355:cefad50507d8

Merge with hs25-b53

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Fri, 11 Oct 2013 10:38:03 +0200
parents	29bdcf12457c
children	3213ba4d3dff

comparison

equal deleted inserted replaced

-:ccb4f2af2319
+:cefad50507d8
 #include "oops/objArrayKlass.hpp"
 #include "opto/addnode.hpp"
 #include "opto/callGenerator.hpp"
 #include "opto/cfgnode.hpp"
 #include "opto/idealKit.hpp"
+#include "opto/mathexactnode.hpp"
 #include "opto/mulnode.hpp"
 #include "opto/parse.hpp"
 #include "opto/runtime.hpp"
 #include "opto/subnode.hpp"
 #include "prims/nativeLookup.hpp"
 // Extend the set of intrinsics known to the runtime:
 public:
 private:
 bool             _is_virtual;
 bool             _is_predicted;
+bool             _does_virtual_dispatch;
 vmIntrinsics::ID _intrinsic_id;
 public:
-LibraryIntrinsic(ciMethod* m, bool is_virtual, bool is_predicted, vmIntrinsics::ID id)
+LibraryIntrinsic(ciMethod* m, bool is_virtual, bool is_predicted, bool does_virtual_dispatch, vmIntrinsics::ID id)
 : InlineCallGenerator(m),
 _is_virtual(is_virtual),
 _is_predicted(is_predicted),
+_does_virtual_dispatch(does_virtual_dispatch),
 _intrinsic_id(id)
 {
 }
 virtual bool is_intrinsic() const { return true; }
 virtual bool is_virtual()   const { return _is_virtual; }
 virtual bool is_predicted()   const { return _is_predicted; }
+virtual bool does_virtual_dispatch()   const { return _does_virtual_dispatch; }
 virtual JVMState* generate(JVMState* jvms);
 virtual Node* generate_predicate(JVMState* jvms);
 vmIntrinsics::ID intrinsic_id() const { return _intrinsic_id; }
 };
 Node* round_double_node(Node* n);
 bool runtime_math(const TypeFunc* call_type, address funcAddr, const char* funcName);
 bool inline_math_native(vmIntrinsics::ID id);
 bool inline_trig(vmIntrinsics::ID id);
 bool inline_math(vmIntrinsics::ID id);
+bool inline_math_mathExact(Node* math);
+bool inline_math_addExact();
 bool inline_exp();
 bool inline_pow();
 void finish_pow_exp(Node* result, Node* x, Node* y, const TypeFunc* call_type, address funcAddr, const char* funcName);
 bool inline_min_max(vmIntrinsics::ID id);
 Node* generate_min_max(vmIntrinsics::ID id, Node* x, Node* y);
 // Generates the guards that check whether the result of
 // Unsafe.getObject should be recorded in an SATB log buffer.
 void insert_pre_barrier(Node* base_oop, Node* offset, Node* pre_val, bool need_mem_bar);
 bool inline_unsafe_access(bool is_native_ptr, bool is_store, BasicType type, bool is_volatile);
 bool inline_unsafe_prefetch(bool is_native_ptr, bool is_store, bool is_static);
+static bool klass_needs_init_guard(Node* kls);
 bool inline_unsafe_allocate();
 bool inline_unsafe_copyMemory();
 bool inline_native_currentThread();
 #ifdef TRACE_HAVE_INTRINSICS
 bool inline_native_classID();
 return NULL;
 }
 }
 bool is_predicted = false;
+bool does_virtual_dispatch = false;
 switch (id) {
 case vmIntrinsics::_compareTo:
 if (!SpecialStringCompareTo)  return NULL;
 if (!Matcher::match_rule_supported(Op_StrComp))  return NULL;
 if (StubRoutines::unsafe_arraycopy() == NULL)  return NULL;
 if (!InlineArrayCopy)  return NULL;
 break;
 case vmIntrinsics::_hashCode:
 if (!InlineObjectHash)  return NULL;
+does_virtual_dispatch = true;
 break;
 case vmIntrinsics::_clone:
+does_virtual_dispatch = true;
 case vmIntrinsics::_copyOf:
 case vmIntrinsics::_copyOfRange:
 if (!InlineObjectCopy)  return NULL;
 // These also use the arraycopy intrinsic mechanism:
 if (!InlineArrayCopy)  return NULL;
 case vmIntrinsics::_updateCRC32:
 case vmIntrinsics::_updateBytesCRC32:
 case vmIntrinsics::_updateByteBufferCRC32:
 if (!UseCRC32Intrinsics) return NULL;
+break;
+case vmIntrinsics::_addExact:
+if (!Matcher::match_rule_supported(Op_AddExactI)) {
+return NULL;
+}
+if (!UseMathExactIntrinsics) {
+return NULL;
+}
 break;
 default:
 assert(id <= vmIntrinsics::LAST_COMPILER_INLINE, "caller responsibility");
 assert(id != vmIntrinsics::_Object_init && id != vmIntrinsics::_invoke, "enum out of order?");
 // -XX:-InlineUnsafeOps disables natives from the Unsafe class.
 if (m->holder()->name() == ciSymbol::sun_misc_Unsafe()) {
 if (!InlineUnsafeOps)  return NULL;
 }
-return new LibraryIntrinsic(m, is_virtual, is_predicted, (vmIntrinsics::ID) id);
+return new LibraryIntrinsic(m, is_virtual, is_predicted, does_virtual_dispatch, (vmIntrinsics::ID) id);
 }
 //----------------------register_library_intrinsics-----------------------
 // Initialize this file's data structures, for each Compile instance.
 void Compile::register_library_intrinsics() {
 JVMState* LibraryIntrinsic::generate(JVMState* jvms) {
 LibraryCallKit kit(jvms, this);
 Compile* C = kit.C;
 int nodes = C->unique();
 #ifndef PRODUCT
-if ((PrintIntrinsics || PrintInlining NOT_PRODUCT( || PrintOptoInlining) ) && Verbose) {
+if ((C->print_intrinsics() || C->print_inlining()) && Verbose) {
 char buf[1000];
 const char* str = vmIntrinsics::short_name_as_C_string(intrinsic_id(), buf, sizeof(buf));
 tty->print_cr("Intrinsic %s", str);
 }
 #endif
 ciMethod* callee = kit.callee();
 const int bci    = kit.bci();
 // Try to inline the intrinsic.
 if (kit.try_to_inline()) {
-if (PrintIntrinsics || PrintInlining NOT_PRODUCT( || PrintOptoInlining) ) {
+if (C->print_intrinsics() || C->print_inlining()) {
 C->print_inlining(callee, jvms->depth() - 1, bci, is_virtual() ? "(intrinsic, virtual)" : "(intrinsic)");
 }
 C->gather_intrinsic_statistics(intrinsic_id(), is_virtual(), Compile::_intrinsic_worked);
 if (C->log()) {
 C->log()->elem("intrinsic id='%s'%s nodes='%d'",
 kit.push_result();
 return kit.transfer_exceptions_into_jvms();
 }
 // The intrinsic bailed out
-if (PrintIntrinsics || PrintInlining NOT_PRODUCT( || PrintOptoInlining) ) {
+if (C->print_intrinsics() || C->print_inlining()) {
 if (jvms->has_method()) {
 // Not a root compile.
 const char* msg = is_virtual() ? "failed to inline (intrinsic, virtual)" : "failed to inline (intrinsic)";
 C->print_inlining(callee, jvms->depth() - 1, bci, msg);
 } else {
 LibraryCallKit kit(jvms, this);
 Compile* C = kit.C;
 int nodes = C->unique();
 #ifndef PRODUCT
 assert(is_predicted(), "sanity");
-if ((PrintIntrinsics || PrintInlining NOT_PRODUCT( || PrintOptoInlining) ) && Verbose) {
+if ((C->print_intrinsics() || C->print_inlining()) && Verbose) {
 char buf[1000];
 const char* str = vmIntrinsics::short_name_as_C_string(intrinsic_id(), buf, sizeof(buf));
 tty->print_cr("Predicate for intrinsic %s", str);
 }
 #endif
 ciMethod* callee = kit.callee();
 const int bci    = kit.bci();
 Node* slow_ctl = kit.try_to_predicate();
 if (!kit.failing()) {
-if (PrintIntrinsics || PrintInlining NOT_PRODUCT( || PrintOptoInlining) ) {
+if (C->print_intrinsics() || C->print_inlining()) {
 C->print_inlining(callee, jvms->depth() - 1, bci, is_virtual() ? "(intrinsic, virtual)" : "(intrinsic)");
 }
 C->gather_intrinsic_statistics(intrinsic_id(), is_virtual(), Compile::_intrinsic_worked);
 if (C->log()) {
 C->log()->elem("predicate_intrinsic id='%s'%s nodes='%d'",
 }
 return slow_ctl; // Could be NULL if the check folds.
 }
 // The intrinsic bailed out
-if (PrintIntrinsics || PrintInlining NOT_PRODUCT( || PrintOptoInlining) ) {
+if (C->print_intrinsics() || C->print_inlining()) {
 if (jvms->has_method()) {
 // Not a root compile.
 const char* msg = "failed to generate predicate for intrinsic";
 C->print_inlining(kit.callee(), jvms->depth() - 1, bci, msg);
 } else {
 case vmIntrinsics::_dlog10:
 case vmIntrinsics::_dpow:                     return inline_math_native(intrinsic_id());
 case vmIntrinsics::_min:
 case vmIntrinsics::_max:                      return inline_min_max(intrinsic_id());
+case vmIntrinsics::_addExact:                 return inline_math_addExact();
 case vmIntrinsics::_arraycopy:                return inline_arraycopy();
 case vmIntrinsics::_compareTo:                return inline_string_compareTo();
 case vmIntrinsics::_indexOf:                  return inline_string_indexOf();
 Node* target = _gvn.transform( makecon(TypeOopPtr::make_from_constant(target_array, true)));
 jint target_length = target_array->length();
 const TypeAry* target_array_type = TypeAry::make(TypeInt::CHAR, TypeInt::make(0, target_length, Type::WidenMin));
 const TypeAryPtr* target_type = TypeAryPtr::make(TypePtr::BotPTR, target_array_type, target_array->klass(), true, Type::OffsetBot);
+// String.value field is known to be @Stable.
+if (UseImplicitStableValues) {
+target = cast_array_to_stable(target, target_type);
+}
 IdealKit kit(this, false, true);
 #define __ kit.
 Node* zero             = __ ConI(0);
 Node* one              = __ ConI(1);
 Node* cache            = __ ConI(cache_i);
 }
 //----------------------------inline_min_max-----------------------------------
 bool LibraryCallKit::inline_min_max(vmIntrinsics::ID id) {
 set_result(generate_min_max(id, argument(0), argument(1)));
+return true;
+}
+bool LibraryCallKit::inline_math_mathExact(Node* math) {
+Node* result = _gvn.transform( new(C) ProjNode(math, MathExactNode::result_proj_node));
+Node* flags = _gvn.transform( new(C) FlagsProjNode(math, MathExactNode::flags_proj_node));
+Node* bol = _gvn.transform( new (C) BoolNode(flags, BoolTest::overflow) );
+IfNode* check = create_and_map_if(control(), bol, PROB_UNLIKELY_MAG(3), COUNT_UNKNOWN);
+Node* fast_path = _gvn.transform( new (C) IfFalseNode(check));
+Node* slow_path = _gvn.transform( new (C) IfTrueNode(check) );
+{
+PreserveJVMState pjvms(this);
+PreserveReexecuteState preexecs(this);
+jvms()->set_should_reexecute(true);
+set_control(slow_path);
+set_i_o(i_o());
+uncommon_trap(Deoptimization::Reason_intrinsic,
+Deoptimization::Action_none);
+}
+set_control(fast_path);
+set_result(result);
+return true;
+}
+bool LibraryCallKit::inline_math_addExact() {
+Node* arg1 = argument(0);
+Node* arg2 = argument(1);
+Node* add = _gvn.transform( new(C) AddExactINode(NULL, arg1, arg2) );
+if (add->Opcode() == Op_AddExactI) {
+return inline_math_mathExact(add);
+} else {
+set_result(add);
+}
 return true;
 }
 Node*
 LibraryCallKit::generate_min_max(vmIntrinsics::ID id, Node* x0, Node* y0) {
 // contraint in place.
 if (sharpened_klass != NULL && sharpened_klass->is_loaded()) {
 const TypeOopPtr* tjp = TypeOopPtr::make_from_klass(sharpened_klass);
 #ifndef PRODUCT
-if (PrintIntrinsics || PrintInlining || PrintOptoInlining) {
+if (C->print_intrinsics() || C->print_inlining()) {
 tty->print("  from base type: ");  adr_type->dump();
 tty->print("  sharpened value: ");  tjp->dump();
 }
 #endif
 // Sharpen the value type.
 // Execute transformation here to avoid barrier generation in such case.
 if (_gvn.type(newval) == TypePtr::NULL_PTR)
 newval = _gvn.makecon(TypePtr::NULL_PTR);
 // Reference stores need a store barrier.
-pre_barrier(true /* do_load*/,
+if (kind == LS_xchg) {
-control(), base, adr, alias_idx, newval, value_type->make_oopptr(),
+// If pre-barrier must execute before the oop store, old value will require do_load here.
-NULL /* pre_val*/,
+if (!can_move_pre_barrier()) {
-T_OBJECT);
+pre_barrier(true /* do_load*/,
+control(), base, adr, alias_idx, newval, value_type->make_oopptr(),
+NULL /* pre_val*/,
+T_OBJECT);
+} // Else move pre_barrier to use load_store value, see below.
+} else if (kind == LS_cmpxchg) {
+// Same as for newval above:
+if (_gvn.type(oldval) == TypePtr::NULL_PTR) {
+oldval = _gvn.makecon(TypePtr::NULL_PTR);
+}
+// The only known value which might get overwritten is oldval.
+pre_barrier(false /* do_load */,
+control(), NULL, NULL, max_juint, NULL, NULL,
+oldval /* pre_val */,
+T_OBJECT);
+} else {
+ShouldNotReachHere();
+}
 #ifdef _LP64
 if (adr->bottom_type()->is_ptr_to_narrowoop()) {
 Node *newval_enc = _gvn.transform(new (C) EncodePNode(newval, newval->bottom_type()->make_narrowoop()));
 if (kind == LS_xchg) {
 load_store = _gvn.transform(new (C) GetAndSetNNode(control(), mem, adr,
 // main role is to prevent LoadStore nodes from being optimized away
 // when their results aren't used.
 Node* proj = _gvn.transform(new (C) SCMemProjNode(load_store));
 set_memory(proj, alias_idx);
+if (type == T_OBJECT && kind == LS_xchg) {
+#ifdef _LP64
+if (adr->bottom_type()->is_ptr_to_narrowoop()) {
+load_store = _gvn.transform(new (C) DecodeNNode(load_store, load_store->get_ptr_type()));
+}
+#endif
+if (can_move_pre_barrier()) {
+// Don't need to load pre_val. The old value is returned by load_store.
+// The pre_barrier can execute after the xchg as long as no safepoint
+// gets inserted between them.
+pre_barrier(false /* do_load */,
+control(), NULL, NULL, max_juint, NULL, NULL,
+load_store /* pre_val */,
+T_OBJECT);
+}
+}
 // Add the trailing membar surrounding the access
 insert_mem_bar(Op_MemBarCPUOrder);
 insert_mem_bar(Op_MemBarAcquire);
-#ifdef _LP64
-if (type == T_OBJECT && adr->bottom_type()->is_ptr_to_narrowoop() && kind == LS_xchg) {
-load_store = _gvn.transform(new (C) DecodeNNode(load_store, load_store->get_ptr_type()));
-}
-#endif
 assert(type2size[load_store->bottom_type()->basic_type()] == type2size[rtype], "result type should match");
 set_result(load_store);
 return true;
 }
 fatal_unexpected_iid(id);
 return false;
 }
 }
+bool LibraryCallKit::klass_needs_init_guard(Node* kls) {
+if (!kls->is_Con()) {
+return true;
+}
+const TypeKlassPtr* klsptr = kls->bottom_type()->isa_klassptr();
+if (klsptr == NULL) {
+return true;
+}
+ciInstanceKlass* ik = klsptr->klass()->as_instance_klass();
+// don't need a guard for a klass that is already initialized
+return !ik->is_initialized();
+}
 //----------------------------inline_unsafe_allocate---------------------------
-// public native Object sun.mics.Unsafe.allocateInstance(Class<?> cls);
+// public native Object sun.misc.Unsafe.allocateInstance(Class<?> cls);
 bool LibraryCallKit::inline_unsafe_allocate() {
 if (callee()->is_static())  return false;  // caller must have the capability!
 null_check_receiver();  // null-check, then ignore
 Node* cls = null_check(argument(1));
 Node* kls = load_klass_from_mirror(cls, false, NULL, 0);
 kls = null_check(kls);
 if (stopped())  return true;  // argument was like int.class
-// Note:  The argument might still be an illegal value like
+Node* test = NULL;
-// Serializable.class or Object[].class.   The runtime will handle it.
+if (LibraryCallKit::klass_needs_init_guard(kls)) {
-// But we must make an explicit check for initialization.
+// Note:  The argument might still be an illegal value like
-Node* insp = basic_plus_adr(kls, in_bytes(InstanceKlass::init_state_offset()));
+// Serializable.class or Object[].class.   The runtime will handle it.
-// Use T_BOOLEAN for InstanceKlass::_init_state so the compiler
+// But we must make an explicit check for initialization.
-// can generate code to load it as unsigned byte.
+Node* insp = basic_plus_adr(kls, in_bytes(InstanceKlass::init_state_offset()));
-Node* inst = make_load(NULL, insp, TypeInt::UBYTE, T_BOOLEAN);
+// Use T_BOOLEAN for InstanceKlass::_init_state so the compiler
-Node* bits = intcon(InstanceKlass::fully_initialized);
+// can generate code to load it as unsigned byte.
-Node* test = _gvn.transform(new (C) SubINode(inst, bits));
+Node* inst = make_load(NULL, insp, TypeInt::UBYTE, T_BOOLEAN);
-// The 'test' is non-zero if we need to take a slow path.
+Node* bits = intcon(InstanceKlass::fully_initialized);
+test = _gvn.transform(new (C) SubINode(inst, bits));
+// The 'test' is non-zero if we need to take a slow path.
+}
 Node* obj = new_instance(kls, test);
 set_result(obj);
 return true;
 }
 const TypeInstPtr* mirror_con = _gvn.type(mirror)->isa_instptr();
 if (mirror_con == NULL)  return false;  // cannot happen?
 #ifndef PRODUCT
-if (PrintIntrinsics || PrintInlining || PrintOptoInlining) {
+if (C->print_intrinsics() || C->print_inlining()) {
 ciType* k = mirror_con->java_mirror_type();
 if (k) {
 tty->print("Inlining %s on constant Class ", vmIntrinsics::name_at(intrinsic_id()));
 k->print_name();
 tty->cr();
 // Helper for hashCode and clone.  Peeks inside the vtable to avoid a call.
 Node* LibraryCallKit::generate_virtual_guard(Node* obj_klass,
 RegionNode* slow_region) {
 ciMethod* method = callee();
 int vtable_index = method->vtable_index();
+assert(vtable_index >= 0 || vtable_index == Method::nonvirtual_vtable_index,
+err_msg_res("bad index %d", vtable_index));
 // Get the Method* out of the appropriate vtable entry.
 int entry_offset  = (InstanceKlass::vtable_start_offset() +
 vtable_index*vtableEntry::size()) * wordSize +
 vtableEntry::method_offset_in_bytes();
 Node* entry_addr  = basic_plus_adr(obj_klass, entry_offset);
 } else {
 // hashCode and clone are not a miranda methods,
 // so the vtable index is fixed.
 // No need to use the linkResolver to get it.
 vtable_index = method->vtable_index();
+assert(vtable_index >= 0 || vtable_index == Method::nonvirtual_vtable_index,
+err_msg_res("bad index %d", vtable_index));
 }
 slow_call = new(C) CallDynamicJavaNode(tf,
 SharedRuntime::get_resolve_virtual_call_stub(),
 method, vtable_index, bci());
 } else {  // neither virtual nor static:  opt_virtual
 // NOTE: This code must perform the same logic as JVM_GetCallerClass
 // in that it must skip particular security frames and checks for
 // caller sensitive methods.
 bool LibraryCallKit::inline_native_Reflection_getCallerClass() {
 #ifndef PRODUCT
-if ((PrintIntrinsics || PrintInlining || PrintOptoInlining) && Verbose) {
+if ((C->print_intrinsics() || C->print_inlining()) && Verbose) {
 tty->print_cr("Attempting to inline sun.reflect.Reflection.getCallerClass");
 }
 #endif
 if (!jvms()->has_method()) {
 #ifndef PRODUCT
-if ((PrintIntrinsics || PrintInlining || PrintOptoInlining) && Verbose) {
+if ((C->print_intrinsics() || C->print_inlining()) && Verbose) {
 tty->print_cr("  Bailing out because intrinsic was inlined at top level");
 }
 #endif
 return false;
 }
 break;
 case 1:
 // Frame 0 and 1 must be caller sensitive (see JVM_GetCallerClass).
 if (!m->caller_sensitive()) {
 #ifndef PRODUCT
-if ((PrintIntrinsics || PrintInlining || PrintOptoInlining) && Verbose) {
+if ((C->print_intrinsics() || C->print_inlining()) && Verbose) {
 tty->print_cr("  Bailing out: CallerSensitive annotation expected at frame %d", n);
 }
 #endif
 return false;  // bail-out; let JVM_GetCallerClass do the work
 }
 ciInstanceKlass* caller_klass = caller_jvms->method()->holder();
 ciInstance* caller_mirror = caller_klass->java_mirror();
 set_result(makecon(TypeInstPtr::make(caller_mirror)));
 #ifndef PRODUCT
-if ((PrintIntrinsics || PrintInlining || PrintOptoInlining) && Verbose) {
+if ((C->print_intrinsics() || C->print_inlining()) && Verbose) {
 tty->print_cr("  Succeeded: caller = %d) %s.%s, JVMS depth = %d", n, caller_klass->name()->as_utf8(), caller_jvms->method()->name()->as_utf8(), jvms()->depth());
 tty->print_cr("  JVM state at this point:");
 for (int i = jvms()->depth(), n = 1; i >= 1; i--, n++) {
 ciMethod* m = jvms()->of_depth(i)->method();
 tty->print_cr("   %d) %s.%s", n, m->holder()->name()->as_utf8(), m->name()->as_utf8());
 break;
 }
 }
 #ifndef PRODUCT
-if ((PrintIntrinsics || PrintInlining || PrintOptoInlining) && Verbose) {
+if ((C->print_intrinsics() || C->print_inlining()) && Verbose) {
 tty->print_cr("  Bailing out because caller depth exceeded inlining depth = %d", jvms()->depth());
 tty->print_cr("  JVM state at this point:");
 for (int i = jvms()->depth(), n = 1; i >= 1; i--, n++) {
 ciMethod* m = jvms()->of_depth(i)->method();
 tty->print_cr("   %d) %s.%s", n, m->holder()->name()->as_utf8(), m->name()->as_utf8());
 // base_off:
 // 8  - 32-bit VM
 // 12 - 64-bit VM, compressed klass
 // 16 - 64-bit VM, normal klass
 if (base_off % BytesPerLong != 0) {
-assert(UseCompressedKlassPointers, "");
+assert(UseCompressedClassPointers, "");
 if (is_array) {
 // Exclude length to copy by 8 bytes words.
 base_off += sizeof(int);
 } else {
 // Include klass to copy by 8 bytes words.

Mercurial > hg > truffle

comparison src/share/vm/opto/library_call.cpp @ 12355:cefad50507d8