diff options
Diffstat (limited to '3rdparty/asmjit/asmjit-testing/bench/asmjit_bench_codegen_a64.cpp')
| -rw-r--r-- | 3rdparty/asmjit/asmjit-testing/bench/asmjit_bench_codegen_a64.cpp | 707 |
1 files changed, 707 insertions, 0 deletions
diff --git a/3rdparty/asmjit/asmjit-testing/bench/asmjit_bench_codegen_a64.cpp b/3rdparty/asmjit/asmjit-testing/bench/asmjit_bench_codegen_a64.cpp new file mode 100644 index 00000000000..7bb85356b93 --- /dev/null +++ b/3rdparty/asmjit/asmjit-testing/bench/asmjit_bench_codegen_a64.cpp @@ -0,0 +1,707 @@ +// This file is part of AsmJit project <https://asmjit.com> +// +// See <asmjit/core.h> or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#include <asmjit/core.h> + +#if !defined(ASMJIT_NO_AARCH64) +#include <asmjit/a64.h> + +#include <asmjit-testing/bench/asmjit_bench_codegen.h> + +#include <limits> +#include <stdio.h> +#include <string.h> + +using namespace asmjit; + +// Generates a long sequence of GP instructions. +template<typename Emitter> +static void generate_gp_sequence_internal( + Emitter& cc, + const a64::Gp& a, const a64::Gp& b, const a64::Gp& c, const a64::Gp& d) { + + using namespace asmjit::a64; + + Gp wa = a.w(); + Gp wb = b.w(); + Gp wc = c.w(); + Gp wd = d.w(); + + Gp xa = a.x(); + Gp xb = b.x(); + Gp xc = c.x(); + Gp xd = d.x(); + + Mem m = ptr(xd); + + cc.mov(wa, 0); + cc.mov(wb, 1); + cc.mov(wc, 2); + cc.mov(wd, 3); + + cc.adc(wa, wb, wc); + cc.adc(xa, xb, xc); + cc.adc(wa, wzr, wc); + cc.adc(xa, xzr, xc); + cc.adc(wzr, wb, wc); + cc.adc(xzr, xb, xc); + cc.adcs(wa, wb, wc); + cc.adcs(xa, xb, xc); + cc.add(wa, wb, wc); + cc.add(xa, xb, xc); + cc.add(wa, wb, wc, lsl(3)); + cc.add(xa, xb, xc, lsl(3)); + cc.add(wa, wzr, wc); + cc.add(xa, xzr, xc); + cc.add(wzr, wb, wc); + cc.add(xzr, xb, xc); + cc.add(wc, wd, 0, lsl(12)); + cc.add(xc, xd, 0, lsl(12)); + cc.add(wc, wd, 1024, lsl(12)); + cc.add(xc, xd, 1024, lsl(12)); + cc.add(wc, wd, 1024, lsl(12)); + cc.add(xc, xd, 1024, lsl(12)); + cc.adds(wa, wb, wc); + cc.adds(xa, xb, xc); + cc.adr(xa, 0); + cc.adr(xa, 256); + cc.adrp(xa, 4096); + cc.and_(wa, wb, wc); + cc.and_(xa, xb, xc); + cc.and_(wa, wb, 1); + cc.and_(xa, xb, 1); + cc.and_(wa, wb, 15); + cc.and_(xa, xb, 15); + cc.and_(wa, wzr, wc); + cc.and_(xa, xzr, xc); + cc.and_(wzr, wb, wc); + cc.and_(xzr, xb, xc); + cc.and_(wa, wb, 0x1); + cc.and_(xa, xb, 0x1); + cc.and_(wa, wb, 0xf); + cc.and_(xa, xb, 0xf); + cc.ands(wa, wb, wc); + cc.ands(xa, xb, xc); + cc.ands(wa, wzr, wc); + cc.ands(xa, xzr, xc); + cc.ands(wzr, wb, wc); + cc.ands(xzr, xb, xc); + cc.ands(wa, wb, 0x1); + cc.ands(xa, xb, 0x1); + cc.ands(wa, wb, 0xf); + cc.ands(xa, xb, 0xf); + cc.asr(wa, wb, 15); + cc.asr(xa, xb, 15); + cc.asrv(wa, wb, wc); + cc.asrv(xa, xb, xc); + cc.bfc(wa, 8, 16); + cc.bfc(xa, 8, 16); + cc.bfi(wa, wb, 8, 16); + cc.bfi(xa, xb, 8, 16); + cc.bfm(wa, wb, 8, 16); + cc.bfm(xa, xb, 8, 16); + cc.bfxil(wa, wb, 8, 16); + cc.bfxil(xa, xb, 8, 16); + cc.bic(wa, wb, wc, lsl(4)); + cc.bic(xa, xb, xc, lsl(4)); + cc.bic(wa, wzr, wc); + cc.bic(xa, xzr, xc); + cc.bics(wa, wb, wc, lsl(4)); + cc.bics(xa, xb, xc, lsl(4)); + cc.bics(wa, wzr, wc); + cc.bics(xa, xzr, xc); + cc.cas(wa, wb, m); + cc.cas(xa, xb, m); + cc.casa(wa, wb, m); + cc.casa(xa, xb, m); + cc.casab(wa, wb, m); + cc.casah(wa, wb, m); + cc.casal(wa, wb, m); + cc.casal(xa, xb, m); + cc.casalb(wa, wb, m); + cc.casalh(wa, wb, m); + cc.casb(wa, wb, m); + cc.cash(wa, wb, m); + cc.casl(wa, wb, m); + cc.casl(xa, xb, m); + cc.caslb(wa, wb, m); + cc.caslh(wa, wb, m); + cc.ccmn(wa, wb, 3, CondCode::kEQ); + cc.ccmn(xa, xb, 3, CondCode::kEQ); + cc.ccmn(wa, 2, 3, CondCode::kEQ); + cc.ccmn(xa, 2, 3, CondCode::kEQ); + cc.ccmn(wa, wzr, 3, CondCode::kEQ); + cc.ccmn(xa, xzr, 3, CondCode::kEQ); + cc.ccmp(wa, wb, 3, CondCode::kEQ); + cc.ccmp(xa, xb, 3, CondCode::kEQ); + cc.ccmp(wa, 2, 3, CondCode::kEQ); + cc.ccmp(xa, 2, 3, CondCode::kEQ); + cc.ccmp(wa, wzr, 3, CondCode::kEQ); + cc.ccmp(xa, xzr, 3, CondCode::kEQ); + cc.cinc(wa, wb, CondCode::kEQ); + cc.cinc(xa, xb, CondCode::kEQ); + cc.cinc(wzr, wb, CondCode::kEQ); + cc.cinc(wa, wzr, CondCode::kEQ); + cc.cinc(xzr, xb, CondCode::kEQ); + cc.cinc(xa, xzr, CondCode::kEQ); + cc.cinv(wa, wb, CondCode::kEQ); + cc.cinv(xa, xb, CondCode::kEQ); + cc.cinv(wzr, wb, CondCode::kEQ); + cc.cinv(wa, wzr, CondCode::kEQ); + cc.cinv(xzr, xb, CondCode::kEQ); + cc.cinv(xa, xzr, CondCode::kEQ); + cc.cls(wa, wb); + cc.cls(xa, xb); + cc.cls(wa, wzr); + cc.cls(xa, xzr); + cc.cls(wzr, wb); + cc.cls(xzr, xb); + cc.clz(wa, wb); + cc.clz(xa, xb); + cc.clz(wa, wzr); + cc.clz(xa, xzr); + cc.clz(wzr, wb); + cc.clz(xzr, xb); + cc.cmn(wa, 33); + cc.cmn(xa, 33); + cc.cmn(wa, wb); + cc.cmn(xa, xb); + cc.cmn(wa, wb, uxtb(2)); + cc.cmn(xa, wb, uxtb(2)); + cc.cmp(wa, 33); + cc.cmp(xa, 33); + cc.cmp(wa, wb); + cc.cmp(xa, xb); + cc.cmp(wa, wb, uxtb(2)); + cc.cmp(xa, wb, uxtb(2)); + cc.crc32b(wa, wb, wc); + cc.crc32b(wzr, wb, wc); + cc.crc32b(wa, wzr, wc); + cc.crc32b(wa, wb, wzr); + cc.crc32cb(wa, wb, wc); + cc.crc32cb(wzr, wb, wc); + cc.crc32cb(wa, wzr, wc); + cc.crc32cb(wa, wb, wzr); + cc.crc32ch(wa, wb, wc); + cc.crc32ch(wzr, wb, wc); + cc.crc32ch(wa, wzr, wc); + cc.crc32ch(wa, wb, wzr); + cc.crc32cw(wa, wb, wc); + cc.crc32cw(wzr, wb, wc); + cc.crc32cw(wa, wzr, wc); + cc.crc32cw(wa, wb, wzr); + cc.crc32cx(wa, wb, xc); + cc.crc32cx(wzr, wb, xc); + cc.crc32cx(wa, wzr, xc); + cc.crc32cx(wa, wb, xzr); + cc.crc32h(wa, wb, wc); + cc.crc32h(wzr, wb, wc); + cc.crc32h(wa, wzr, wc); + cc.crc32h(wa, wb, wzr); + cc.crc32w(wa, wb, wc); + cc.crc32w(wzr, wb, wc); + cc.crc32w(wa, wzr, wc); + cc.crc32w(wa, wb, wzr); + cc.crc32x(wa, wb, xc); + cc.crc32x(wzr, wb, xc); + cc.crc32x(wa, wzr, xc); + cc.crc32x(wa, wb, xzr); + cc.csel(wa, wb, wc, CondCode::kEQ); + cc.csel(xa, xb, xc, CondCode::kEQ); + cc.cset(wa, CondCode::kEQ); + cc.cset(xa, CondCode::kEQ); + cc.cset(wa, CondCode::kEQ); + cc.cset(xa, CondCode::kEQ); + cc.csetm(wa, CondCode::kEQ); + cc.csetm(xa, CondCode::kEQ); + cc.csinc(wa, wb, wc, CondCode::kEQ); + cc.csinc(xa, xb, xc, CondCode::kEQ); + cc.csinv(wa, wb, wc, CondCode::kEQ); + cc.csinv(xa, xb, xc, CondCode::kEQ); + cc.csneg(wa, wb, wc, CondCode::kEQ); + cc.csneg(xa, xb, xc, CondCode::kEQ); + cc.eon(wa, wb, wc); + cc.eon(wzr, wb, wc); + cc.eon(wa, wzr, wc); + cc.eon(wa, wb, wzr); + cc.eon(wa, wb, wc, lsl(4)); + cc.eon(xa, xb, xc); + cc.eon(xzr, xb, xc); + cc.eon(xa, xzr, xc); + cc.eon(xa, xb, xzr); + cc.eon(xa, xb, xc, lsl(4)); + cc.eor(wa, wb, wc); + cc.eor(wzr, wb, wc); + cc.eor(wa, wzr, wc); + cc.eor(wa, wb, wzr); + cc.eor(xa, xb, xc); + cc.eor(xzr, xb, xc); + cc.eor(xa, xzr, xc); + cc.eor(xa, xb, xzr); + cc.eor(wa, wb, wc, lsl(4)); + cc.eor(xa, xb, xc, lsl(4)); + cc.eor(wa, wb, 0x4000); + cc.eor(xa, xb, 0x8000); + cc.extr(wa, wb, wc, 15); + cc.extr(wzr, wb, wc, 15); + cc.extr(wa, wzr, wc, 15); + cc.extr(wa, wb, wzr, 15); + cc.extr(xa, xb, xc, 15); + cc.extr(xzr, xb, xc, 15); + cc.extr(xa, xzr, xc, 15); + cc.extr(xa, xb, xzr, 15); + cc.ldadd(wa, wb, m); + cc.ldadd(xa, xb, m); + cc.ldadda(wa, wb, m); + cc.ldadda(xa, xb, m); + cc.ldaddab(wa, wb, m); + cc.ldaddah(wa, wb, m); + cc.ldaddal(wa, wb, m); + cc.ldaddal(xa, xb, m); + cc.ldaddalb(wa, wb, m); + cc.ldaddalh(wa, wb, m); + cc.ldaddb(wa, wb, m); + cc.ldaddh(wa, wb, m); + cc.ldaddl(wa, wb, m); + cc.ldaddl(xa, xb, m); + cc.ldaddlb(wa, wb, m); + cc.ldaddlh(wa, wb, m); + cc.ldclr(wa, wb, m); + cc.ldclr(xa, xb, m); + cc.ldclra(wa, wb, m); + cc.ldclra(xa, xb, m); + cc.ldclrab(wa, wb, m); + cc.ldclrah(wa, wb, m); + cc.ldclral(wa, wb, m); + cc.ldclral(xa, xb, m); + cc.ldclralb(wa, wb, m); + cc.ldclralh(wa, wb, m); + cc.ldclrb(wa, wb, m); + cc.ldclrh(wa, wb, m); + cc.ldclrl(wa, wb, m); + cc.ldclrl(xa, xb, m); + cc.ldclrlb(wa, wb, m); + cc.ldclrlh(wa, wb, m); + cc.ldeor(wa, wb, m); + cc.ldeor(xa, xb, m); + cc.ldeora(wa, wb, m); + cc.ldeora(xa, xb, m); + cc.ldeorab(wa, wb, m); + cc.ldeorah(wa, wb, m); + cc.ldeoral(wa, wb, m); + cc.ldeoral(xa, xb, m); + cc.ldeoralb(wa, wb, m); + cc.ldeoralh(wa, wb, m); + cc.ldeorb(wa, wb, m); + cc.ldeorh(wa, wb, m); + cc.ldeorl(wa, wb, m); + cc.ldeorl(xa, xb, m); + cc.ldeorlb(wa, wb, m); + cc.ldeorlh(wa, wb, m); + cc.ldlar(wa, m); + cc.ldlar(xa, m); + cc.ldlarb(wa, m); + cc.ldlarh(wa, m); + cc.ldnp(wa, wb, m); + cc.ldnp(xa, xb, m); + cc.ldp(wa, wb, m); + cc.ldp(xa, xb, m); + cc.ldpsw(xa, xb, m); + cc.ldr(wa, m); + cc.ldr(xa, m); + cc.ldrb(wa, m); + cc.ldrh(wa, m); + cc.ldrsw(xa, m); + cc.ldraa(xa, m); + cc.ldrab(xa, m); + cc.ldset(wa, wb, m); + cc.ldset(xa, xb, m); + cc.ldseta(wa, wb, m); + cc.ldseta(xa, xb, m); + cc.ldsetab(wa, wb, m); + cc.ldsetah(wa, wb, m); + cc.ldsetal(wa, wb, m); + cc.ldsetal(xa, xb, m); + cc.ldsetalh(wa, wb, m); + cc.ldsetalb(wa, wb, m); + cc.ldsetb(wa, wb, m); + cc.ldseth(wa, wb, m); + cc.ldsetl(wa, wb, m); + cc.ldsetl(xa, xb, m); + cc.ldsetlb(wa, wb, m); + cc.ldsetlh(wa, wb, m); + cc.ldsmax(wa, wb, m); + cc.ldsmax(xa, xb, m); + cc.ldsmaxa(wa, wb, m); + cc.ldsmaxa(xa, xb, m); + cc.ldsmaxab(wa, wb, m); + cc.ldsmaxah(wa, wb, m); + cc.ldsmaxal(wa, wb, m); + cc.ldsmaxal(xa, xb, m); + cc.ldsmaxalb(wa, wb, m); + cc.ldsmaxalh(wa, wb, m); + cc.ldsmaxb(wa, wb, m); + cc.ldsmaxh(wa, wb, m); + cc.ldsmaxl(wa, wb, m); + cc.ldsmaxl(xa, xb, m); + cc.ldsmaxlb(wa, wb, m); + cc.ldsmaxlh(wa, wb, m); + cc.ldsmin(wa, wb, m); + cc.ldsmin(xa, xb, m); + cc.ldsmina(wa, wb, m); + cc.ldsmina(xa, xb, m); + cc.ldsminab(wa, wb, m); + cc.ldsminah(wa, wb, m); + cc.ldsminal(wa, wb, m); + cc.ldsminal(xa, xb, m); + cc.ldsminalb(wa, wb, m); + cc.ldsminalh(wa, wb, m); + cc.ldsminb(wa, wb, m); + cc.ldsminh(wa, wb, m); + cc.ldsminl(wa, wb, m); + cc.ldsminl(xa, xb, m); + cc.ldsminlb(wa, wb, m); + cc.ldsminlh(wa, wb, m); + cc.ldtr(wa, m); + cc.ldtr(xa, m); + cc.ldtrb(wa, m); + cc.ldtrh(wa, m); + cc.ldtrsb(wa, m); + cc.ldtrsh(wa, m); + cc.ldtrsw(xa, m); + cc.ldumax(wa, wb, m); + cc.ldumax(xa, xb, m); + cc.ldumaxa(wa, wb, m); + cc.ldumaxa(xa, xb, m); + cc.ldumaxab(wa, wb, m); + cc.ldumaxah(wa, wb, m); + cc.ldumaxal(wa, wb, m); + cc.ldumaxal(xa, xb, m); + cc.ldumaxalb(wa, wb, m); + cc.ldumaxalh(wa, wb, m); + cc.ldumaxb(wa, wb, m); + cc.ldumaxh(wa, wb, m); + cc.ldumaxl(wa, wb, m); + cc.ldumaxl(xa, xb, m); + cc.ldumaxlb(wa, wb, m); + cc.ldumaxlh(wa, wb, m); + cc.ldumin(wa, wb, m); + cc.ldumin(xa, xb, m); + cc.ldumina(wa, wb, m); + cc.ldumina(xa, xb, m); + cc.lduminab(wa, wb, m); + cc.lduminah(wa, wb, m); + cc.lduminal(wa, wb, m); + cc.lduminal(xa, xb, m); + cc.lduminalb(wa, wb, m); + cc.lduminalh(wa, wb, m); + cc.lduminb(wa, wb, m); + cc.lduminh(wa, wb, m); + cc.lduminl(wa, wb, m); + cc.lduminl(xa, xb, m); + cc.lduminlb(wa, wb, m); + cc.lduminlh(wa, wb, m); + cc.ldur(wa, m); + cc.ldur(xa, m); + cc.ldurb(wa, m); + cc.ldurh(wa, m); + cc.ldursb(wa, m); + cc.ldursh(wa, m); + cc.ldursw(xa, m); + cc.ldxp(wa, wb, m); + cc.ldxp(xa, xb, m); + cc.ldxr(wa, m); + cc.ldxr(xa, m); + cc.ldxrb(wa, m); + cc.ldxrh(wa, m); + cc.lsl(wa, wb, wc); + cc.lsl(xa, xb, xc); + cc.lsl(wa, wb, 15); + cc.lsl(xa, xb, 15); + cc.lslv(wa, wb, wc); + cc.lslv(xa, xb, xc); + cc.lsr(wa, wb, wc); + cc.lsr(xa, xb, xc); + cc.lsr(wa, wb, 15); + cc.lsr(xa, xb, 15); + cc.lsrv(wa, wb, wc); + cc.lsrv(xa, xb, xc); + cc.madd(wa, wb, wc, wd); + cc.madd(xa, xb, xc, xd); + cc.mneg(wa, wb, wc); + cc.mneg(xa, xb, xc); + cc.mov(wa, wb); + cc.mov(xa, xb); + cc.mov(wa, 0); + cc.mov(wa, 1); + cc.mov(wa, 2); + cc.mov(wa, 3); + cc.mov(wa, 4); + cc.mov(wa, 5); + cc.mov(wa, 6); + cc.mov(wa, 7); + cc.mov(wa, 8); + cc.mov(wa, 9); + cc.mov(wa, 10); + cc.mov(wa, 0xA234); + cc.mov(xa, 0xA23400000000); + cc.msub(wa, wb, wc, wd); + cc.msub(xa, xb, xc, xd); + cc.mul(wa, wb, wc); + cc.mul(xa, xb, xc); + cc.mvn_(wa, wb); + cc.mvn_(xa, xb); + cc.mvn_(wa, wb, lsl(4)); + cc.mvn_(xa, xb, lsl(4)); + cc.neg(wa, wb); + cc.neg(xa, xb); + cc.neg(wa, wb, lsl(4)); + cc.neg(xa, xb, lsl(4)); + cc.negs(wa, wb); + cc.negs(xa, xb); + cc.negs(wa, wb, lsl(4)); + cc.negs(xa, xb, lsl(4)); + cc.ngc(wa, wb); + cc.ngc(xa, xb); + cc.ngcs(wa, wb); + cc.ngcs(xa, xb); + cc.orn(wa, wb, wc); + cc.orn(xa, xb, xc); + cc.orn(wa, wb, wc, lsl(4)); + cc.orn(xa, xb, xc, lsl(4)); + cc.orr(wa, wb, wc); + cc.orr(xa, xb, xc); + cc.orr(wa, wb, wc, lsl(4)); + cc.orr(xa, xb, xc, lsl(4)); + cc.orr(wa, wb, 0x4000); + cc.orr(xa, xb, 0x8000); + cc.rbit(wa, wb); + cc.rbit(xa, xb); + cc.rev(wa, wb); + cc.rev(xa, xb); + cc.rev16(wa, wb); + cc.rev16(xa, xb); + cc.rev32(xa, xb); + cc.rev64(xa, xb); + cc.ror(wa, wb, wc); + cc.ror(xa, xb, xc); + cc.ror(wa, wb, 15); + cc.ror(xa, xb, 15); + cc.rorv(wa, wb, wc); + cc.rorv(xa, xb, xc); + cc.sbc(wa, wb, wc); + cc.sbc(xa, xb, xc); + cc.sbcs(wa, wb, wc); + cc.sbcs(xa, xb, xc); + cc.sbfiz(wa, wb, 5, 10); + cc.sbfiz(xa, xb, 5, 10); + cc.sbfm(wa, wb, 5, 10); + cc.sbfm(xa, xb, 5, 10); + cc.sbfx(wa, wb, 5, 10); + cc.sbfx(xa, xb, 5, 10); + cc.sdiv(wa, wb, wc); + cc.sdiv(xa, xb, xc); + cc.smaddl(xa, wb, wc, xd); + cc.smnegl(xa, wb, wc); + cc.smsubl(xa, wb, wc, xd); + cc.smulh(xa, xb, xc); + cc.smull(xa, wb, wc); + cc.stp(wa, wb, m); + cc.stp(xa, xb, m); + cc.sttr(wa, m); + cc.sttr(xa, m); + cc.sttrb(wa, m); + cc.sttrh(wa, m); + cc.stur(wa, m); + cc.stur(xa, m); + cc.sturb(wa, m); + cc.sturh(wa, m); + cc.stxp(wa, wb, wc, m); + cc.stxp(wa, xb, xc, m); + cc.stxr(wa, wb, m); + cc.stxr(wa, xb, m); + cc.stxrb(wa, wb, m); + cc.stxrh(wa, wb, m); + cc.sub(wa, wb, wc); + cc.sub(xa, xb, xc); + cc.sub(wa, wb, wc, lsl(3)); + cc.sub(xa, xb, xc, lsl(3)); + cc.subg(xa, xb, 32, 11); + cc.subp(xa, xb, xc); + cc.subps(xa, xb, xc); + cc.subs(wa, wb, wc); + cc.subs(xa, xb, xc); + cc.subs(wa, wb, wc, lsl(3)); + cc.subs(xa, xb, xc, lsl(3)); + cc.sxtb(wa, wb); + cc.sxtb(xa, wb); + cc.sxth(wa, wb); + cc.sxth(xa, wb); + cc.sxtw(xa, wb); + cc.tst(wa, 1); + cc.tst(xa, 1); + cc.tst(wa, wb); + cc.tst(xa, xb); + cc.tst(wa, wb, lsl(4)); + cc.tst(xa, xb, lsl(4)); + cc.udiv(wa, wb, wc); + cc.udiv(xa, xb, xc); + cc.ubfiz(wa, wb, 5, 10); + cc.ubfiz(xa, xb, 5, 10); + cc.ubfm(wa, wb, 5, 10); + cc.ubfm(xa, xb, 5, 10); + cc.ubfx(wa, wb, 5, 10); + cc.ubfx(xa, xb, 5, 10); + cc.umaddl(xa, wb, wc, xd); + cc.umnegl(xa, wb, wc); + cc.umsubl(xa, wb, wc, xd); + cc.umulh(xa, xb, xc); + cc.umull(xa, wb, wc); + cc.uxtb(wa, wb); + cc.uxth(wa, wb); +} + +static void generate_gp_sequence(BaseEmitter& emitter, bool emit_prolog_epilog) { +#ifndef ASMJIT_NO_COMPILER + if (emitter.is_compiler()) { + a64::Compiler& cc = *emitter.as<a64::Compiler>(); + + a64::Gp a = cc.new_gp_ptr("a"); + a64::Gp b = cc.new_gp_ptr("b"); + a64::Gp c = cc.new_gp_ptr("c"); + a64::Gp d = cc.new_gp_ptr("d"); + + cc.add_func(FuncSignature::build<void>()); + generate_gp_sequence_internal(cc, a, b, c, d); + cc.end_func(); + + return; + } +#endif + +#ifndef ASMJIT_NO_BUILDER + if (emitter.is_builder()) { + a64::Builder& cc = *emitter.as<a64::Builder>(); + + a64::Gp a = a64::x0; + a64::Gp b = a64::x1; + a64::Gp c = a64::x2; + a64::Gp d = a64::x3; + + if (emit_prolog_epilog) { + FuncDetail func; + func.init(FuncSignature::build<void, void*, const void*, size_t>(), cc.environment()); + + FuncFrame frame; + frame.init(func); + frame.add_dirty_regs(a, b, c, d); + frame.finalize(); + + cc.emit_prolog(frame); + generate_gp_sequence_internal(cc, a, b, c, d); + cc.emit_epilog(frame); + } + else { + generate_gp_sequence_internal(cc, a, b, c, d); + } + + return; + } +#endif + + if (emitter.is_assembler()) { + a64::Assembler& cc = *emitter.as<a64::Assembler>(); + + a64::Gp a = a64::x0; + a64::Gp b = a64::x1; + a64::Gp c = a64::x2; + a64::Gp d = a64::x3; + + if (emit_prolog_epilog) { + FuncDetail func; + func.init(FuncSignature::build<void, void*, const void*, size_t>(), cc.environment()); + + FuncFrame frame; + frame.init(func); + frame.add_dirty_regs(a, b, c, d); + frame.finalize(); + + cc.emit_prolog(frame); + generate_gp_sequence_internal(cc, a, b, c, d); + cc.emit_epilog(frame); + } + else { + generate_gp_sequence_internal(cc, a, b, c, d); + } + + return; + } +} + +template<typename EmitterFn> +static void benchmark_a64_function(Arch arch, uint32_t num_iterations, const char* description, const EmitterFn& emitter_fn) noexcept { + CodeHolder code; + printf("%s:\n", description); + + uint32_t instruction_count = 0; + +#ifndef ASMJIT_NO_BUILDER + instruction_count = asmjit_perf_utils::calculate_instruction_count<a64::Builder>(code, arch, [&](a64::Builder& cc) { + emitter_fn(cc, false); + }); +#endif + + asmjit_perf_utils::bench<a64::Assembler>(code, arch, num_iterations, "[raw]", instruction_count, [&](a64::Assembler& cc) { + emitter_fn(cc, false); + }); + + asmjit_perf_utils::bench<a64::Assembler>(code, arch, num_iterations, "[validated]", instruction_count, [&](a64::Assembler& cc) { + cc.add_diagnostic_options(DiagnosticOptions::kValidateAssembler); + emitter_fn(cc, false); + }); + + asmjit_perf_utils::bench<a64::Assembler>(code, arch, num_iterations, "[prolog/epilog]", instruction_count, [&](a64::Assembler& cc) { + cc.add_diagnostic_options(DiagnosticOptions::kValidateAssembler); + emitter_fn(cc, true); + }); + +#ifndef ASMJIT_NO_BUILDER + asmjit_perf_utils::bench<a64::Builder>(code, arch, num_iterations, "[no-asm]", instruction_count, [&](a64::Builder& cc) { + emitter_fn(cc, false); + }); + + asmjit_perf_utils::bench<a64::Builder>(code, arch, num_iterations, "[finalized]", instruction_count, [&](a64::Builder& cc) { + emitter_fn(cc, false); + cc.finalize(); + }); + + asmjit_perf_utils::bench<a64::Builder>(code, arch, num_iterations, "[prolog/epilog]", instruction_count, [&](a64::Builder& cc) { + emitter_fn(cc, true); + cc.finalize(); + }); +#endif + +#ifndef ASMJIT_NO_COMPILER + asmjit_perf_utils::bench<a64::Compiler>(code, arch, num_iterations, "[no-asm]", instruction_count, [&](a64::Compiler& cc) { + emitter_fn(cc, true); + }); + + asmjit_perf_utils::bench<a64::Compiler>(code, arch, num_iterations, "[finalized]", instruction_count, [&](a64::Compiler& cc) { + emitter_fn(cc, true); + cc.finalize(); + }); +#endif + + printf("\n"); +} + +void benchmark_aarch64_emitters(uint32_t num_iterations) { + static const char description[] = "GpSequence (Sequence of GP instructions - reg/mem)"; + benchmark_a64_function(Arch::kAArch64, num_iterations, description, [](BaseEmitter& emitter, bool emit_prolog_epilog) { + generate_gp_sequence(emitter, emit_prolog_epilog); + }); +} + +#endif // !ASMJIT_NO_AARCH64 |
