protected override void Compile(CodeContext c) { var dst = c.IntPtr("dst"); var src = c.IntPtr("src"); var cnt = c.UIntPtr("cnt"); var loop = c.Label(); // Create base labels we use var exit = c.Label(); // in our function. c.SetArgument(0, dst); c.SetArgument(1, src); c.SetArgument(2, cnt); c.Allocate(dst); // Allocate all registers now, c.Allocate(src); // because we want to keep them c.Allocate(cnt); // in physical registers only. c.Test(cnt, cnt); // Exit if length is zero. c.Jz(exit); c.Bind(loop); // Bind the loop label here. var tmp = c.Int32("tmp"); // Copy a single dword (4 bytes). c.Mov(tmp, Memory.DWord(src)); c.Mov(Memory.DWord(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(loop); c.Bind(exit); // Bind the exit label here. }
protected override void Compile(CodeContext c) { var dst = c.IntPtr("dst"); var src = c.IntPtr("src"); var cnt = c.IntPtr("cnt"); c.SetArgument(0, dst); c.SetArgument(1, src); c.SetArgument(2, cnt); c.RepMovsb(dst, src, cnt); }
protected override void Compile(CodeContext c) { var a = c.IntPtr("a"); var b = c.IntPtr("b"); c.SetArgument(0, a); c.SetArgument(1, b); var dummy = c.Int32("dummy"); c.Xor(dummy, dummy); c.Idiv(dummy, a, b); c.Ret(a); }
protected override void Compile(CodeContext c) { const int count = 8; var a0 = c.IntPtr("a0"); var a1 = c.IntPtr("a1"); c.SetArgument(0, a0); c.SetArgument(1, a1); // Create some variables. var t = c.Int32("t"); var x = new GpVariable[count]; int i; for (i = 0; i < count; i++) { x[i] = c.Int32("x" + i); } // Setup variables (use mov with reg/imm to se if register allocator works). for (i = 0; i < count; i++) { c.Mov(x[i], i + 1); } // Make sum (addition). c.Xor(t, t); for (i = 0; i < count; i++) { c.Add(t, x[i]); } // Store result to a given pointer in first argument. c.Mov(Memory.DWord(a0), t); // Clear t. c.Xor(t, t); // Make sum (subtraction). for (i = 0; i < count; i++) { c.Sub(t, x[i]); } // Store result to a given pointer in second argument. c.Mov(Memory.DWord(a1), t); }
protected override void Compile(CodeContext c) { var stack = c.Stack(256, 1).SetSize(1); var i = c.IntPtr("i"); var a = c.Int32("a"); var b = c.Int32("b"); var l1 = c.Label(); var l2 = c.Label(); // Fill stack by sequence [0, 1, 2, 3 ... 255]. c.Xor(i, i); c.Bind(l1); c.Mov(stack.Clone().SetIndex(i), i.As8()); c.Inc(i); c.Cmp(i, 255); c.Jle(l1); // Sum sequence in stack. c.Xor(i, i); c.Xor(a, a); c.Bind(l2); c.Movzx(b, stack.Clone().SetIndex(i)); c.Add(a, b); c.Inc(i); c.Cmp(i, 255); c.Jle(l2); c.Ret(a); }
protected override void Compile(CodeContext c) { const int cnt = 7; var p = c.IntPtr("p"); var xv = new XmmVariable[cnt]; int i; for (i = 0; i < cnt; i++) { xv[i] = c.XmmSd("xv" + i); c.SetArgument(i, xv[i]); } c.SetArgument(7, p); c.Addsd(xv[0], xv[1]); c.Addsd(xv[0], xv[2]); c.Addsd(xv[0], xv[3]); c.Addsd(xv[0], xv[4]); c.Addsd(xv[0], xv[5]); c.Addsd(xv[0], xv[6]); c.Movsd(Memory.Ptr(p), xv[0]); }
protected override void Compile(CodeContext c) { var fn = c.IntPtr("fn"); var rv = c.Int32("rv"); var fp = Memory.Fn(new Func <IntPtr, IntPtr, IntPtr, IntPtr, IntPtr, IntPtr, IntPtr, IntPtr, IntPtr, IntPtr, int>(CalledFunction)); c.Mov(fn, fp); var call = c.Call(fn, fp); call.SetArgument(0, 1); call.SetArgument(1, 2); call.SetArgument(2, 3); call.SetArgument(3, 4); call.SetArgument(4, 5); call.SetArgument(5, 6); call.SetArgument(6, 7); call.SetArgument(7, 8); call.SetArgument(8, 9); call.SetArgument(9, 10); call.SetReturn(0, rv); c.Ret(rv); }
protected override void Compile(CodeContext c) { var v0 = c.Int32("v0"); var v1 = c.Int32("v1"); var v2 = c.Int32("v2"); c.SetArgument(0, v0); c.SetArgument(1, v1); c.SetArgument(2, v2); var fp = Memory.Fn(new Func <int, int, int, int>(CalledFunction)); // Just do something. c.Shl(v0, 1); c.Shl(v1, 1); c.Shl(v2, 1); var fn = c.IntPtr("fn"); c.Mov(fn, fp); var call = c.Call(fn, fp); call.SetArgument(0, v2); call.SetArgument(1, v1); call.SetArgument(2, v0); call.SetReturn(0, v0); c.Ret(v0); }
protected override void Compile(CodeContext c) { var fn = c.IntPtr("fn"); var a = c.Int32("a"); var fp = Memory.Fn(new Func <int, int, int, int, int, int, int, int, int, int, int>(CalledFunction)); c.Mov(fn, fp); c.Mov(a, 3); var call = c.Call(fn, fp); call.SetArgument(0, a); call.SetArgument(1, a); call.SetArgument(2, a); call.SetArgument(3, a); call.SetArgument(4, a); call.SetArgument(5, a); call.SetArgument(6, a); call.SetArgument(7, a); call.SetArgument(8, a); call.SetArgument(9, a); call.SetReturn(0, a); c.Ret(a); }
protected override void Compile(CodeContext c) { var fn = c.IntPtr("fn"); var rv = c.Int32("rv"); var fp = Memory.Fn(new Func <int, int, int, int, int, int, int, int, int, int, int>(CalledFunction)); c.Mov(fn, fp); var call = c.Call(fn, fp); call.SetArgument(0, 0x03); call.SetArgument(1, 0x12); call.SetArgument(2, 0xA0); call.SetArgument(3, 0x0B); call.SetArgument(4, 0x2F); call.SetArgument(5, 0x02); call.SetArgument(6, 0x0C); call.SetArgument(7, 0x12); call.SetArgument(8, 0x18); call.SetArgument(9, 0x1E); call.SetReturn(0, rv); c.Ret(rv); }
protected override void Compile(CodeContext c) { var dstHi = c.IntPtr("dstHi"); var dstLo = c.IntPtr("dstLo"); var vLo = c.Int32("vLo"); var src = c.Int32("src"); c.SetArgument(0, dstHi); c.SetArgument(1, dstLo); c.SetArgument(2, vLo); c.SetArgument(3, src); var vHi = c.Int32("vHi"); c.Imul(vHi, vLo, src); c.Mov(Memory.DWord(dstHi), vHi); c.Mov(Memory.DWord(dstLo), vLo); }
protected override void Compile(CodeContext c) { int i; var buf = c.IntPtr("buf"); var acc0 = c.Int32("acc0"); var acc1 = c.Int32("acc1"); c.SetArgument(0, buf); c.Mov(acc0, 0); c.Mov(acc1, 0); for (i = 0; i < 4; i++) { var ret = c.Int32("ret"); var ptr = c.IntPtr("ptr"); var idx = c.Int32("idx"); c.Mov(ptr, buf); c.Mov(idx, i); var call = c.Call(Memory.Fn(new Func <IntPtr, int, int>(CalledFunction) /*, CallingConvention.HostDefaultFast*/)); call.SetArgument(0, ptr); call.SetArgument(1, idx); call.SetReturn(0, ret); c.Add(acc0, ret); c.Mov(ptr, buf); c.Mov(idx, i); call = c.Call(Memory.Fn(new Func <IntPtr, int, int>(CalledFunction) /*, CallingConvention.HostDefaultFast*/)); call.SetArgument(0, ptr); call.SetArgument(1, idx); call.SetReturn(0, ret); c.Sub(acc1, ret); } c.Add(acc0, acc1); c.Ret(acc0); }
protected override void Compile(CodeContext c) { var p = c.IntPtr("p"); var fn = c.IntPtr("fn"); var arg = c.XmmSd("arg"); var ret = c.XmmSd("ret"); var fp = Memory.Fn(new Func <double, double>(CalledFunction)); c.SetArgument(0, p); c.Movsd(arg, Memory.Ptr(p)); c.Mov(fn, fp); var call = c.Call(fn, fp); call.SetArgument(0, arg); call.SetReturn(0, ret); c.Ret(ret); }
protected override void Compile(CodeContext c) { var src0 = c.Int32("src0"); var src1 = c.Int32("src1"); var dst0 = c.IntPtr("dst0"); c.SetArgument(0, src0); c.SetArgument(1, src1); c.SetArgument(2, dst0); c.Cmp(src0, src1); c.Setz(Memory.Byte(dst0)); }
protected override void Compile(CodeContext c) { var dst = c.IntPtr("dst"); var src = c.IntPtr("src"); c.SetArgument(0, dst); c.SetArgument(1, src); for (var i = 0; i < 4; i++) { var x = c.Int32("x"); var y = c.Int32("y"); var hi = c.Int32("hi"); c.Mov(x, Memory.DWord(src, 0)); c.Mov(y, Memory.DWord(src, 4)); c.Imul(hi, x, y); c.Add(Memory.DWord(dst, 0), hi); c.Add(Memory.DWord(dst, 4), x); } }
protected override void Compile(CodeContext c) { var dst = c.IntPtr("dst"); var var = c.Int32("var"); var vShlParam = c.Int32("vShlParam"); var vRorParam = c.Int32("vRorParam"); c.SetArgument(0, dst); c.SetArgument(1, var); c.SetArgument(2, vShlParam); c.SetArgument(3, vRorParam); c.Shl(var, vShlParam); c.Ror(var, vRorParam); c.Mov(Memory.DWord(dst), var); }
protected override void Compile(CodeContext c) { var fn = c.IntPtr("fn"); var va = c.Int32("va"); var vb = c.Int32("vb"); var vc = c.Int32("vc"); var vd = c.Int32("vd"); var ve = c.Int32("ve"); var vf = c.Int32("vf"); var vg = c.Int32("vg"); var vh = c.Int32("vh"); var vi = c.Int32("vi"); var vj = c.Int32("vj"); var fp = Memory.Fn(new Func <int, int, int, int, int, int, int, int, int, int, int>(CalledFunction)); c.Mov(fn, fp); c.Mov(va, 0x03); c.Mov(vb, 0x12); c.Mov(vc, 0xA0); c.Mov(vd, 0x0B); c.Mov(ve, 0x2F); c.Mov(vf, 0x02); c.Mov(vg, 0x0C); c.Mov(vh, 0x12); c.Mov(vi, 0x18); c.Mov(vj, 0x1E); var call = c.Call(fn, fp); call.SetArgument(0, va); call.SetArgument(1, vb); call.SetArgument(2, vc); call.SetArgument(3, vd); call.SetArgument(4, ve); call.SetArgument(5, vf); call.SetArgument(6, vg); call.SetArgument(7, vh); call.SetArgument(8, vi); call.SetArgument(9, vj); call.SetReturn(0, va); c.Ret(va); }
protected override void Compile(CodeContext c) { var fn = c.IntPtr("fn"); var a = c.XmmSd("a"); var b = c.XmmSd("b"); var ret = c.XmmSd("ret"); c.SetArgument(0, a); c.SetArgument(1, b); var fp = Memory.Fn(new Func <double, double, double>(CalledFunction)); c.Mov(fn, fp); var call = c.Call(fn, fp); call.SetArgument(0, a); call.SetArgument(1, b); call.SetReturn(0, ret); c.Ret(ret); }
protected override void Compile(CodeContext c) { var var = new GpVariable[32]; var a = c.IntPtr("a"); c.SetArgument(0, a); int i; for (i = 0; i < var.Length; i++) { var[i] = c.Int32("var" + i); } for (i = 0; i < var.Length; i++) { c.Xor(var[i], var[i]); } var v0 = c.Int32("v0"); var l = c.Label(); c.Mov(v0, 32); c.Bind(l); for (i = 0; i < var.Length; i++) { c.Add(var[i], i); } c.Dec(v0); c.Jnz(l); for (i = 0; i < var.Length; i++) { c.Mov(Memory.DWord(a, i * 4), var[i]); } }
protected override void Compile(CodeContext c) { var var = c.Int32("var"); var fn = c.IntPtr("fn"); c.SetArgument(0, var); var fp = Memory.Fn(new Func <int, int>(CalledFunction) /*, CallingConvention.HostDefaultFast*/); c.Mov(fn, fp); var call = c.Call(fn, fp); call.SetArgument(0, var); call.SetReturn(0, var); call = c.Call(fn, fp); call.SetArgument(0, var); call.SetReturn(0, var); c.Ret(var); }
protected override void Compile(CodeContext c) { const int cnt = 8; var var = new GpVariable[cnt]; int i; for (i = 0; i < cnt; i++) { var[i] = c.IntPtr("var" + i); c.SetArgument(i, var[i]); } for (i = 0; i < cnt; i++) { c.Add(var[i], i + 1); } for (i = 0; i < cnt; i++) { c.Add(Memory.Byte(var[i]), i + 1); } }
protected override void Compile(CodeContext c) { var dst = c.IntPtr("dst"); var src = c.IntPtr("src"); var i = c.IntPtr("i"); var j = c.IntPtr("j"); var t = c.IntPtr("t"); var cZero = c.Xmm("cZero"); var cMul255A = c.Xmm("cMul255A"); var cMul255M = c.Xmm("cMul255M"); var x0 = c.Xmm("x0"); var x1 = c.Xmm("x1"); var y0 = c.Xmm("y0"); var a0 = c.Xmm("a0"); var a1 = c.Xmm("a1"); var smallLoop = c.Label(); var smallEnd = c.Label(); var largeLoop = c.Label(); var largeEnd = c.Label(); var data = c.Label(); c.SetArgument(0, dst); c.SetArgument(1, src); c.SetArgument(2, i); c.Allocate(dst); c.Allocate(src); c.Allocate(i); // How many pixels have to be processed to make the loop aligned. c.Lea(t, Memory.Ptr(data)); c.Xor(j, j); c.Xorps(cZero, cZero); c.Sub(j, dst); c.Movaps(cMul255A, Memory.Ptr(t, 0)); c.And(j, 15); c.Movaps(cMul255M, Memory.Ptr(t, 16)); c.Shr(j, 2); c.Jz(smallEnd); // j = min(i, j). c.Cmp(j, i); c.Cmovg(j, i); // i -= j. c.Sub(i, j); // Small loop. c.Bind(smallLoop); c.Pcmpeqb(a0, a0); c.Movd(y0, Memory.Ptr(src)); c.Pxor(a0, y0); c.Movd(x0, Memory.Ptr(dst)); c.Psrlw(a0, 8); c.Punpcklbw(x0, cZero); c.Pshuflw(a0, a0, AsmJit.Common.Utils.Shuffle(1, 1, 1, 1)); c.Punpcklbw(y0, cZero); c.Pmullw(x0, a0); c.Paddsw(x0, cMul255A); c.Pmulhuw(x0, cMul255M); c.Paddw(x0, y0); c.Packuswb(x0, x0); c.Movd(Memory.Ptr(dst), x0); c.Add(dst, 4); c.Add(src, 4); c.Dec(j); c.Jnz(smallLoop); // Second section, prepare for an aligned loop. c.Bind(smallEnd); c.Test(i, i); c.Mov(j, i); c.Jz(c.Exit); c.And(j, 3); c.Shr(i, 2); c.Jz(largeEnd); // Aligned loop. c.Bind(largeLoop); c.Movups(y0, Memory.Ptr(src)); c.Pcmpeqb(a0, a0); c.Movaps(x0, Memory.Ptr(dst)); c.Xorps(a0, y0); c.Movaps(x1, x0); c.Psrlw(a0, 8); c.Punpcklbw(x0, cZero); c.Movaps(a1, a0); c.Punpcklwd(a0, a0); c.Punpckhbw(x1, cZero); c.Punpckhwd(a1, a1); c.Pshufd(a0, a0, AsmJit.Common.Utils.Shuffle(3, 3, 1, 1)); c.Pshufd(a1, a1, AsmJit.Common.Utils.Shuffle(3, 3, 1, 1)); c.Pmullw(x0, a0); c.Pmullw(x1, a1); c.Paddsw(x0, cMul255A); c.Paddsw(x1, cMul255A); c.Pmulhuw(x0, cMul255M); c.Pmulhuw(x1, cMul255M); c.Add(src, 16); c.Packuswb(x0, x1); c.Paddw(x0, y0); c.Movaps(Memory.Ptr(dst), x0); c.Add(dst, 16); c.Dec(i); c.Jnz(largeLoop); c.Bind(largeEnd); c.Test(j, j); c.Jnz(smallLoop); // Data c.Data(data, 16, Data.Of(0x0080008000800080, 0x0080008000800080), Data.Of(0x0101010101010101, 0x0080008000800080)); }