jdk-sandbox: comparison hotspot/src/share/vm/compiler/compileBroker.cpp

equal deleted inserted replaced

-:18e7896ca9fe
+:3c94db05e903
 #include "classfile/vmSymbols.hpp"
 #include "code/codeCache.hpp"
 #include "compiler/compileBroker.hpp"
 #include "compiler/compileLog.hpp"
 #include "compiler/compilerOracle.hpp"
+#include "compiler/directivesParser.hpp"
 #include "interpreter/linkResolver.hpp"
 #include "memory/allocation.inline.hpp"
 #include "oops/methodData.hpp"
 #include "oops/method.hpp"
 #include "oops/oop.inline.hpp"
 }
 };
 static CompilationLog* _compilation_log = NULL;
-void compileBroker_init() {
+bool compileBroker_init() {
 if (LogEvents) {
 _compilation_log = new CompilationLog();
 }
+// init directives stack, adding default directive
+DirectivesStack::init();
+if (DirectivesParser::has_file()) {
+return DirectivesParser::parse_from_flag();
+} else if (PrintCompilerDirectives) {
+// Print default directive even when no other was added
+DirectivesStack::print(tty);
+}
+return true;
 }
 CompileTaskWrapper::CompileTaskWrapper(CompileTask* task) {
 CompilerThread* thread = CompilerThread::current();
 thread->set_task(task);
 // ------------------------------------------------------------------
 // CompileBroker::compilation_is_complete
 //
 // See if compilation of this method is already complete.
 bool CompileBroker::compilation_is_complete(const methodHandle& method,
-int          osr_bci,
+int                 osr_bci,
-int          comp_level) {
+int                 comp_level) {
 bool is_osr = (osr_bci != standard_entry_bci);
 if (is_osr) {
 if (method->is_not_osr_compilable(comp_level)) {
 return true;
 } else {
 (!CICompileOSR || comp == NULL || !comp->supports_osr())) {
 method->set_not_osr_compilable(comp_level);
 return true;
 }
+// Breaking the abstraction - directives are only used inside a compilation otherwise.
+DirectiveSet* directive = DirectivesStack::getMatchingDirective(method, comp);
+bool excluded = directive->ExcludeOption;
+DirectivesStack::release(directive);
 // The method may be explicitly excluded by the user.
-bool quietly;
 double scale;
-if (CompilerOracle::should_exclude(method, quietly)
+if (excluded || (CompilerOracle::has_option_value(method, "CompileThresholdScaling", scale) && scale == 0)) {
-|| (CompilerOracle::has_option_value(method, "CompileThresholdScaling", scale) && scale == 0)) {
+bool quietly = CompilerOracle::should_exclude_quietly();
-if (!quietly) {
+if (PrintCompilation && !quietly) {
 // This does not happen quietly...
 ResourceMark rm;
 tty->print("### Excluding %s:%s",
 method->is_native() ? "generation of native wrapper" : "compile",
 (method->is_static() ? " static" : ""));
 method->print_short_name(tty);
 tty->cr();
 }
-method->set_not_compilable(CompLevel_all, !quietly, "excluded by CompileCommand");
+method->set_not_compilable(comp_level, !quietly, "excluded by CompileCommand");
 }
 return false;
 }
 // ------------------------------------------------------------------
 // CompileBroker::create_compile_task
 //
 // Create a CompileTask object representing the current request for
 // compilation.  Add this task to the queue.
-CompileTask* CompileBroker::create_compile_task(CompileQueue* queue,
+CompileTask* CompileBroker::create_compile_task(CompileQueue*       queue,
-int           compile_id,
+int                 compile_id,
-const methodHandle&  method,
+const methodHandle& method,
-int           osr_bci,
+int                 osr_bci,
-int           comp_level,
+int                 comp_level,
-const methodHandle&  hot_method,
+const methodHandle& hot_method,
-int           hot_count,
+int                 hot_count,
-const char*   comment,
+const char*         comment,
-bool          blocking) {
+bool                blocking) {
 CompileTask* new_task = CompileTask::allocate();
 new_task->initialize(compile_id, method, osr_bci, comp_level,
 hot_method, hot_count, comment,
 blocking);
 queue->add(new_task);
 ci_env.cache_dtrace_flags();
 // Switch back to VM state to do compiler initialization
 ThreadInVMfromNative tv(thread);
 ResetNoHandleMark rnhm;
 if (!comp->is_shark()) {
 // Perform per-thread and global initializations
 comp->initialize();
 }
 event.set_inlinedBytes(task->num_inlined_bytecodes());
 event.commit();
 }
 }
+int DirectivesStack::_depth = 0;
+CompilerDirectives* DirectivesStack::_top = NULL;
+CompilerDirectives* DirectivesStack::_bottom = NULL;
 // ------------------------------------------------------------------
 // CompileBroker::invoke_compiler_on_method
 //
 // Compile a method.
 //
 int osr_bci = task->osr_bci();
 bool is_osr = (osr_bci != standard_entry_bci);
 bool should_log = (thread->log() != NULL);
 bool should_break = false;
 int task_level = task->comp_level();
+// Look up matching directives
+DirectiveSet* directive = DirectivesStack::getMatchingDirective(task->method(), compiler(task_level));
+should_break = directive->BreakAtExecuteOption || task->check_break_at_flags();
+if (should_log && !directive->LogOption) {
+should_log = false;
+}
 {
 // create the handle inside it's own block so it can't
 // accidentally be referenced once the thread transitions to
 // native.  The NoHandleMark before the transition should catch
 // any cases where this occurs in the future.
 methodHandle method(thread, task->method());
-should_break = check_break_at(method, compile_id, is_osr);
-if (should_log && !CompilerOracle::should_log(method)) {
-should_log = false;
-}
 assert(!method->is_native(), "no longer compile natives");
 // Save information about this method in case of failure.
 set_last_compile(thread, method, is_osr, task_level);
 MonitorLockerEx locker(Compilation_lock, Mutex::_no_safepoint_check_flag);
 while (WhiteBox::compilation_locked) {
 locker.wait(Mutex::_no_safepoint_check_flag);
 }
 }
-comp->compile_method(&ci_env, target, osr_bci);
+comp->compile_method(&ci_env, target, osr_bci, directive);
 }
 if (!ci_env.failing() && task->code() == NULL) {
 //assert(false, "compiler should always document failure");
 // The compiler elected, without comment, not to register a result.
 }
 }
 post_compile(thread, task, event, !ci_env.failing(), &ci_env);
 }
+DirectivesStack::release(directive);
 pop_jni_handle_block();
 methodHandle method(thread, task->method());
 DTRACE_METHOD_COMPILE_END_PROBE(method, compiler_name(task_level), task->is_success());
 thread->set_active_handles(java_handles);
 compile_handles->set_pop_frame_link(NULL);
 JNIHandleBlock::release_block(compile_handles, thread); // may block
 }
-// ------------------------------------------------------------------
-// CompileBroker::check_break_at
-//
-// Should the compilation break at the current compilation.
-bool CompileBroker::check_break_at(const methodHandle& method, int compile_id, bool is_osr) {
-if (CICountOSR && is_osr && (compile_id == CIBreakAtOSR)) {
-return true;
-} else if( CompilerOracle::should_break_at(method) ) { // break when compiling
-return true;
-} else {
-return (compile_id == CIBreakAt);
-}
-}
 // ------------------------------------------------------------------
 // CompileBroker::collect_statistics
 //
 // Collect statistics about the compilation.

changeset 33626	3c94db05e903
parent 33611	9abd65805e19
parent 33478	e119795bddb7
child 34185	ee71c590a456