AVX512 Support

CMakeLists.txt

@@ -93,6 +93,8 @@ if (SUPPORTS_MACRO_PREFIX_MAP)
  set(FLAGS_COMMON "${FLAGS_COMMON} -fmacro-prefix-map=${CMAKE_SOURCE_DIR}/=")
 endif()
 
+try_compile(AVX512F_SUPPORT ${CMAKE_SOURCE_DIR} ${CMAKE_SOURCE_DIR}/src/test/gdb_avx512.c CMAKE_FLAGS -DCOMPILE_DEFINITIONS=-march=native)
+
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${FLAGS_COMMON} -Wstrict-prototypes -std=gnu11")
 # Define __STDC_LIMIT_MACROS so |#include <stdint.h>| works as expected.
 # Define __STDC_FORMAT_MACROS so |#include <inttypes.h>| works as expected.
@@ -758,21 +760,25 @@ set_source_files_properties(src/exec_stub.c
 
 set(RR_GDB_RESOURCES
  32bit-avx.xml
+ 32bit-avx512.xml
  32bit-core.xml
  32bit-linux.xml
  32bit-sse.xml
  32bit-pkeys.xml
  64bit-avx.xml
+ 64bit-avx512.xml
  64bit-core.xml
  64bit-linux.xml
  64bit-seg.xml
  64bit-sse.xml
  64bit-pkeys.xml
  amd64-pkeys-linux.xml
  amd64-avx-linux.xml
+ amd64-avx512-linux.xml
  amd64-linux.xml
  i386-pkeys-linux.xml
  i386-avx-linux.xml
+ i386-avx512-linux.xml
  i386-linux.xml
  aarch64-core.xml
  aarch64-fpu.xml
@@ -1744,6 +1750,10 @@ set(TESTS_WITHOUT_PROGRAM
  when
 )
 
+if(AVX512F_SUPPORT)
+ set(TESTS_WITHOUT_PROGRAM ${TESTS_WITHOUT_PROGRAM} gdb_avx512)
+endif()
+
 if(BUILD_TESTS)
  # Part of the installable testsuite (test files).
  if(INSTALL_TESTSUITE)
@@ -1818,6 +1828,14 @@ if(BUILD_TESTS)
  PROPERTIES COMPILE_FLAGS "${RR_TEST_FLAGS} -g -O3")
  add_dependencies(watchpoint_unaligned2 Generated)
 
+ if(AVX512F_SUPPORT)
+ add_executable(gdb_avx512 src/test/gdb_avx512.c)
+ post_build_executable(gdb_avx512)
+ set_target_properties(gdb_avx512
+ PROPERTIES COMPILE_FLAGS "${RR_TEST_FLAGS} -g3 -mavx512f")
+ add_dependencies(gdb_avx512 Generated)
+ endif()
+
  # Test disabled because it requires libuvc to be built and installed, and a
  # working USB camera
  # add_executable(usb src/test/usb.c)
@@ -1921,7 +1939,7 @@ if(BUILD_TESTS)
  bash source_dir/src/test/${test}.run ${testname} -n bin_dir ${TEST_MONITOR_DEFAULT_TIMEOUT})
  configure_test(${test}-no-syscallbuf)
  endforeach(test)
-
+ 
  # Run 32-bit tests on 64-bit builds.
  # We copy the test files into '32' subdirectories in the output
  # directory, so we can set different compile options on them.
@@ -1942,6 +1960,11 @@ if(BUILD_TESTS)
  PROPERTIES COMPILE_FLAGS "-m32 ${RR_TEST_FLAGS}")
  endforeach(test)
 
+ if(AVX512F_SUPPORT)
+ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/test/gdb_avx512.c" "${CMAKE_CURRENT_BINARY_DIR}/32/gdb_avx512.c" COPYONLY)
+ set_source_files_properties("${CMAKE_CURRENT_BINARY_DIR}/32/${test}.c" PROPERTIES COMPILE_FLAGS "-m32 ${RR_TEST_FLAGS} -g3 -mavx512f")
+ endif()
+
  foreach(test ${BASIC_CPP_TESTS})
  configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/test/${test}.cc"
  "${CMAKE_CURRENT_BINARY_DIR}/32/${test}.cc"
@@ -1999,6 +2022,16 @@ if(BUILD_TESTS)
  COMPILE_FLAGS "-m32 ${RR_TEST_FLAGS} -g -O3")
  add_dependencies(watchpoint_unaligned2_32 Generated)
 
