/// <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)
{
if (arg.Kind != null)
{
return(argDeser.Deserialize(arg, arg.Kind));
}
Debug.Assert(iregs.Length == fregs.Length);
if (idx < fregs.Length)
{
var reg = (IsReal(arg.Type) ? fregs : iregs)[idx];
return(argDeser.Deserialize(arg, new Register_v1(reg)));
}
if (convention == null)
{
return(argDeser.Deserialize(arg, new StackVariable_v1()));
}
switch (convention)
{
case "":
case "stdapi":
case "cdecl":
case "__cdecl":
case "__stdcall":
case "pascal":
case "__thiscall":
return(argDeser.Deserialize(arg, new StackVariable_v1 {
}));
}
throw new NotSupportedException(string.Format("Unsupported calling convention '{0}'.", convention));
}
/// <summary>
/// This hack loops through all the registers in a <see cref="SerializedService"/> loaded
/// from the realmodeintservices.xml file and replaces sequences that look like segmented
/// 32-bit pointers with their flat 32-bit equivalents.
/// It's a placeholder and should be replaced by a "protectedmodeintservices.xml" that should
/// generated from realmodeintservices.xml.
/// </summary>
private SerializedService ExtendRegisters(SerializedService svc)
{
if (svc.Signature != null && svc.Signature.Arguments != null)
{
var args = new List <Argument_v1>();
foreach (var arg in svc.Signature.Arguments)
{
if (arg.Type is PointerType_v1 ptr &&
arg.Kind is SerializedSequence seq &&
seq.Registers != null &&
seq.Registers.Length == 2 &&
seq.Registers[1].Name != null)
{
var off = seq.Registers[1].Name;
var eoff = "e" + off;
var argNew = new Argument_v1
{
Name = arg.Name,
Kind = new Register_v1 {
Name = eoff
},
OutParameter = arg.OutParameter,
Type = arg.Type,
};
args.Add(argNew);
}
else
{
args.Add(arg);
}
}
public void ArgSer_DeserializeTwoNamedStackVariables()
{
var argA = new Argument_v1
{
Name = "a",
Kind = new StackVariable_v1(),
Type = new PrimitiveType_v1 {
ByteSize = 4, Domain = Domain.SignedInt
}
};
var argB = new Argument_v1
{
Name = "b",
Kind = new StackVariable_v1(),
Type = new PrimitiveType_v1 {
ByteSize = 4, Domain = Domain.Real
}
};
var a = argser.Deserialize(argA);
var b = argser.Deserialize(argB);
Assert.AreEqual("a", a.Name);
Assert.AreEqual("int32", a.DataType.ToString());
Assert.AreEqual("Stack +000D", a.Storage.ToString());
Assert.AreEqual("b", b.Name);
Assert.AreEqual("real32", b.DataType.ToString());
Assert.AreEqual("Stack +0011", b.Storage.ToString());
}
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 (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 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 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(
new Identifier(edx.Name, edx.DataType, edx),
new Identifier(eax.Name, eax.DataType, eax)));
}
throw new NotImplementedException();
}
public override Storage GetReturnRegister(Argument_v1 sArg, int bitSize)
{
var dtArg = sArg.Type.Accept(TypeLoader);
var ptArg = dtArg as PrimitiveType;
if (ptArg != null)
{
if (ptArg.Domain == Domain.Real)
{
var f0 = Architecture.GetRegister("f0");
if (ptArg.Size <= 4)
{
return(f0);
}
var f1 = Architecture.GetRegister("f1");
return(new SequenceStorage(f1, f0));
}
return(Architecture.GetRegister("o0"));
}
else if (dtArg is Pointer)
{
return(Architecture.GetRegister("o0"));
}
else if (dtArg.Size <= this.Architecture.WordWidth.Size)
{
return(Architecture.GetRegister("o0"));
}
throw new NotImplementedException();
}
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 f0 = Architecture.GetRegister("f0");
if (bitSize <= 64)
{
return(f0);
}
throw new NotImplementedException();
}
var v0 = Architecture.GetRegister("r2");
if (bitSize <= 32)
{
return(v0);
}
if (bitSize <= 64)
{
var v1 = Architecture.GetRegister("r3");
return(new SequenceStorage(v1, v0));
}
throw new NotImplementedException();
}
public Func<NamedDataType, NamedDataType> VisitFunction(FunctionDeclarator function)
{
var fn = function.Declarator.Accept(this);
return (nt) =>
{
var parameters = function.Parameters
.Select(p => ConvertParameter(p))
.ToArray();
// Special case for C, where foo(void) means a function with no parameters,
// not a function with one parameter of type "void".
if (FirstParameterVoid(parameters))
parameters = new Argument_v1[0];
Argument_v1 ret = null;
if (nt.DataType != null)
{
ret = new Argument_v1
{
Type = nt.DataType,
};
}
nt.DataType = new SerializedSignature
{
Convention = callingConvention != CTokenType.None
? callingConvention.ToString().ToLower()
: null,
ReturnValue = ret,
Arguments = parameters.ToArray(),
};
return fn(nt);
};
}
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));
}
/// <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)
{
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":
case "pascal":
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)
{
if (bitSize > 64)
{
throw new NotImplementedException("Large return values not implemented yet");
}
return(Architecture.GetRegister(IsReal(sArg.Type) ? "xmm0" : "rax"));
}
public override Storage GetReturnRegister(Argument_v1 sArg, int bitSize)
{
if (bitSize <= 32)
{
return(Architecture.GetRegister("d0"));
}
throw new NotImplementedException();
}
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()));
}
public void SargSerializeFlag()
{
var arg = new Identifier("SZ", PrimitiveType.Byte, new FlagGroupStorage(3, "SZ", PrimitiveType.Byte));
Argument_v1 sarg = argser.Serialize(arg);
Assert.AreEqual("SZ", sarg.Name);
FlagGroup_v1 sflag = (FlagGroup_v1)sarg.Kind;
Assert.AreEqual("SZ", sflag.Name);
}
public void SargWriteNamelessRegisterArgument()
{
Argument_v1 sarg = new Argument_v1
{
Type = new TypeReference_v1("int"),
Kind = new Register_v1("eax"),
};
Verify(sarg, "Core/SargWriteNamelessRegisterArgument.txt");
}
public void SargWriteRegisterArgument()
{
Argument_v1 sarg = new Argument_v1 {
Name = "foo",
Type = new SerializedTypeReference("int"),
Kind = new Register_v1("eax"),
};
Verify(sarg, "Core/SargWriteRegisterArgument.txt");
}
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 ArgSer_SerializeRegister()
{
var arg = new Identifier(Registers.ax.Name, Registers.ax.DataType, Registers.ax);
Argument_v1 sarg = argser.Serialize(arg);
Assert.AreEqual("ax", sarg.Name);
Register_v1 sreg = (Register_v1)sarg.Kind;
Assert.IsNotNull(sreg);
Assert.AreEqual("ax", sreg.Name);
}
private Identifier DeserializeImplicitThisArgument(SerializedSignature ss)
{
var sArg = new Argument_v1
{
Type = new PointerType_v1(ss.EnclosingType),
Name = "this",
Kind = new Register_v1("rcx")
};
var arg = argDeser.Deserialize(sArg);
return(arg);
}
public void SargWriteOutArgument()
{
Argument_v1 sarg = new Argument_v1
{
Name = "bxOut",
Type = new TypeReference_v1("int"),
OutParameter = true,
Kind = new Register_v1("bx")
};
Verify(sarg, "Core/SargWriteOutArgument.txt");
}
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 void ArgSer_SerializeOutArgument()
{
Identifier id = new Identifier("qOut", PrimitiveType.Word32,
new OutArgumentStorage(new Identifier("q", PrimitiveType.Word32, new RegisterStorage("q", 4, 0, PrimitiveType.Word32))));
Argument_v1 arg = argser.Serialize(id);
Assert.AreEqual("qOut", arg.Name);
Assert.IsTrue(arg.OutParameter);
Register_v1 sr = (Register_v1)arg.Kind;
Assert.AreEqual("q", sr.Name);
}
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(Architecture.GetRegister("f1"));
}
}
return(Architecture.GetRegister("r3"));
}
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);
}
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 TypeReference_v1 {
TypeName = type
},
};
return(arg);
}
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();
}
public void ArgSet_DerserializeReturnRegisterWithType()
{
var arg = new Argument_v1
{
Kind = new Register_v1("eax"),
Type = new PointerType_v1 {
DataType = new PrimitiveType_v1 {
ByteSize = 1, Domain = Domain.Character
}
}
};
var id = argser.DeserializeReturnValue(arg);
Assert.AreEqual("(ptr char)", id.DataType.ToString());
}
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"));
}
public void ArgSer_DeserializeStackVariable()
{
var arg = new Argument_v1
{
Kind = new StackVariable_v1(),
Type = new PointerType_v1 {
DataType = new PrimitiveType_v1 {
ByteSize = 1, Domain = Domain.Character
}
}
};
var id = argser.Deserialize(arg);
Assert.AreEqual("ptrArg04", id.Name);
Assert.AreEqual("(ptr char)", id.DataType.ToString());
}
