private Dictionary<Address32, ImportReference> LoadImports()
{
Dictionary<Address32, ImportReference> imports = new Dictionary<Address32, ImportReference>();
XbeLibrary kernelLibrary = new XbeLibrary(rdr.ReadAt(ctx.KernelLibraryAddress - ctx.BaseAddress, (rdr) =>
{
return rdr.ReadStruct<XbeLibraryVersion>();
}));
rdr.Seek(ctx.KernelThunkAddress - ctx.BaseAddress, System.IO.SeekOrigin.Begin);
for (uint i = 0; ; i++)
{
Address32 ordinalAddress = (Address32) ctx.KernelThunkAddress.Add(i * 4);
if(!rdr.TryReadUInt32(out uint dword))
{
throw new BadImageFormatException("Unexpected EOF while reading import table.");
}
if (dword == 0)
{
break;
} else if((dword >> 31) == 0)
{
throw new NotSupportedException("Named ordinals not expected in XBE files.");
}
int ordinalValue = (int) (dword & 0x7FFFFFFF);
imports.Add(ordinalAddress, new OrdinalImportReference(ordinalAddress, kernelLibrary.LibraryName, ordinalValue, SymbolType.ExternalProcedure));
}
return imports;
}
public void Setup()
{
this.mr = new MockRepository();
this.sc = new ServiceContainer();
loader = mr.Stub <ILoader>();
arch = mr.StrictMock <IProcessorArchitecture>();
this.listener = mr.Stub <DecompilerEventListener>();
Address dummy;
arch.Stub(a => a.TryParseAddress(null, out dummy)).IgnoreArguments().WhenCalled(m =>
{
Address addr;
var sAddr = (string)m.Arguments[0];
var iColon = sAddr.IndexOf(':');
if (iColon > 0)
{
addr = Address.SegPtr(
Convert.ToUInt16(sAddr.Remove(iColon)),
Convert.ToUInt16(sAddr.Substring(iColon + 1)));
m.ReturnValue = true;
}
else
{
m.ReturnValue = Address32.TryParse32((string)m.Arguments[0], out addr);
}
m.Arguments[1] = addr;
}).Return(false);
this.cfgSvc = mr.Stub <IConfigurationService>();
this.sc.AddService <IConfigurationService>(cfgSvc);
}
public override Program Load(Address addrLoad)
{
var cfgSvc = Services.RequireService <IConfigurationService>();
var arch = cfgSvc.GetArchitecture("ppc-be-64");
var platform = cfgSvc.GetEnvironment("xbox360").Load(Services, arch);
LoadHeaders();
LoadImageData();
LoadPEImage();
PopulateImports();
addrLoad = new Address32(xexData.exe_address);
var segmentMap = new SegmentMap(addrLoad, segments.ToArray());
var entryPointAddress = new Address32(xexData.exe_entry_point);
var entryPoint = ImageSymbol.Procedure(arch, entryPointAddress);
var program = new Program(
segmentMap,
arch,
platform
)
{
ImageSymbols = { { entryPointAddress, entryPoint } },
EntryPoints = { { entryPointAddress, entryPoint } },
};
foreach (var import in imports)
{
program.ImportReferences.Add(import.Key, import.Value);
}
return(program);
}
public void Cvp_CreateGlobalsViewerIfNotVisible()
{
var segment = new ImageSegment(
".seg", Address32.Ptr32(0x17), 0, AccessMode.ReadWrite);
var label = ".seg global variables";
var uiSvc = AddMockService <IDecompilerShellUiService>();
uiSvc.Expect(s => s.FindDocumentWindow(
"CombinedCodeViewInteractor", segment))
.Return(null);
var windowPane = mr.Stub <CombinedCodeViewInteractor>();
var windowFrame = mr.StrictMock <IWindowFrame>();
windowFrame.Stub(f => f.Pane).Return(windowPane);
uiSvc.Expect(s => s.CreateDocumentWindow(
Arg <string> .Is.Equal("CombinedCodeViewInteractor"),
Arg <string> .Is.Equal(segment),
Arg <string> .Is.Equal(label),
Arg <IWindowPane> .Is.Anything))
.Return(windowFrame);
windowFrame.Expect(s => s.Show());
mr.ReplayAll();
var codeViewerSvc = new CodeViewerServiceImpl(sc);
codeViewerSvc.DisplayGlobals(program, segment);
uiSvc.VerifyAllExpectations();
}
public void Setup()
{
mr = new MockRepository();
services = new ServiceContainer();
declarationForm = mr.Stub <IDeclarationForm>();
textBox = new FakeTextBox();
declarationForm.Stub(f => f.TextBox).Return(textBox);
declarationForm.Stub(f => f.ShowAt(new Point()));
declarationForm.Stub(f => f.Hide());
declarationForm.Stub(f => f.Dispose());
var dlgFactory = mr.Stub <IDialogFactory>();
dlgFactory.Stub(f => f.CreateDeclarationForm()).Return(declarationForm);
services.AddService <IDialogFactory>(dlgFactory);
mr.ReplayAll();
interactor = new DeclarationFormInteractor(services);
var mem = new MemoryArea(Address32.Ptr32(0x10), new byte[40]);
var seg = new ImageSegment(".text", mem, AccessMode.ReadWrite);
var segmentMap = new SegmentMap(Address32.Ptr32(0x05), seg);
var arch = new X86ArchitectureFlat32("x86-protected-32");
var platform = new Win32Platform(null, arch);
program = new Program(segmentMap, arch, platform);
program.ImageMap = segmentMap.CreateImageMap();
}
private void Given_ProcedureName(uint addr, string name)
{
var address = Address32.Ptr32(addr);
var proc = new Procedure(name, null);
program.Procedures[address] = proc;
}
public void Cvp_CreateGlobalsViewerIfNotVisible()
{
var segment = new ImageSegment(
".seg", Address32.Ptr32(0x17), 0, AccessMode.ReadWrite);
var label = ".seg global variables";
var uiSvc = AddMockService <IDecompilerShellUiService>();
uiSvc.Setup(s => s.FindDocumentWindow(
"CombinedCodeViewInteractor", segment))
.Returns((IWindowFrame)null)
.Verifiable();
var windowPane = new Mock <CombinedCodeViewInteractor>();
var windowFrame = new Mock <IWindowFrame>();
windowFrame.Setup(f => f.Pane).Returns(windowPane.Object);
uiSvc.Setup(s => s.CreateDocumentWindow(
"CombinedCodeViewInteractor",
segment,
label,
It.IsAny <IWindowPane>()))
.Returns(windowFrame.Object);
windowFrame.Setup(s => s.Show()).Verifiable();
var codeViewerSvc = new CodeViewerServiceImpl(sc);
codeViewerSvc.DisplayGlobals(program, segment);
uiSvc.VerifyAll();
windowFrame.VerifyAll();
}
private void Given_ImageSegment(uint addr, params byte[] bytes)
{
var mem = new MemoryArea(Address32.Ptr32(addr), bytes);
var seg = new ImageSegment(".text", mem, AccessMode.ReadWrite);
program.ImageMap.AddSegment(seg);
}
public void Setup()
{
mockFactory = new CommonMockFactory();
var platform = mockFactory.CreateMockPlatform();
var imageMap = new SegmentMap(Address32.Ptr32(0x05));
program = new Program(imageMap, platform.Object.Architecture, platform.Object);
interactor = new CombinedCodeViewInteractor();
var uiPreferencesSvc = new Mock <IUiPreferencesService>();
var uiSvc = new Mock <IDecompilerShellUiService>();
var styles = new Dictionary <string, UiStyle>()
{
{
UiStyles.CodeWindow,
new UiStyle
{
Background = new SolidBrush(Color.White),
}
}
};
uiPreferencesSvc.Setup(u => u.Styles).Returns(styles);
var sc = new ServiceContainer();
sc.AddService <IUiPreferencesService>(uiPreferencesSvc.Object);
sc.AddService <IDecompilerShellUiService>(uiSvc.Object);
interactor.SetSite(sc);
}
private void Given_ProcedureSignature(uint addr, string CSignature)
{
Given_ProcedureName(addr, "<unnamed>");
var address = Address32.Ptr32(addr);
var sProc = new Procedure_v1()
{
CSignature = CSignature,
};
program.User.Procedures[address] = sProc;
}
private void Given_ImageMapItem(uint addr, DataType dataType, string name)
{
var address = Address32.Ptr32(addr);
var item = new ImageMapItem(address)
{
DataType = dataType,
Name = name,
Size = (uint)dataType.Size,
};
program.ImageMap.AddItem(address, item);
}
private void PopulateImports()
{
BeImageReader memRdr = new BeImageReader(xexData.memoryData);
for (int i = 0; i < xexData.import_records.Count; i++)
{
UInt32 tableAddress = xexData.import_records[i];
UInt32 memOffset = tableAddress - xexData.exe_address;
if (memOffset > xexData.memorySize)
{
throw new BadImageFormatException($"XEX: invalid import record offset: 0x{memOffset}");
}
UInt32 value = memRdr.ReadAt <UInt32>(memOffset, rdr => rdr.ReadUInt32());
XexImportType type = (XexImportType)((value & 0xFF000000) >> 24);
byte libIndex = (byte)((value & 0x00FF0000) >> 16);
if (type > XexImportType.Function)
{
decompilerEventListener.Error(
$"XEX: Unsupported import type {type}, value: 0x{value:X}");
continue;
}
if (libIndex >= xexData.libNames.Count)
{
throw new BadImageFormatException($"XEX: invalid import record lib index ({libIndex}, max:{xexData.libNames.Count})");
}
UInt32 importOrdinal = (value & 0xFFFF);
string importLibName = xexData.libNames[libIndex];
Address32 importAddress = new Address32(xexData.import_records[i]);
SymbolType symbolType = SymbolType.Unknown;
switch (type)
{
case XexImportType.Data:
symbolType = SymbolType.Data;
break;
case XexImportType.Function:
symbolType = SymbolType.ExternalProcedure;
break;
}
imports.Add(importAddress, new OrdinalImportReference(importAddress, importLibName, (int)importOrdinal, symbolType));
}
}
private void PopulateImports()
{
BeImageReader memRdr = new BeImageReader(xexData.memoryData);
for (int i = 0; i < xexData.import_records.Count; i++)
{
UInt32 tableAddress = xexData.import_records[i];
UInt32 memOffset = tableAddress - xexData.exe_address;
if (memOffset > xexData.memorySize)
{
throw new BadImageFormatException($"XEX: invalid import record offset: 0x{memOffset}");
}
UInt32 value = memRdr.ReadAt <UInt32>(memOffset, rdr => rdr.ReadUInt32());
byte type = (byte)((value & 0xFF000000) >> 24);
byte libIndex = (byte)((value & 0x00FF0000) >> 16);
if (type == 0)
{
if (libIndex >= xexData.libNames.Count)
{
throw new BadImageFormatException($"XEX: invalid import type 0 record lib index ({libIndex}, max:{xexData.libNames.Count})");
}
UInt32 importOrdinal = (value & 0xFFFF);
string importLibName = xexData.libNames[libIndex];
UInt32 importAddress = xexData.import_records[i];
var theAddress = new Address32(importAddress);
imports.Add(theAddress, new OrdinalImportReference(theAddress, importLibName, (int)importOrdinal, SymbolType.ExternalProcedure));
}
else if (type == 1)
{
if (libIndex >= xexData.libNames.Count)
{
throw new BadImageFormatException($"XEX: invalid import type 0 record lib index ({libIndex}, max:{xexData.libNames.Count})");
}
UInt32 importOrdinal = (value & 0xFFFF);
string importLibName = xexData.libNames[libIndex];
UInt32 importAddress = xexData.import_records[i];
var theAddress = new Address32(importAddress);
imports.Add(theAddress, new OrdinalImportReference(theAddress, importLibName, (int)importOrdinal, SymbolType.ExternalProcedure));
}
}
}
public DolHeader(DolStructure hdr)
{
this.offsetText = hdr.offsetText;
this.offsetData = hdr.offsetData;
this.sizeText = hdr.sizeText;
this.sizeBSS = hdr.sizeBSS;
for (int i = 0; i < 7; i++)
{
this.addressText[i] = new Address32(hdr.addressText[i]);
}
for (int i = 0; i < 11; i++)
{
this.addressData[i] = new Address32(hdr.addressData[i]);
}
this.addressBSS = new Address32(hdr.addressBSS);
this.entrypoint = new Address32(hdr.entrypoint);
}
private void Given_StubProcedure(uint addr, uint size)
{
var address = Address32.Ptr32(addr);
var m = new ProcedureBuilder("fnTest");
m.Return();
this.proc = m.Procedure;
this.program.Procedures[address] = proc;
var item = new ImageMapBlock
{
Address = address,
Size = size,
Block = new Block(proc, "fakeBlock")
};
program.ImageMap.AddItemWithSize(address, item);
}
private void When_MovedTo(uint addr)
{
interactor.SelectedAddress = Address32.Ptr32(addr);
}
private void When_DeclarationFormCreated(uint addr)
{
interactor.Show(new Point(0, 0), program, Address32.Ptr32(addr));
}
public void ExaUsrGlobals_Real32()
{
Given_GlobalVariable(
Address32.Ptr32(0x10001200), PrimitiveType.Real32);
RunTest(Constant.Create(PrimitiveType.Real32, 0x10001200));
}
public override Address ReadPreferredImageBase(EndianImageReader rdr)
{
uint rvaBaseOfData = rdr.ReadLeUInt32(); // Only exists in PE32, not PE32+
return(Address32.Ptr32(rdr.ReadLeUInt32()));
}
