Rely on a generic arch.h file instead of x86-64

Summary: Previously many different files were relying on x86-64 internals. Instead, rely on an arch.h file that imports the platform-specific internals necessary. Each file is responsible for implementing the same interface.

Reviewed By: alexmalyshev

Differential Revision: D86322928

fbshipit-source-id: 8e6ba2b7a0325284d3fab8c6a7583ec4425c72e0

Author: kddnewton

cinderx/Jit/codegen/arch.cpp

@@ -0,0 +1,11 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+#include "cinderx/Jit/codegen/arch.h"
+
+namespace jit::codegen {
+
+std::ostream& operator<<(std::ostream& out, const PhyLocation& loc) {
+  return out << loc.toString();
+}
+
+} // namespace jit::codegen

cinderx/Jit/codegen/arch.h

@@ -2,10 +2,16 @@
 
 #pragma once
 
+#include "cinderx/Jit/codegen/arch/detection.h"
+#include "fmt/ostream.h"
+
 #include <asmjit/asmjit.h>
 
-#if defined(__x86_64__)
-#define CINDER_X86_64
+#include <iosfwd>
+
+#if defined(CINDER_X86_64)
+
+#include "cinderx/Jit/codegen/arch/x86_64.h"
 
 #include <asmjit/x86/x86builder.h>
 #include <asmjit/x86/x86emitter.h>
@@ -26,19 +32,28 @@ using EmitterExplicitT = asmjit::x86::EmitterExplicitT<T>;
 // If you change this register you'll also need to change the deopt
 // trampoline code that saves all registers.
 constexpr auto reg_scratch_deopt = asmjit::x86::r15;
-constexpr auto reg_general_return_64 = asmjit::x86::rax;
+constexpr auto reg_general_return_loc = RAX;
+constexpr auto reg_general_auxilary_return_loc = RDX;
+constexpr auto reg_double_return_loc = XMM0;
+constexpr auto reg_double_auxilary_return_loc = XMM1;
+constexpr auto reg_frame_pointer_loc = RBP;
+constexpr auto reg_stack_pointer_loc = RSP;
 
 } // namespace jit::codegen::arch
 
 #else
-// This macro is a marker for places that need platform-specific code.
-#define CINDER_UNSUPPORTED
+
+#include "cinderx/Jit/codegen/arch/unknown.h"
 
 namespace jit::codegen::arch {
 
 class Builder : public asmjit::BaseBuilder {
  public:
-  explicit Builder(asmjit::CodeHolder* code = nullptr) noexcept;
+  explicit Builder(asmjit::CodeHolder* code = nullptr) noexcept {
+    if (code) {
+      code->attach(this);
+    }
+  }
 };
 
 using Emitter = asmjit::BaseEmitter;
@@ -51,8 +66,37 @@ template <typename T>
 struct EmitterExplicitT {};
 
 constexpr auto reg_scratch_deopt = asmjit::BaseReg();
-constexpr auto reg_general_return_64 = asmjit::BaseReg();
+constexpr auto reg_general_return_loc = R0;
+constexpr auto reg_general_auxilary_return_loc = R1;
+constexpr auto reg_double_return_loc = D0;
+constexpr auto reg_double_auxilary_return_loc = D1;
+constexpr auto reg_frame_pointer_loc = R3;
+constexpr auto reg_stack_pointer_loc = SP;
 
 } // namespace jit::codegen::arch
 
 #endif
+
+namespace jit::codegen {
+
+std::ostream& operator<<(std::ostream& out, const PhyLocation& loc);
+
+} // namespace jit::codegen
+
+inline auto format_as(jit::codegen::RegId reg) {
+  return fmt::underlying(reg);
+}
+
+namespace std {
+
+template <>
+struct hash<jit::codegen::PhyLocation> {
+  std::size_t operator()(jit::codegen::PhyLocation const& s) const noexcept {
+    return s.loc;
+  }
+};
+
+} // namespace std
+
+template <>
+struct fmt::formatter<jit::codegen::PhyLocation> : fmt::ostream_formatter {};

cinderx/Jit/codegen/arch/detection.h

@@ -0,0 +1,16 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+#pragma once
+
+#if defined(__x86_64__)
+
+#define CINDER_X86_64
+
+#else
+
+#define CINDER_UNKNOWN
+
+// This macro is a marker for places that need platform-specific code.
+#define CINDER_UNSUPPORTED
+
+#endif

cinderx/Jit/codegen/arch/unknown.cpp

