public Identifier DeserializeReturnValue(Argument_v1 arg)
{
argCur = arg;
DataType dt = null;
if (this.argCur.Type != null)
{
dt = this.argCur.Type.Accept(procSer.TypeLoader);
}
if (dt is VoidType)
{
return(null);
}
Identifier id;
if (arg.Kind != null)
{
id = arg.Kind.Deserialize(this);
id.DataType = dt ?? id.DataType;
}
else
{
var reg = procSer.GetReturnRegister(arg, dt.BitSize);
id = new Identifier(reg.ToString(), dt, reg);
}
return(id);
}
public SerializedType VisitFunctionType(FunctionType ft)
{
Argument_v1 ret = null;
if (!ft.HasVoidReturn)
{
ret = SerializeArgument(null, null, ft.ReturnValue.DataType);
}
Argument_v1[] parms;
if (ft.Parameters != null)
{
parms = new Argument_v1[ft.Parameters.Length];
for (int i = 0; i < ft.Parameters.Length; ++i)
{
parms[i] = SerializeArgument(ft.Parameters[i].Name, null, ft.Parameters[i].DataType);
}
}
else
{
parms = new Argument_v1[0];
}
return(new SerializedSignature
{
Arguments = parms,
ReturnValue = ret
});
}
public SerializedType VisitFunctionType(FunctionType ft)
{
Argument_v1 ret = null;
if (ft.ReturnType != null)
{
ret = SerializeArgument(null, null, ft.ReturnType);
}
Argument_v1[] parms;
if (ft.ArgumentTypes != null)
{
parms = new Argument_v1[ft.ArgumentTypes.Length];
for (int i = 0; i < ft.ArgumentTypes.Length; ++i)
{
var type = ft.ArgumentTypes[i].Accept(this);
parms[i] = SerializeArgument(ft.ArgumentNames[i], null, ft.ArgumentTypes[i]);
}
}
else
{
parms = new Argument_v1[0];
}
return(new SerializedSignature
{
Arguments = parms,
ReturnValue = ret
});
}
public Identifier DeserializeArgument(Argument_v1 sArg, int idx, string convention)
{
if (sArg.Kind != null)
{
return argser.Deserialize(sArg, sArg.Kind);
}
return argser.Deserialize(sArg, new StackVariable_v1());
}
private Identifier DeserializeArgument(ArgumentDeserializer argser, Argument_v1 sArg)
{
Identifier arg;
if (sArg.Kind != null)
return sArg.Kind.Deserialize(argser);
var dtArg = sArg.Type.Accept(TypeLoader);
var prim = dtArg as PrimitiveType;
//if (prim != null && prim.Domain == Domain.Real)
//{
// if (this.fr > 8)
// {
// arg = argser.Deserialize(sArg, new StackVariable_v1());
// }
// else
// {
// arg = argser.Deserialize(sArg, new Register_v1("f" + this.fr));
// ++this.fr;
// }
// return arg;
//}
if (dtArg.Size <= 4)
{
if (this.gr > 3)
{
arg = argser.Deserialize(sArg, new StackVariable_v1());
}
else
{
arg = argser.Deserialize(sArg, new Register_v1("r" + gr));
++this.gr;
}
return arg;
}
if (dtArg.Size <= 8)
{
if (this.gr > 9)
{
arg = argser.Deserialize(sArg, new StackVariable_v1());
}
else
{
if ((gr & 1) == 0)
++gr;
arg = argser.Deserialize(sArg, new SerializedSequence
{
Registers = new Register_v1[] {
new Register_v1("r" + gr),
new Register_v1("r" + (gr+1))
}
});
gr += 2;
}
return arg;
}
throw new NotImplementedException();
}
public void SargWriteNamelessRegisterArgument()
{
Argument_v1 sarg = new Argument_v1
{
Type = new SerializedTypeReference("int"),
Kind = new Register_v1("eax"),
};
Verify(sarg, "Core/SargWriteNamelessRegisterArgument.txt");
}
public void SargWriteRegisterArgument()
{
Argument_v1 sarg = new Argument_v1 {
Name = "foo",
Type = new TypeReference_v1("int"),
Kind = new Register_v1("eax"),
};
Verify(sarg, "Core/SargWriteRegisterArgument.txt");
}
public override Storage GetReturnRegister(Argument_v1 sArg, int bitSize)
{
if (sArg.Kind == null)
throw new NotImplementedException();
var reg = sArg.Kind as Register_v1;
if (reg != null)
return Architecture.GetRegister(reg.Name);
throw new NotImplementedException();
}
/// <summary>
/// Deserializes an argument.
/// </summary>
/// <param name="arg"></param>
/// <param name="idx"></param>
/// <param name="convention"></param>
/// <returns></returns>
public Identifier DeserializeArgument(Argument_v1 arg, int idx, string convention)
{
var kind = arg.Kind;
if (kind == null)
{
kind = new StackVariable_v1();
}
return(argDeser.Deserialize(arg, kind));
}
public void SargWriteStackArgument()
{
Argument_v1 sarg = new Argument_v1
{
Name = "bar",
Type = new TypeReference_v1("int"),
Kind = new StackVariable_v1()
};
Verify(sarg, "Core/SargWriteStackArgument.txt");
}
public void SargWriteOutArgument()
{
Argument_v1 sarg = new Argument_v1
{
Name = "bxOut",
Type = new SerializedTypeReference("int"),
OutParameter = true,
Kind = new Register_v1("bx")
};
Verify(sarg, "Core/SargWriteOutArgument.txt");
}
private Identifier DeserializeArgument(ArgumentDeserializer argser, Argument_v1 sArg)
{
Identifier arg;
if (sArg.Kind != null)
return argser.Deserialize(sArg);
var dtArg = sArg.Type.Accept(TypeLoader);
var prim = dtArg as PrimitiveType;
arg = argser.Deserialize(sArg, new Register_v1("r" + gr));
++this.gr;
return arg;
}
public void ArgSer_DeserializeRegister()
{
Register_v1 reg = new Register_v1("eax");
Argument_v1 arg = new Argument_v1
{
Name = "eax",
Kind = reg,
};
Identifier id = argser.Deserialize(arg);
Assert.AreEqual("eax", id.Name);
Assert.AreEqual(32, id.DataType.BitSize);
}
public Argument_v1 Serialize(Identifier arg)
{
if (arg == null)
return null;
if (arg.DataType == null)
throw new ArgumentNullException("arg.DataType");
Argument_v1 sarg = new Argument_v1
{
Name = arg.Name,
Kind = arg.Storage.Serialize(),
OutParameter = arg.Storage is OutArgumentStorage,
Type = arg.DataType.Accept(new DataTypeSerializer()),
};
return sarg;
}
public static SerializedSignature BuildSsigAxBxCl()
{
SerializedSignature ssig = new SerializedSignature();
Argument_v1 sarg = new Argument_v1();
sarg.Type = new PrimitiveType_v1(Domain.SignedInt, 2);
sarg.Kind = new Register_v1("ax");
ssig.ReturnValue = sarg;
ssig.Arguments = new Argument_v1[]
{
new Argument_v1 { Kind = new Register_v1("bx") },
new Argument_v1 { Kind = new Register_v1("cl") },
};
return ssig;
}
public void SseqBuildSequence()
{
Frame f = arch.CreateFrame();
Identifier head = f.EnsureRegister(Registers.dx);
Identifier tail = f.EnsureRegister(Registers.ax);
Identifier seq = f.EnsureSequence(head, tail, PrimitiveType.Word32);
SerializedSequence sq = new SerializedSequence((SequenceStorage) seq.Storage);
Argument_v1 sa = new Argument_v1();
sa.Kind = sq;
SerializedSignature ssig = new SerializedSignature();
ssig.Arguments = new Argument_v1[] { sa };
Given_X86ProcedureSerializer();
ProcedureSignature ps = ser.Deserialize(ssig, f);
Assert.AreEqual("void foo(Sequence word32 dx_ax)", ps.ToString("foo"));
}
public Argument_v1 Serialize(Identifier arg)
{
if (arg == null)
{
return(null);
}
if (arg.DataType == null)
{
throw new ArgumentNullException("arg.DataType");
}
Argument_v1 sarg = new Argument_v1
{
Name = arg.Name,
Kind = arg.Storage != null?arg.Storage.Serialize() : null,
OutParameter = arg.Storage is OutArgumentStorage,
Type = arg.DataType.Accept(new DataTypeSerializer()),
};
return(sarg);
}
public Identifier DeserializeArgument(Argument_v1 arg, int idx, string convention)
{
if (arg.Kind != null)
{
return argser.Deserialize(arg, arg.Kind);
}
if (convention == null)
return argser.Deserialize(arg, new StackVariable_v1());
switch (convention)
{
case "":
case "stdapi":
case "__cdecl":
case "__stdcall":
return argser.Deserialize(arg, new StackVariable_v1 { });
case "__thiscall":
if (idx == 0)
return argser.Deserialize(arg, new Register_v1("ecx"));
else
return argser.Deserialize(arg, new StackVariable_v1());
}
throw new NotSupportedException(string.Format("Unsupported calling convention '{0}'.", convention));
}
public override Storage GetReturnRegister(Argument_v1 sArg, int bitSize)
{
var dtArg = sArg.Type.Accept(TypeLoader) as PrimitiveType;
if (dtArg != null && dtArg.Domain == Domain.Real)
{
return argser.Deserialize(new FpuStackVariable_v1 { ByteSize = dtArg.Size }).Storage;
}
var eax = Architecture.GetRegister("eax");
if (bitSize <= 32)
return eax;
if (bitSize <= 64)
{
var edx = Architecture.GetRegister("edx");
return new SequenceStorage(edx, eax);
}
throw new NotImplementedException();
}
public abstract Storage GetReturnRegister(Argument_v1 sArg, int bitSize);
private Argument_v1 ParseStackArgument(string typeName, string argName)
{
PrimitiveType p;
int sizeInWords;
int wordSize = arch.WordWidth.Size;
if (PrimitiveType.TryParse(typeName, out p))
{
sizeInWords = (p.Size + (wordSize - 1))/wordSize;
}
else
{
sizeInWords = 1; // A reasonable guess, but is it a good one?
}
Argument_v1 arg = new Argument_v1();
arg.Name = argName;
arg.Type = new SerializedTypeReference { TypeName = typeName };
arg.Kind = new StackVariable_v1(); // (sizeInWords * wordSize);
return arg;
}
private Argument_v1 ParseArg()
{
var w = GetNextWord();
if (w == null)
return null;
RegisterStorage reg;
string type = null;
if (!arch.TryGetRegister(w, out reg))
{
type = w;
w = GetNextWord();
if (w == null)
return null;
if (w.Contains("_"))
{
var retval = ParseRegisterSequenceWithUnderscore(w);
if (retval != null)
return retval;
}
if (!arch.TryGetRegister(w, out reg))
{
return ParseStackArgument(type, w);
}
}
if (PeekChar(':') || PeekChar('_'))
{
return ParseRegisterSequence(reg, type);
}
var arg = new Argument_v1()
{
Name = reg.Name,
Kind = new Register_v1(reg.Name),
OutParameter = false,
Type = new SerializedTypeReference { TypeName = type },
};
return arg;
}
public Identifier Deserialize(Argument_v1 arg, SerializedKind kind)
{
argCur = arg;
return kind.Deserialize(this);
}
public Identifier Deserialize(Argument_v1 arg)
{
argCur = arg;
return arg.Kind.Deserialize(this);
}
public Identifier Deserialize(Argument_v1 arg)
{
argCur = arg;
return(arg.Kind.Deserialize(this));
}
public override Storage GetReturnRegister(Argument_v1 sArg, int bitSize)
{
switch (bitSize)
{
case 32:
if (Architecture.WordWidth.BitSize == 16)
return new SequenceStorage(
new Identifier("dx", PrimitiveType.Word16, Architecture.GetRegister("dx")),
new Identifier("ax", PrimitiveType.Word16, Architecture.GetRegister("ax")));
break;
case 64: if (Architecture.WordWidth.BitSize == 32)
return new SequenceStorage(
new Identifier("edx", PrimitiveType.Word16, Architecture.GetRegister("edx")),
new Identifier("eax", PrimitiveType.Word16, Architecture.GetRegister("eax")));
break;
}
return Architecture.GetRegister("rax").GetSubregister(0, bitSize);
}
private void Verify(Argument_v1 sarg, string outputFilename)
{
using (FileUnitTester fut = new FileUnitTester(outputFilename))
{
XmlTextWriter x = new FilteringXmlWriter(fut.TextWriter);
x.Formatting = Formatting.Indented;
XmlSerializer ser = SerializedLibrary.CreateSerializer_v1(sarg.GetType());
ser.Serialize(x, sarg);
fut.AssertFilesEqual();
}
}
public override Storage GetReturnRegister(Argument_v1 sArg, int bitSize)
{
if (bitSize == 0)
bitSize = Architecture.WordWidth.BitSize;
switch (bitSize)
{
case 32:
if (Architecture.WordWidth.BitSize == 16)
return new SequenceStorage(
Architecture.GetRegister("dx"),
Architecture.GetRegister("ax"));
break;
case 64: if (Architecture.WordWidth.BitSize == 32)
return new SequenceStorage(
Architecture.GetRegister("edx"),
Architecture.GetRegister("eax"));
break;
}
var reg = Architecture.GetRegister("rax");
return Architecture.GetSubregister(reg, 0, bitSize);
}
public override Storage GetReturnRegister(Argument_v1 sArg, int bitSize)
{
var prim = sArg.Type as PrimitiveType_v1;
if (prim != null)
{
if (prim.Domain == Domain.Real)
return arch.GetRegister("f1");
}
return arch.GetRegister("r3");
}
private AmigaSystemFunction ParseLine(string line)
{
lex = new Lexer(line);
if (!PeekAndDiscard(TokenType.HASH))
return null;
Expect(TokenType.Number); // Ordinal
var decOffset = (int) Expect(TokenType.Number); // offset (in decimal)
var hexOffset = (int) Expect(TokenType.Number); // offset (in hex)
if (decOffset != hexOffset)
throw new InvalidOperationException(string.Format(
"Decimal offset {0} and hexadecimal offset {1:X} do not match.", decOffset, hexOffset));
var name = (string) Expect(TokenType.Id); // fn name
var parameters = new List<Argument_v1>();
Argument_v1 returnValue = null;
Expect(TokenType.LPAREN);
if (!PeekAndDiscard(TokenType.RPAREN))
{
do {
var argName = (string) Expect(TokenType.Id);
Expect(TokenType.SLASH);
var regName = (string)Expect(TokenType.Id);
parameters.Add(new Argument_v1
{
Kind = new Register_v1 { Name = regName },
Name = argName,
});
} while (PeekAndDiscard(TokenType.COMMA));
if (PeekAndDiscard(TokenType.SEMI))
{
var argName = (string) Expect(TokenType.Id);
Expect(TokenType.SLASH);
var regName = (string) Expect(TokenType.Id);
returnValue = new Argument_v1
{
Kind = new Register_v1 { Name = regName }
};
}
Expect(TokenType.RPAREN);
}
return new AmigaSystemFunction
{
Offset = -decOffset,
Name = name,
Signature = new SerializedSignature
{
Arguments = parameters.ToArray(),
ReturnValue = returnValue,
}
};
}
public Identifier DeserializeReturnValue(Argument_v1 arg)
{
argCur = arg;
DataType dt = null;
if (this.argCur.Type != null)
dt = this.argCur.Type.Accept(procSer.TypeLoader);
if (dt is VoidType)
return null;
Identifier id;
if (arg.Kind != null)
{
id = arg.Kind.Deserialize(this);
id.DataType = dt ?? id.DataType;
}
else
{
var reg = procSer.GetReturnRegister(arg, dt.BitSize);
id = new Identifier(reg.ToString(), dt, reg);
}
return id;
}
public override Storage GetReturnRegister(Argument_v1 sArg, int bitSize)
{
throw new NotImplementedException();
}
public override Storage GetReturnRegister(Argument_v1 sArg, int bitSize)
{
return A32Registers.r0;
}
private bool HasExplicitStorage(Argument_v1 sArg)
{
return(sArg.Kind != null);
}
public override Storage GetReturnRegister(Argument_v1 sArg, int bitSize)
{
var dtArg = sArg.Type.Accept(TypeLoader) as PrimitiveType;
if (dtArg != null && dtArg.Domain == Domain.Real)
{
var xmm0 = Architecture.GetRegister("xmm0");
if (bitSize <= 64)
return xmm0;
if (bitSize <= 128)
{
var xmm1 = Architecture.GetRegister("xmm1");
return new SequenceStorage(xmm1, xmm0);
}
throw new NotImplementedException();
}
var rax = Architecture.GetRegister("rax");
if (bitSize <= 64)
return rax;
if (bitSize <= 128)
{
var rdx = Architecture.GetRegister("rdx");
return new SequenceStorage(rdx, rax);
}
throw new NotImplementedException();
}
public Identifier Deserialize(Argument_v1 arg, SerializedKind kind)
{
argCur = arg;
return(kind.Deserialize(this));
}
public Identifier DeserializeArgument(Argument_v1 sArg, int idx, string convention)
{
if (sArg.Kind != null)
{
return argser.Deserialize(sArg, sArg.Kind);
}
Identifier arg;
var dtArg = sArg.Type.Accept(TypeLoader);
var prim = dtArg as PrimitiveType;
if (prim != null && prim.Domain == Domain.Real)
{
if (this.fr >= fregs.Length)
{
arg = argser.Deserialize(sArg, new StackVariable_v1());
}
else
{
arg = argser.Deserialize(sArg, new Register_v1 { Name = fregs[fr] });
}
++this.fr;
return arg;
}
if (dtArg.Size <= 8)
{
if (this.ir >= iregs.Length)
{
arg = argser.Deserialize(sArg, new StackVariable_v1());
}
else
{
arg = argser.Deserialize(sArg, new Register_v1 { Name = iregs[ir] });
}
++this.ir;
return arg;
}
int regsNeeded = (dtArg.Size + 7) / 8;
if (regsNeeded > 4 || ir + regsNeeded >= iregs.Length)
{
return argser.Deserialize(sArg, new StackVariable_v1());
}
throw new NotImplementedException();
}
public void SsigDeserializeOutArgument()
{
Argument_v1 arg = new Argument_v1
{
Kind = new Register_v1("bp"),
OutParameter = true
};
SerializedSignature sig = new SerializedSignature();
sig.Arguments = new Argument_v1[] { arg };
Given_X86ProcedureSerializer();
FunctionType ps = sser.Deserialize(sig, arch.CreateFrame());
Assert.AreEqual("void foo(Register out ptr16 bpOut)", ps.ToString("foo"));
}
private Identifier DeserializeImplicitThisArgument(SerializedSignature ss)
{
var sArg = new Argument_v1
{
Type = new PointerType_v1(ss.EnclosingType),
Name = "this",
};
if (ss.Convention == "__thiscall")
{
sArg.Kind = new Register_v1("ecx");
}
else
sArg.Kind = new StackVariable_v1();
var arg = argDeser.Deserialize(sArg);
return arg;
}