asmjit 0.2.0 → 0.2.1

data/ext/asmjit/asmjit/src/asmjit/core/codewriter.cpp

@@ -0,0 +1,175 @@
+// This file is part of AsmJit project <https://asmjit.com>
+//
+// See asmjit.h or LICENSE.md for license and copyright information
+// SPDX-License-Identifier: Zlib
+
+#include "../core/api-build_p.h"
+#include "../core/codeholder.h"
+#include "../core/codewriter_p.h"
+
+ASMJIT_BEGIN_NAMESPACE
+
+bool CodeWriterUtils::encodeOffset32(uint32_t* dst, int64_t offset64, const OffsetFormat& format) noexcept {
+  uint32_t bitCount = format.immBitCount();
+  uint32_t bitShift = format.immBitShift();
+  uint32_t discardLsb = format.immDiscardLsb();
+
+  // Invalid offset (should not happen).
+  if (!bitCount || bitCount > format.valueSize() * 8u)
+    return false;
+
+  uint32_t value;
+
+  // First handle all unsigned offset types.
+  if (format.type() == OffsetType::kUnsignedOffset) {
+    if (discardLsb) {
+      ASMJIT_ASSERT(discardLsb <= 32);
+      if ((offset64 & Support::lsbMask<uint32_t>(discardLsb)) != 0)
+        return false;
+      offset64 = int64_t(uint64_t(offset64) >> discardLsb);
+    }
+
+    value = uint32_t(offset64 & Support::lsbMask<uint32_t>(bitCount));
+    if (value != offset64)
+      return false;
+  }
+  else {
+    // The rest of OffsetType options are all signed.
+    if (discardLsb) {
+      ASMJIT_ASSERT(discardLsb <= 32);
+      if ((offset64 & Support::lsbMask<uint32_t>(discardLsb)) != 0)
+        return false;
+      offset64 >>= discardLsb;
+    }
+
+    if (!Support::isInt32(offset64))
+      return false;
+
+    value = uint32_t(int32_t(offset64));
+    if (!Support::isEncodableOffset32(int32_t(value), bitCount))
+      return false;
+  }
+
+  switch (format.type()) {
+    case OffsetType::kSignedOffset:
+    case OffsetType::kUnsignedOffset: {
+      *dst = (value & Support::lsbMask<uint32_t>(bitCount)) << bitShift;
+      return true;
+    }
+
+    case OffsetType::kAArch64_ADR:
+    case OffsetType::kAArch64_ADRP: {
+      // Sanity checks.
+      if (format.valueSize() != 4 || bitCount != 21 || bitShift != 5)
+        return false;
+
+      uint32_t immLo = value & 0x3u;
+      uint32_t immHi = (value >> 2) & Support::lsbMask<uint32_t>(19);
+
+      *dst = (immLo << 29) | (immHi << 5);
+      return true;
+    }
+
+    default:
+      return false;
+  }
+}
+
+bool CodeWriterUtils::encodeOffset64(uint64_t* dst, int64_t offset64, const OffsetFormat& format) noexcept {
+  uint32_t bitCount = format.immBitCount();
+  uint32_t discardLsb = format.immDiscardLsb();
+
+  if (!bitCount || bitCount > format.valueSize() * 8u)
+    return false;
+
+  uint64_t value;
+
+  // First handle all unsigned offset types.
+  if (format.type() == OffsetType::kUnsignedOffset) {
+    if (discardLsb) {
+      ASMJIT_ASSERT(discardLsb <= 32);
+      if ((offset64 & Support::lsbMask<uint32_t>(discardLsb)) != 0)
+        return false;
+      offset64 = int64_t(uint64_t(offset64) >> discardLsb);
+    }
+
+    value = uint64_t(offset64) & Support::lsbMask<uint64_t>(bitCount);
+    if (value != uint64_t(offset64))
+      return false;
+  }
+  else {
+    // The rest of OffsetType options are all signed.
+    if (discardLsb) {
+      ASMJIT_ASSERT(discardLsb <= 32);
+      if ((offset64 & Support::lsbMask<uint32_t>(discardLsb)) != 0)
+        return false;
+      offset64 >>= discardLsb;
+    }
+
+    if (!Support::isEncodableOffset64(offset64, bitCount))
+      return false;
+
+    value = uint64_t(offset64);
+  }
+
+  switch (format.type()) {
+    case OffsetType::kSignedOffset:
+    case OffsetType::kUnsignedOffset: {
+      *dst = (value & Support::lsbMask<uint64_t>(bitCount)) << format.immBitShift();
+      return true;
+    }
+
+    default:
+      return false;
+  }
+}
+
+bool CodeWriterUtils::writeOffset(void* dst, int64_t offset64, const OffsetFormat& format) noexcept {
+  // Offset the destination by ValueOffset so the `dst` points to the
+  // patched word instead of the beginning of the patched region.
+  dst = static_cast<char*>(dst) + format.valueOffset();
+
+  switch (format.valueSize()) {
+    case 1: {
+      uint32_t mask;
+      if (!encodeOffset32(&mask, offset64, format))
+        return false;
+
+      Support::writeU8(dst, uint8_t(Support::readU8(dst) | mask));
+      return true;
+    }
+
+    case 2: {
+      uint32_t mask;
+      if (!encodeOffset32(&mask, offset64, format))
+        return false;
+
+      Support::writeU16uLE(dst, uint16_t(Support::readU16uLE(dst) | mask));
+      return true;
+    }
+
+    case 4: {
+      uint32_t mask;
+      if (!encodeOffset32(&mask, offset64, format)) {
+        return false;
+      }
+
+      Support::writeU32uLE(dst, Support::readU32uLE(dst) | mask);
+      return true;
+    }
+
+    case 8: {
+      uint64_t mask;
+      if (!encodeOffset64(&mask, offset64, format))
+        return false;
+
+      Support::writeU64uLE(dst, Support::readU64uLE(dst) | mask);
+      return true;
+    }
+
+    default:
+      return false;
+  }
+}
+
+ASMJIT_END_NAMESPACE

