public override FunctionType Deserialize(SerializedSignature ss, Frame frame)
{
if (ss == null)
return null;
this.argDeser = new ArgumentDeserializer(this, Architecture, frame, 0, Architecture.WordWidth.Size);
Identifier ret = null;
int fpuDelta = FpuStackOffset;
FpuStackOffset = 0;
if (ss.ReturnValue != null)
{
ret = argDeser.DeserializeReturnValue(ss.ReturnValue);
fpuDelta += FpuStackOffset;
}
FpuStackOffset = 0;
var args = new List<Identifier>();
if (ss.Arguments != null)
{
for (int iArg = 0; iArg < ss.Arguments.Length; ++iArg)
{
var sArg = ss.Arguments[iArg];
var arg = DeserializeArgument(sArg, iArg, ss.Convention);
args.Add(arg);
}
fpuDelta -= FpuStackOffset;
}
FpuStackOffset = fpuDelta;
var sig = new FunctionType(ret, args.ToArray());
ApplyConvention(ss, sig);
return sig;
}
public override FunctionType Deserialize(SerializedSignature ss, Frame frame)
{
if (ss == null)
return new FunctionType();
if (ss == null)
return null;
var argser = new ArgumentDeserializer(this, Architecture, frame, 0, Architecture.WordWidth.Size);
Identifier ret = null;
if (ss.ReturnValue != null)
{
ret = argser.DeserializeReturnValue(ss.ReturnValue);
}
var args = new List<Identifier>();
this.gr = 0;
if (ss.Arguments != null)
{
for (int iArg = 0; iArg < ss.Arguments.Length; ++iArg)
{
var sArg = ss.Arguments[iArg];
Identifier arg = DeserializeArgument(argser, sArg);
args.Add(arg);
}
}
var sig = new FunctionType(ret, args.ToArray());
return sig;
}
public override FunctionType Deserialize(SerializedSignature ss, Frame frame)
{
int ncrn = 0;
int nsaa = 0;
// mem arg forb ret val
var argser = new ArgumentDeserializer(
this,
Architecture,
frame,
Architecture.PointerType.Size,
Architecture.WordWidth.Size);
Identifier ret = null;
if (ss.ReturnValue != null)
{
ret = argser.DeserializeReturnValue(ss.ReturnValue);
}
var args = new List<Identifier>();
if (ss.Arguments != null)
{
foreach (var sArg in ss.Arguments)
{
var dt = sArg.Type.Accept(TypeLoader);
var sizeInWords = (dt.Size + 3) / 4;
if (sizeInWords == 2 && (ncrn & 1) == 1)
++ncrn;
Identifier arg;
if (sizeInWords <= 4 - ncrn)
{
if (sizeInWords == 2)
{
arg = frame.EnsureSequence(
Architecture.GetRegister(argRegs[ncrn]),
Architecture.GetRegister(argRegs[ncrn + 1]),
dt);
ncrn += 2;
}
else
{
arg = frame.EnsureRegister(
Architecture.GetRegister(argRegs[ncrn]));
ncrn += 1;
}
}
else
{
arg = frame.EnsureStackArgument(nsaa, dt);
nsaa += AlignedStackArgumentSize(dt);
}
args.Add(arg);
}
}
return new FunctionType(ret, args.ToArray());
}
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 override FunctionType Deserialize(SerializedSignature ss, Frame frame)
{
if (ss == null)
return null;
this.argDeser = new ArgumentDeserializer(
this,
Architecture,
frame,
Architecture.PointerType.Size, //$BUG: x86 real mode?
Architecture.WordWidth.Size);
Identifier ret = null;
int fpuDelta = FpuStackOffset;
FpuStackOffset = 0;
if (ss.ReturnValue != null)
{
ret = argDeser.DeserializeReturnValue(ss.ReturnValue);
fpuDelta += FpuStackOffset;
}
FpuStackOffset = 0;
var args = new List<Identifier>();
if (ss.EnclosingType != null)
{
var arg = DeserializeImplicitThisArgument(ss);
args.Add(arg);
}
if (ss.Arguments != null)
{
if (ss.Convention == "pascal")
{
for (int iArg = ss.Arguments.Length -1; iArg >= 0; --iArg)
{
var sArg = ss.Arguments[iArg];
var arg = DeserializeArgument(sArg, iArg, ss.Convention);
args.Add(arg);
}
args.Reverse();
}
else
{
for (int iArg = 0; iArg < ss.Arguments.Length; ++iArg)
{
var sArg = ss.Arguments[iArg];
var arg = DeserializeArgument(sArg, iArg, ss.Convention);
args.Add(arg);
}
}
fpuDelta -= FpuStackOffset;
}
FpuStackOffset = fpuDelta;
var sig = new FunctionType(ret, args.ToArray());
sig.IsInstanceMetod = ss.IsInstanceMethod;
ApplyConvention(ss, sig);
return sig;
}
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 Setup()
{
mr = new MockRepository();
var sc = new ServiceContainer();
sc.AddService<IFileSystemService>(new FileSystemServiceImpl());
arch = new X86ArchitectureReal();
platform = new MsdosPlatform(sc, arch);
sigser = mr.Stub<ProcedureSerializer>(
arch,
new TypeLibraryDeserializer(platform, true, new TypeLibrary()),
"stdapi");
argser = new ArgumentDeserializer(
sigser,
arch,
arch.CreateFrame(),
// It's possible that old, hand-written assembler passes
// arguments on unaligned offsets
13,
4);
mr.ReplayAll();
}
public override Identifier Deserialize(ArgumentDeserializer sser)
{
return(sser.Deserialize(this));
}
public override Identifier Deserialize(ArgumentDeserializer sser)
{
return(sser.VisitRegister(this));
}
public override Identifier Deserialize(ArgumentDeserializer sser)
{
return sser.VisitRegister(this);
}
public override Identifier Deserialize(ArgumentDeserializer sser)
{
return sser.Deserialize(this);
}
/// <summary>
/// Deserializes the signature <paramref name="ss"/>. Any instantiated
/// registers or stack variables are introduced into the Frame.
/// </summary>
/// <param name="ss"></param>
/// <param name="frame"></param>
/// <returns></returns>
public FunctionType Deserialize(SerializedSignature ss, Frame frame)
{
if (ss == null)
{
return(null);
}
// If there is no explict return address size,
// use the architecture's default return address size.
var retAddrSize = ss.ReturnAddressOnStack != 0
? ss.ReturnAddressOnStack
: this.Architecture.ReturnAddressOnStack;
if (!ss.ParametersValid)
{
return(new FunctionType
{
StackDelta = ss.StackDelta,
ReturnAddressOnStack = retAddrSize,
});
}
var parameters = new List <Identifier>();
Identifier ret = null;
if (UseUserSpecifiedStorages(ss))
{
this.argDeser = new ArgumentDeserializer(
this,
Architecture,
frame,
retAddrSize,
Architecture.WordWidth.Size);
int fpuDelta = FpuStackOffset;
FpuStackOffset = 0;
if (ss.ReturnValue != null)
{
ret = DeserializeArgument(ss.ReturnValue, -1, "");
fpuDelta += FpuStackOffset;
}
FpuStackOffset = 0;
if (ss.Arguments != null)
{
for (int iArg = 0; iArg < ss.Arguments.Length; ++iArg)
{
var sArg = ss.Arguments[iArg];
var arg = DeserializeArgument(sArg, iArg, ss.Convention);
if (arg != null)
{
parameters.Add(arg);
}
}
}
fpuDelta -= FpuStackOffset;
FpuStackOffset = fpuDelta;
var sig = new FunctionType(ret, parameters.ToArray())
{
IsVariadic = this.IsVariadic,
IsInstanceMetod = ss.IsInstanceMethod,
};
ApplyConvention(ss, sig);
return(sig);
}
else
{
var dtRet = ss.ReturnValue != null && ss.ReturnValue.Type != null
? ss.ReturnValue.Type.Accept(TypeLoader)
: null;
var dtThis = ss.EnclosingType != null
? new Pointer(ss.EnclosingType.Accept(TypeLoader), Architecture.PointerType.BitSize)
: null;
var dtParameters = ss.Arguments != null
? ss.Arguments
.TakeWhile(p => p.Name != "...")
.Select(p => p.Type.Accept(TypeLoader))
.ToList()
: new List <DataType>();
// A calling convention governs the storage of a the
// parameters
var cc = platform.GetCallingConvention(ss.Convention);
if (cc == null)
{
// It was impossible to determine a calling convention,
// so we don't know how to decode this signature accurately.
return(new FunctionType
{
StackDelta = ss.StackDelta,
ReturnAddressOnStack = retAddrSize,
});
}
var res = new CallingConventionEmitter();
cc.Generate(res, dtRet, dtThis, dtParameters);
if (res.Return != null)
{
var retReg = res.Return as RegisterStorage;
ret = new Identifier(retReg != null ? retReg.Name : "", dtRet, res.Return);
}
if (res.ImplicitThis != null)
{
var param = new Identifier("this", dtThis, res.ImplicitThis);
parameters.Add(param);
}
bool isVariadic = false;
if (ss.Arguments != null)
{
for (int i = 0; i < ss.Arguments.Length; ++i)
{
if (ss.Arguments[i].Name == "...")
{
isVariadic = true;
}
else
{
var name = GenerateParameterName(ss.Arguments[i].Name, dtParameters[i], res.Parameters[i]);
var param = new Identifier(name, dtParameters[i], res.Parameters[i]);
parameters.Add(param);
}
}
}
var ft = new FunctionType(ret, parameters.ToArray())
{
IsInstanceMetod = ss.IsInstanceMethod,
StackDelta = ss.StackDelta != 0
? ss.StackDelta
: res.StackDelta,
FpuStackDelta = res.FpuStackDelta,
ReturnAddressOnStack = retAddrSize,
IsVariadic = isVariadic,
};
return(ft);
}
}
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;
if (prim != null && prim.Domain == Domain.Real && !firstArgIntegral)
{
if ((ir % 2) != 0)
++ir;
if (this.ir >= 4)
{
arg = argser.Deserialize(sArg, new StackVariable_v1());
}
else
{
if (prim.Size == 4)
{
arg = argser.Deserialize(sArg, new Register_v1("f" + (this.ir + 12)));
this.ir += 1;
}
else if (prim.Size == 8)
{
arg = argser.Deserialize(sArg, new SerializedSequence
{
Registers = new[] {
new Register_v1("f" + (this.ir + 12)),
new Register_v1("f" + (this.ir + 13))
}
});
this.ir += 2;
}
else
{
throw new NotSupportedException(string.Format("Real type of size {0} not supported.", prim.Size));
}
}
return arg;
}
if (ir == 0)
firstArgIntegral = true;
if (dtArg.Size <= 4)
{
if (this.ir >= 4)
{
arg = argser.Deserialize(sArg, new StackVariable_v1());
}
else
{
arg = argser.Deserialize(sArg, new Register_v1("r" + (ir+4)));
++this.ir;
}
return arg;
}
if (dtArg.Size <= 8)
{
if ((ir & 1) != 0)
++ir;
if (this.ir >= 4)
{
arg = argser.Deserialize(sArg, new StackVariable_v1());
}
else
{
arg = argser.Deserialize(sArg, new SerializedSequence
{
Registers = new Register_v1[] {
new Register_v1("r" + (ir+4)),
new Register_v1("r" + (ir+5))
}
});
ir += 2;
}
return arg;
}
throw new NotImplementedException();
}
public override FunctionType Deserialize(SerializedSignature ss, Frame frame)
{
if (ss == null)
return null;
this.argDeser = new ArgumentDeserializer(
this,
Architecture,
frame,
Architecture.PointerType.Size,
Architecture.WordWidth.Size);
Identifier ret = null;
if (ss.ReturnValue != null)
{
ret = argDeser.DeserializeReturnValue(ss.ReturnValue);
}
var args = new List<Identifier>();
int iArg = 0;
if (ss.EnclosingType != null && ss.IsInstanceMethod)
{
var arg = DeserializeImplicitThisArgument(ss);
args.Add(arg);
++iArg;
}
if (ss.Arguments != null)
{
for (iArg = 0; iArg < ss.Arguments.Length; ++iArg)
{
var sArg = ss.Arguments[iArg];
var arg = DeserializeArgument(sArg, iArg, ss.Convention);
args.Add(arg);
}
}
var sig = new FunctionType(ret, args.ToArray());
sig.IsInstanceMetod = ss.IsInstanceMethod;
ApplyConvention(ss, sig);
return sig;
}
/// <summary>
/// Deserializes the signature <paramref name="ss"/>. Any instantiated
/// registers or stack variables are introduced into the Frame.
/// </summary>
/// <param name="ss"></param>
/// <param name="frame"></param>
/// <returns></returns>
public FunctionType Deserialize(SerializedSignature ss, Frame frame)
{
if (ss == null)
{
return(null);
}
var retAddrSize = this.Architecture.PointerType.Size; //$TODO: deal with near/far calls in x86-realmode
if (!ss.ParametersValid)
{
return(new FunctionType
{
StackDelta = ss.StackDelta,
ReturnAddressOnStack = retAddrSize,
});
}
var parameters = new List <Identifier>();
Identifier ret = null;
if (UseUserSpecifiedStorages(ss))
{
this.argDeser = new ArgumentDeserializer(
this,
Architecture,
frame,
retAddrSize,
Architecture.WordWidth.Size);
int fpuDelta = FpuStackOffset;
FpuStackOffset = 0;
if (ss.ReturnValue != null)
{
ret = DeserializeArgument(ss.ReturnValue, -1, "");
fpuDelta += FpuStackOffset;
}
FpuStackOffset = 0;
if (ss.Arguments != null)
{
for (int iArg = 0; iArg < ss.Arguments.Length; ++iArg)
{
var sArg = ss.Arguments[iArg];
var arg = DeserializeArgument(sArg, iArg, ss.Convention);
parameters.Add(arg);
}
}
fpuDelta -= FpuStackOffset;
FpuStackOffset = fpuDelta;
var sig = new FunctionType(ret, parameters.ToArray())
{
IsInstanceMetod = ss.IsInstanceMethod,
};
ApplyConvention(ss, sig);
return(sig);
}
else
{
var dtRet = ss.ReturnValue != null && ss.ReturnValue.Type != null
? ss.ReturnValue.Type.Accept(TypeLoader)
: null;
var dtThis = ss.EnclosingType != null
? new Pointer(ss.EnclosingType.Accept(TypeLoader), Architecture.PointerType.BitSize)
: null;
var dtParameters = ss.Arguments != null
? ss.Arguments
.TakeWhile(p => p.Name != "...")
.Select(p => p.Type.Accept(TypeLoader))
.ToList()
: new List <DataType>();
// A calling convention governs the storage of a the
// parameters
var cc = platform.GetCallingConvention(ss.Convention);
var res = new CallingConventionEmitter();
cc.Generate(res, dtRet, dtThis, dtParameters);
if (res.Return != null)
{
var retReg = res.Return as RegisterStorage;
ret = new Identifier(retReg != null ? retReg.Name : "", dtRet, res.Return);
}
if (res.ImplicitThis != null)
{
var param = new Identifier("this", dtThis, res.ImplicitThis);
parameters.Add(param);
}
if (ss.Arguments != null)
{
for (int i = 0; i < ss.Arguments.Length; ++i)
{
if (ss.Arguments[i].Name == "...")
{
var unk = new UnknownType();
parameters.Add(new Identifier("...", unk, new StackArgumentStorage(0, unk)));
}
else
{
var name = GenerateParameterName(ss.Arguments[i].Name, dtParameters[i], res.Parameters[i]);
var param = new Identifier(name, dtParameters[i], res.Parameters[i]);
parameters.Add(param);
}
}
}
var ft = new FunctionType(ret, parameters.ToArray())
{
IsInstanceMetod = ss.IsInstanceMethod,
StackDelta = ss.StackDelta != 0
? ss.StackDelta
: res.StackDelta,
FpuStackDelta = res.FpuStackDelta,
ReturnAddressOnStack = retAddrSize,
};
return(ft);
}
}
public abstract Identifier Deserialize(ArgumentDeserializer sser);
public abstract Identifier Deserialize(ArgumentDeserializer sser);