28 #include "oops/oop.inline.hpp"

    29 #include "runtime/arguments.hpp"

    31 

    32 const char* Abstract_VM_Version::_s_vm_release = Abstract_VM_Version::vm_release();

    33 const char* Abstract_VM_Version::_s_internal_vm_info_string = Abstract_VM_Version::internal_vm_info_string();

    34 

    35 uint64_t Abstract_VM_Version::_features = 0;

    36 const char* Abstract_VM_Version::_features_string = "";

    37 

    38 bool Abstract_VM_Version::_supports_cx8 = false;

    39 bool Abstract_VM_Version::_supports_atomic_getset4 = false;

    40 bool Abstract_VM_Version::_supports_atomic_getset8 = false;

    41 bool Abstract_VM_Version::_supports_atomic_getadd4 = false;

    42 bool Abstract_VM_Version::_supports_atomic_getadd8 = false;

    43 unsigned int Abstract_VM_Version::_logical_processors_per_package = 1U;

    44 unsigned int Abstract_VM_Version::_L1_data_cache_line_size = 0;

    45 unsigned int Abstract_VM_Version::_data_cache_line_flush_size = 0;

    46 

    47 VirtualizationType Abstract_VM_Version::_detected_virtualization = NoDetectedVirtualization;

    48 

    49 #ifndef HOTSPOT_VERSION_STRING

    50   #error HOTSPOT_VERSION_STRING must be defined

    51 #endif

    52 

    53 #ifndef VERSION_FEATURE

    54   #error VERSION_FEATURE must be defined

    55 #endif

    56 #ifndef VERSION_INTERIM

    57   #error VERSION_INTERIM must be defined

    58 #endif

    59 #ifndef VERSION_UPDATE

    60   #error VERSION_UPDATE must be defined

    61 #endif

    62 #ifndef VERSION_PATCH

    63   #error VERSION_PATCH must be defined

    64 #endif

    65 #ifndef VERSION_BUILD

    66   #error VERSION_BUILD must be defined

    67 #endif

    68 

    69 #ifndef VERSION_STRING

    70   #error VERSION_STRING must be defined

    71 #endif

    72 

    73 #ifndef DEBUG_LEVEL

    74   #error DEBUG_LEVEL must be defined

    75 #endif

    76 

    77 #define VM_RELEASE HOTSPOT_VERSION_STRING

    78 

    79 // HOTSPOT_VERSION_STRING equals the JDK VERSION_STRING (unless overridden

    80 // in a standalone build).

    81 int Abstract_VM_Version::_vm_major_version = VERSION_FEATURE;

    82 int Abstract_VM_Version::_vm_minor_version = VERSION_INTERIM;

    83 int Abstract_VM_Version::_vm_security_version = VERSION_UPDATE;

    84 int Abstract_VM_Version::_vm_patch_version = VERSION_PATCH;

    85 int Abstract_VM_Version::_vm_build_number = VERSION_BUILD;

    86 

    87 #if defined(_LP64)

    88   #define VMLP "64-Bit "

    89 #else

    90   #define VMLP ""

    91 #endif

    92 

    93 #ifndef VMTYPE

    94   #ifdef TIERED

    95     #define VMTYPE "Server"

    96   #else // TIERED

    97   #ifdef ZERO

    98     #define VMTYPE "Zero"

    99   #else // ZERO

   100      #define VMTYPE COMPILER1_PRESENT("Client")   \

   101                     COMPILER2_PRESENT("Server")

   102   #endif // ZERO

   103   #endif // TIERED

   104 #endif

   105 

   106 #ifndef HOTSPOT_VM_DISTRO

   107   #error HOTSPOT_VM_DISTRO must be defined

   108 #endif

   109 #define VMNAME HOTSPOT_VM_DISTRO " " VMLP VMTYPE " VM"

   110 

   111 const char* Abstract_VM_Version::vm_name() {

   112   return VMNAME;

   113 }

   114 

   115 

   116 const char* Abstract_VM_Version::vm_vendor() {

   117 #ifdef VENDOR

   118   return VENDOR;

   119 #else

   120   return "Oracle Corporation";

   121 #endif

   122 }

   123 

   124 

   125 const char* Abstract_VM_Version::vm_info_string() {

   126   switch (Arguments::mode()) {

   127     case Arguments::_int:

   128       return UseSharedSpaces ? "interpreted mode, sharing" : "interpreted mode";

   129     case Arguments::_mixed:

   130       if (UseSharedSpaces) {

   131         if (UseAOT) {

   132           return "mixed mode, aot, sharing";

   133 #ifdef TIERED

   134         } else if(is_client_compilation_mode_vm()) {

   135           return "mixed mode, emulated-client, sharing";

   136 #endif

   137         } else {

   138           return "mixed mode, sharing";

   139          }

   140       } else {

   141         if (UseAOT) {

   142           return "mixed mode, aot";

   143 #ifdef TIERED

   144         } else if(is_client_compilation_mode_vm()) {

   145           return "mixed mode, emulated-client";

   146 #endif

   147         } else {

   148           return "mixed mode";

   149         }

   150       }

   151     case Arguments::_comp:

   152 #ifdef TIERED

   153       if (is_client_compilation_mode_vm()) {

   154          return UseSharedSpaces ? "compiled mode, emulated-client, sharing" : "compiled mode, emulated-client";

   155       }

   156 #endif

   157       return UseSharedSpaces ? "compiled mode, sharing"    : "compiled mode";

   158   };

   159   ShouldNotReachHere();

   160   return "";

   161 }

   162 

   163 // NOTE: do *not* use stringStream. this function is called by

   164 //       fatal error handler. if the crash is in native thread,

   165 //       stringStream cannot get resource allocated and will SEGV.

   166 const char* Abstract_VM_Version::vm_release() {

   167   return VM_RELEASE;

   168 }

   169 

   170 // NOTE: do *not* use stringStream. this function is called by

   171 //       fatal error handlers. if the crash is in native thread,

   172 //       stringStream cannot get resource allocated and will SEGV.

   173 const char* Abstract_VM_Version::jre_release_version() {

   174   return VERSION_STRING;

   175 }

   176 

   177 #define OS       LINUX_ONLY("linux")             \

   178                  WINDOWS_ONLY("windows")         \

   179                  SOLARIS_ONLY("solaris")         \

   180                  AIX_ONLY("aix")                 \

   181                  BSD_ONLY("bsd")

   182 

   183 #ifndef CPU

   184 #ifdef ZERO

   185 #define CPU      ZERO_LIBARCH

   186 #elif defined(PPC64)

   187 #if defined(VM_LITTLE_ENDIAN)

   188 #define CPU      "ppc64le"

   189 #else

   190 #define CPU      "ppc64"

   191 #endif // PPC64

   192 #else

   193 #define CPU      AARCH64_ONLY("aarch64")         \

   194                  AMD64_ONLY("amd64")             \

   195                  IA32_ONLY("x86")                \

   196                  IA64_ONLY("ia64")               \

   197                  S390_ONLY("s390")               \

   198                  SPARC_ONLY("sparc")

   199 #endif // !ZERO

   200 #endif // !CPU

   201 

   202 const char *Abstract_VM_Version::vm_platform_string() {

   203   return OS "-" CPU;

   204 }

   205 

   206 const char* Abstract_VM_Version::internal_vm_info_string() {

   207   #ifndef HOTSPOT_BUILD_USER

   208     #define HOTSPOT_BUILD_USER unknown

   209   #endif

   210 

   211   #ifndef HOTSPOT_BUILD_COMPILER

   212     #ifdef _MSC_VER

   213       #if _MSC_VER == 1600

   214         #define HOTSPOT_BUILD_COMPILER "MS VC++ 10.0 (VS2010)"

   215       #elif _MSC_VER == 1700

   216         #define HOTSPOT_BUILD_COMPILER "MS VC++ 11.0 (VS2012)"

   217       #elif _MSC_VER == 1800

   218         #define HOTSPOT_BUILD_COMPILER "MS VC++ 12.0 (VS2013)"

   219       #elif _MSC_VER == 1900

   220         #define HOTSPOT_BUILD_COMPILER "MS VC++ 14.0 (VS2015)"

   221       #elif _MSC_VER == 1911

   222         #define HOTSPOT_BUILD_COMPILER "MS VC++ 15.3 (VS2017)"

   223       #elif _MSC_VER == 1912

   224         #define HOTSPOT_BUILD_COMPILER "MS VC++ 15.5 (VS2017)"

   225       #elif _MSC_VER == 1913

   226         #define HOTSPOT_BUILD_COMPILER "MS VC++ 15.6 (VS2017)"

   227       #elif _MSC_VER == 1914

   228         #define HOTSPOT_BUILD_COMPILER "MS VC++ 15.7 (VS2017)"

   229       #elif _MSC_VER == 1915

   230         #define HOTSPOT_BUILD_COMPILER "MS VC++ 15.8 (VS2017)"

   231       #else

   232         #define HOTSPOT_BUILD_COMPILER "unknown MS VC++:" XSTR(_MSC_VER)

   233       #endif

   234     #elif defined(__SUNPRO_CC)

   235       #if __SUNPRO_CC == 0x580

   236         #define HOTSPOT_BUILD_COMPILER "Workshop 5.8"

   237       #elif __SUNPRO_CC == 0x590

   238         #define HOTSPOT_BUILD_COMPILER "Workshop 5.9"

   239       #elif __SUNPRO_CC == 0x5100

   240         #define HOTSPOT_BUILD_COMPILER "Sun Studio 12u1"

   241       #elif __SUNPRO_CC == 0x5120

   242         #define HOTSPOT_BUILD_COMPILER "Sun Studio 12u3"

   243       #elif __SUNPRO_CC == 0x5130

   244         #define HOTSPOT_BUILD_COMPILER "Sun Studio 12u4"

   245       #else

   246         #define HOTSPOT_BUILD_COMPILER "unknown Workshop:" XSTR(__SUNPRO_CC)

   247       #endif

   248     #elif defined(__clang_version__)

   249         #define HOTSPOT_BUILD_COMPILER "clang " __VERSION__

   250     #elif defined(__GNUC__)

   251         #define HOTSPOT_BUILD_COMPILER "gcc " __VERSION__

   252     #else

   253       #define HOTSPOT_BUILD_COMPILER "unknown compiler"

   254     #endif

   255   #endif

   256 

   257   #ifndef FLOAT_ARCH

   258     #if defined(__SOFTFP__)

   259       #define FLOAT_ARCH_STR "-sflt"

   260     #else

   261       #define FLOAT_ARCH_STR ""

   262     #endif

   263   #else

   264     #define FLOAT_ARCH_STR XSTR(FLOAT_ARCH)

   265   #endif

   266 

   267   #define INTERNAL_VERSION_SUFFIX VM_RELEASE ")" \

   268          " for " OS "-" CPU FLOAT_ARCH_STR \

   269          " JRE (" VERSION_STRING "), built on " __DATE__ " " __TIME__ \

   270          " by " XSTR(HOTSPOT_BUILD_USER) " with " HOTSPOT_BUILD_COMPILER

   271 

   272   return strcmp(DEBUG_LEVEL, "release") == 0

   273       ? VMNAME " (" INTERNAL_VERSION_SUFFIX

   274       : VMNAME " (" DEBUG_LEVEL " " INTERNAL_VERSION_SUFFIX;

   275 }

   276 

   277 const char *Abstract_VM_Version::vm_build_user() {

   278   return HOTSPOT_BUILD_USER;

   279 }

   280 

   281 const char *Abstract_VM_Version::jdk_debug_level() {

   282   return DEBUG_LEVEL;

   283 }

   284 

   285 const char *Abstract_VM_Version::printable_jdk_debug_level() {

   286   // Debug level is not printed for "release" builds

   287   return strcmp(DEBUG_LEVEL, "release") == 0 ? "" : DEBUG_LEVEL " ";

   288 }

   289 

   290 unsigned int Abstract_VM_Version::jvm_version() {

   291   return ((Abstract_VM_Version::vm_major_version() & 0xFF) << 24) |

   292          ((Abstract_VM_Version::vm_minor_version() & 0xFF) << 16) |

   293          ((Abstract_VM_Version::vm_security_version() & 0xFF) << 8) |

   294          (Abstract_VM_Version::vm_build_number() & 0xFF);

   295 }

   307 

   308 bool Abstract_VM_Version::print_matching_lines_from_file(const char* filename, outputStream* st, const char* keywords_to_match[]) {

   309   char line[500];

   310   FILE* fp = fopen(filename, "r");

   311   if (fp == NULL) {

   312     return false;

   313   }

   314 

   315   st->print_cr("Virtualization information:");

   316   while (fgets(line, sizeof(line), fp) != NULL) {

   317     int i = 0;

   318     while (keywords_to_match[i] != NULL) {

   319       if (strncmp(line, keywords_to_match[i], strlen(keywords_to_match[i])) == 0) {

   320         st->print("%s", line);

   321         break;

   322       }

   323       i++;

   324     }

   325   }

   326   fclose(fp);

   327   return true;

   328 }

   329 

   330