Merge

src/share/vm/c1/c1_Compilation.cpp

@@ -471,7 +471,14 @@ Compilation::Compilation(AbstractCompiler* compiler, ciEnv* env, ciMethod* metho
   _exception_info_list = new ExceptionInfoList();
   _implicit_exception_table.set_size(0);
   compile_method();
-  if (is_profiling() && _would_profile) {
+  if (bailed_out()) {
+    _env->record_method_not_compilable(bailout_msg(), !TieredCompilation);
+    if (is_profiling()) {
+      // Compilation failed, create MDO, which would signal the interpreter
+      // to start profiling on its own.
+      _method->build_method_data();
+    }
+  } else if (is_profiling() && _would_profile) {
     ciMethodData *md = method->method_data();
     assert (md != NULL, "Should have MDO");
     md->set_would_profile(_would_profile);

src/share/vm/compiler/compileBroker.cpp

@@ -1535,7 +1535,7 @@ void CompileBroker::invoke_compiler_on_method(CompileTask* task) {
       //assert(false, "compiler should always document failure");
       // The compiler elected, without comment, not to register a result.
       // Do not attempt further compilations of this method.
-      ci_env.record_method_not_compilable("compile failed");
+      ci_env.record_method_not_compilable("compile failed", !TieredCompilation);
     }
 
     if (ci_env.failing()) {
@@ -1544,15 +1544,8 @@ void CompileBroker::invoke_compiler_on_method(CompileTask* task) {
       if (PrintCompilation) {
         const char* reason = ci_env.failure_reason();
         if (compilable == ciEnv::MethodCompilable_not_at_tier) {
-          if (is_highest_tier_compile(ci_env.comp_level())) {
-            // Already at highest tier, promote to not compilable.
-            compilable = ciEnv::MethodCompilable_never;
-          } else {
             tty->print_cr("%3d   COMPILE SKIPPED: %s (retry at different tier)", compile_id, reason);
-          }
-        }
-
-        if (compilable == ciEnv::MethodCompilable_never) {
+        } else if (compilable == ciEnv::MethodCompilable_never) {
           tty->print_cr("%3d   COMPILE SKIPPED: %s (not retryable)", compile_id, reason);
         } else if (compilable == ciEnv::MethodCompilable) {
           tty->print_cr("%3d   COMPILE SKIPPED: %s", compile_id, reason);

src/share/vm/memory/universe.cpp

@@ -864,7 +864,8 @@ jint Universe::initialize_heap() {
     // compressed oops for pstack code.
     if (PrintCompressedOopsMode) {
       tty->cr();
-      tty->print("heap address: "PTR_FORMAT, Universe::heap()->base());
+      tty->print("heap address: " PTR_FORMAT ", size: " SIZE_FORMAT " MB",
+                 Universe::heap()->base(), Universe::heap()->reserved_region().byte_size()/M);
     }
     if ((uint64_t)Universe::heap()->reserved_region().end() > OopEncodingHeapMax) {
       // Can't reserve heap below 32Gb.

src/share/vm/opto/graphKit.cpp

@@ -569,7 +569,8 @@ void GraphKit::builtin_throw(Deoptimization::DeoptReason reason, Node* arg) {
       const TypePtr* adr_typ = ex_con->add_offset(offset);
 
       Node *adr = basic_plus_adr(ex_node, ex_node, offset);
-      Node *store = store_oop_to_object(control(), ex_node, adr, adr_typ, null(), ex_con, T_OBJECT);
+      const TypeOopPtr* val_type = TypeOopPtr::make_from_klass(env()->String_klass());
+      Node *store = store_oop_to_object(control(), ex_node, adr, adr_typ, null(), val_type, T_OBJECT);
 
       add_exception_state(make_exception_state(ex_node));
       return;

src/share/vm/runtime/arguments.cpp

@@ -1341,8 +1341,11 @@ bool verify_object_alignment() {
 }
 
 inline uintx max_heap_for_compressed_oops() {
-  // Heap should be above HeapBaseMinAddress to get zero based compressed oops.
-  LP64_ONLY(return OopEncodingHeapMax - MaxPermSize - os::vm_page_size() - HeapBaseMinAddress);
+  // Avoid sign flip.
+  if (OopEncodingHeapMax < MaxPermSize + os::vm_page_size()) {
+    return 0;
+  }
+  LP64_ONLY(return OopEncodingHeapMax - MaxPermSize - os::vm_page_size());
   NOT_LP64(ShouldNotReachHere(); return 0);
 }
 
@@ -1520,7 +1523,13 @@ void Arguments::set_heap_size() {
     }
     if (UseCompressedOops) {
       // Limit the heap size to the maximum possible when using compressed oops
-      reasonable_max = MIN2(reasonable_max, (julong)max_heap_for_compressed_oops());
+      julong max_coop_heap = (julong)max_heap_for_compressed_oops();
+      if (HeapBaseMinAddress + MaxHeapSize < max_coop_heap) {
+        // Heap should be above HeapBaseMinAddress to get zero based compressed oops
+        // but it should be not less than default MaxHeapSize.
+        max_coop_heap -= HeapBaseMinAddress;
+      }
+      reasonable_max = MIN2(reasonable_max, max_coop_heap);
     }
     reasonable_max = os::allocatable_physical_memory(reasonable_max);
 

src/share/vm/runtime/simpleThresholdPolicy.cpp

@@ -176,11 +176,11 @@ void SimpleThresholdPolicy::compile(methodHandle mh, int bci, CompLevel level, T
   if (level == CompLevel_none) {
     return;
   }
-  // Check if the method can be compiled, if not - try different levels.
+  // 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_full_optimization)) {
-      compile(mh, bci, CompLevel_full_optimization, THREAD);
-    }
     if (level == CompLevel_full_optimization && can_be_compiled(mh, CompLevel_simple)) {
         compile(mh, bci, CompLevel_simple, THREAD);
     }