@@ -0,0 +1,41 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+#include "cinderx/Jit/codegen/arch/unknown.h"
+
+#include "cinderx/Jit/codegen/arch/detection.h"
+
+#ifdef CINDER_UNKNOWN
+
+namespace jit::codegen {
+
+PhyLocation PhyLocation::parse(std::string_view name) {
+#define FIND_GP_REG(V)                \
+  if (name == #V) {                   \
+    return PhyLocation{RegId::V, 64}; \
+  }
+
+#define FIND_VECD_REG(V)              \
+  if (name == #V) {                   \
+    return PhyLocation{RegId::V, 64}; \
+  }
+
+  FOREACH_GP(FIND_GP_REG)
+  FOREACH_VECD(FIND_VECD_REG)
+  if (name == "SP") {
+    return PhyLocation{SP, 64};
+  }
+#undef FIND_GP_REG
+#undef FIND_VECD_REG
+  JIT_ABORT("Unrecognized register {}", name);
+}
+
+std::string PhyLocation::toString() const {
+  if (is_memory()) {
+    return fmt::format("[FP({})]", loc);
+  }
+  return std::string{name(static_cast<RegId>(loc))};
+}
+
+} // namespace jit::codegen
+
+#endif

cinderx/Jit/codegen/arch/unknown.h

