public StackMemory SetIndex(GpVariable index, int shift = 0)
{
Index = index.Id;
VSib = Constants.X86.MemVSibGpz;
Shift = shift;
return(this);
}
internal TV CreateVariable <TV>(VariableType type, string name = null) where TV : Variable
{
type = type.GetMappedType();
if (type.IsInvalid())
{
throw new ArgumentException();
}
var varInfo = type.GetVariableInfo();
VariableData varData;
Variable var;
switch (type)
{
case VariableType.Int8:
case VariableType.UInt8:
case VariableType.Int16:
case VariableType.UInt16:
case VariableType.Int32:
case VariableType.UInt32:
case VariableType.Int64:
case VariableType.UInt64:
case VariableType.IntPtr:
case VariableType.UIntPtr:
if (typeof(TV) != typeof(GpVariable))
{
throw new ArgumentException();
}
varData = CreateVariableData(type, varInfo, name);
var = new GpVariable((GpVariableType)type, varData.Id);
break;
case VariableType.Fp32:
case VariableType.Fp64:
if (typeof(TV) != typeof(FpVariable))
{
throw new ArgumentException();
}
varData = CreateVariableData(type, varInfo, name);
var = new FpVariable((FpVariableType)type, varData.Id);
break;
case VariableType.Xmm:
case VariableType.XmmSs:
case VariableType.XmmSd:
if (typeof(TV) != typeof(XmmVariable))
{
throw new ArgumentException();
}
varData = CreateVariableData(type, varInfo, name);
var = new XmmVariable((XmmVariableType)type, varData.Id);
break;
default:
throw new ArgumentException();
}
return((TV)var);
}
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 rPtr = c.UIntPtr("rPtr");
var rSum = c.UInt32("rSum");
c.SetArgument(0, rPtr);
var rVar = new GpVariable[Cnt];
int i;
for (i = 0; i < Cnt; i++)
{
rVar[i] = c.UInt32("x" + i);
}
// Init pseudo-regs with values from our array.
for (i = 0; i < Cnt; i++)
{
c.Mov(rVar[i], Memory.DWord(rPtr, i * 4));
}
for (i = 2; i < Cnt; i++)
{
// Add and truncate to 8 bit; no purpose, just mess with jit.
c.Add(rVar[i], rVar[i - 1]);
c.Movzx(rVar[i], rVar[i].As8());
c.Movzx(rVar[i - 2], rVar[i - 1].As8());
c.Movzx(rVar[i - 1], rVar[i - 2].As8());
}
// Sum up all computed values.
c.Mov(rSum, 0);
for (i = 0; i < Cnt; i++)
{
c.Add(rSum, rVar[i]);
}
// Return the sum.
c.Ret(rSum);
}
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)
{
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);
}
}
