midasm.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstddef>
#include <string_view>
#include <tuple>
#include <type_traits>
 
#include <rex/memory/mapped_ptr.h>
#include <rex/ppc/context.h>
#include <rex/types.h>

#define REX_DETAIL_MIDASM_COUNT(...)                                                             \
  REX_DETAIL_MIDASM_PICK(__VA_ARGS__ __VA_OPT__(, ) 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22,  \
                         21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, \
                         1, 0)

#define REX_DETAIL_MIDASM_PICK(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, \
                               _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28,  \
                               _29, _30, _31, _32, count, ...)                                   \
  count

#define REX_DETAIL_MIDASM_UNPAREN(...) __VA_ARGS__

#define REX_DETAIL_MIDASM_EXPAND_PASTE(a, b) REX_DETAIL_MIDASM_PASTE(a, b)

#define REX_DETAIL_MIDASM_PASTE(a, b) a##b

#define REX_DETAIL_MIDASM_PARAM(body, index)                                               \
  rex::ppc::detail::MidAsmErasedT<rex::ppc::detail::MidAsmArg<decltype(&(body)), (index)>> \
      rex_arg##index

#define REX_DETAIL_MIDASM_ARG(body, index)                                                     \
  rex::ppc::detail::RestoreMidAsmArg<rex::ppc::detail::MidAsmArg<decltype(&(body)), (index)>>( \
      rex_arg##index)

#define REX_DETAIL_MIDASM_LIST_0(body, each)

#define REX_DETAIL_MIDASM_LIST_1(body, each) each(body, 0)

#define REX_DETAIL_MIDASM_LIST_2(body, each) REX_DETAIL_MIDASM_LIST_1(body, each), each(body, 1)

#define REX_DETAIL_MIDASM_LIST_3(body, each) REX_DETAIL_MIDASM_LIST_2(body, each), each(body, 2)

#define REX_DETAIL_MIDASM_LIST_4(body, each) REX_DETAIL_MIDASM_LIST_3(body, each), each(body, 3)

#define REX_DETAIL_MIDASM_LIST_5(body, each) REX_DETAIL_MIDASM_LIST_4(body, each), each(body, 4)

#define REX_DETAIL_MIDASM_LIST_6(body, each) REX_DETAIL_MIDASM_LIST_5(body, each), each(body, 5)

#define REX_DETAIL_MIDASM_LIST_7(body, each) REX_DETAIL_MIDASM_LIST_6(body, each), each(body, 6)

#define REX_DETAIL_MIDASM_LIST_8(body, each) REX_DETAIL_MIDASM_LIST_7(body, each), each(body, 7)

#define REX_DETAIL_MIDASM_LIST_9(body, each) REX_DETAIL_MIDASM_LIST_8(body, each), each(body, 8)

#define REX_DETAIL_MIDASM_LIST_10(body, each) REX_DETAIL_MIDASM_LIST_9(body, each), each(body, 9)

#define REX_DETAIL_MIDASM_LIST_11(body, each) REX_DETAIL_MIDASM_LIST_10(body, each), each(body, 10)

#define REX_DETAIL_MIDASM_LIST_12(body, each) REX_DETAIL_MIDASM_LIST_11(body, each), each(body, 11)

#define REX_DETAIL_MIDASM_LIST_13(body, each) REX_DETAIL_MIDASM_LIST_12(body, each), each(body, 12)

#define REX_DETAIL_MIDASM_LIST_14(body, each) REX_DETAIL_MIDASM_LIST_13(body, each), each(body, 13)

#define REX_DETAIL_MIDASM_LIST_15(body, each) REX_DETAIL_MIDASM_LIST_14(body, each), each(body, 14)

#define REX_DETAIL_MIDASM_LIST_16(body, each) REX_DETAIL_MIDASM_LIST_15(body, each), each(body, 15)

#define REX_DETAIL_MIDASM_LIST_17(body, each) REX_DETAIL_MIDASM_LIST_16(body, each), each(body, 16)

#define REX_DETAIL_MIDASM_LIST_18(body, each) REX_DETAIL_MIDASM_LIST_17(body, each), each(body, 17)

#define REX_DETAIL_MIDASM_LIST_19(body, each) REX_DETAIL_MIDASM_LIST_18(body, each), each(body, 18)

#define REX_DETAIL_MIDASM_LIST_20(body, each) REX_DETAIL_MIDASM_LIST_19(body, each), each(body, 19)

#define REX_DETAIL_MIDASM_LIST_21(body, each) REX_DETAIL_MIDASM_LIST_20(body, each), each(body, 20)

#define REX_DETAIL_MIDASM_LIST_22(body, each) REX_DETAIL_MIDASM_LIST_21(body, each), each(body, 21)

#define REX_DETAIL_MIDASM_LIST_23(body, each) REX_DETAIL_MIDASM_LIST_22(body, each), each(body, 22)

#define REX_DETAIL_MIDASM_LIST_24(body, each) REX_DETAIL_MIDASM_LIST_23(body, each), each(body, 23)

#define REX_DETAIL_MIDASM_LIST_25(body, each) REX_DETAIL_MIDASM_LIST_24(body, each), each(body, 24)

#define REX_DETAIL_MIDASM_LIST_26(body, each) REX_DETAIL_MIDASM_LIST_25(body, each), each(body, 25)

#define REX_DETAIL_MIDASM_LIST_27(body, each) REX_DETAIL_MIDASM_LIST_26(body, each), each(body, 26)

#define REX_DETAIL_MIDASM_LIST_28(body, each) REX_DETAIL_MIDASM_LIST_27(body, each), each(body, 27)

#define REX_DETAIL_MIDASM_LIST_29(body, each) REX_DETAIL_MIDASM_LIST_28(body, each), each(body, 28)

#define REX_DETAIL_MIDASM_LIST_30(body, each) REX_DETAIL_MIDASM_LIST_29(body, each), each(body, 29)

#define REX_DETAIL_MIDASM_LIST_31(body, each) REX_DETAIL_MIDASM_LIST_30(body, each), each(body, 30)

#define REX_DETAIL_MIDASM_LIST_32(body, each) REX_DETAIL_MIDASM_LIST_31(body, each), each(body, 31)

// NOLINTBEGIN(bugprone-macro-parentheses): ret declares a function
#define REX_DETAIL_MIDASM_ENTRY(ret, name, params)                                           \
  extern "C" ret name(REX_DETAIL_MIDASM_EXPAND_PASTE(                                        \
      REX_DETAIL_MIDASM_LIST_, REX_DETAIL_MIDASM_COUNT(REX_DETAIL_MIDASM_UNPAREN params))(   \
      name##_rex_body, REX_DETAIL_MIDASM_PARAM)) {                                           \
    return name##_rex_body(REX_DETAIL_MIDASM_EXPAND_PASTE(                                   \
        REX_DETAIL_MIDASM_LIST_, REX_DETAIL_MIDASM_COUNT(REX_DETAIL_MIDASM_UNPAREN params))( \
        name##_rex_body, REX_DETAIL_MIDASM_ARG));                                            \
  }
// NOLINTEND(bugprone-macro-parentheses)
 
namespace rex::ppc::detail {
 
enum class MidAsmType : u8 {
  kHook,     
  kBranch,   
  kReturnIf, 
};
 
enum class MidAsmParam : u8 {
  kInvalid, 
  kU32,     
  kU64,     
  kF64,     
  kVector,
  kVectorRef,
  kPointer,       
  kMappedPointer, 
  kRegister,
  kCR,
  kXER,
  kFPSCR,
  kContext,
};
 
enum class MidAsmRegisterType : u8 {
  kInvalid, 
  kGPR,     
  kFPR,     
  kVR,      
  kCR,      
  kCTR,
  kXER,
  kFPSCR,
  kReserved,
  kContext,
};
 
enum class MidAsmAtResult : u8 {
  kOk,
  kBadPlacement,     
  kUnexpectedTarget, 
  kMissingTarget,
  kBadTarget,   
  kBadRegister, 
  kCountMismatch,
  kTypeMismatch,
};
 
inline constexpr size_t kMaxMidAsmParams = 32;
 
struct MidAsmBody {
  MidAsmType type;
  size_t count;
  std::array<MidAsmParam, kMaxMidAsmParams> params;
};

template <typename T>
constexpr MidAsmParam ClassifyMidAsmParam() {
  if constexpr (!std::is_reference_v<T>) {
    if constexpr (std::is_same_v<T, u32>) {
      return MidAsmParam::kU32;
    } else if constexpr (std::is_same_v<T, u64>) {
      return MidAsmParam::kU64;
    } else if constexpr (std::is_same_v<T, f64>) {
      return MidAsmParam::kF64;
    } else if constexpr (std::is_same_v<T, PPCVRegister>) {
      return MidAsmParam::kVector;
    } else if constexpr (std::is_pointer_v<T> && !std::is_function_v<std::remove_pointer_t<T>>) {
      return MidAsmParam::kPointer;
    } else if constexpr (memory::is_mapped_ptr_v<T>) {
      return MidAsmParam::kMappedPointer;
    } else {
      return MidAsmParam::kInvalid;
    }
  } else if constexpr (std::is_lvalue_reference_v<T> &&
                       !std::is_const_v<std::remove_reference_t<T>>) {
    using Bare = std::remove_reference_t<T>;
    if constexpr (std::is_same_v<Bare, PPCRegister>) {
      return MidAsmParam::kRegister;
    } else if constexpr (std::is_same_v<Bare, PPCVRegister>) {
      return MidAsmParam::kVectorRef;
    } else if constexpr (std::is_same_v<Bare, PPCCRRegister>) {
      return MidAsmParam::kCR;
    } else if constexpr (std::is_same_v<Bare, PPCXERRegister>) {
      return MidAsmParam::kXER;
    } else if constexpr (std::is_same_v<Bare, PPCFPSCRRegister>) {
      return MidAsmParam::kFPSCR;
    } else if constexpr (std::is_same_v<Bare, PPCContext>) {
      return MidAsmParam::kContext;
    } else {
      return MidAsmParam::kInvalid;
    }
  } else {
    return MidAsmParam::kInvalid;
  }
}

template <typename F>
struct MidAsmParams;
 
template <typename R, typename... A>
struct MidAsmParams<R (*)(A...)> {
  static constexpr size_t kCount = sizeof...(A);
  using Types = std::tuple<A...>;
  static constexpr std::array<MidAsmParam, sizeof...(A)> kTypes = {ClassifyMidAsmParam<A>()...};
};
 
template <typename F, size_t I>
using MidAsmArg = std::tuple_element_t<I, typename MidAsmParams<F>::Types>;

template <typename T>
struct MidAsmErased {
  using Type = T;
};

template <typename T>
struct MidAsmErased<T*> {
  using Type = void*;
};

template <typename T>
struct MidAsmErased<memory::MappedPtr<T>> {
  using Type = memory::MappedPtr<u8>;
};

template <typename T>
using MidAsmErasedT = MidAsmErased<T>::Type;

template <typename T>
constexpr T RestoreMidAsmArg(MidAsmErasedT<T> value) {
  if constexpr (std::is_pointer_v<T>) {
    return static_cast<T>(value);
  } else if constexpr (memory::is_mapped_ptr_v<T>) {
    return T(reinterpret_cast<memory::MappedPtrInnerType<T>::type*>(value.GetHostPtr()),
             value.GetGuestAddress());
  } else {
    return value;
  }
}

template <typename F>
constexpr MidAsmBody MakeMidAsmBody(MidAsmType type) {
  using Traits = MidAsmParams<F>;
  static_assert(Traits::kCount <= kMaxMidAsmParams, "A mid asm body takes at most 32 parameters");
  MidAsmBody body{type, Traits::kCount, {}};
  for (size_t index = 0; index < Traits::kCount; ++index) {
    body.params[index] = Traits::kTypes[index];
  }
  return body;
}

constexpr bool IsMidAsmBodyValid(const MidAsmBody& body) {
  for (size_t index = 0; index < body.count; ++index) {
    if (body.params[index] == MidAsmParam::kInvalid) {
      return false;
    }
  }
  return true;
}

constexpr bool ParseMidAsmIndex(std::string_view text, u32 limit, u32& value) {
  if (text.empty() || text.size() > 3 || (text.size() > 1 && text[0] == '0')) {
    return false;
  }
  u32 result = 0;
  for (const char digit : text) {
    if (digit < '0' || digit > '9') {
      return false;
    }
    result = result * 10 + static_cast<u32>(digit - '0');
  }
  if (result > limit) {
    return false;
  }
  value = result;
  return true;
}

constexpr bool ParseMidAsmAddress(std::string_view text, u32& value) {
  while (!text.empty() &&
         (text.back() == 'u' || text.back() == 'U' || text.back() == 'l' || text.back() == 'L')) {
    text.remove_suffix(1);
  }
  if (text.empty()) {
    return false;
  }
  u64 result = 0;
  size_t index = 0;
  u32 radix = 10;
  if (text.size() > 2 && text[0] == '0' && (text[1] == 'x' || text[1] == 'X')) {
    radix = 16;
    index = 2;
  } else if (text.size() > 2 && text[0] == '0' && (text[1] == 'b' || text[1] == 'B')) {
    radix = 2;
    index = 2;
  } else if (text.size() > 1 && text[0] == '0') {
    radix = 8;
    index = 1;
  }
  bool digits = false;
  for (; index < text.size(); ++index) {
    const char digit = text[index];
    u32 digit_value = 0;
    if (digit == '\'' && digits && index + 1 < text.size()) {
      continue;
    }
    if (digit >= '0' && digit <= '9') {
      digit_value = static_cast<u32>(digit - '0');
    } else if (radix == 16 && digit >= 'a' && digit <= 'f') {
      digit_value = static_cast<u32>(digit - 'a') + 10;
    } else if (radix == 16 && digit >= 'A' && digit <= 'F') {
      digit_value = static_cast<u32>(digit - 'A') + 10;
    } else {
      return false;
    }
    if (digit_value >= radix) {
      return false;
    }
    digits = true;
    result = result * radix + digit_value;
    if (result > 0xFFFFFFFFull) {
      return false;
    }
  }
  if (!digits) {
    return false;
  }
  value = static_cast<u32>(result);
  return true;
}

constexpr bool IsMidAsmAddress(u64 address) {
  return address != 0 && address % 4 == 0 && address <= 0xFFFFFFFFull;
}
 
constexpr std::string_view TrimMidAsmToken(std::string_view text) {
  while (!text.empty() && (text.front() == ' ' || text.front() == '\t' || text.front() == '\n' ||
                           text.front() == '\r')) {
    text.remove_prefix(1);
  }
  while (!text.empty() && (text.back() == ' ' || text.back() == '\t' || text.back() == '\n' ||
                           text.back() == '\r')) {
    text.remove_suffix(1);
  }
  return text;
}

constexpr MidAsmRegisterType ParseMidAsmRegister(std::string_view token) {
  u32 index = 0;
  if (token == "ctx") {
    return MidAsmRegisterType::kContext;
  }
  if (token == "ctr") {
    return MidAsmRegisterType::kCTR;
  }
  if (token == "xer") {
    return MidAsmRegisterType::kXER;
  }
  if (token == "fpscr") {
    return MidAsmRegisterType::kFPSCR;
  }
  if (token == "reserved") {
    return MidAsmRegisterType::kReserved;
  }
  if (token.starts_with("cr")) {
    return ParseMidAsmIndex(token.substr(2), 7, index) ? MidAsmRegisterType::kCR
                                                       : MidAsmRegisterType::kInvalid;
  }
  if (token.starts_with("r")) {
    return ParseMidAsmIndex(token.substr(1), 31, index) && index != 1
               ? MidAsmRegisterType::kGPR
               : MidAsmRegisterType::kInvalid;
  }
  if (token.starts_with("f")) {
    return ParseMidAsmIndex(token.substr(1), 31, index) ? MidAsmRegisterType::kFPR
                                                        : MidAsmRegisterType::kInvalid;
  }
  if (token.starts_with("v")) {
    return ParseMidAsmIndex(token.substr(1), 127, index) ? MidAsmRegisterType::kVR
                                                         : MidAsmRegisterType::kInvalid;
  }
  return MidAsmRegisterType::kInvalid;
}

constexpr bool IsMidAsmRegisterFit(MidAsmRegisterType reg, MidAsmParam param) {
  switch (reg) {
    case MidAsmRegisterType::kGPR:
      return param == MidAsmParam::kU32 || param == MidAsmParam::kU64 ||
             param == MidAsmParam::kRegister || param == MidAsmParam::kPointer ||
             param == MidAsmParam::kMappedPointer;
    case MidAsmRegisterType::kFPR:
      return param == MidAsmParam::kF64 || param == MidAsmParam::kRegister;
    case MidAsmRegisterType::kVR:
      return param == MidAsmParam::kVector || param == MidAsmParam::kVectorRef;
    case MidAsmRegisterType::kCR:
      return param == MidAsmParam::kCR;
    case MidAsmRegisterType::kCTR:
    case MidAsmRegisterType::kReserved:
      return param == MidAsmParam::kRegister;
    case MidAsmRegisterType::kXER:
      return param == MidAsmParam::kXER;
    case MidAsmRegisterType::kFPSCR:
      return param == MidAsmParam::kFPSCR;
    case MidAsmRegisterType::kContext:
      return param == MidAsmParam::kContext;
    case MidAsmRegisterType::kInvalid:
      return false;
  }
  return false;
}

constexpr MidAsmAtResult CheckMidAsmAt(const MidAsmBody& body, std::string_view placement,
                                       std::string_view arguments) {
  if (TrimMidAsmToken(placement) != "before" && TrimMidAsmToken(placement) != "after") {
    return MidAsmAtResult::kBadPlacement;
  }
  std::string_view rest = TrimMidAsmToken(arguments);
  const bool has_arguments = !rest.empty();
  size_t registers = 0;
  bool first = true;
  while (has_arguments) {
    const size_t comma = rest.find(',');
    const std::string_view token = TrimMidAsmToken(rest.substr(0, comma));
    const bool is_number = !token.empty() && token[0] >= '0' && token[0] <= '9';
    if (first && body.type == MidAsmType::kBranch) {
      if (!is_number) {
        return MidAsmAtResult::kMissingTarget;
      }
      u32 target = 0;
      if (!ParseMidAsmAddress(token, target) || !IsMidAsmAddress(target)) {
        return MidAsmAtResult::kBadTarget;
      }
    } else if (first && is_number) {
      return MidAsmAtResult::kUnexpectedTarget;
    } else {
      const MidAsmRegisterType type = ParseMidAsmRegister(token);
      if (type == MidAsmRegisterType::kInvalid) {
        return MidAsmAtResult::kBadRegister;
      }
      if (registers < body.count && !IsMidAsmRegisterFit(type, body.params[registers])) {
        return MidAsmAtResult::kTypeMismatch;
      }
      ++registers;
    }
    first = false;
    if (comma == std::string_view::npos) {
      break;
    }
    rest.remove_prefix(comma + 1);
  }
  if (body.type == MidAsmType::kBranch && first) {
    return MidAsmAtResult::kMissingTarget;
  }
  if (registers != body.count) {
    return MidAsmAtResult::kCountMismatch;
  }
  return MidAsmAtResult::kOk;
}
 
}  // namespace rex::ppc::detail

// NOLINTBEGIN(bugprone-macro-parentheses): ret and params declare a function
#define REX_DETAIL_MIDASM_BODY(type, ret, name, params)                                      \
  static ret name##_rex_body params;                                                         \
  inline constexpr rex::ppc::detail::MidAsmBody name##_rex_midasm =                          \
      rex::ppc::detail::MakeMidAsmBody<decltype(&name##_rex_body)>(                          \
          rex::ppc::detail::MidAsmType::type);                                               \
  static_assert(rex::ppc::detail::IsMidAsmBodyValid(name##_rex_midasm),                      \
                "A mid asm body takes u32, u64, f64, PPCVRegister, a pointer, a MappedPtr, " \
                "or a non const reference to a register type or PPCContext");                \
  REX_DETAIL_MIDASM_ENTRY(ret, name, params)                                                 \
  static ret name##_rex_body params
// NOLINTEND(bugprone-macro-parentheses)

#define REX_MIDASM_HOOK(name, params) REX_DETAIL_MIDASM_BODY(kHook, void, name, params)

#define REX_MIDASM_BRANCH(name, params) REX_DETAIL_MIDASM_BODY(kBranch, bool, name, params)

#define REX_MIDASM_RETURN_IF(name, params) REX_DETAIL_MIDASM_BODY(kReturnIf, bool, name, params)

#define REX_DETAIL_MIDASM_AT_CHECK(name, placement, arguments, code, text)                  \
  static_assert(rex::ppc::detail::CheckMidAsmAt(name##_rex_midasm, placement, arguments) != \
                    rex::ppc::detail::MidAsmAtResult::code,                                 \
                text)

#define REX_MIDASM_AT(name, address, placement, ...)                                           \
  static_assert(rex::ppc::detail::IsMidAsmAddress(address),                                    \
                "REX_MIDASM_AT address must be a nonzero multiple of 4");                      \
  REX_DETAIL_MIDASM_AT_CHECK(name, #placement, #__VA_ARGS__, kBadPlacement,                    \
                             "REX_MIDASM_AT placement must be before or after");               \
  REX_DETAIL_MIDASM_AT_CHECK(name, #placement, #__VA_ARGS__, kUnexpectedTarget,                \
                             "REX_MIDASM_AT takes a target only for a branch body");           \
  REX_DETAIL_MIDASM_AT_CHECK(name, #placement, #__VA_ARGS__, kMissingTarget,                   \
                             "REX_MIDASM_AT needs the target of a branch body first");         \
  REX_DETAIL_MIDASM_AT_CHECK(name, #placement, #__VA_ARGS__, kBadTarget,                       \
                             "REX_MIDASM_AT target must be a nonzero multiple of 4");          \
  REX_DETAIL_MIDASM_AT_CHECK(name, #placement, #__VA_ARGS__, kBadRegister,                     \
                             "REX_MIDASM_AT register must be r0 to r31 except r1, f0 to f31, " \
                             "v0 to v127, cr0 to cr7, ctr, xer, fpscr, reserved or ctx");      \
  REX_DETAIL_MIDASM_AT_CHECK(name, #placement, #__VA_ARGS__, kCountMismatch,                   \
                             "REX_MIDASM_AT register count must equal the body parameters");   \
  REX_DETAIL_MIDASM_AT_CHECK(name, #placement, #__VA_ARGS__, kTypeMismatch,                    \
                             "REX_MIDASM_AT register type does not fit its parameter")