graal-jvmci-8: src/share/vm/runtime/simpleThresholdPolicy.cpp comparison

comparison src/share/vm/runtime/simpleThresholdPolicy.cpp @ 4825:20334ed5ed3c

7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS Summary: Make sure that CompilationPolicy::event() doesn't throw exceptions Reviewed-by: kvn, never

author	iveresov
date	Thu, 26 Jan 2012 12:15:24 -0800
parents	973293defacd
children	da91efe96a93

comparison

equal deleted inserted replaced

-:5dbed2f542ff
+:20334ed5ed3c
 if (sd->is_top()) break;
 }
 }
 nmethod* SimpleThresholdPolicy::event(methodHandle method, methodHandle inlinee,
-int branch_bci, int bci, CompLevel comp_level, nmethod* nm, TRAPS) {
+int branch_bci, int bci, CompLevel comp_level, nmethod* nm, JavaThread* thread) {
 if (comp_level == CompLevel_none &&
-JvmtiExport::can_post_interpreter_events()) {
+JvmtiExport::can_post_interpreter_events() &&
-assert(THREAD->is_Java_thread(), "Should be java thread");
+thread->is_interp_only_mode()) {
-if (((JavaThread*)THREAD)->is_interp_only_mode()) {
+return NULL;
-return NULL;
-}
 }
 nmethod *osr_nm = NULL;
 handle_counter_overflow(method());
 if (method() != inlinee()) {
 if (PrintTieredEvents) {
 print_event(bci == InvocationEntryBci ? CALL : LOOP, method, inlinee, bci, comp_level);
 }
 if (bci == InvocationEntryBci) {
-method_invocation_event(method, inlinee, comp_level, nm, THREAD);
+method_invocation_event(method, inlinee, comp_level, nm, thread);
 } else {
-method_back_branch_event(method, inlinee, bci, comp_level, nm, THREAD);
+method_back_branch_event(method, inlinee, bci, comp_level, nm, thread);
 // method == inlinee if the event originated in the main method
 int highest_level = inlinee->highest_osr_comp_level();
 if (highest_level > comp_level) {
 osr_nm = inlinee->lookup_osr_nmethod_for(bci, highest_level, false);
 }
 }
 return osr_nm;
 }
 // Check if the method can be compiled, change level if necessary
-void SimpleThresholdPolicy::compile(methodHandle mh, int bci, CompLevel level, TRAPS) {
+void SimpleThresholdPolicy::compile(methodHandle mh, int bci, CompLevel level, JavaThread* thread) {
 assert(level <= TieredStopAtLevel, "Invalid compilation level");
 if (level == CompLevel_none) {
 return;
 }
 // Check if the method can be compiled. If it cannot be compiled with C1, continue profiling
 // in the interpreter and then compile with C2 (the transition function will request that,
 // see common() ). If the method cannot be compiled with C2 but still can with C1, compile it with
 // pure C1.
 if (!can_be_compiled(mh, level)) {
 if (level == CompLevel_full_optimization && can_be_compiled(mh, CompLevel_simple)) {
-compile(mh, bci, CompLevel_simple, THREAD);
+compile(mh, bci, CompLevel_simple, thread);
 }
 return;
 }
 if (bci != InvocationEntryBci && mh->is_not_osr_compilable()) {
 return;
 }
 if (!CompileBroker::compilation_is_in_queue(mh, bci)) {
 if (PrintTieredEvents) {
 print_event(COMPILE, mh, mh, bci, level);
 }
-submit_compile(mh, bci, level, THREAD);
+submit_compile(mh, bci, level, thread);
 }
 }
 // Tell the broker to compile the method
-void SimpleThresholdPolicy::submit_compile(methodHandle mh, int bci, CompLevel level, TRAPS) {
+void SimpleThresholdPolicy::submit_compile(methodHandle mh, int bci, CompLevel level, JavaThread* thread) {
 int hot_count = (bci == InvocationEntryBci) ? mh->invocation_count() : mh->backedge_count();
-CompileBroker::compile_method(mh, bci, level, mh, hot_count, "tiered", THREAD);
+CompileBroker::compile_method(mh, bci, level, mh, hot_count, "tiered", thread);
 }
 // Call and loop predicates determine whether a transition to a higher
 // compilation level should be performed (pointers to predicate functions
 // are passed to common() transition function).
 }
 // Handle the invocation event.
 void SimpleThresholdPolicy::method_invocation_event(methodHandle mh, methodHandle imh,
-CompLevel level, nmethod* nm, TRAPS) {
+CompLevel level, nmethod* nm, JavaThread* thread) {
 if (is_compilation_enabled() && !CompileBroker::compilation_is_in_queue(mh, InvocationEntryBci)) {
 CompLevel next_level = call_event(mh(), level);
 if (next_level != level) {
-compile(mh, InvocationEntryBci, next_level, THREAD);
+compile(mh, InvocationEntryBci, next_level, thread);
 }
 }
 }
 // Handle the back branch event. Notice that we can compile the method
 // with a regular entry from here.
 void SimpleThresholdPolicy::method_back_branch_event(methodHandle mh, methodHandle imh,
-int bci, CompLevel level, nmethod* nm, TRAPS) {
+int bci, CompLevel level, nmethod* nm, JavaThread* thread) {
 // If the method is already compiling, quickly bail out.
 if (is_compilation_enabled() && !CompileBroker::compilation_is_in_queue(mh, bci)) {
 // Use loop event as an opportinity to also check there's been
 // enough calls.
 CompLevel cur_level = comp_level(mh());
 next_level = MAX2(next_level,
 next_osr_level < CompLevel_full_optimization ? next_osr_level : cur_level);
 bool is_compiling = false;
 if (next_level != cur_level) {
-compile(mh, InvocationEntryBci, next_level, THREAD);
+compile(mh, InvocationEntryBci, next_level, thread);
 is_compiling = true;
 }
 // Do the OSR version
 if (!is_compiling && next_osr_level != level) {
-compile(mh, bci, next_osr_level, THREAD);
+compile(mh, bci, next_osr_level, thread);
 }
 }
 }

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/runtime/simpleThresholdPolicy.cpp @ 4825:20334ed5ed3c