+ if(AVX512F_SUPPORT)
+ add_executable(gdb_avx512_32 "${CMAKE_CURRENT_BINARY_DIR}/32/gdb_avx512.c")
+ post_build_executable(gdb_avx512_32)
+ set_target_properties(gdb_avx512_32
+ PROPERTIES 
+ LINK_FLAGS "-m32"
+ COMPILE_FLAGS "-m32 ${RR_TEST_FLAGS} -g3 -mavx512f")
+ add_dependencies(gdb_avx512_32 Generated)
+ endif()
+
  add_library(test_lib_32
  "${CMAKE_CURRENT_BINARY_DIR}/32/test_lib.c"
  )

src/ExtraRegisters.cc

@@ -66,17 +66,59 @@ static bool reg_in_range(GdbServerRegister regno, GdbServerRegister low, GdbServ
  return true;
 }
 
-static const int AVX_FEATURE_BIT = 2;
-static const int PKRU_FEATURE_BIT = 9;
+static constexpr int AVX_FEATURE_BIT = 2;
+static constexpr int AVX_OPMASK_FEATURE_BIT = 5;
+static constexpr int AVX_ZMM_HI256_FEATURE_BIT = 6;
+static constexpr int AVX_ZMM_HI16_FEATURE_BIT = 7;
+static constexpr int PKRU_FEATURE_BIT = 9;
 
 static const uint64_t PKRU_FEATURE_MASK = 1 << PKRU_FEATURE_BIT;
 
 static const size_t xsave_header_offset = 512;
 static const size_t xsave_header_size = 64;
 static const size_t xsave_header_end = xsave_header_offset + xsave_header_size;
-// This is always at 576 since AVX is always the first optional feature,
-// if present.
-static const size_t AVX_xsave_offset = 576;
+struct RegisterConfig {
+ int8_t feature;
+ GdbServerRegister base;
+ int8_t size;
+ int stride;
+
+ int register_offset(GdbServerRegister reg, int base_offset) const noexcept {
+ const auto& layout = xsave_native_layout();
+ return layout.feature_layouts[feature].offset + base_offset + (reg - base) * stride;
+ }
+};
+
+static constexpr std::array<RegisterConfig, 6> RegisterConfigLookupTable{
+ { { AVX_FEATURE_BIT, DREG_64_YMM0H, 16, 16 },
+ { AVX_ZMM_HI16_FEATURE_BIT, DREG_64_XMM16, 16, 64 },
+ { AVX_ZMM_HI16_FEATURE_BIT, DREG_64_YMM16H, 16, 64 },
+ { AVX_ZMM_HI256_FEATURE_BIT, DREG_64_ZMM0H, 32, 32 },
+ { AVX_ZMM_HI16_FEATURE_BIT, DREG_64_ZMM16H, 32, 64 },
+ { AVX_OPMASK_FEATURE_BIT, DREG_64_K0, 8, 8 } }
+};
+
+static constexpr auto YMM16_31 = 0b10;
+static constexpr auto ZMM16_31 = 0b100;
+
+// Every range of registers (except K0-7) are 16 registers long. We use this fact to build
+// a lookup table, for the AVX2 and AVX512 registers.
+static bool reg_is_avx2_or_512(GdbServerRegister reg, RegData& out) noexcept {
+ if(reg < DREG_64_YMM0H || reg > DREG_64_K7) {
+ return false;
+ }
+
+ const auto selector = (reg - DREG_64_YMM0H) >> 4;
+ DEBUG_ASSERT(selector >= 0 && selector <= 5 && "GdbServerRegister enum values has been changed.");
+ const auto cfg = RegisterConfigLookupTable[selector];
+ out.xsave_feature_bit = cfg.feature;
+ out.size = cfg.size;
+
+ // only YMM16-31 and ZMM16-31 have a base offset (16 and 32 respectively)
+ const auto base_offset = cfg.size * (selector == YMM16_31) | cfg.size * (selector == ZMM16_31);
+ out.offset = cfg.register_offset(reg, base_offset);
+ return true;
+}
 
 // Return the size and data location of register |regno|.
 // If we can't read the register, returns -1 in 'offset'.
