asmjit 0.2.0 → 0.2.1

data/ext/asmjit/asmjit/test/asmjit_test_emitters.cpp

@@ -0,0 +1,197 @@
+// 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 <asmjit/core.h>
+
+#if !defined(ASMJIT_NO_X86) && ASMJIT_ARCH_X86
+#include <asmjit/x86.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+using namespace asmjit;
+
+// Signature of the generated function.
+typedef void (*SumIntsFunc)(int* dst, const int* a, const int* b);
+
+// This function works with both x86::Assembler and x86::Builder. It shows how
+// `x86::Emitter` can be used to make your code more generic.
+static void makeRawFunc(x86::Emitter* emitter) noexcept {
+  // Decide which registers will be mapped to function arguments. Try changing
+  // registers of `dst`, `src_a`, and `src_b` and see what happens in function's
+  // prolog and epilog.
+  x86::Gp dst   = emitter->zax();
+  x86::Gp src_a = emitter->zcx();
+  x86::Gp src_b = emitter->zdx();
+
+  // Decide which vector registers to use. We use these to keep the code generic,
+  // you can switch to any other registers when needed.
+  x86::Xmm vec0 = x86::xmm0;
+  x86::Xmm vec1 = x86::xmm1;
+
+  // Create and initialize `FuncDetail` and `FuncFrame`.
+  FuncDetail func;
+  func.init(FuncSignatureT<void, int*, const int*, const int*>(CallConvId::kHost), emitter->environment());
+
+  FuncFrame frame;
+  frame.init(func);
+
+  // Make XMM0 and XMM1 dirty. VEC group includes XMM|YMM|ZMM registers.
+  frame.addDirtyRegs(x86::xmm0, x86::xmm1);
+
+  FuncArgsAssignment args(&func);         // Create arguments assignment context.
+  args.assignAll(dst, src_a, src_b);      // Assign our registers to arguments.
+  args.updateFuncFrame(frame);            // Reflect our args in FuncFrame.
+  frame.finalize();
+
+  // Emit prolog and allocate arguments to registers.
+  emitter->emitProlog(frame);
+  emitter->emitArgsAssignment(frame, args);
+
+  emitter->movdqu(vec0, x86::ptr(src_a)); // Load 4 ints from [src_a] to XMM0.
+  emitter->movdqu(vec1, x86::ptr(src_b)); // Load 4 ints from [src_b] to XMM1.
+
+  emitter->paddd(vec0, vec1);             // Add 4 ints in XMM1 to XMM0.
+  emitter->movdqu(x86::ptr(dst), vec0);   // Store the result to [dst].
+
+  // Emit epilog and return.
+  emitter->emitEpilog(frame);
+}
+
+#ifndef ASMJIT_NO_COMPILER
+// This function works with x86::Compiler, provided for comparison.
+static void makeCompiledFunc(x86::Compiler* cc) noexcept {
+  x86::Gp dst = cc->newIntPtr("dst");
+  x86::Gp src_a = cc->newIntPtr("src_a");
+  x86::Gp src_b = cc->newIntPtr("src_b");
+  x86::Xmm vec0 = cc->newXmm("vec0");
+  x86::Xmm vec1 = cc->newXmm("vec1");
+
+  FuncNode* funcNode = cc->addFunc(FuncSignatureT<void, int*, const int*, const int*>(CallConvId::kHost));
+  funcNode->setArg(0, dst);
+  funcNode->setArg(1, src_a);
+  funcNode->setArg(2, src_b);
+
+  cc->movdqu(vec0, x86::ptr(src_a));
+  cc->movdqu(vec1, x86::ptr(src_b));
+  cc->paddd(vec0, vec1);
+  cc->movdqu(x86::ptr(dst), vec0);
+  cc->endFunc();
+}
+#endif
+
+static uint32_t testFunc(JitRuntime& rt, EmitterType emitterType) noexcept {
+#ifndef ASMJIT_NO_LOGGING
+  FileLogger logger(stdout);
+  logger.setIndentation(FormatIndentationGroup::kCode, 2);
+#endif
+
+  CodeHolder code;
+  code.init(rt.environment());
+
+#ifndef ASMJIT_NO_LOGGING
+  code.setLogger(&logger);
+#endif
+
+  Error err = kErrorOk;
+  switch (emitterType) {
+    case EmitterType::kNone: {
+      break;
+    }
+
+    case EmitterType::kAssembler: {
+      printf("Using x86::Assembler:\n");
+      x86::Assembler a(&code);
+      makeRawFunc(a.as<x86::Emitter>());
+      break;
+    }
+
+#ifndef ASMJIT_NO_BUILDER
+    case EmitterType::kBuilder: {
+      printf("Using x86::Builder:\n");
+      x86::Builder cb(&code);
+      makeRawFunc(cb.as<x86::Emitter>());
+
+      err = cb.finalize();
+      if (err) {
+        printf("** FAILURE: x86::Builder::finalize() failed (%s) **\n", DebugUtils::errorAsString(err));
+        return 1;
+      }
+      break;
+    }
+#endif
+
+#ifndef ASMJIT_NO_COMPILER
+    case EmitterType::kCompiler: {
+      printf("Using x86::Compiler:\n");
+      x86::Compiler cc(&code);
+      makeCompiledFunc(&cc);
+
+      err = cc.finalize();
+      if (err) {
+        printf("** FAILURE: x86::Compiler::finalize() failed (%s) **\n", DebugUtils::errorAsString(err));
+        return 1;
+      }
+      break;
+    }
+#endif
+  }
+
+  // Add the code generated to the runtime.
+  SumIntsFunc fn;
+  err = rt.add(&fn, &code);
+
+  if (err) {
+    printf("** FAILURE: JitRuntime::add() failed (%s) **\n", DebugUtils::errorAsString(err));
+    return 1;
+  }
+
+  // Execute the generated function.
+  int inA[4] = { 4, 3, 2, 1 };
+  int inB[4] = { 1, 5, 2, 8 };
+  int out[4];
+  fn(out, inA, inB);
+
+  // Should print {5 8 4 9}.
+  printf("Result = { %d %d %d %d }\n\n", out[0], out[1], out[2], out[3]);
+
+  rt.release(fn);
+  return !(out[0] == 5 && out[1] == 8 && out[2] == 4 && out[3] == 9);
+}
+
+int main() {
+  printf("AsmJit Emitters Test-Suite v%u.%u.%u\n",
+    unsigned((ASMJIT_LIBRARY_VERSION >> 16)       ),
+    unsigned((ASMJIT_LIBRARY_VERSION >>  8) & 0xFF),
+    unsigned((ASMJIT_LIBRARY_VERSION      ) & 0xFF));
+  printf("\n");
+
+  JitRuntime rt;
+  unsigned nFailed = 0;
+
+  nFailed += testFunc(rt, EmitterType::kAssembler);
+
+#ifndef ASMJIT_NO_BUILDER
+  nFailed += testFunc(rt, EmitterType::kBuilder);
+#endif
+
+#ifndef ASMJIT_NO_COMPILER
+  nFailed += testFunc(rt, EmitterType::kCompiler);
+#endif
+
+  if (!nFailed)
+    printf("** SUCCESS **\n");
+  else
+    printf("** FAILURE - %u %s failed ** \n", nFailed, nFailed == 1 ? "test" : "tests");
+
+  return nFailed ? 1 : 0;
+}
+#else
+int main() {
+  printf("AsmJit X86 Emitter Test is disabled on non-x86 host\n\n");
+  return 0;
+}
+#endif // !ASMJIT_NO_X86 && ASMJIT_ARCH_X86

