public StartupFinder(IServiceProvider services, Program program, Address addrStart)
{
this.services = services;
this.prog= program;
this.start = addrStart;
this.state = program.Architecture.CreateProcessorState();
}
public List<Address> BuildAux(Backwalker bw, Address addrFrom, ProcessorState state)
{
int limit = 0;
int[] permutation = null;
foreach (BackwalkOperation op in bw.Operations)
{
BackwalkError err = op as BackwalkError;
if (err != null)
{
return PostError(err.ErrorMessage, addrFrom, bw.VectorAddress);
}
var deref = op as BackwalkDereference;
if (deref != null)
{
permutation = BuildMapping(deref, limit);
}
limit = op.Apply(limit);
}
if (limit == 0)
return PostError("Unable to determine limit", addrFrom, bw.VectorAddress);
return BuildTable(
bw.VectorAddress,
limit,
permutation,
(bw.Stride == 1 || bw.Stride == 0) && bw.JumpSize > 1
? bw.JumpSize
: bw.Stride,
state);
}
private BlockWorkitem CreateWorkItem(Address addr, ProcessorState state)
{
return new BlockWorkitem(
scanner,
program,
state,
addr);
}
public override SystemService FindService(int vector, ProcessorState state)
{
if (TypeLibs.Length == 0)
return null;
SystemService svc;
this.TypeLibs[0].ServicesByVector.TryGetValue(vector&0xFFFF , out svc);
return svc;
}
public override IEnumerable<RtlInstructionCluster> CreateRewriter(ImageReader rdr, ProcessorState state, Frame frame, IRewriterHost host)
{
return new MipsRewriter(
this,
new MipsDisassembler(this, rdr, IsVersion6OrLater),
frame,
host);
}
public IEnumerable<RtlInstructionCluster> CreateRewriter(ImageReader rdr, ProcessorState state, Frame frame, IRewriterHost host)
{
var linAddr = rdr.Address.ToLinear();
RtlTrace trace;
if (!rewriters.Traces.TryGetValue(rdr.Address, out trace))
NUnit.Framework.Assert.Fail(string.Format("Unexpected request for a rewriter at address {0}", rdr.Address));
return trace;
}
public override SystemService FindService(int vector, ProcessorState state)
{
foreach (SystemService svc in realModeServices)
{
if (svc.SyscallInfo.Matches(vector, state))
return svc;
}
return null;
}
public List<Address> Build(Address addrTable, Address addrFrom, ProcessorState state)
{
bw = new Backwalker(this, null, null);
if (bw == null)
return null;
List<BackwalkOperation> operations = bw.BackWalk(null);
if (operations == null)
return PostError("Unable to determine limit", addrFrom, addrTable);
return BuildAux(bw, addrFrom, state);
}
public override SystemService FindService(int vector, ProcessorState state)
{
EnsureTypeLibraries();
return this.typelibs
.Where(t => t.ServicesByVector != null && t.ServicesByVector.Count > 0)
.SelectMany(t => t.ServicesByVector)
.Where(svc => svc.Value.SyscallInfo.Matches(vector, state))
.Select(svc => svc.Value)
.FirstOrDefault();
}
public EntryPoint(Address addr, string name, ProcessorState state)
{
if (addr == null)
throw new ArgumentNullException("addr");
if (state == null)
throw new ArgumentNullException("state");
this.Address = addr;
this.Name = name;
this.ProcessorState = state;
}
public override SystemService FindService(int vector, ProcessorState state)
{
EnsureTypeLibraries(PlatformIdentifier);
foreach (SystemService svc in realModeServices)
{
if (svc.SyscallInfo.Matches(vector, state))
return svc;
}
return null;
}
public void Setup()
{
arch = new IntelArchitecture(ProcessorMode.Protected32);
m = new ProcedureBuilder();
state = arch.CreateProcessorState();
expSimp = new ExpressionSimplifier(
new IntelArchitecture(ProcessorMode.Protected32).CreateProcessorState());
SCZO = m.Frame.EnsureFlagGroup((uint)(FlagM.SF | FlagM.CF | FlagM.ZF | FlagM.OF), "SCZO", PrimitiveType.Byte);
host = new BackwalkerHost();
}
public override SystemService FindService(int vector, ProcessorState state)
{
base.EnsureTypeLibraries(base.PlatformIdentifier);
foreach (var module in this.Metadata.Modules.Values)
{
SystemService svc;
if (module.ServicesByVector.TryGetValue(vector & 0xFFFF, out svc))
return svc;
}
return null;
}
private bool Matches(ProcessorState state)
{
for (int i = 0; i < RegisterValues.Length; ++i)
{
Constant v = state.GetRegister(RegisterValues[i].Register);
if (v == null || v == Constant.Invalid)
return false;
if (v.ToUInt32() != RegisterValues[i].Value)
return false;
}
return true;
}
protected Address ReadSegmentedCodeAddress(int byteSize, ImageReader rdr, ProcessorState state)
{
if (byteSize == PrimitiveType.Word16.Size)
{
return Address.SegPtr(state.GetRegister(Registers.cs).ToUInt16(), rdr.ReadLeUInt16());
}
else
{
ushort off = rdr.ReadLeUInt16();
ushort seg = rdr.ReadLeUInt16();
return Address.SegPtr(seg, off);
}
}
public override SystemService FindService(int vector, ProcessorState state)
{
base.EnsureTypeLibraries(PlatformIdentifier);
int uVec = vector & 0xFFFF;
foreach (var svc in this.Metadata.Modules.Values.SelectMany(m => m.ServicesByVector.Values))
{
if (svc.SyscallInfo.Matches(uVec, state))
{
return svc;
}
}
return null;
}
public override SystemService FindService(RtlInstruction rtl, ProcessorState state)
{
if (!a6Pattern.Match(rtl))
return null;
var reg = ((Identifier) a6Pattern.CapturedExpressions("addrReg")).Storage as RegisterStorage;
var offset = ((Constant) a6Pattern.CapturedExpressions("offset")).ToInt32();
if (reg != Registers.a6)
return null;
if (funcs == null)
funcs = LoadFuncs();
SystemService svc;
return funcs.TryGetValue(offset, out svc) ? svc : null;
}
public override SystemService FindService(int vector, ProcessorState state)
{
switch (vector)
{
// http://www.riscos.com/support/developers/prm/errors.html#89849
case 0x2B:
return new SystemService
{
Name = "OS_GenerateError",
Characteristics = new ProcedureCharacteristics {
Terminates = true,
},
Signature = new ProcedureSignature(null,
new Identifier("r0", PrimitiveType.Pointer32, A32Registers.r0))
};
}
throw new NotSupportedException(string.Format("Unknown RiscOS vector &{0:X}.", vector));
}
public void Setup()
{
arch = new FakeArchitecture();
m = new ProcedureBuilder();
state = arch.CreateProcessorState();
expSimp = new ExpressionSimplifier(arch.CreateProcessorState());
host = new BackwalkerHost(arch);
}
public override SystemService FindService(int vector, ProcessorState state)
{
throw new NotImplementedException();
}
public override BlockWorkitem CreateBlockWorkItem(Address addrStart, Procedure proc, ProcessorState state)
{
Test_State = state;
Test_LastBlockWorkitem = base.CreateBlockWorkItem(addrStart, proc, state);
return Test_LastBlockWorkitem;
}
public override SystemService FindService(int vector, ProcessorState state)
{
if (int3svc.SyscallInfo.Matches(vector, state))
return int3svc;
if (int29svc.SyscallInfo.Matches(vector, state))
return int29svc;
throw new NotImplementedException("INT services are not supported by " + this.GetType().Name);
}
public IEnumerable<RtlInstructionCluster> CreateRewriter(ImageReader rdr, ProcessorState state, Frame frame, IRewriterHost host)
{
throw new NotImplementedException();
}
public abstract Address ReadCodeAddress(int byteSize, ImageReader rdr, ProcessorState state);
public override Address ReadCodeAddress(int byteSize, ImageReader rdr, ProcessorState state)
{
return Address.Ptr64(rdr.ReadLeUInt64());
}
public override Address ReadCodeAddress(int byteSize, ImageReader rdr, ProcessorState state)
{
return ReadSegmentedCodeAddress(byteSize, rdr, state);
}
public virtual SystemService FindService(RtlInstruction rtl, ProcessorState state)
{
return null;
}
public override Address ReadCodeAddress(int size, ImageReader rdr, ProcessorState state)
{
throw new NotImplementedException();
}
public override IEnumerable<RtlInstructionCluster> CreateRewriter(ImageReader rdr, ProcessorState state, Frame frame, IRewriterHost host)
{
return new SparcRewriter(this, rdr, (SparcProcessorState)state, frame, host);
}
public abstract SystemService FindService(int vector, ProcessorState state);