data/ext/asmjit/asmjit/src/asmjit/core/codewriter_p.h

@@ -0,0 +1,179 @@
+// This file is part of AsmJit project <https://asmjit.com>
+//
+// See asmjit.h or LICENSE.md for license and copyright information
+// SPDX-License-Identifier: Zlib
+
+#ifndef ASMJIT_CORE_CODEBUFFERWRITER_P_H_INCLUDED
+#define ASMJIT_CORE_CODEBUFFERWRITER_P_H_INCLUDED
+
+#include "../core/assembler.h"
+#include "../core/codebuffer.h"
+#include "../core/support.h"
+
+ASMJIT_BEGIN_NAMESPACE
+
+//! \cond INTERNAL
+//! \addtogroup asmjit_assembler
+//! \{
+
+struct OffsetFormat;
+
+//! Helper that is used to write into a \ref CodeBuffer held by \ref BaseAssembler.
+class CodeWriter {
+public:
+  uint8_t* _cursor;
+
+  ASMJIT_FORCE_INLINE explicit CodeWriter(BaseAssembler* a) noexcept
+    : _cursor(a->_bufferPtr) {}
+
+  ASMJIT_FORCE_INLINE Error ensureSpace(BaseAssembler* a, size_t n) noexcept {
+    size_t remainingSpace = (size_t)(a->_bufferEnd - _cursor);
+    if (ASMJIT_UNLIKELY(remainingSpace < n)) {
+      CodeBuffer& buffer = a->_section->_buffer;
+      Error err = a->_code->growBuffer(&buffer, n);
+      if (ASMJIT_UNLIKELY(err))
+        return a->reportError(err);
+      _cursor = a->_bufferPtr;
+    }
+    return kErrorOk;
+  }
+
+  ASMJIT_FORCE_INLINE uint8_t* cursor() const noexcept { return _cursor; }
+  ASMJIT_FORCE_INLINE void setCursor(uint8_t* cursor) noexcept { _cursor = cursor; }
+  ASMJIT_FORCE_INLINE void advance(size_t n) noexcept { _cursor += n; }
+
+  ASMJIT_FORCE_INLINE size_t offsetFrom(uint8_t* from) const noexcept {
+    ASMJIT_ASSERT(_cursor >= from);
+    return (size_t)(_cursor - from);
+  }
+
+  template<typename T>
+  ASMJIT_FORCE_INLINE void emit8(T val) noexcept {
+    typedef typename std::make_unsigned<T>::type U;
+    _cursor[0] = uint8_t(U(val) & U(0xFF));
+    _cursor++;
+  }
+
+  template<typename T, typename Y>
+  ASMJIT_FORCE_INLINE void emit8If(T val, Y cond) noexcept {
+    typedef typename std::make_unsigned<T>::type U;
+    ASMJIT_ASSERT(size_t(cond) <= 1u);
+
+    _cursor[0] = uint8_t(U(val) & U(0xFF));
+    _cursor += size_t(cond);
+  }
+
+  template<typename T>
+  ASMJIT_FORCE_INLINE void emit16uLE(T val) noexcept {
+    typedef typename std::make_unsigned<T>::type U;
+    Support::writeU16uLE(_cursor, uint16_t(U(val) & 0xFFFFu));
+    _cursor += 2;
+  }
+
+  template<typename T>
+  ASMJIT_FORCE_INLINE void emit16uBE(T val) noexcept {
+    typedef typename std::make_unsigned<T>::type U;
+    Support::writeU16uBE(_cursor, uint16_t(U(val) & 0xFFFFu));
+    _cursor += 2;
+  }
+
+  template<typename T>
+  ASMJIT_FORCE_INLINE void emit32uLE(T val) noexcept {
+    typedef typename std::make_unsigned<T>::type U;
+    Support::writeU32uLE(_cursor, uint32_t(U(val) & 0xFFFFFFFFu));
+    _cursor += 4;
+  }
+
+  template<typename T>
+  ASMJIT_FORCE_INLINE void emit32uBE(T val) noexcept {
+    typedef typename std::make_unsigned<T>::type U;
+    Support::writeU32uBE(_cursor, uint32_t(U(val) & 0xFFFFFFFFu));
+    _cursor += 4;
+  }
+
+  ASMJIT_FORCE_INLINE void emitData(const void* data, size_t size) noexcept {
+    ASMJIT_ASSERT(size != 0);
+    memcpy(_cursor, data, size);
+    _cursor += size;
+  }
+
+  template<typename T>
+  ASMJIT_FORCE_INLINE void emitValueLE(const T& value, size_t size) noexcept {
+    typedef typename std::make_unsigned<T>::type U;
+    ASMJIT_ASSERT(size <= sizeof(T));
+
+    U v = U(value);
+    for (uint32_t i = 0; i < size; i++) {
+      _cursor[i] = uint8_t(v & 0xFFu);
+      v >>= 8;
+    }
+    _cursor += size;
+  }
+
+  template<typename T>
+  ASMJIT_FORCE_INLINE void emitValueBE(const T& value, size_t size) noexcept {
+    typedef typename std::make_unsigned<T>::type U;
+    ASMJIT_ASSERT(size <= sizeof(T));
+
+    U v = U(value);
+    for (uint32_t i = 0; i < size; i++) {
+      _cursor[i] = uint8_t(v >> (sizeof(T) - 8));
+      v <<= 8;
+    }
+    _cursor += size;
+  }
+
+  ASMJIT_FORCE_INLINE void emitZeros(size_t size) noexcept {
+    ASMJIT_ASSERT(size != 0);
+    memset(_cursor, 0, size);
+    _cursor += size;
+  }
+
+  ASMJIT_FORCE_INLINE void remove8(uint8_t* where) noexcept {
+    ASMJIT_ASSERT(where < _cursor);
+
+    uint8_t* p = where;
+    while (++p != _cursor)
+      p[-1] = p[0];
+    _cursor--;
+  }
+
+  template<typename T>
+  ASMJIT_FORCE_INLINE void insert8(uint8_t* where, T val) noexcept {
+    uint8_t* p = _cursor;
+
+    while (p != where) {
+      p[0] = p[-1];
+      p--;
+    }
+
+    *p = uint8_t(val & 0xFF);
+    _cursor++;
+  }
+
+  ASMJIT_FORCE_INLINE void done(BaseAssembler* a) noexcept {
+    CodeBuffer& buffer = a->_section->_buffer;
+    size_t newSize = (size_t)(_cursor - a->_bufferData);
+    ASMJIT_ASSERT(newSize <= buffer.capacity());
+
+    a->_bufferPtr = _cursor;
+    buffer._size = Support::max(buffer._size, newSize);
+  }
+};
+
+//! Code writer utilities.
+namespace CodeWriterUtils {
+
+bool encodeOffset32(uint32_t* dst, int64_t offset64, const OffsetFormat& format) noexcept;
+bool encodeOffset64(uint64_t* dst, int64_t offset64, const OffsetFormat& format) noexcept;
+
+bool writeOffset(void* dst, int64_t offset64, const OffsetFormat& format) noexcept;
+
+} // {CodeWriterUtils}
+
+//! \}
+//! \endcond
+
+ASMJIT_END_NAMESPACE
+
+#endif // ASMJIT_CORE_CODEBUFFERWRITER_P_H_INCLUDED