hotspot/src/share/vm/runtime/java.cpp

@@ -633,14 +633,12 @@
 
   void *lib_handle = os::native_java_library();
   jdk_version_info_fn_t func = CAST_TO_FN_PTR(jdk_version_info_fn_t,
      os::dll_lookup(lib_handle, "JDK_GetVersionInfo0"));
 
-  if (func == NULL) {
-    // JDK older than 1.6
-    _current._partially_initialized = true;
-  } else {
+  assert(func != NULL, "Support for JDK 1.5 or older has been removed after JEP-223");
+  
     (*func)(&info, sizeof(info));
 
     int major = JDK_VERSION_MAJOR(info.jdk_version);
     int minor = JDK_VERSION_MINOR(info.jdk_version);
     int security = JDK_VERSION_SECURITY(info.jdk_version);

@@ -649,91 +647,56 @@
     // Incompatible with pre-4243978 JDK.
     if (info.pending_list_uses_discovered_field == 0) {
       vm_exit_during_initialization(
         "Incompatible JDK is not using Reference.discovered field for pending list");
     }
-    _current = JDK_Version(major, minor, security, info.update_version,
-                           info.special_update_version, build,
+  _current = JDK_Version(major, minor, security, info.patch_version, build,
                            info.thread_park_blocker == 1,
                            info.post_vm_init_hook_enabled == 1);
-  }
-}
-
-void JDK_Version::fully_initialize(
-    uint8_t major, uint8_t minor, uint8_t security, uint8_t update) {
-  // This is only called when current is less than 1.6 and we've gotten
-  // far enough in the initialization to determine the exact version.
-  assert(major < 6, "not needed for JDK version >= 6");
-  assert(is_partially_initialized(), "must not initialize");
-  if (major < 5) {
-    // JDK verison sequence: 1.2.x, 1.3.x, 1.4.x, 5.0.x, 6.0.x, etc.
-    security = minor;
-    minor = major;
-    major = 1;
-  }
-  _current = JDK_Version(major, minor, security, update);
 }
 
 void JDK_Version_init() {
   JDK_Version::initialize();
 }
 
 static int64_t encode_jdk_version(const JDK_Version& v) {
   return
-    ((int64_t)v.major_version()          << (BitsPerByte * 5)) |
-    ((int64_t)v.minor_version()          << (BitsPerByte * 4)) |
-    ((int64_t)v.security_version()       << (BitsPerByte * 3)) |
-    ((int64_t)v.update_version()         << (BitsPerByte * 2)) |
-    ((int64_t)v.special_update_version() << (BitsPerByte * 1)) |
+    ((int64_t)v.major_version()          << (BitsPerByte * 4)) |
+    ((int64_t)v.minor_version()          << (BitsPerByte * 3)) |
+    ((int64_t)v.security_version()       << (BitsPerByte * 2)) |
+    ((int64_t)v.patch_version()          << (BitsPerByte * 1)) |
     ((int64_t)v.build_number()           << (BitsPerByte * 0));
 }
 
 int JDK_Version::compare(const JDK_Version& other) const {
   assert(is_valid() && other.is_valid(), "Invalid version (uninitialized?)");
-  if (!is_partially_initialized() && other.is_partially_initialized()) {
-    return -(other.compare(*this)); // flip the comparators
-  }
-  assert(!other.is_partially_initialized(), "Not initialized yet");
-  if (is_partially_initialized()) {
-    assert(other.major_version() >= 6,
-           "Invalid JDK version comparison during initialization");
-    return -1;
-  } else {
     uint64_t e = encode_jdk_version(*this);
     uint64_t o = encode_jdk_version(other);
     return (e > o) ? 1 : ((e == o) ? 0 : -1);
-  }
 }
 
 void JDK_Version::to_string(char* buffer, size_t buflen) const {
   assert(buffer && buflen > 0, "call with useful buffer");
   size_t index = 0;
 
   if (!is_valid()) {
     jio_snprintf(buffer, buflen, "%s", "(uninitialized)");
-  } else if (is_partially_initialized()) {
-    jio_snprintf(buffer, buflen, "%s", "(uninitialized) pre-1.6.0");
   } else {
     int rc = jio_snprintf(
         &buffer[index], buflen - index, "%d.%d", _major, _minor);
     if (rc == -1) return;
     index += rc;
     if (_security > 0) {
       rc = jio_snprintf(&buffer[index], buflen - index, ".%d", _security);
     }
-    if (_update > 0) {
-      rc = jio_snprintf(&buffer[index], buflen - index, "_%02d", _update);
-      if (rc == -1) return;
-      index += rc;
-    }
-    if (_special > 0) {
-      rc = jio_snprintf(&buffer[index], buflen - index, "%c", _special);
+    if (_patch > 0) {
+      rc = jio_snprintf(&buffer[index], buflen - index, ".%d", _patch);
       if (rc == -1) return;
       index += rc;
     }
     if (_build > 0) {
-      rc = jio_snprintf(&buffer[index], buflen - index, "-b%02d", _build);
+      rc = jio_snprintf(&buffer[index], buflen - index, "+%d", _build);
       if (rc == -1) return;
       index += rc;
     }
   }
 }