asmjit 0.2.0 → 0.2.1

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

@@ -0,0 +1,247 @@
+// 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_FORMATTER_H_INCLUDED
+#define ASMJIT_CORE_FORMATTER_H_INCLUDED
+
+#include "../core/globals.h"
+#include "../core/inst.h"
+#include "../core/string.h"
+#include "../core/support.h"
+
+ASMJIT_BEGIN_NAMESPACE
+
+//! \addtogroup asmjit_logging
+//! \{
+
+class BaseBuilder;
+class BaseEmitter;
+class BaseNode;
+struct Operand_;
+
+//! Format flags used by \ref Logger and \ref FormatOptions.
+enum class FormatFlags : uint32_t {
+  //! No formatting flags.
+  kNone = 0u,
+
+  //! Show also binary form of each logged instruction (Assembler).
+  kMachineCode = 0x00000001u,
+  //! Show a text explanation of some immediate values.
+  kExplainImms = 0x00000002u,
+  //! Use hexadecimal notation of immediate values.
+  kHexImms = 0x00000004u,
+  //! Use hexadecimal notation of addresses and offsets in addresses.
+  kHexOffsets = 0x00000008u,
+  //! Show casts between virtual register types (Compiler output).
+  kRegCasts = 0x00000010u,
+  //! Show positions associated with nodes (Compiler output).
+  kPositions = 0x00000020u
+};
+ASMJIT_DEFINE_ENUM_FLAGS(FormatFlags)
+
+//! Format indentation group, used by \ref FormatOptions.
+enum class FormatIndentationGroup : uint32_t {
+  //! Indentation used for instructions and directives.
+  kCode = 0u,
+  //! Indentation used for labels and function nodes.
+  kLabel = 1u,
+  //! Indentation used for comments (not inline comments).
+  kComment = 2u,
+
+  //! \cond INTERNAL
+  //! Reserved for future use.
+  kReserved = 3u,
+  //! \endcond
+
+  //! Maximum value of `FormatIndentationGroup`.
+  kMaxValue = kReserved
+};
+
+//! Format padding group, used by \ref FormatOptions.
+enum class FormatPaddingGroup : uint32_t {
+  //! Describes padding of a regular line, which can represent instruction, data, or assembler directives.
+  kRegularLine = 0,
+  //! Describes padding of machine code dump that is visible next to the instruction, if enabled.
+  kMachineCode = 1,
+
+  //! Maximum value of `FormatPaddingGroup`.
+  kMaxValue = kMachineCode
+};
+
+//! Formatting options used by \ref Logger and \ref Formatter.
+class FormatOptions {
+public:
+  //! \name Members
+  //! \{
+
+  //! Format flags.
+  FormatFlags _flags = FormatFlags::kNone;
+  //! Indentations for each indentation group.
+  Support::Array<uint8_t, uint32_t(FormatIndentationGroup::kMaxValue) + 1> _indentation {};
+  //! Paddings for each padding group.
+  Support::Array<uint16_t, uint32_t(FormatPaddingGroup::kMaxValue) + 1> _padding {};
+
+  //! \}
+
+  //! \name Reset
+  //! \{
+
+  //! Resets FormatOptions to its default initialized state.
+  inline void reset() noexcept {
+    _flags = FormatFlags::kNone;
+    _indentation.fill(uint8_t(0));
+    _padding.fill(uint16_t(0));
+  }
+
+  //! \}
+
+  //! \name Accessors
+  //! \{
+
+  //! Returns format flags.
+  inline FormatFlags flags() const noexcept { return _flags; }
+  //! Tests whether the given `flag` is set in format flags.
+  inline bool hasFlag(FormatFlags flag) const noexcept { return Support::test(_flags, flag); }
+
+  //! Resets all format flags to `flags`.
+  inline void setFlags(FormatFlags flags) noexcept { _flags = flags; }
+  //! Adds `flags` to format flags.
+  inline void addFlags(FormatFlags flags) noexcept { _flags |= flags; }
+  //! Removes `flags` from format flags.
+  inline void clearFlags(FormatFlags flags) noexcept { _flags &= ~flags; }
+
+  //! Returns indentation for the given indentation `group`.
+  inline uint8_t indentation(FormatIndentationGroup group) const noexcept { return _indentation[group]; }
+  //! Sets indentation for the given indentation `group`.
+  inline void setIndentation(FormatIndentationGroup group, uint32_t n) noexcept { _indentation[group] = uint8_t(n); }
+  //! Resets indentation for the given indentation `group` to zero.
+  inline void resetIndentation(FormatIndentationGroup group) noexcept { _indentation[group] = uint8_t(0); }
+
+  //! Returns pading for the given padding `group`.
+  inline size_t padding(FormatPaddingGroup group) const noexcept { return _padding[group]; }
+  //! Sets pading for the given padding `group`.
+  inline void setPadding(FormatPaddingGroup group, size_t n) noexcept { _padding[group] = uint16_t(n); }
+  //! Resets pading for the given padding `group` to zero, which means that a default padding will be used
+  //! based on the target architecture properties.
+  inline void resetPadding(FormatPaddingGroup group) noexcept { _padding[group] = uint16_t(0); }
+
+  //! \}
+};
+
+//! Provides formatting functionality to format operands, instructions, and nodes.
+namespace Formatter {
+
+#ifndef ASMJIT_NO_LOGGING
+
+//! Appends a formatted `typeId` to the output string `sb`.
+ASMJIT_API Error formatTypeId(
+  String& sb,
+  TypeId typeId) noexcept;
+
+//! Appends a formatted `featureId` to the output string `sb`.
+//!
+//! See \ref CpuFeatures.
+ASMJIT_API Error formatFeature(
+  String& sb,
+  Arch arch,
+  uint32_t featureId) noexcept;
+
+//! Appends a formatted register to the output string `sb`.
+//!
+//! \note Emitter is optional, but it's required to format virtual registers, which won't be formatted properly
+//! if the `emitter` is not provided.
+ASMJIT_API Error formatRegister(
+  String& sb,
+  FormatFlags formatFlags,
+  const BaseEmitter* emitter,
+  Arch arch,
+  RegType regType,
+  uint32_t regId) noexcept;
+
+//! Appends a formatted label to the output string `sb`.
+//!
+//! \note Emitter is optional, but it's required to format named labels properly, otherwise the formatted as
+//! it is an anonymous label.
+ASMJIT_API Error formatLabel(
+  String& sb,
+  FormatFlags formatFlags,
+  const BaseEmitter* emitter,
+  uint32_t labelId) noexcept;
+
+//! Appends a formatted operand to the output string `sb`.
+//!
+//! \note Emitter is optional, but it's required to format named labels and virtual registers. See
+//! \ref formatRegister() and \ref formatLabel() for more details.
+ASMJIT_API Error formatOperand(
+  String& sb,
+  FormatFlags formatFlags,
+  const BaseEmitter* emitter,
+  Arch arch,
+  const Operand_& op) noexcept;
+
+//! Appends a formatted data-type to the output string `sb`.
+ASMJIT_API Error formatDataType(
+  String& sb,
+  FormatFlags formatFlags,
+  Arch arch,
+  TypeId typeId) noexcept;
+
+//! Appends a formatted data to the output string `sb`.
+ASMJIT_API Error formatData(
+  String& sb,
+  FormatFlags formatFlags,
+  Arch arch,
+  TypeId typeId, const void* data, size_t itemCount, size_t repeatCount = 1) noexcept;
+
+//! Appends a formatted instruction to the output string `sb`.
+//!
+//! \note Emitter is optional, but it's required to format named labels and virtual registers. See
+//! \ref formatRegister() and \ref formatLabel() for more details.
+ASMJIT_API Error formatInstruction(
+  String& sb,
+  FormatFlags formatFlags,
+  const BaseEmitter* emitter,
+  Arch arch,
+  const BaseInst& inst, const Operand_* operands, size_t opCount) noexcept;
+
+#ifndef ASMJIT_NO_BUILDER
+//! Appends a formatted node to the output string `sb`.
+//!
+//! The `node` must belong to the provided `builder`.
+ASMJIT_API Error formatNode(
+  String& sb,
+  const FormatOptions& formatOptions,
+  const BaseBuilder* builder,
+  const BaseNode* node) noexcept;
+
+//! Appends formatted nodes to the output string `sb`.
+//!
+//! All nodes that are part of the given `builder` will be appended.
+ASMJIT_API Error formatNodeList(
+  String& sb,
+  const FormatOptions& formatOptions,
+  const BaseBuilder* builder) noexcept;
+
+//! Appends formatted nodes to the output string `sb`.
+//!
+//! This function works the same as \ref formatNode(), but appends more nodes to the output string,
+//! separating each node with a newline '\n' character.
+ASMJIT_API Error formatNodeList(
+  String& sb,
+  const FormatOptions& formatOptions,
+  const BaseBuilder* builder,
+  const BaseNode* begin,
+  const BaseNode* end) noexcept;
+#endif
+
+#endif
+
+} // {Formatter}
+
+//! \}
+
+ASMJIT_END_NAMESPACE
+
+#endif // ASMJIT_CORE_FORMATTER_H_INCLUDED

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