data/ext/asmjit/asmjit/test/asmjit_test_instinfo.cpp

@@ -0,0 +1,181 @@
+// 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 <asmjit/core.h>
+
+#if !defined(ASMJIT_NO_X86)
+#include <asmjit/x86.h>
+#endif
+
+#include <stdio.h>
+
+using namespace asmjit;
+
+static char accessLetter(bool r, bool w) noexcept {
+  return r && w ? 'X' : r ? 'R' : w ? 'W' : '_';
+}
+
+static void printInfo(Arch arch, const BaseInst& inst, const Operand_* operands, size_t opCount) {
+  StringTmp<512> sb;
+
+  // Read & Write Information
+  // ------------------------
+
+  InstRWInfo rw;
+  InstAPI::queryRWInfo(arch, inst, operands, opCount, &rw);
+
+#ifndef ASMJIT_NO_LOGGING
+  Formatter::formatInstruction(sb, FormatFlags::kNone, nullptr, arch, inst, operands, opCount);
+#else
+  sb.append("<Logging-Not-Available>");
+#endif
+  sb.append("\n");
+
+  sb.append("  Operands:\n");
+  for (uint32_t i = 0; i < rw.opCount(); i++) {
+    const OpRWInfo& op = rw.operand(i);
+
+    sb.appendFormat("    [%u] Op=%c Read=%016llX Write=%016llX Extend=%016llX",
+                    i,
+                    accessLetter(op.isRead(), op.isWrite()),
+                    op.readByteMask(),
+                    op.writeByteMask(),
+                    op.extendByteMask());
+
+    if (op.isMemBaseUsed()) {
+      sb.appendFormat(" Base=%c", accessLetter(op.isMemBaseRead(), op.isMemBaseWrite()));
+      if (op.isMemBasePreModify())
+        sb.appendFormat(" <PRE>");
+      if (op.isMemBasePostModify())
+        sb.appendFormat(" <POST>");
+    }
+
+    if (op.isMemIndexUsed()) {
+      sb.appendFormat(" Index=%c", accessLetter(op.isMemIndexRead(), op.isMemIndexWrite()));
+    }
+
+    sb.append("\n");
+  }
+
+  // CPU Flags (Read/Write)
+  // ----------------------
+
+  if ((rw.readFlags() | rw.writeFlags()) != CpuRWFlags::kNone) {
+    sb.append("  Flags: \n");
+
+    struct FlagMap {
+      CpuRWFlags flag;
+      char name[4];
+    };
+
+    static const FlagMap flagMap[] = {
+      { CpuRWFlags::kX86_CF, "CF" },
+      { CpuRWFlags::kX86_OF, "OF" },
+      { CpuRWFlags::kX86_SF, "SF" },
+      { CpuRWFlags::kX86_ZF, "ZF" },
+      { CpuRWFlags::kX86_AF, "AF" },
+      { CpuRWFlags::kX86_PF, "PF" },
+      { CpuRWFlags::kX86_DF, "DF" },
+      { CpuRWFlags::kX86_IF, "IF" },
+      { CpuRWFlags::kX86_AC, "AC" },
+      { CpuRWFlags::kX86_C0, "C0" },
+      { CpuRWFlags::kX86_C1, "C1" },
+      { CpuRWFlags::kX86_C2, "C2" },
+      { CpuRWFlags::kX86_C3, "C3" }
+    };
+
+    sb.append("    ");
+    for (uint32_t f = 0; f < 13; f++) {
+      char c = accessLetter((rw.readFlags() & flagMap[f].flag) != CpuRWFlags::kNone,
+                            (rw.writeFlags() & flagMap[f].flag) != CpuRWFlags::kNone);
+      if (c != '_')
+        sb.appendFormat("%s=%c ", flagMap[f].name, c);
+    }
+
+    sb.append("\n");
+  }
+
+  // CPU Features
+  // ------------
+
+  CpuFeatures features;
+  InstAPI::queryFeatures(arch, inst, operands, opCount, &features);
+
+#ifndef ASMJIT_NO_LOGGING
+  if (!features.empty()) {
+    sb.append("  Features:\n");
+    sb.append("    ");
+
+    bool first = true;
+    CpuFeatures::Iterator it(features.iterator());
+    while (it.hasNext()) {
+      uint32_t featureId = uint32_t(it.next());
+      if (!first)
+        sb.append(" & ");
+      Formatter::formatFeature(sb, arch, featureId);
+      first = false;
+    }
+    sb.append("\n");
+  }
+#endif
+
+  printf("%s\n", sb.data());
+}
+
+template<typename... Args>
+static void printInfoSimple(Arch arch,InstId instId, InstOptions options, Args&&... args) {
+  BaseInst inst(instId);
+  inst.addOptions(options);
+  Operand_ opArray[] = { std::forward<Args>(args)... };
+  printInfo(arch, inst, opArray, sizeof...(args));
+}
+
+template<typename... Args>
+static void printInfoExtra(Arch arch, InstId instId, InstOptions options, const BaseReg& extraReg, Args&&... args) {
+  BaseInst inst(instId);
+  inst.addOptions(options);
+  inst.setExtraReg(extraReg);
+  Operand_ opArray[] = { std::forward<Args>(args)... };
+  printInfo(arch, inst, opArray, sizeof...(args));
+}
+
+static void testX86Arch() {
+#if !defined(ASMJIT_NO_X86)
+  using namespace x86;
+  Arch arch = Arch::kX64;
+
+  printInfoSimple(arch, Inst::kIdAdd, InstOptions::kNone, eax, ebx);
+  printInfoSimple(arch, Inst::kIdLods, InstOptions::kNone, eax, dword_ptr(rsi));
+
+  printInfoSimple(arch, Inst::kIdPshufd, InstOptions::kNone, xmm0, xmm1, imm(0));
+  printInfoSimple(arch, Inst::kIdPabsb, InstOptions::kNone, mm1, mm2);
+  printInfoSimple(arch, Inst::kIdPabsb, InstOptions::kNone, xmm1, xmm2);
+  printInfoSimple(arch, Inst::kIdPextrw, InstOptions::kNone, eax, mm1, imm(0));
+  printInfoSimple(arch, Inst::kIdPextrw, InstOptions::kNone, eax, xmm1, imm(0));
+  printInfoSimple(arch, Inst::kIdPextrw, InstOptions::kNone, ptr(rax), xmm1, imm(0));
+
+  printInfoSimple(arch, Inst::kIdVpdpbusd, InstOptions::kNone, xmm0, xmm1, xmm2);
+  printInfoSimple(arch, Inst::kIdVpdpbusd, InstOptions::kX86_Vex, xmm0, xmm1, xmm2);
+
+  printInfoSimple(arch, Inst::kIdVaddpd, InstOptions::kNone, ymm0, ymm1, ymm2);
+  printInfoSimple(arch, Inst::kIdVaddpd, InstOptions::kNone, ymm0, ymm30, ymm31);
+  printInfoSimple(arch, Inst::kIdVaddpd, InstOptions::kNone, zmm0, zmm1, zmm2);
+
+  printInfoExtra(arch, Inst::kIdVaddpd, InstOptions::kNone, k1, zmm0, zmm1, zmm2);
+  printInfoExtra(arch, Inst::kIdVaddpd, InstOptions::kX86_ZMask, k1, zmm0, zmm1, zmm2);
+#endif
+}
+
+int main() {
+  printf("AsmJit Instruction Info Test-Suite v%u.%u.%u\n",
+    unsigned((ASMJIT_LIBRARY_VERSION >> 16)       ),
+    unsigned((ASMJIT_LIBRARY_VERSION >>  8) & 0xFF),
+    unsigned((ASMJIT_LIBRARY_VERSION      ) & 0xFF));
+  printf("\n");
+
+  testX86Arch();
+
+  return 0;
+}

