8358738: AOT cache created without graal jit should not be used with graal jit

Reviewed-by: iklam, ccheung

Author: Vladimir Kozlov

src/hotspot/share/cds/filemap.cpp

@@ -44,6 +44,7 @@
 #include "classfile/systemDictionaryShared.hpp"
 #include "classfile/vmClasses.hpp"
 #include "classfile/vmSymbols.hpp"
+#include "compiler/compilerDefinitions.inline.hpp"
 #include "jvm.h"
 #include "logging/log.hpp"
 #include "logging/logMessage.hpp"
@@ -232,6 +233,8 @@ void FileMapHeader::populate(FileMapInfo *info, size_t core_region_alignment,
   } else {
     _narrow_klass_pointer_bits = _narrow_klass_shift = -1;
   }
+  // Which JIT compier is used
+  _compiler_type = (u1)CompilerConfig::compiler_type();
   _type_profile_level = TypeProfileLevel;
   _type_profile_args_limit = TypeProfileArgsLimit;
   _type_profile_parms_limit = TypeProfileParmsLimit;
@@ -1935,6 +1938,23 @@ bool FileMapHeader::validate() {
                   CompactStrings   ? "enabled" : "disabled");
     return false;
   }
+  bool jvmci_compiler_is_enabled = CompilerConfig::is_jvmci_compiler_enabled();
+  CompilerType compiler_type = CompilerConfig::compiler_type();
+  CompilerType archive_compiler_type = CompilerType(_compiler_type);
+  // JVMCI compiler does different type profiling settigns and generate
+  // different code. We can't use archive which was produced
+  // without it and reverse.
+  // Only allow mix when JIT compilation is disabled.
+  // Interpreter is used by default when dumping archive.
+  bool intepreter_is_used = (archive_compiler_type == CompilerType::compiler_none) ||
+                            (compiler_type == CompilerType::compiler_none);
+  if (!intepreter_is_used &&
+      jvmci_compiler_is_enabled != (archive_compiler_type == CompilerType::compiler_jvmci)) {
+    MetaspaceShared::report_loading_error("The %s's JIT compiler setting (%s)"
+                                          " does not equal the current setting (%s).", file_type,
+                                          compilertype2name(archive_compiler_type), compilertype2name(compiler_type));
+    return false;
+  }
   if (TrainingData::have_data()) {
     if (_type_profile_level != TypeProfileLevel) {
       MetaspaceShared::report_loading_error("The %s's TypeProfileLevel setting (%d)"

src/hotspot/share/cds/filemap.hpp

@@ -147,6 +147,7 @@ class FileMapHeader: private CDSFileMapHeaderBase {
   size_t _ro_ptrmap_start_pos;          // The first bit in the ptrmap corresponds to this position in the ro region
 
   // The following are parameters that affect MethodData layout.
+  u1      _compiler_type;
   uint    _type_profile_level;
   int     _type_profile_args_limit;
   int     _type_profile_parms_limit;

src/hotspot/share/compiler/compilerDefinitions.hpp

@@ -149,6 +149,8 @@ class CompilerConfig : public AllStatic {
   inline static bool is_c2_or_jvmci_compiler_only();
   inline static bool is_c2_or_jvmci_compiler_enabled();
 
+  inline static CompilerType compiler_type();
+
 private:
   static bool is_compilation_mode_selected();
   static void set_compilation_policy_flags();

src/hotspot/share/compiler/compilerDefinitions.inline.hpp

@@ -131,4 +131,17 @@ inline bool CompilerConfig::is_c2_or_jvmci_compiler_enabled() {
   return is_c2_enabled() || is_jvmci_compiler_enabled();
 }
 
+// Return type of most optimizing compiler which is used
+inline CompilerType CompilerConfig::compiler_type() {
+  CompilerType compiler_type = CompilerType::compiler_none; // Interpreter only
+  if (CompilerConfig::is_c2_enabled()) {
+    compiler_type = CompilerType::compiler_c2;
+  } else if (CompilerConfig::is_jvmci_compiler_enabled()) {
+    compiler_type = CompilerType::compiler_jvmci;
+  } else if (CompilerConfig::is_c1_enabled()) {
+    compiler_type = CompilerType::compiler_c1;
+  }
+  return compiler_type;
+}
+
 #endif // SHARE_COMPILER_COMPILERDEFINITIONS_INLINE_HPP