virtual void compile(X86Compiler& c) { c.newFunc(kX86FuncConvDefault, FuncBuilder0<int>()); c.getFunc()->setHint(kFuncHintNaked, false); GpVar v0(c.newGpVar(kX86VarTypeGpd)); GpVar v1(c.newGpVar(kX86VarTypeGpd)); GpVar cnt(c.newGpVar(kX86VarTypeGpd)); c.xor_(v0, v0); c.xor_(v1, v1); c.spill(v0); c.spill(v1); Label L(c.newLabel()); c.mov(cnt, imm(32)); c.bind(L); c.inc(v1); c.add(v0, v1); c.dec(cnt); c.jnz(L); c.ret(v0); c.endFunc(); }
virtual void compile(X86Compiler& c) { c.newFunc(kX86FuncConvDefault, FuncBuilder3<Void, uint32_t*, const uint32_t*, size_t>()); c.getFunc()->setHint(kFuncHintNaked, true); // Omit unnecessary prolog/epilog. Label L_Loop = c.newLabel(); // Create base labels we use Label L_Exit = c.newLabel(); // in our function. GpVar dst(c.getGpArg(0)); // Get reference to function GpVar src(c.getGpArg(1)); // arguments. GpVar cnt(c.getGpArg(2)); c.alloc(dst); // Allocate all registers now, c.alloc(src); // because we want to keep them c.alloc(cnt); // in physical registers only. c.test(cnt, cnt); // Exit if length is zero. c.jz(L_Exit); c.bind(L_Loop); // Bind the loop label here. GpVar tmp(c.newGpVar(kX86VarTypeGpd)); // Copy a single dword (4 bytes). c.mov(tmp, dword_ptr(src)); c.mov(dword_ptr(dst), tmp); c.add(src, 4); // Increment dst/src pointers. c.add(dst, 4); c.dec(cnt); // Loop until cnt isn't zero. c.jnz(L_Loop); c.bind(L_Exit); // Bind the exit label here. c.endFunc(); // End of function. }
virtual void compile(X86Compiler& c) { c.newFunc(kX86FuncConvDefault, FuncBuilder1<int, int>()); c.getFunc()->setHint(kFuncHintNaked, true); // Call a function. GpVar address(c.newGpVar()); GpVar var(c.getGpArg(0)); c.mov(address, imm((sysint_t)(void*)calledFunc)); X86CompilerFuncCall* ctx; ctx = c.call(address); ctx->setPrototype(kX86FuncConvCompatFastCall, FuncBuilder1<int, int>()); ctx->setArgument(0, var); ctx->setReturn(var); ctx = c.call(address); ctx->setPrototype(kX86FuncConvCompatFastCall, FuncBuilder1<int, int>()); ctx->setArgument(0, var); ctx->setReturn(var); c.ret(var); c.endFunc(); }
virtual void compile(X86Compiler& c) { switch (_argsCount) { case 0: c.newFunc(kX86FuncConvDefault, FuncBuilder0<int>()); break; case 1: c.newFunc(kX86FuncConvDefault, FuncBuilder1<int, int>()); break; case 2: c.newFunc(kX86FuncConvDefault, FuncBuilder2<int, int, int>()); break; case 3: c.newFunc(kX86FuncConvDefault, FuncBuilder3<int, int, int, int>()); break; } if (_naked ) c.getFunc()->setHint(kFuncHintNaked, true); if (_pushPop) c.getFunc()->setHint(kX86FuncHintPushPop, true); GpVar gvar(c.newGpVar()); XmmVar xvar(c.newXmmVar(kX86VarTypeXmm)); // Alloc, use and spill preserved registers. if (_varsCount) { uint var = 0; uint index = 0; uint mask = 1; uint preserved = c.getFunc()->getDecl()->getGpPreservedMask(); do { if ((preserved & mask) != 0 && (index != kX86RegIndexEsp && index != kX86RegIndexEbp)) { GpVar somevar(c.newGpVar(kX86VarTypeGpd)); c.alloc(somevar, index); c.mov(somevar, imm(0)); c.spill(somevar); var++; } index++; mask <<= 1; } while (var < _varsCount && index < kX86RegNumGp); } c.alloc(gvar, zax); c.lea(gvar, xvar.m()); c.and_(gvar, imm(15)); c.ret(gvar); c.endFunc(); }
virtual void compile(X86Compiler& c) { c.newFunc(kX86FuncConvCompatFastCall, FuncBuilder1<int, int*>()); c.getFunc()->setHint(kFuncHintNaked, true); GpVar buf(c.getGpArg(0)); GpVar acc0(c.newGpVar(kX86VarTypeGpd)); GpVar acc1(c.newGpVar(kX86VarTypeGpd)); c.mov(acc0, 0); c.mov(acc1, 0); uint i; for (i = 0; i < 4; i++) { { GpVar ret = c.newGpVar(kX86VarTypeGpd); GpVar ptr = c.newGpVar(kX86VarTypeGpz); GpVar idx = c.newGpVar(kX86VarTypeGpd); c.mov(ptr, buf); c.mov(idx, imm(i)); X86CompilerFuncCall* fCall = c.call((void*)calledFunc); fCall->setPrototype(kX86FuncConvCompatFastCall, FuncBuilder2<int, int*, int>()); fCall->setArgument(0, ptr); fCall->setArgument(1, idx); fCall->setReturn(ret); c.add(acc0, ret); } { GpVar ret = c.newGpVar(kX86VarTypeGpd); GpVar ptr = c.newGpVar(kX86VarTypeGpz); GpVar idx = c.newGpVar(kX86VarTypeGpd); c.mov(ptr, buf); c.mov(idx, imm(i)); X86CompilerFuncCall* fCall = c.call((void*)calledFunc); fCall->setPrototype(kX86FuncConvCompatFastCall, FuncBuilder2<int, int*, int>()); fCall->setArgument(0, ptr); fCall->setArgument(1, idx); fCall->setReturn(ret); c.sub(acc1, ret); } } GpVar ret(c.newGpVar()); c.mov(ret, acc0); c.add(ret, acc1); c.ret(ret); c.endFunc(); }
virtual void compile(X86Compiler& c) { c.newFunc(kX86FuncConvDefault, FuncBuilder3<Void, void*, void*, size_t>()); c.getFunc()->setHint(kFuncHintNaked, true); GpVar dst(c.getGpArg(0)); GpVar src(c.getGpArg(1)); GpVar cnt(c.getGpArg(2)); c.rep_movsb(dst, src, cnt); c.endFunc(); }
virtual void compile(X86Compiler& c) { c.newFunc(kX86FuncConvDefault, FuncBuilder3<Void, int, int, char*>()); c.getFunc()->setHint(kFuncHintNaked, true); GpVar src0(c.getGpArg(0)); GpVar src1(c.getGpArg(1)); GpVar dst0(c.getGpArg(2)); c.cmp(src0, src1); c.setz(byte_ptr(dst0)); c.endFunc(); }
virtual void compile(X86Compiler& c) { c.newFunc(kX86FuncConvDefault, FuncBuilder4<Void, int*, int*, int, int>()); c.getFunc()->setHint(kFuncHintNaked, true); GpVar dst0_hi(c.getGpArg(0)); GpVar dst0_lo(c.getGpArg(1)); GpVar v0_hi(c.newGpVar(kX86VarTypeGpd)); GpVar v0_lo(c.getGpArg(2)); GpVar src0(c.getGpArg(3)); c.imul(v0_hi, v0_lo, src0); c.mov(dword_ptr(dst0_hi), v0_hi); c.mov(dword_ptr(dst0_lo), v0_lo); c.endFunc(); }
virtual void compile(X86Compiler& c) { c.newFunc(kX86FuncConvDefault, FuncBuilder2<Void, int*, const int*>()); c.getFunc()->setHint(kFuncHintNaked, true); GpVar dst = c.getGpArg(0); GpVar src = c.getGpArg(1); for (uint i = 0; i < 4; i++) { GpVar x = c.newGpVar(kX86VarTypeGpd); GpVar y = c.newGpVar(kX86VarTypeGpd); GpVar hi = c.newGpVar(kX86VarTypeGpd); c.mov(x, dword_ptr(src, 0)); c.mov(y, dword_ptr(src, 4)); c.imul(hi, x, y); c.add(dword_ptr(dst, 0), hi); c.add(dword_ptr(dst, 4), x); } c.endFunc(); }
int main(int argc, char* argv[]) { using namespace AsmJit; // ========================================================================== // Log compiler output. FileLogger logger(stderr); logger.setLogBinary(true); // Create compiler. /* X86Compiler c; c.setLogger(&logger); c.newFunc(kX86FuncConvDefault, FuncBuilder0<Void>()); c.getFunc()->setHint(kFuncHintNaked, true); X86CompilerFuncCall* ctx = c.call((void*)dummyFunc); ctx->setPrototype(kX86FuncConvDefault, FuncBuilder0<Void>()); c.endFunc(); */ X86Compiler c; c.setLogger(&logger); c.newFunc(kX86FuncConvDefault, FuncBuilder0<void>()); c.getFunc()->setHint(kFuncHintNaked, true); Label l91 = c.newLabel(); Label l92 = c.newLabel(); Label l93 = c.newLabel(); Label l94 = c.newLabel(); Label l95 = c.newLabel(); Label l96 = c.newLabel(); Label l97 = c.newLabel(); c.bind(l92); GpVar _var91(c.newGpVar()); GpVar _var92(c.newGpVar()); c.bind(l93); c.jmp(l91); c.bind(l95); c.mov(_var91, imm(0)); c.bind(l96); c.jmp(l93); c.mov(_var92, imm(1)); c.jmp(l91); c.bind(l94); c.jmp(l92); c.bind(l97); c.add(_var91, _var92); c.bind(l91); c.ret(); c.endFunc(); typedef void (*Func9)(void); Func9 func9 = asmjit_cast<Func9>(c.make()); // ========================================================================== // ========================================================================== // Make the function. // MyFn fn = asmjit_cast<MyFn>(c.make()); // Call it. // printf("Result %llu\n", (unsigned long long)fn()); // Free the generated function if it's not needed anymore. //MemoryManager::getGlobal()->free((void*)fn); // ========================================================================== return 0; }