virtual void compile(X86Compiler& c)
{
Label skip(c.newLabel());
X86CompilerFuncDecl* func = c.newFunc(kX86FuncConvDefault, FuncBuilder1<int, int>());
func->setHint(kFuncHintNaked, true);
GpVar var(c.getGpArg(0));
c.cmp(var, imm(1));
c.jle(skip);
GpVar tmp(c.newGpVar(kX86VarTypeInt32));
c.mov(tmp, var);
c.dec(tmp);
X86CompilerFuncCall* fCall = c.call(func->getEntryLabel());
fCall->setPrototype(kX86FuncConvDefault, FuncBuilder1<int, int>());
fCall->setArgument(0, tmp);
fCall->setReturn(tmp);
c.mul(c.newGpVar(kX86VarTypeInt32), var, tmp);
c.bind(skip);
c.ret(var);
c.endFunc();
}
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)
{
int i;
GpVar var[32];
c.newFunc(kX86FuncConvDefault, FuncBuilder1<Void, int*>());
for (i = 0; i < ASMJIT_ARRAY_SIZE(var); i++)
{
var[i] = c.newGpVar(kX86VarTypeGpd);
c.xor_(var[i], var[i]);
}
GpVar v0(c.newGpVar(kX86VarTypeGpd));
Label L(c.newLabel());
c.mov(v0, imm(32));
c.bind(L);
for (i = 0; i < ASMJIT_ARRAY_SIZE(var); i++)
{
c.add(var[i], imm(i));
}
c.dec(v0);
c.jnz(L);
GpVar a0(c.getGpArg(0));
for (i = 0; i < ASMJIT_ARRAY_SIZE(var); i++)
{
c.mov(dword_ptr(a0, i * 4), var[i]);
}
c.endFunc();
}
virtual void compile(X86Compiler& c)
{
c.newFunc(kX86FuncConvDefault, FuncBuilder0<Void>());
Label L_A = c.newLabel();
Label L_B = c.newLabel();
Label L_C = c.newLabel();
c.jmp(L_B);
c.bind(L_A);
c.jmp(L_C);
c.bind(L_B);
c.jmp(L_A);
c.bind(L_C);
c.ret();
c.endFunc();
}
virtual void compile(X86Compiler& c)
{
c.newFunc(kX86FuncConvDefault, FuncBuilder3<int, int, int, int>());
GpVar x(c.getGpArg(0));
GpVar y(c.getGpArg(1));
GpVar op(c.getGpArg(2));
GpVar result;
X86CompilerFuncCall* fCall;
Label opAdd(c.newLabel());
Label opMul(c.newLabel());
c.cmp(op, 0);
c.jz(opAdd);
c.cmp(op, 1);
c.jz(opMul);
result = c.newGpVar();
c.mov(result, imm(0));
c.ret(result);
c.bind(opAdd);
result = c.newGpVar();
fCall = c.call((void*)calledFuncAdd);
fCall->setPrototype(kX86FuncConvDefault, FuncBuilder2<int, int, int>());
fCall->setArgument(0, x);
fCall->setArgument(1, y);
fCall->setReturn(result);
c.ret(result);
c.bind(opMul);
result = c.newGpVar();
fCall = c.call((void*)calledFuncMul);
fCall->setPrototype(kX86FuncConvDefault, FuncBuilder2<int, int, int>());
fCall->setArgument(0, x);
fCall->setArgument(1, y);
fCall->setReturn(result);
c.ret(result);
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;
}