data/ext/asmjit/asmjit/test/asmjit_test_misc.h

@@ -0,0 +1,257 @@
+// 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_TEST_MISC_H_INCLUDED
+#define ASMJIT_TEST_MISC_H_INCLUDED
+
+#include <asmjit/x86.h>
+
+namespace asmtest {
+
+using namespace asmjit;
+
+// Generates a typical alpha blend function that uses SSE2 instruction set.
+// This function combines emitting instructions with control flow constructs
+// like binding Labels and jumping to them. This should be pretty representative.
+template<typename Emitter>
+static void generateSseAlphaBlendInternal(
+  Emitter& cc,
+  const x86::Gp& dst, const x86::Gp& src, const x86::Gp& n,
+  const x86::Gp& gp0,
+  const x86::Xmm& simd0, const x86::Xmm& simd1, const x86::Xmm& simd2, const x86::Xmm& simd3,
+  const x86::Xmm& simd4, const x86::Xmm& simd5, const x86::Xmm& simd6, const x86::Xmm& simd7) {
+
+  x86::Gp i = n;
+  x86::Gp j = gp0;
+
+  x86::Xmm vzero = simd0;
+  x86::Xmm v0080 = simd1;
+  x86::Xmm v0101 = simd2;
+
+  Label L_SmallLoop = cc.newLabel();
+  Label L_SmallEnd  = cc.newLabel();
+  Label L_LargeLoop = cc.newLabel();
+  Label L_LargeEnd  = cc.newLabel();
+  Label L_Done = cc.newLabel();
+
+  // Load SIMD Constants.
+  cc.xorps(vzero, vzero);
+  cc.mov(gp0.r32(), 0x00800080);
+  cc.movd(v0080, gp0.r32());
+  cc.mov(gp0.r32(), 0x01010101);
+  cc.movd(v0101, gp0.r32());
+  cc.pshufd(v0080, v0080, x86::shuffleImm(0, 0, 0, 0));
+  cc.pshufd(v0101, v0101, x86::shuffleImm(0, 0, 0, 0));
+
+  // How many pixels have to be processed to make the loop aligned.
+  cc.xor_(j, j);
+  cc.sub(j, dst);
+  cc.and_(j, 15);
+  cc.shr(j, 2);
+  cc.jz(L_SmallEnd);
+
+  cc.cmp(j, i);
+  cc.cmovg(j, i); // j = min(i, j)
+  cc.sub(i, j);   // i -= j
+
+  // Small loop.
+  cc.bind(L_SmallLoop);
+  {
+    x86::Xmm x0 = simd3;
+    x86::Xmm y0 = simd4;
+    x86::Xmm a0 = simd5;
+
+    cc.movd(y0, x86::ptr(src));
+    cc.movd(x0, x86::ptr(dst));
+
+    cc.pcmpeqb(a0, a0);
+    cc.pxor(a0, y0);
+    cc.psrlw(a0, 8);
+    cc.punpcklbw(x0, vzero);
+
+    cc.pshuflw(a0, a0, x86::shuffleImm(1, 1, 1, 1));
+    cc.punpcklbw(y0, vzero);
+
+    cc.pmullw(x0, a0);
+    cc.paddsw(x0, v0080);
+    cc.pmulhuw(x0, v0101);
+
+    cc.paddw(x0, y0);
+    cc.packuswb(x0, x0);
+
+    cc.movd(x86::ptr(dst), x0);
+
+    cc.add(dst, 4);
+    cc.add(src, 4);
+
+    cc.dec(j);
+    cc.jnz(L_SmallLoop);
+  }
+
+  // Second section, prepare for an aligned loop.
+  cc.bind(L_SmallEnd);
+
+  cc.test(i, i);
+  cc.mov(j, i);
+  cc.jz(L_Done);
+
+  cc.and_(j, 3);
+  cc.shr(i, 2);
+  cc.jz(L_LargeEnd);
+
+  // Aligned loop.
+  cc.bind(L_LargeLoop);
+  {
+    x86::Xmm x0 = simd3;
+    x86::Xmm x1 = simd4;
+    x86::Xmm y0 = simd5;
+    x86::Xmm a0 = simd6;
+    x86::Xmm a1 = simd7;
+
+    cc.movups(y0, x86::ptr(src));
+    cc.movaps(x0, x86::ptr(dst));
+
+    cc.pcmpeqb(a0, a0);
+    cc.xorps(a0, y0);
+    cc.movaps(x1, x0);
+
+    cc.psrlw(a0, 8);
+    cc.punpcklbw(x0, vzero);
+
+    cc.movaps(a1, a0);
+    cc.punpcklwd(a0, a0);
+
+    cc.punpckhbw(x1, vzero);
+    cc.punpckhwd(a1, a1);
+
+    cc.pshufd(a0, a0, x86::shuffleImm(3, 3, 1, 1));
+    cc.pshufd(a1, a1, x86::shuffleImm(3, 3, 1, 1));
+
+    cc.pmullw(x0, a0);
+    cc.pmullw(x1, a1);
+
+    cc.paddsw(x0, v0080);
+    cc.paddsw(x1, v0080);
+
+    cc.pmulhuw(x0, v0101);
+    cc.pmulhuw(x1, v0101);
+
+    cc.add(src, 16);
+    cc.packuswb(x0, x1);
+
+    cc.paddw(x0, y0);
+    cc.movaps(x86::ptr(dst), x0);
+
+    cc.add(dst, 16);
+
+    cc.dec(i);
+    cc.jnz(L_LargeLoop);
+  }
+
+  cc.bind(L_LargeEnd);
+  cc.test(j, j);
+  cc.jnz(L_SmallLoop);
+
+  cc.bind(L_Done);
+}
+
+static void generateSseAlphaBlend(asmjit::BaseEmitter& emitter, bool emitPrologEpilog) {
+  using namespace asmjit::x86;
+
+  if (emitter.isAssembler()) {
+    Assembler& cc = *emitter.as<Assembler>();
+
+    x86::Gp dst = cc.zax();
+    x86::Gp src = cc.zcx();
+    x86::Gp i = cc.zdx();
+    x86::Gp j = cc.zdi();
+
+    if (emitPrologEpilog) {
+      FuncDetail func;
+      func.init(FuncSignatureT<void, void*, const void*, size_t>(CallConvId::kHost), cc.environment());
+
+      FuncFrame frame;
+      frame.init(func);
+      frame.addDirtyRegs(dst, src, i, j);
+      frame.addDirtyRegs(xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7);
+
+      FuncArgsAssignment args(&func);
+      args.assignAll(dst, src, i);
+      args.updateFuncFrame(frame);
+      frame.finalize();
+
+      cc.emitProlog(frame);
+      cc.emitArgsAssignment(frame, args);
+      generateSseAlphaBlendInternal(cc, dst, src, i, j, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7);
+      cc.emitEpilog(frame);
+    }
+    else {
+      generateSseAlphaBlendInternal(cc, dst, src, i, j, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7);
+    }
+  }
+#ifndef ASMJIT_NO_BUILDER
+  else if (emitter.isBuilder()) {
+    Builder& cc = *emitter.as<Builder>();
+
+    x86::Gp dst = cc.zax();
+    x86::Gp src = cc.zcx();
+    x86::Gp i = cc.zdx();
+    x86::Gp j = cc.zdi();
+
+    if (emitPrologEpilog) {
+      FuncDetail func;
+      func.init(FuncSignatureT<void, void*, const void*, size_t>(CallConvId::kHost), cc.environment());
+
+      FuncFrame frame;
+      frame.init(func);
+      frame.addDirtyRegs(dst, src, i, j);
+      frame.addDirtyRegs(xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7);
+
+      FuncArgsAssignment args(&func);
+      args.assignAll(dst, src, i);
+      args.updateFuncFrame(frame);
+      frame.finalize();
+
+      cc.emitProlog(frame);
+      cc.emitArgsAssignment(frame, args);
+      generateSseAlphaBlendInternal(cc, dst, src, i, j, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7);
+      cc.emitEpilog(frame);
+    }
+    else {
+      generateSseAlphaBlendInternal(cc, dst, src, i, j, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7);
+    }
+  }
+#endif
+#ifndef ASMJIT_NO_COMPILER
+  else if (emitter.isCompiler()) {
+    Compiler& cc = *emitter.as<Compiler>();
+
+    Gp dst = cc.newIntPtr("dst");
+    Gp src = cc.newIntPtr("src");
+    Gp i = cc.newIntPtr("i");
+    Gp j = cc.newIntPtr("j");
+
+    Xmm v0 = cc.newXmm("v0");
+    Xmm v1 = cc.newXmm("v1");
+    Xmm v2 = cc.newXmm("v2");
+    Xmm v3 = cc.newXmm("v3");
+    Xmm v4 = cc.newXmm("v4");
+    Xmm v5 = cc.newXmm("v5");
+    Xmm v6 = cc.newXmm("v6");
+    Xmm v7 = cc.newXmm("v7");
+
+    FuncNode* funcNode = cc.addFunc(FuncSignatureT<void, void*, const void*, size_t>(CallConvId::kHost));
+    funcNode->setArg(0, dst);
+    funcNode->setArg(1, src);
+    funcNode->setArg(2, i);
+    generateSseAlphaBlendInternal(cc, dst, src, i, j, v0, v1, v2, v3, v4, v5, v6, v7);
+    cc.endFunc();
+  }
+#endif
+}
+
+} // {asmtest}
+
+#endif // ASMJIT_TEST_MISC_H_INCLUDED

