8283494: Factor out calculation of actual number of XMM registers

Reviewed-by: dlong, kvn

src/hotspot/cpu/x86/c1_FrameMap_x86.hpp

@@ -152,14 +152,8 @@
     return range;
   }
 
-  static int get_num_caller_save_xmms(void) {
-    int num_caller_save_xmm_regs = nof_caller_save_xmm_regs;
-#ifdef _LP64
-    if (UseAVX < 3) {
-      num_caller_save_xmm_regs = num_caller_save_xmm_regs / 2;
-    }
-#endif
-    return num_caller_save_xmm_regs;
+  static int get_num_caller_save_xmms() {
+    return XMMRegisterImpl::available_xmm_registers();
   }
 
   static int nof_caller_save_cpu_regs() { return adjust_reg_range(pd_nof_caller_save_cpu_regs_frame_map); }

src/hotspot/cpu/x86/c1_LinearScan_x86.hpp

@@ -101,12 +101,7 @@ inline void LinearScan::pd_add_temps(LIR_Op* op) {
 // Implementation of LinearScanWalker
 
 inline bool LinearScanWalker::pd_init_regs_for_alloc(Interval* cur) {
-  int last_xmm_reg = pd_last_xmm_reg;
-#ifdef _LP64
-  if (UseAVX < 3) {
-    last_xmm_reg = pd_first_xmm_reg + (pd_nof_xmm_regs_frame_map / 2) - 1;
-  }
-#endif
+  int last_xmm_reg = pd_first_xmm_reg + XMMRegisterImpl::available_xmm_registers() - 1;
   if (allocator()->gen()->is_vreg_flag_set(cur->reg_num(), LIRGenerator::byte_reg)) {
     assert(cur->type() != T_FLOAT && cur->type() != T_DOUBLE, "cpu regs only");
     _first_reg = pd_first_byte_reg;

src/hotspot/cpu/x86/c1_Runtime1_x86.cpp

@@ -25,6 +25,7 @@
 #include "precompiled.hpp"
 #include "asm/assembler.hpp"
 #include "c1/c1_Defs.hpp"
+#include "c1/c1_FrameMap.hpp"
 #include "c1/c1_MacroAssembler.hpp"
 #include "c1/c1_Runtime1.hpp"
 #include "ci/ciUtilities.hpp"
@@ -369,12 +370,7 @@ static OopMap* generate_oop_map(StubAssembler* sasm, int num_rt_args,
   map->set_callee_saved(VMRegImpl::stack2reg(r15H_off + num_rt_args), r15->as_VMReg()->next());
 #endif // _LP64
 
-  int xmm_bypass_limit = FrameMap::nof_xmm_regs;
-#ifdef _LP64
-  if (UseAVX < 3) {
-    xmm_bypass_limit = xmm_bypass_limit / 2;
-  }
-#endif
+  int xmm_bypass_limit = FrameMap::get_num_caller_save_xmms();
 
   if (save_fpu_registers) {
 #ifndef _LP64
@@ -487,13 +483,8 @@ void C1_MacroAssembler::save_live_registers_no_oop_map(bool save_fpu_registers)
       // so always save them as doubles.
       // note that float values are _not_ converted automatically, so for float values
       // the second word contains only garbage data.
-      int xmm_bypass_limit = FrameMap::nof_xmm_regs;
+      int xmm_bypass_limit = FrameMap::get_num_caller_save_xmms();
       int offset = 0;
-#ifdef _LP64
-      if (UseAVX < 3) {
-        xmm_bypass_limit = xmm_bypass_limit / 2;
-      }
-#endif
       for (int n = 0; n < xmm_bypass_limit; n++) {
         XMMRegister xmm_name = as_XMMRegister(n);
         __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + offset), xmm_name);
@@ -513,10 +504,7 @@ static void restore_fpu(C1_MacroAssembler* sasm, bool restore_fpu_registers) {
 #ifdef _LP64
   if (restore_fpu_registers) {
     // restore XMM registers
-    int xmm_bypass_limit = FrameMap::nof_xmm_regs;
-    if (UseAVX < 3) {
-      xmm_bypass_limit = xmm_bypass_limit / 2;
-    }
+    int xmm_bypass_limit = FrameMap::get_num_caller_save_xmms();
     int offset = 0;
     for (int n = 0; n < xmm_bypass_limit; n++) {
       XMMRegister xmm_name = as_XMMRegister(n);

src/hotspot/cpu/x86/macroAssembler_x86.cpp

@@ -26,7 +26,6 @@
 #include "jvm.h"
 #include "asm/assembler.hpp"
 #include "asm/assembler.inline.hpp"
-#include "c1/c1_FrameMap.hpp"
 #include "compiler/compiler_globals.hpp"
 #include "compiler/disassembler.hpp"
 #include "gc/shared/barrierSet.hpp"
@@ -3594,14 +3593,15 @@ RegSet MacroAssembler::call_clobbered_gp_registers() {
 }
 
 XMMRegSet MacroAssembler::call_clobbered_xmm_registers() {
+  int num_xmm_registers = XMMRegisterImpl::available_xmm_registers();
 #if defined(WINDOWS) && defined(_LP64)
   XMMRegSet result = XMMRegSet::range(xmm0, xmm5);
-  if (FrameMap::get_num_caller_save_xmms() > 16) {
-     result += XMMRegSet::range(xmm16, as_XMMRegister(FrameMap::get_num_caller_save_xmms() - 1));
+  if (num_xmm_registers > 16) {
+     result += XMMRegSet::range(xmm16, as_XMMRegister(num_xmm_registers - 1));
   }
   return result;
 #else
-  return XMMRegSet::range(xmm0, as_XMMRegister(FrameMap::get_num_caller_save_xmms() - 1));
+  return XMMRegSet::range(xmm0, as_XMMRegister(num_xmm_registers - 1));
 #endif
 }
 

src/hotspot/cpu/x86/register_x86.cpp

@@ -23,6 +23,7 @@
  */
 
 #include "precompiled.hpp"
+
 #include "register_x86.hpp"
 
 #ifndef AMD64

src/hotspot/cpu/x86/register_x86.hpp

@@ -26,6 +26,7 @@
 #define CPU_X86_REGISTER_X86_HPP
 
 #include "asm/register.hpp"
+#include "runtime/globals.hpp"
 #include "utilities/count_leading_zeros.hpp"
 #include "utilities/powerOfTwo.hpp"
 
@@ -163,6 +164,18 @@ class XMMRegisterImpl: public AbstractRegisterImpl {
   bool  is_valid() const                          { return 0 <= (intptr_t)this && (intptr_t)this < number_of_registers; }
   const char* name() const;
   const char* sub_word_name(int offset) const;
+
+  // Actually available XMM registers for use, depending on actual CPU capabilities
+  // and flags.
+  static int available_xmm_registers() {
+    int num_xmm_regs = XMMRegisterImpl::number_of_registers;
+#ifdef _LP64
+    if (UseAVX < 3) {
+      num_xmm_regs /= 2;
+    }
+#endif
+    return num_xmm_regs;
+  }
 };
 
 

src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp

@@ -174,10 +174,7 @@ PRAGMA_DIAG_PUSH
 PRAGMA_NONNULL_IGNORED
 OopMap* RegisterSaver::save_live_registers(MacroAssembler* masm, int additional_frame_words, int* total_frame_words, bool save_vectors) {
   int off = 0;
-  int num_xmm_regs = XMMRegisterImpl::number_of_registers;
-  if (UseAVX < 3) {
-    num_xmm_regs = num_xmm_regs/2;
-  }
+  int num_xmm_regs = XMMRegisterImpl::available_xmm_registers();
 #if COMPILER2_OR_JVMCI
   if (save_vectors && UseAVX == 0) {
     save_vectors = false; // vectors larger than 16 byte long are supported only with AVX
@@ -367,10 +364,7 @@ OopMap* RegisterSaver::save_live_registers(MacroAssembler* masm, int additional_
 PRAGMA_DIAG_POP
 
 void RegisterSaver::restore_live_registers(MacroAssembler* masm, bool restore_vectors) {
-  int num_xmm_regs = XMMRegisterImpl::number_of_registers;
-  if (UseAVX < 3) {
-    num_xmm_regs = num_xmm_regs/2;
-  }
+  int num_xmm_regs = XMMRegisterImpl::available_xmm_registers();
   if (frame::arg_reg_save_area_bytes != 0) {
     // Pop arg register save area
     __ addptr(rsp, frame::arg_reg_save_area_bytes);

src/hotspot/cpu/x86/vmreg_x86.hpp

@@ -25,7 +25,7 @@
 #ifndef CPU_X86_VMREG_X86_HPP
 #define CPU_X86_VMREG_X86_HPP
 
-
+#include "register_x86.hpp"
 
 inline bool is_Register() {
   return (unsigned int) value() < (unsigned int) ConcreteRegisterImpl::max_gpr;
@@ -36,14 +36,8 @@ inline bool is_FloatRegister() {
 }
 
 inline bool is_XMMRegister() {
-  int uarch_max_xmm = ConcreteRegisterImpl::max_xmm;
-
-#ifdef _LP64
-  if (UseAVX < 3) {
-    int half_xmm = (XMMRegisterImpl::max_slots_per_register * XMMRegisterImpl::number_of_registers) / 2;
-    uarch_max_xmm -= half_xmm;
-  }
-#endif
+  int uarch_max_xmm = ConcreteRegisterImpl::max_fpr +
+    (XMMRegisterImpl::max_slots_per_register * XMMRegisterImpl::available_xmm_registers());
 
   return (value() >= ConcreteRegisterImpl::max_fpr && value() < uarch_max_xmm);
 }