@@ -0,0 +1,34 @@
+// 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_FORMATTER_P_H_INCLUDED
+#define ASMJIT_CORE_FORMATTER_P_H_INCLUDED
+
+#include "../core/formatter.h"
+
+ASMJIT_BEGIN_NAMESPACE
+
+//! \cond INTERNAL
+//! \addtogroup asmjit_logging
+//! \{
+
+namespace Formatter {
+
+static ASMJIT_FORCE_INLINE size_t paddingFromOptions(const FormatOptions& formatOptions, FormatPaddingGroup group) noexcept {
+  static constexpr uint16_t _defaultPaddingTable[uint32_t(FormatPaddingGroup::kMaxValue) + 1] = { 44, 26 };
+  static_assert(uint32_t(FormatPaddingGroup::kMaxValue) + 1 == 2, "If a new group is defined it must be added here");
+
+  size_t padding = formatOptions.padding(group);
+  return padding ? padding : size_t(_defaultPaddingTable[uint32_t(group)]);
+}
+
+} // {Formatter}
+
+//! \}
+//! \endcond
+
+ASMJIT_END_NAMESPACE
+
+#endif // ASMJIT_CORE_FORMATTER_H_P_INCLUDED

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

@@ -0,0 +1,286 @@
+// 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/archtraits.h"
+#include "../core/func.h"
+#include "../core/operand.h"
+#include "../core/type.h"
+#include "../core/funcargscontext_p.h"
+
+#if !defined(ASMJIT_NO_X86)
+  #include "../x86/x86func_p.h"
+#endif
+
+#if !defined(ASMJIT_NO_AARCH64)
+  #include "../arm/a64func_p.h"
+#endif
+
+ASMJIT_BEGIN_NAMESPACE
+
+// CallConv - Init & Reset
+// =======================
+
+ASMJIT_FAVOR_SIZE Error CallConv::init(CallConvId ccId, const Environment& environment) noexcept {
+  reset();
+
+#if !defined(ASMJIT_NO_X86)
+  if (environment.isFamilyX86())
+    return x86::FuncInternal::initCallConv(*this, ccId, environment);
+#endif
+
+#if !defined(ASMJIT_NO_AARCH64)
+  if (environment.isFamilyAArch64())
+    return a64::FuncInternal::initCallConv(*this, ccId, environment);
+#endif
+
+  return DebugUtils::errored(kErrorInvalidArgument);
+}
+
+// FuncDetail - Init / Reset
+// =========================
+
+ASMJIT_FAVOR_SIZE Error FuncDetail::init(const FuncSignature& signature, const Environment& environment) noexcept {
+  CallConvId ccId = signature.callConvId();
+  uint32_t argCount = signature.argCount();
+
+  if (ASMJIT_UNLIKELY(argCount > Globals::kMaxFuncArgs))
+    return DebugUtils::errored(kErrorInvalidArgument);
+
+  CallConv& cc = _callConv;
+  ASMJIT_PROPAGATE(cc.init(ccId, environment));
+
+  uint32_t registerSize = Environment::registerSizeFromArch(cc.arch());
+  uint32_t deabstractDelta = TypeUtils::deabstractDeltaOfSize(registerSize);
+
+  const TypeId* signatureArgs = signature.args();
+  for (uint32_t argIndex = 0; argIndex < argCount; argIndex++) {
+    FuncValuePack& argPack = _args[argIndex];
+    argPack[0].initTypeId(TypeUtils::deabstract(signatureArgs[argIndex], deabstractDelta));
+  }
+
+  _argCount = uint8_t(argCount);
+  _vaIndex = uint8_t(signature.vaIndex());
+
+  TypeId ret = signature.ret();
+  if (ret != TypeId::kVoid)
+    _rets[0].initTypeId(TypeUtils::deabstract(ret, deabstractDelta));
+
+#if !defined(ASMJIT_NO_X86)
+  if (environment.isFamilyX86())
+    return x86::FuncInternal::initFuncDetail(*this, signature, registerSize);
+#endif
+
+#if !defined(ASMJIT_NO_AARCH64)
+  if (environment.isFamilyAArch64())
+    return a64::FuncInternal::initFuncDetail(*this, signature, registerSize);
+#endif
+
+  // We should never bubble here as if `cc.init()` succeeded then there has to be an implementation for the current
+  // architecture. However, stay safe.
+  return DebugUtils::errored(kErrorInvalidArgument);
+}
+
+// FuncFrame - Init
+// ================
+
+ASMJIT_FAVOR_SIZE Error FuncFrame::init(const FuncDetail& func) noexcept {
+  Arch arch = func.callConv().arch();
+  if (!Environment::isValidArch(arch))
+    return DebugUtils::errored(kErrorInvalidArch);
+
+  const ArchTraits& archTraits = ArchTraits::byArch(arch);
+
+  // Initializing FuncFrame means making a copy of some properties of `func`. Properties like `_localStackSize` will
+  // be set by the user before the frame is finalized.
+  reset();
+
+  _arch = arch;
+  _spRegId = uint8_t(archTraits.spRegId());
+  _saRegId = uint8_t(BaseReg::kIdBad);
+
+  uint32_t naturalStackAlignment = func.callConv().naturalStackAlignment();
+  uint32_t minDynamicAlignment = Support::max<uint32_t>(naturalStackAlignment, 16);
+
+  if (minDynamicAlignment == naturalStackAlignment)
+    minDynamicAlignment <<= 1;
+
+  _naturalStackAlignment = uint8_t(naturalStackAlignment);
+  _minDynamicAlignment = uint8_t(minDynamicAlignment);
+  _redZoneSize = uint8_t(func.redZoneSize());
+  _spillZoneSize = uint8_t(func.spillZoneSize());
+  _finalStackAlignment = uint8_t(_naturalStackAlignment);
+
+  if (func.hasFlag(CallConvFlags::kCalleePopsStack)) {
+    _calleeStackCleanup = uint16_t(func.argStackSize());
+  }
+
+  // Initial masks of dirty and preserved registers.
+  for (RegGroup group : RegGroupVirtValues{}) {
+    _dirtyRegs[group] = func.usedRegs(group);
+    _preservedRegs[group] = func.preservedRegs(group);
+  }
+
+  // Exclude stack pointer - this register is never included in saved GP regs.
+  _preservedRegs[RegGroup::kGp] &= ~Support::bitMask(archTraits.spRegId());
+
+  // The size and alignment of save/restore area of registers for each virtual register group
+  _saveRestoreRegSize = func.callConv()._saveRestoreRegSize;
+  _saveRestoreAlignment = func.callConv()._saveRestoreAlignment;
+
+  return kErrorOk;
+}
+
+// FuncFrame - Finalize
+// ====================
+
+ASMJIT_FAVOR_SIZE Error FuncFrame::finalize() noexcept {
+  if (!Environment::isValidArch(arch()))
+    return DebugUtils::errored(kErrorInvalidArch);
+
+  const ArchTraits& archTraits = ArchTraits::byArch(arch());
+
+  uint32_t registerSize = _saveRestoreRegSize[RegGroup::kGp];
+  uint32_t vectorSize = _saveRestoreRegSize[RegGroup::kVec];
+  uint32_t returnAddressSize = archTraits.hasLinkReg() ? 0u : registerSize;
+
+  // The final stack alignment must be updated accordingly to call and local stack alignments.
+  uint32_t stackAlignment = _finalStackAlignment;
+  ASMJIT_ASSERT(stackAlignment == Support::max(_naturalStackAlignment,
+                                               _callStackAlignment,
+                                               _localStackAlignment));
+
+  bool hasFP = hasPreservedFP();
+  bool hasDA = hasDynamicAlignment();
+
+  uint32_t kSp = archTraits.spRegId();
+  uint32_t kFp = archTraits.fpRegId();
+  uint32_t kLr = archTraits.linkRegId();
+
+  // Make frame pointer dirty if the function uses it.
+  if (hasFP) {
+    _dirtyRegs[RegGroup::kGp] |= Support::bitMask(kFp);
+
+    // Currently required by ARM, if this works differently across architectures we would have to generalize most
+    // likely in CallConv.
+    if (kLr != BaseReg::kIdBad)
+      _dirtyRegs[RegGroup::kGp] |= Support::bitMask(kLr);
+  }
+
+  // These two are identical if the function doesn't align its stack dynamically.
+  uint32_t saRegId = _saRegId;
+  if (saRegId == BaseReg::kIdBad)
+    saRegId = kSp;
+
+  // Fix stack arguments base-register from SP to FP in case it was not picked before and the function performs
+  // dynamic stack alignment.
+  if (hasDA && saRegId == kSp)
+    saRegId = kFp;
+
+  // Mark as dirty any register but SP if used as SA pointer.
+  if (saRegId != kSp)
+    _dirtyRegs[RegGroup::kGp] |= Support::bitMask(saRegId);
+
+  _spRegId = uint8_t(kSp);
+  _saRegId = uint8_t(saRegId);
+
+  // Setup stack size used to save preserved registers.
+  uint32_t saveRestoreSizes[2] {};
+  for (RegGroup group : RegGroupVirtValues{})
+    saveRestoreSizes[size_t(!archTraits.hasInstPushPop(group))]
+      += Support::alignUp(Support::popcnt(savedRegs(group)) * saveRestoreRegSize(group), saveRestoreAlignment(group));
+
+  _pushPopSaveSize  = uint16_t(saveRestoreSizes[0]);
+  _extraRegSaveSize = uint16_t(saveRestoreSizes[1]);
+
+  uint32_t v = 0;                            // The beginning of the stack frame relative to SP after prolog.
+  v += callStackSize();                      // Count 'callStackSize'      <- This is used to call functions.
+  v  = Support::alignUp(v, stackAlignment);  // Align to function's stack alignment.
+
+  _localStackOffset = v;                     // Store 'localStackOffset'   <- Function's local stack starts here.
+  v += localStackSize();                     // Count 'localStackSize'     <- Function's local stack ends here.
+
+  // If the function's stack must be aligned, calculate the alignment necessary to store vector registers, and set
+  // `FuncAttributes::kAlignedVecSR` to inform PEI that it can use instructions that perform aligned stores/loads.
+  if (stackAlignment >= vectorSize && _extraRegSaveSize) {
+    addAttributes(FuncAttributes::kAlignedVecSR);
+    v = Support::alignUp(v, vectorSize);     // Align 'extraRegSaveOffset'.
+  }
+
+  _extraRegSaveOffset = v;                   // Store 'extraRegSaveOffset' <- Non-GP save/restore starts here.
+  v += _extraRegSaveSize;                    // Count 'extraRegSaveSize'   <- Non-GP save/restore ends here.
+
+  // Calculate if dynamic alignment (DA) slot (stored as offset relative to SP) is required and its offset.
+  if (hasDA && !hasFP) {
+    _daOffset = v;                           // Store 'daOffset'           <- DA pointer would be stored here.
+    v += registerSize;                       // Count 'daOffset'.
+  }
+  else {
+    _daOffset = FuncFrame::kTagInvalidOffset;
+  }
+
+  // Link Register
+  // -------------
+  //
+  // The stack is aligned after the function call as the return address is stored in a link register. Some
+  // architectures may require to always have aligned stack after PUSH/POP operation, which is represented
+  // by ArchTraits::stackAlignmentConstraint().
+  //
+  // No Link Register (X86/X64)
+  // --------------------------
+  //
+  // The return address should be stored after GP save/restore regs. It has the same size as `registerSize`
+  // (basically the native register/pointer size). We don't adjust it now as `v` now contains the exact size
+  // that the function requires to adjust (call frame + stack frame, vec stack size). The stack (if we consider
+  // this size) is misaligned now, as it's always aligned before the function call - when `call()` is executed
+  // it pushes the current EIP|RIP onto the stack, and misaligns it by 12 or 8 bytes (depending on the
+  // architecture). So count number of bytes needed to align it up to the function's CallFrame (the beginning).
+  if (v || hasFuncCalls() || !returnAddressSize)
+    v += Support::alignUpDiff(v + pushPopSaveSize() + returnAddressSize, stackAlignment);
+
+  _pushPopSaveOffset = v;                    // Store 'pushPopSaveOffset'  <- Function's push/pop save/restore starts here.
+  _stackAdjustment = v;                      // Store 'stackAdjustment'    <- SA used by 'add SP, SA' and 'sub SP, SA'.
+  v += _pushPopSaveSize;                     // Count 'pushPopSaveSize'    <- Function's push/pop save/restore ends here.
+  _finalStackSize = v;                       // Store 'finalStackSize'     <- Final stack used by the function.
+
+  if (!archTraits.hasLinkReg())
+    v += registerSize;                       // Count 'ReturnAddress'      <- As CALL pushes onto stack.
+
+  // If the function performs dynamic stack alignment then the stack-adjustment must be aligned.
+  if (hasDA)
+    _stackAdjustment = Support::alignUp(_stackAdjustment, stackAlignment);
+
+  // Calculate where the function arguments start relative to SP.
+  _saOffsetFromSP = hasDA ? FuncFrame::kTagInvalidOffset : v;
+
+  // Calculate where the function arguments start relative to FP or user-provided register.
+  _saOffsetFromSA = hasFP ? returnAddressSize + registerSize      // Return address + frame pointer.
+                          : returnAddressSize + _pushPopSaveSize; // Return address + all push/pop regs.
+
+  return kErrorOk;
+}
+
+// FuncArgsAssignment - UpdateFuncFrame
+// ====================================
+
+ASMJIT_FAVOR_SIZE Error FuncArgsAssignment::updateFuncFrame(FuncFrame& frame) const noexcept {
+  Arch arch = frame.arch();
+  const FuncDetail* func = funcDetail();
+
+  if (!func)
+    return DebugUtils::errored(kErrorInvalidState);
+
+  RAConstraints constraints;
+  ASMJIT_PROPAGATE(constraints.init(arch));
+
+  FuncArgsContext ctx;
+  ASMJIT_PROPAGATE(ctx.initWorkData(frame, *this, &constraints));
+  ASMJIT_PROPAGATE(ctx.markDstRegsDirty(frame));
+  ASMJIT_PROPAGATE(ctx.markScratchRegs(frame));
+  ASMJIT_PROPAGATE(ctx.markStackArgsReg(frame));
+  return kErrorOk;
+}
+
+ASMJIT_END_NAMESPACE