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);
}
public override FunctionType Deserialize(SerializedSignature ss, Frame frame)
{
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.ir = 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 ProcedureSignature Deserialize(SerializedSignature ss, Frame frame)
{
if (ss == null)
{
return(null);
}
this.argser = new ArgumentDeserializer(this, Architecture, frame, Architecture.PointerType.Size);
Identifier ret = null;
if (ss.ReturnValue != null)
{
ret = argser.DeserializeReturnValue(ss.ReturnValue);
}
this.ir = 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);
}
}
var sig = new ProcedureSignature(ret, args.ToArray());
ApplyConvention(ss, sig);
return(sig);
}
public override ProcedureSignature Deserialize(SerializedSignature ss, Frame frame)
{
if (ss == null)
{
return(null);
}
var argser = new ArgumentDeserializer(this, Architecture, frame, 4);
Identifier ret = null;
if (ss.ReturnValue != null)
{
ret = argser.DeserializeReturnValue(ss.ReturnValue);
}
var args = new List <Identifier>();
if (ss.Arguments != null)
{
for (int iArg = 0; iArg < ss.Arguments.Length; ++iArg)
{
var sArg = ss.Arguments[iArg];
Identifier arg = argser.Deserialize(sArg);
args.Add(arg);
}
}
var sig = new ProcedureSignature(ret, args.ToArray());
return(sig);
}
public void Setup()
{
var sc = new ServiceContainer();
sc.AddService <IFileSystemService>(new FileSystemServiceImpl());
arch = new X86ArchitectureReal();
platform = new MsdosPlatform(sc, arch);
sigser = new X86ProcedureSerializer(
arch,
new TypeLibraryDeserializer(platform, true, new TypeLibrary()),
"stdapi");
argser = new ArgumentDeserializer(sigser, arch, arch.CreateFrame(), 4);
}
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 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);
}
public override FunctionType Deserialize(SerializedSignature ss, Frame frame)
{
if (ss == null)
{
return(null);
}
this.argser = new ArgumentDeserializer(
this,
Architecture,
frame,
Architecture.PointerType.Size,
Architecture.WordWidth.Size);
Identifier ret = null;
int fpuDelta = FpuStackOffset;
FpuStackOffset = 0;
if (ss.ReturnValue != null)
{
ret = argser.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 void Setup()
{
var sc = new ServiceContainer();
sc.AddService <IFileSystemService>(new FileSystemServiceImpl());
arch = new X86ArchitectureReal("x86-real-16");
platform = new MsdosPlatform(sc, arch);
sigser = new ProcedureSerializer(
platform,
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);
}
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();
}
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)
{
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 > 10)
{
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)
{
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()));
}
