graal-jvmci-8: src/share/vm/opto/compile.cpp comparison

comparison src/share/vm/opto/compile.cpp @ 17810:62c54fcc0a35

Merge

author	kvn
date	Tue, 25 Mar 2014 17:07:36 -0700
parents	752ba2e5f6d0 606acabe7b5c
children	31e28ee4c9b4

comparison

equal deleted inserted replaced

-:a433eb716ce1
+:62c54fcc0a35
 }
 #endif
 set_print_inlining(PrintInlining || method()->has_option("PrintInlining") NOT_PRODUCT( || PrintOptoInlining));
 set_print_intrinsics(PrintIntrinsics || method()->has_option("PrintIntrinsics"));
-if (ProfileTraps) {
+if (ProfileTraps RTM_OPT_ONLY( || UseRTMLocking )) {
 // Make sure the method being compiled gets its own MDO,
 // so we can at least track the decompile_count().
+// Need MDO to record RTM code generation state.
 method()->ensure_method_data();
 }
 Init(::AliasLevel);
 frame_size_in_words(), _oop_map_set,
 &_handler_table, &_inc_table,
 compiler,
 env()->comp_level(),
 has_unsafe_access(),
-SharedRuntime::is_wide_vector(max_vector_size())
+SharedRuntime::is_wide_vector(max_vector_size()),
+rtm_state()
 );
 if (log() != NULL) // Print code cache state into compiler log
 log()->code_cache_state();
 }
 set_max_inline_size(MaxInlineSize);
 set_freq_inline_size(FreqInlineSize);
 set_do_scheduling(OptoScheduling);
 set_do_count_invocations(false);
 set_do_method_data_update(false);
+set_rtm_state(NoRTM); // No RTM lock eliding by default
+#if INCLUDE_RTM_OPT
+if (UseRTMLocking && has_method() && (method()->method_data_or_null() != NULL)) {
+int rtm_state = method()->method_data()->rtm_state();
+if (method_has_option("NoRTMLockEliding") || ((rtm_state & NoRTM) != 0)) {
+// Don't generate RTM lock eliding code.
+set_rtm_state(NoRTM);
+} else if (method_has_option("UseRTMLockEliding") || ((rtm_state & UseRTM) != 0) || !UseRTMDeopt) {
+// Generate RTM lock eliding code without abort ratio calculation code.
+set_rtm_state(UseRTM);
+} else if (UseRTMDeopt) {
+// Generate RTM lock eliding code and include abort ratio calculation
+// code if UseRTMDeopt is on.
+set_rtm_state(ProfileRTM);
+}
+}
+#endif
 if (debug_info()->recording_non_safepoints()) {
 set_node_note_array(new(comp_arena()) GrowableArray<Node_Notes*>
 (comp_arena(), 8, 0, NULL));
 set_default_node_notes(Node_Notes::make(this));
 }
 case Op_CmpD3:
 frc.inc_double_count();
 break;
 case Op_Opaque1:              // Remove Opaque Nodes before matching
 case Op_Opaque2:              // Remove Opaque Nodes before matching
+case Op_Opaque3:
 n->subsume_by(n->in(1), this);
 break;
 case Op_CallStaticJava:
 case Op_CallJava:
 case Op_CallDynamicJava:
 // confuses register allocation.
 if (n->req() > MemBarNode::Precedent) {
 n->set_req(MemBarNode::Precedent, top());
 }
 break;
-// Must set a control edge on all nodes that produce a FlagsProj
-// so they can't escape the block that consumes the flags.
-// Must also set the non throwing branch as the control
-// for all nodes that depends on the result. Unless the node
-// already have a control that isn't the control of the
-// flag producer
-case Op_FlagsProj:
-{
-MathExactNode* math = (MathExactNode*)  n->in(0);
-Node* ctrl = math->control_node();
-Node* non_throwing = math->non_throwing_branch();
-math->set_req(0, ctrl);
-Node* result = math->result_node();
-if (result != NULL) {
-for (DUIterator_Fast jmax, j = result->fast_outs(jmax); j < jmax; j++) {
-Node* out = result->fast_out(j);
-// Phi nodes shouldn't be moved. They would only match below if they
-// had the same control as the MathExactNode. The only time that
-// would happen is if the Phi is also an input to the MathExact
-//
-// Cmp nodes shouldn't have control set at all.
-if (out->is_Phi() ||
-out->is_Cmp()) {
-continue;
-}
-if (out->in(0) == NULL) {
-out->set_req(0, non_throwing);
-} else if (out->in(0) == ctrl) {
-out->set_req(0, non_throwing);
-}
-}
-}
-}
-break;
 default:
 assert( !n->is_Call(), "" );
 assert( !n->is_Mem(), "" );
 break;
 }
 if (md->is_empty()) {
 // Assume the trap has not occurred, or that it occurred only
 // because of a transient condition during start-up in the interpreter.
 return false;
 }
-if (md->has_trap_at(bci, reason) != 0) {
+ciMethod* m = Deoptimization::reason_is_speculate(reason) ? this->method() : NULL;
+if (md->has_trap_at(bci, m, reason) != 0) {
 // Assume PerBytecodeTrapLimit==0, for a more conservative heuristic.
 // Also, if there are multiple reasons, or if there is no per-BCI record,
 // assume the worst.
 if (log())
 log()->elem("observe trap='%s' count='%d'",
 }
 // Less-accurate variant which does not require a method and bci.
 bool Compile::too_many_traps(Deoptimization::DeoptReason reason,
 ciMethodData* logmd) {
-if (trap_count(reason) >= (uint)PerMethodTrapLimit) {
+if (trap_count(reason) >= Deoptimization::per_method_trap_limit(reason)) {
 // Too many traps globally.
 // Note that we use cumulative trap_count, not just md->trap_count.
 if (log()) {
 int mcount = (logmd == NULL)? -1: (int)logmd->trap_count(reason);
 log()->elem("observe trap='%s' count='0' mcount='%d' ccount='%d'",
 // Pick a cutoff point well within PerBytecodeRecompilationCutoff.
 uint bc_cutoff = (uint) PerBytecodeRecompilationCutoff / 8;
 uint m_cutoff  = (uint) PerMethodRecompilationCutoff / 2 + 1;  // not zero
 Deoptimization::DeoptReason per_bc_reason
 = Deoptimization::reason_recorded_per_bytecode_if_any(reason);
+ciMethod* m = Deoptimization::reason_is_speculate(reason) ? this->method() : NULL;
 if ((per_bc_reason == Deoptimization::Reason_none
-|| md->has_trap_at(bci, reason) != 0)
+|| md->has_trap_at(bci, m, reason) != 0)
 // The trap frequency measure we care about is the recompile count:
-&& md->trap_recompiled_at(bci)
+&& md->trap_recompiled_at(bci, m)
 && md->overflow_recompile_count() >= bc_cutoff) {
 // Do not emit a trap here if it has already caused recompilations.
 // Also, if there are multiple reasons, or if there is no per-BCI record,
 // assume the worst.
 if (log())

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/opto/compile.cpp @ 17810:62c54fcc0a35