@@ -0,0 +1,236 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+#pragma once
+
+#include "cinderx/Common/log.h"
+#include "cinderx/Common/util.h"
+
+#include <fmt/format.h>
+
+#include <array>
+#include <string>
+#include <string_view>
+
+namespace jit::codegen {
+
+#define FOREACH_GP(X) \
+  X(R0)               \
+  X(R1)               \
+  X(R2)               \
+  X(R3)
+
+#define FOREACH_VECD(X) \
+  X(D0)                 \
+  X(D1)                 \
+  X(D2)                 \
+  X(D3)
+
+enum class RegId : uint32_t {
+#define DEFINE_REG(V) V,
+  FOREACH_GP(DEFINE_REG) FOREACH_VECD(DEFINE_REG)
+#undef DEFINE_REG
+      SP,
+};
+
+constexpr uint32_t raw(RegId id) {
+  return static_cast<uint32_t>(id);
+}
+
+#define COUNT_REGS(...) +1
+constexpr int NUM_GP_REGS = FOREACH_GP(COUNT_REGS);
+constexpr int VECD_REG_BASE = raw(RegId::D0);
+constexpr int NUM_VECD_REGS = FOREACH_VECD(COUNT_REGS);
+constexpr int NUM_REGS = NUM_GP_REGS + NUM_VECD_REGS;
+#undef COUNT_REGS
+
+constexpr std::string_view name(RegId id) {
+  switch (id) {
+#define STRING_REG(V) \
+  case RegId::V:      \
+    return #V;
+
+    FOREACH_GP(STRING_REG)
+    FOREACH_VECD(STRING_REG)
+    case RegId::SP:
+      return "SP";
+#undef STRING_REG
+    default:
+      JIT_ABORT("Unrecognized register ID {}", raw(id));
+  }
+}
+
+// A physical location (register or stack slot). If this represents a stack
+// slot (is_memory() is true) then `loc` is relative to R3.
+struct PhyLocation {
+  static constexpr int REG_INVALID = -1;
+
+#define DEFINE_REG(V) static constexpr int V = raw(RegId::V);
+  FOREACH_GP(DEFINE_REG)
+  FOREACH_VECD(DEFINE_REG)
+  static constexpr int SP = raw(RegId::SP);
+#undef DEFINE_REG
+
+  // Parse a register name and return the corresponding physical register.
+  // Return REG_INVALID if the name is not a valid register name.  Does not
+  // support parsing stack slots.
+  static PhyLocation parse(std::string_view name);
+
+  int32_t loc{REG_INVALID};
+  uint32_t bitSize{64};
+
+  PhyLocation() = default;
+
+  /* implicit */ constexpr PhyLocation(RegId reg, size_t size = 64)
+      : PhyLocation{static_cast<int>(reg), size} {}
+
+  /* implicit */ constexpr PhyLocation(RegId reg, int size)
+      : PhyLocation{static_cast<int>(reg), static_cast<size_t>(size)} {}
+
+  /* implicit */ constexpr PhyLocation(int loc, size_t size = 64)
+      : loc{loc}, bitSize{static_cast<uint32_t>(size)} {}
+
+  /* implicit */ constexpr PhyLocation(int loc, int size)
+      : PhyLocation{loc, static_cast<size_t>(size)} {}
+
+  bool is_memory() const {
+    return loc < 0;
+  }
+
+  bool is_register() const {
+    return loc >= 0;
+  }
+
+  bool is_gp_register() const {
+    return is_register() && loc < VECD_REG_BASE;
+  }
+
+  bool is_fp_register() const {
+    return is_register() && loc >= VECD_REG_BASE;
+  }
+
+  std::string toString() const;
+
+  bool operator==(const PhyLocation& rhs) const {
+    return loc == rhs.loc;
+  }
+
+  bool operator!=(const PhyLocation& rhs) const {
+    return loc != rhs.loc;
+  }
+};
+
+// Define global definitions like `R0` and `D0`.
+#define DEFINE_PHY_REG(V) constexpr PhyLocation V{RegId::V, 64};
+
+FOREACH_GP(DEFINE_PHY_REG)
+FOREACH_VECD(DEFINE_PHY_REG)
+constexpr PhyLocation SP{RegId::SP, 64};
+
+#undef DEFINE_PHY_GP_REG
+#undef DEFINE_PHY_VECD_REG
+
+class PhyRegisterSet {
+ public:
+  constexpr PhyRegisterSet() : rs_(0) {}
+  explicit constexpr PhyRegisterSet(PhyLocation r) : rs_(0) {
+    rs_ |= (1 << r.loc);
+  }
+
+  constexpr PhyRegisterSet operator|(PhyLocation reg) const {
+    PhyRegisterSet set;
+    set.rs_ = rs_ | (1 << reg.loc);
+    return set;
+  }
+
+  constexpr PhyRegisterSet operator|(const PhyRegisterSet& rs) const {
+    PhyRegisterSet res;
+    res.rs_ = rs_ | rs.rs_;
+    return res;
+  }
+
+  PhyRegisterSet& operator|=(const PhyRegisterSet& rs) {
+    rs_ |= rs.rs_;
+    return *this;
+  }
+
+  constexpr PhyRegisterSet operator-(PhyLocation rs) const {
+    return operator-(PhyRegisterSet(rs));
+  }
+
+  constexpr PhyRegisterSet operator-(PhyRegisterSet rs) const {
+    PhyRegisterSet set;
+    set.rs_ = rs_ & ~(rs.rs_);
+    return set;
+  }
+
+  constexpr PhyRegisterSet operator&(PhyRegisterSet rs) const {
+    PhyRegisterSet set;
+    set.rs_ = rs_ & rs.rs_;
+    return set;
+  }
+
+  constexpr bool operator==(const PhyRegisterSet& rs) const {
+    return rs_ == rs.rs_;
+  }
+
+  constexpr bool Empty() const {
+    return rs_ == 0ULL;
+  }
+
+  int count() const {
+    return popcount(rs_);
+  }
+
+  PhyLocation GetFirst() const {
+    return __builtin_ctz(rs_);
+  }
+
+  constexpr void RemoveFirst() {
+    rs_ &= (rs_ - 1);
+  }
+
+  void Set(PhyLocation reg) {
+    rs_ |= (1 << reg.loc);
+  }
+  void Reset(PhyLocation reg) {
+    rs_ &= ~(1 << reg.loc);
+  }
+  void ResetAll() {
+    rs_ = 0;
+  }
+
+  bool Has(PhyLocation reg) const {
+    return rs_ & (1 << reg.loc);
+  }
+
+ private:
+  uint32_t rs_;
+};
+
+#define ADD_REG(V) | PhyLocation::V
+constexpr PhyRegisterSet ALL_GP_REGISTERS =
+    PhyRegisterSet() FOREACH_GP(ADD_REG);
+constexpr PhyRegisterSet ALL_VECD_REGISTERS =
+    PhyRegisterSet() FOREACH_VECD(ADD_REG);
+constexpr PhyRegisterSet ALL_REGISTERS = ALL_GP_REGISTERS | ALL_VECD_REGISTERS;
+#undef ADD_REG
+
+constexpr PhyRegisterSet STACK_REGISTERS = PhyRegisterSet();
+constexpr PhyRegisterSet INIT_REGISTERS = ALL_REGISTERS - STACK_REGISTERS;
+constexpr PhyRegisterSet CALLEE_SAVE_REGS = PhyRegisterSet();
+constexpr PhyRegisterSet CALLER_SAVE_REGS = INIT_REGISTERS - CALLEE_SAVE_REGS;
+
+constexpr auto ARGUMENT_REGS = std::to_array({R0});
+constexpr auto RETURN_REGS = std::to_array({R0});
+constexpr auto FP_ARGUMENT_REGS = std::to_array({D0});
+
+// This is where the function prologue will initially store this data at entry
+// to the function body. The register allocator may move things around from
+// there.
+constexpr PhyLocation INITIAL_EXTRA_ARGS_REG = R1;
+constexpr PhyLocation INITIAL_TSTATE_REG = R2;
+constexpr PhyLocation INITIAL_INTERPRETER_FRAME_REG = R3;
+// This is often provided by the first argument in the vector call protocol.
+constexpr PhyLocation INITIAL_FUNC_REG = ARGUMENT_REGS[0];
+
+} // namespace jit::codegen