data/ext/asmjit/asmjit/test/asmjit_test_perf.cpp

@@ -0,0 +1,62 @@
+// 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 <asmjit/core.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cmdline.h"
+
+using namespace asmjit;
+
+#if !defined(ASMJIT_NO_X86)
+void benchmarkX86Emitters(uint32_t numIterations, bool testX86, bool testX64) noexcept;
+#endif
+
+#if !defined(ASMJIT_NO_AARCH64)
+void benchmarkA64Emitters(uint32_t numIterations);
+#endif
+
+int main(int argc, char* argv[]) {
+  CmdLine cmdLine(argc, argv);
+  uint32_t numIterations = 20000;
+
+  printf("AsmJit Performance Suite v%u.%u.%u:\n\n",
+    unsigned((ASMJIT_LIBRARY_VERSION >> 16)       ),
+    unsigned((ASMJIT_LIBRARY_VERSION >>  8) & 0xFF),
+    unsigned((ASMJIT_LIBRARY_VERSION      ) & 0xFF));
+
+  printf("Usage:\n");
+  printf("  --help        Show usage only\n");
+  printf("  --quick       Decrease the number of iterations to make tests quicker\n");
+  printf("  --arch=<ARCH> Select architecture to run ('all' by default)\n");
+  printf("\n");
+
+  if (cmdLine.hasArg("--help"))
+    return 0;
+
+  if (cmdLine.hasArg("--quick"))
+    numIterations = 1000;
+
+  const char* arch = cmdLine.valueOf("--arch", "all");
+
+#if !defined(ASMJIT_NO_X86)
+  bool testX86 = strcmp(arch, "all") == 0 || strcmp(arch, "x86") == 0;
+  bool testX64 = strcmp(arch, "all") == 0 || strcmp(arch, "x64") == 0;
+
+  if (testX86 || testX64)
+    benchmarkX86Emitters(numIterations, testX86, testX64);
+#endif
+
+#if !defined(ASMJIT_NO_AARCH64)
+  bool testAArch64 = strcmp(arch, "all") == 0 || strcmp(arch, "aarch64") == 0;
+
+  if (testAArch64)
+    benchmarkA64Emitters(numIterations);
+#endif
+
+  return 0;
+}