src/hotspot/cpu/x86/vm_version_x86.cpp

@@ -1669,53 +1669,56 @@
   } else if (vrt == HyperV) {
     st->print_cr("HyperV virtualization detected");
   }
 }
 
-void VM_Version::check_virt_cpuid(uint32_t idx, uint32_t *regs) {
-// TODO support 32 bit
-#if defined(_LP64)
-#if defined(_MSC_VER)
+void VM_Version::check_virt_cpuid(uint32_t *regs) {
   // Allocate space for the code
   const int code_size = 100;
   ResourceMark rm;
   CodeBuffer cb("detect_virt", code_size, 0);
   MacroAssembler* a = new MacroAssembler(&cb);
-  address code = a->pc();
-  void (*test)(uint32_t idx, uint32_t *regs) = (void(*)(uint32_t idx, uint32_t *regs))code;
+  void (*test)(uint32_t *regs) = (void(*)(uint32_t *regs))a->pc();
 
-  a->movq(r9, rbx); // save nonvolatile register
+  // save nonvolatile register
+  a->push(rbx);
+#ifdef _WINDOWS
+  a->push(rsi); // RSI is nonvolatile register for Windows
+#endif
+
+  // Copy 1st argument to SI
+#ifdef _LP64
+  a->movptr(rsi, c_rarg0);
+#else
+  int ofs = 8; // return address + EBX
+#ifdef _WINDOWS
+  ofs += 4; // ESI
+#endif
+  a->movptr(rsi, Address(rsp, ofs));
+#endif
+
+  a->movl(rax, 0x40000000);
 
-  // next line would not work on 32-bit
-  a->movq(rax, c_rarg0 /* rcx */);
-  a->movq(r8, c_rarg1 /* rdx */);
   a->cpuid();
-  a->movl(Address(r8,  0), rax);
-  a->movl(Address(r8,  4), rbx);
-  a->movl(Address(r8,  8), rcx);
-  a->movl(Address(r8, 12), rdx);
 
-  a->movq(rbx, r9); // restore nonvolatile register
+  a->movl(Address(rsi,  0), rax);
+  a->movl(Address(rsi,  4), rbx);
+  a->movl(Address(rsi,  8), rcx);
+  a->movl(Address(rsi, 12), rdx);
+
+  // restore nonvolatile register
+#ifdef _WINDOWS
+  a->pop(rsi);
+#endif
+  a->pop(rbx);
+
   a->ret(0);
 
-  uint32_t *code_end = (uint32_t *)a->pc();
   a->flush();
 
   // execute code
-  (*test)(idx, regs);
-#elif defined(__GNUC__)
-  __asm__ volatile (
-     "        cpuid;"
-     "        mov %%eax,(%1);"
-     "        mov %%ebx,4(%1);"
-     "        mov %%ecx,8(%1);"
-     "        mov %%edx,12(%1);"
-     : "+a" (idx)
-     : "S" (regs)
-     : "ebx", "ecx", "edx", "memory" );
-#endif
-#endif
+  test(regs);
 }
 
 
 bool VM_Version::use_biased_locking() {
 #if INCLUDE_RTM_OPT

@@ -1815,43 +1818,33 @@
 //
 // more information :
 // https://kb.vmware.com/s/article/1009458
 //
 void VM_Version::check_virtualizations() {
-#if defined(_LP64)
-  uint32_t registers[4];
-  char signature[13];
-  uint32_t base;
-  signature[12] = '\0';
-  memset((void*)registers, 0, 4*sizeof(uint32_t));
-
-  for (base = 0x40000000; base < 0x40010000; base += 0x100) {
-    check_virt_cpuid(base, registers);
-
-    *(uint32_t *)(signature + 0) = registers[1];
-    *(uint32_t *)(signature + 4) = registers[2];
-    *(uint32_t *)(signature + 8) = registers[3];
+  uint32_t registers[4] = {0};
+  char signature[13] = {0};
+
+  check_virt_cpuid(registers);
+  memcpy(signature, &registers[1], 12);
 
     if (strncmp("VMwareVMware", signature, 12) == 0) {
       Abstract_VM_Version::_detected_virtualization = VMWare;
       // check for extended metrics from guestlib
       VirtualizationSupport::initialize();
-    }
-
-    if (strncmp("Microsoft Hv", signature, 12) == 0) {
+  } else if (strncmp("Microsoft Hv", signature, 12) == 0) {
+#ifdef _WINDOWS
+    if (is_in_VM()) {
       Abstract_VM_Version::_detected_virtualization = HyperV;
     }
-
-    if (strncmp("KVMKVMKVM", signature, 9) == 0) {
+#else
+    Abstract_VM_Version::_detected_virtualization = HyperV;
+#endif
+  } else if (strncmp("KVMKVMKVM", signature, 9) == 0) {
       Abstract_VM_Version::_detected_virtualization = KVM;
-    }
-
-    if (strncmp("XenVMMXenVMM", signature, 12) == 0) {
+  } else if (strncmp("XenVMMXenVMM", signature, 12) == 0) {
       Abstract_VM_Version::_detected_virtualization = XenHVM;
     }
-  }
-#endif
 }
 
 void VM_Version::initialize() {
   ResourceMark rm;
   // Making this stub must be FIRST use of assembler

@@ -1867,9 +1860,9 @@
 
   get_processor_features();
 
   LP64_ONLY(Assembler::precompute_instructions();)
 
-  if (cpu_family() > 4) { // it supports CPUID
+  if (VM_Version::supports_hv()) { // Supports hypervisor
     check_virtualizations();
   }
 }