| public Deserialize ( Reko.Core.Serialization.Argument_v1 arg ) : Identifier | ||
| arg | Reko.Core.Serialization.Argument_v1 | |
| return | Identifier | |
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;
var argser = new ArgumentDeserializer(this, Architecture, frame, 4, 2);
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 FunctionType(ret, args.ToArray());
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;
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();
}
/// <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 override Identifier Deserialize(ArgumentDeserializer sser)
{
return(sser.Deserialize(this));
}
public override Identifier Deserialize(ArgumentDeserializer sser)
{
return sser.Deserialize(this);
}
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();
}