@@ -95,6 +137,14 @@ static RegData xsave_register_data(SupportedArch arch, GdbServerRegister regno)
  regno = (GdbServerRegister)(regno - DREG_YMM0H + DREG_64_YMM0H);
  break;
  }
+ if(regno >= DREG_ZMM0H && regno <= DREG_ZMM7H) {
+ regno = (GdbServerRegister)(regno - DREG_ZMM0H + DREG_64_ZMM0H);
+ break;
+ }
+ if(regno >= DREG_K0 && regno <= DREG_K7) {
+ regno = (GdbServerRegister)(regno - DREG_K0 + DREG_64_K0);
+ break;
+ }
  if (regno == DREG_MXCSR) {
  regno = DREG_64_MXCSR;
  } else if (regno == DREG_PKRU) {
@@ -123,9 +173,7 @@ static RegData xsave_register_data(SupportedArch arch, GdbServerRegister regno)
  return result;
  }
 
- if (reg_in_range(regno, DREG_64_YMM0H, DREG_64_YMM15H, AVX_xsave_offset, 16,
- 16, &result)) {
- result.xsave_feature_bit = AVX_FEATURE_BIT;
+ if(reg_is_avx2_or_512(regno, result)) {
  return result;
  }
 

src/GdbServer.cc

@@ -186,26 +186,9 @@ static void maybe_singlestep_for_event(Task* t, GdbRequest* req) {
 
 void GdbServer::dispatch_regs_request(const Registers& regs,
  const ExtraRegisters& extra_regs) {
- GdbServerRegister end;
- // Send values for all the registers we sent XML register descriptions for.
- // Those descriptions are controlled by GdbServerConnection::cpu_features().
- bool have_PKU = dbg->cpu_features() & GdbServerConnection::CPU_PKU;
- bool have_AVX = dbg->cpu_features() & GdbServerConnection::CPU_AVX;
- switch (regs.arch()) {
- case x86:
- end = have_PKU ? DREG_PKRU : (have_AVX ? DREG_YMM7H : DREG_ORIG_EAX);
- break;
- case x86_64:
- end = have_PKU ? DREG_64_PKRU : (have_AVX ? DREG_64_YMM15H : DREG_GS_BASE);
- break;
- case aarch64:
- end = DREG_FPCR;
- break;
- default:
- FATAL() << "Unknown architecture";
- return;
- }
+ const GdbServerRegister end = arch_reg_end(regs.arch());
  vector<GdbServerRegisterValue> rs;
+ rs.reserve(end);
  for (GdbServerRegister r = GdbServerRegister(0); r <= end; r = GdbServerRegister(r + 1)) {
  rs.push_back(get_reg(regs, extra_regs, r));
  }
@@ -2306,6 +2289,49 @@ void GdbServer::read_back_debugger_mem(DiversionSession& session) {
  }
 }
 
+GdbServerRegister GdbServer::arch_reg_end(SupportedArch arch) noexcept {
+ if(target_regs_end != GdbServerRegister(0)) {
+ return target_regs_end;
+ }
+
+ // Send values for all the registers we sent XML register descriptions for.
+ // Those descriptions are controlled by GdbServerConnection::cpu_features().
+ bool have_PKU = dbg->cpu_features() & GdbServerConnection::CPU_PKU;
+ bool have_AVX = dbg->cpu_features() & GdbServerConnection::CPU_AVX;
+ bool have_AVX512 = dbg->cpu_features() & GdbServerConnection::CPU_AVX512;
+ switch (arch) {
+ case x86:
+ if(have_PKU) {
+ target_regs_end = DREG_PKRU;
+ } else if(have_AVX512) {
+ target_regs_end = DREG_K7;
+ } else if(have_AVX) {
+ target_regs_end = DREG_YMM7H;
+ } else {
+ target_regs_end = DREG_ORIG_EAX;
+ }
+ break;
+ case x86_64:
+ if(have_PKU) {
+ target_regs_end = DREG_64_PKRU;
+ } else if(have_AVX512) {
+ target_regs_end = DREG_64_K7;
+ } else if(have_AVX) {
+ target_regs_end = DREG_64_YMM15H;
+ } else {
+ target_regs_end = DREG_GS_BASE;
+ }
+ break;
+ case aarch64:
+ target_regs_end = DREG_FPCR;
+ break;
+ default:
+ FATAL() << "Unknown architecture";
+ return target_regs_end;
+ }
+ return target_regs_end;
+}
+
 bool GdbServer::debugger_mem_region(ThreadGroupUid tguid, remote_ptr<void> addr,
  int* prot, MemoryRange* mem_range) {
  auto it = debugger_mem.find(tguid);

src/GdbServer.h

@@ -223,6 +223,9 @@ class GdbServer {
  // Read back the contents of all debugger memory regions from the session.
  void read_back_debugger_mem(DiversionSession& session);
 
+ // Get the last GdbServerRegister for "this" arch. If it hasn't be determined, configure it.
+ GdbServerRegister arch_reg_end(SupportedArch arch) noexcept;
+
  // dbg is never null.
  std::unique_ptr<GdbServerConnection> dbg;
  // The ThreadGroupUid of the task being debugged.
@@ -315,6 +318,8 @@ class GdbServer {
  ExtraRegisters extra_regs;
  };
  std::unordered_map<int, SavedRegisters> saved_register_states;
+
+ GdbServerRegister target_regs_end = GdbServerRegister(0);
 };
 
 } // namespace rr

src/GdbServerConnection.cc

@@ -83,10 +83,14 @@ static uint32_t get_cpu_features(SupportedArch arch) {
  auto cpuid_data = cpuid(CPUID_GETEXTENDEDFEATURES, 0);
  if ((cpuid_data.ecx & PKU_FEATURE_FLAG) == PKU_FEATURE_FLAG) {
  // PKU (Skylake) implies AVX (Sandy Bridge).
- cpu_features |= GdbServerConnection::CPU_AVX | GdbServerConnection::CPU_PKU;
+ cpu_features |= GdbServerConnection::CPU_AVX | GdbServerConnection::CPU_AVX512 | GdbServerConnection::CPU_PKU;
  break;
  }
 
+ if((cpuid_data.ebx & AVX_512_FOUNDATION_FLAG) == AVX_512_FOUNDATION_FLAG) {
+ cpu_features |= GdbServerConnection::CPU_AVX512 | GdbServerConnection::CPU_AVX;
+ }
+
  cpuid_data = cpuid(CPUID_GETFEATURES, 0);
  // We're assuming here that AVX support on the system making the recording
  // is the same as the AVX support during replay. But if that's not true,
@@ -512,11 +516,15 @@ static const char* target_description_name(uint32_t cpu_features) {
  return "amd64-linux.xml";
  case GdbServerConnection::CPU_AVX:
  return "i386-avx-linux.xml";
+ case GdbServerConnection::CPU_AVX | GdbServerConnection::CPU_AVX512:
+ return "i386-avx512-linux.xml";
  case GdbServerConnection::CPU_X86_64 | GdbServerConnection::CPU_AVX:
  return "amd64-avx-linux.xml";
- case GdbServerConnection::CPU_PKU | GdbServerConnection::CPU_AVX:
+ case GdbServerConnection::CPU_X86_64 | GdbServerConnection::CPU_AVX | GdbServerConnection::CPU_AVX512:
+ return "amd64-avx512-linux.xml";
+ case GdbServerConnection::CPU_PKU | GdbServerConnection::CPU_AVX | GdbServerConnection::CPU_AVX512:
  return "i386-pkeys-linux.xml";
- case GdbServerConnection::CPU_X86_64 | GdbServerConnection::CPU_PKU | GdbServerConnection::CPU_AVX:
+ case GdbServerConnection::CPU_X86_64 | GdbServerConnection::CPU_PKU | GdbServerConnection::CPU_AVX | GdbServerConnection::CPU_AVX512:
  return "amd64-pkeys-linux.xml";
  case GdbServerConnection::CPU_AARCH64:
  return "aarch64-core.xml";

src/GdbServerConnection.h

@@ -745,11 +745,13 @@ class GdbServerConnection {
  const Features& features() { return features_; }
 
  enum {
- CPU_X86_64 = 0x1,
- CPU_AVX = 0x2,
- CPU_AARCH64 = 0x4,
- CPU_PKU = 0x8
+ CPU_X86_64 = 1 << 0,
+ CPU_AVX = 1 << 1,
+ CPU_AARCH64 = 1 << 2,
+ CPU_PKU = 1 << 3,
+ CPU_AVX512 = 1 << 4
  };
+
  void set_cpu_features(uint32_t features) { cpu_features_ = features; }
  uint32_t cpu_features() const { return cpu_features_; }