private int CountBlockLines(ImageMapItem item)
{
var bi = item as ImageMapBlock;
if (bi != null)
{
return CountDisassembledLines(bi);
}
else
{
return CountMemoryLines(item);
}
}
private Address CreateImageMapItem(ImageMap map, DataType dt, Address addr = null)
{
addr = (addr != null) ? addr : map.Items.Keys.LastOrDefault();
var curAddr = (addr != null) ? addr : map.BaseAddress;
var size = (uint)dt.Size;
var imageMapItem = new ImageMapItem(size) { Address = curAddr };
if (dt != null)
imageMapItem.DataType = dt;
map.AddItemWithSize(curAddr, imageMapItem);
return imageMapItem.EndAddress;
}
private int GetLineOffset(ImageMapItem item, Address addr)
{
if (item is ImageMapBlock bi)
{
int i = 0;
while (i < instructions[bi].Length)
{
if (instructions[bi][i].Address >= addr)
{
break;
}
++i;
}
return(i);
}
else
{
return((int)((Align(addr.ToLinear(), BytesPerLine) -
Align(item.Address.ToLinear(), BytesPerLine)) /
BytesPerLine));
}
}
private BrushTheme GetBrushTheme(ImageMapItem item, bool selected)
{
if (item == null)
{
return(defaultTheme);
}
if (selected)
{
return(selectTheme);
}
if (item is ImageMapBlock)
{
return(codeTheme);
}
if (item.DataType != null && !(item.DataType is UnknownType))
{
return(dataTheme);
}
if (item is ImageMapVectorTable)
{
return(dataTheme);
}
return(defaultTheme);
}
private string DetermineFilename(ImageMapItem item, ImageSegment seg, string fileExtension)
{
return(FilenameBasedOnSegment(item.Address, seg, fileExtension));
}
private Address GetAddressOfLine(ImageMapItem item, int i)
{
if (i == 0)
return item.Address;
else
return Align(item.Address + i * BytesPerLine, BytesPerLine);
}
/// <summary>
/// Find the index of the address within the item.
/// </summary>
/// <param name="item"></param>
/// <param name="addr"></param>
/// <returns></returns>
private int FindIndexOfMemoryAddress(ImageMapItem item, Address addr)
{
var addrStart = Align(item.Address, BytesPerLine);
long idx = (addr - addrStart) / BytesPerLine;
return (int) idx;
}
// Mutators /////////////////////////////////////////////////////////////////
/// <summary>
/// This method is called when the user has created a global item.
/// </summary>
/// <param name="address"></param>
/// <param name="dataType"></param>
/// <returns></returns>
public ImageMapItem AddUserGlobalItem(Address address, DataType dataType)
{
//$TODO: if user enters a segmented address, we need to
// place the item in the respective globals struct.
var size = GetDataSize(address, dataType);
var item = new ImageMapItem
{
Address = address,
Size = size,
DataType = dataType,
};
if (size != 0)
this.ImageMap.AddItemWithSize(address, item);
else
this.ImageMap.AddItem(address, item);
this.User.Globals.Add(address, new Serialization.GlobalDataItem_v2
{
Address = address.ToString(),
DataType = dataType.Accept(new Serialization.DataTypeSerializer()),
});
return item;
}
private int GetLineOffset(ImageMapItem item, Address addr)
{
var bi = item as ImageMapBlock;
if (bi != null)
{
int i = 0;
while (i < instructions[bi].Length)
{
if (instructions[bi][i].Address >= addr)
{
break;
}
++i;
}
return i;
}
else
{
return (int)((Align(addr.ToLinear(), BytesPerLine) -
Align(item.Address.ToLinear(), BytesPerLine)) /
BytesPerLine);
}
}
// Mutators /////////////////////////////////////////////////////////////////
/// <summary>
/// This method is called when the user has created a global item.
/// </summary>
/// <param name="address"></param>
/// <param name="dataType"></param>
/// <returns></returns>
public ImageMapItem AddUserGlobalItem(Address address, DataType dataType)
{
var size = GetDataSize(address, dataType);
var item = new ImageMapItem
{
Address = address,
Size = size,
DataType = dataType,
};
if (size != 0)
this.ImageMap.AddItemWithSize(address, item);
else
this.ImageMap.AddItem(address, item);
this.UserGlobalData.Add(address, new Serialization.GlobalDataItem_v2
{
Address = address.ToString(),
DataType = dataType.Accept(new Serialization.DataTypeSerializer()),
});
return item;
}
private void Given_Item(uint uAddr, uint size)
{
var item = new ImageMapItem(Address.Ptr32(uAddr), size);
program.ImageMap.AddItem(item.Address, item);
}
private void Given_ImageMapItem(uint addr, DataType dataType, string name)
{
var address = Address32.Ptr32(addr);
var item = new ImageMapItem
{
Address = address,
DataType = dataType,
Name = name,
Size = (uint)dataType.Size,
};
program.ImageMap.AddItemWithSize(address, item);
}
public Program VisitInputFile(DecompilerInput_v2 sInput)
{
var bytes = loader.LoadImageBytes(sInput.Filename, 0);
var program = loader.LoadExecutable(sInput.Filename, bytes, null);
program.Filename = sInput.Filename;
if (sInput.UserProcedures != null)
{
program.UserProcedures = sInput.UserProcedures
.Select(sup => {
Address addr;
program.Architecture.TryParseAddress(sup.Address, out addr);
return(new KeyValuePair <Address, Procedure_v1>(addr, sup));
})
.Where(kv => kv.Key != null)
.ToSortedList(kv => kv.Key, kv => kv.Value);
}
if (sInput.UserGlobalData != null)
{
program.UserGlobalData = sInput.UserGlobalData
.Select(sud =>
{
Address addr;
program.Architecture.TryParseAddress(sud.Address, out addr);
return(new KeyValuePair <Address, GlobalDataItem_v2>(
addr,
sud));
})
.Where(kv => kv.Key != null)
.ToSortedList(kv => kv.Key, kv => kv.Value);
}
foreach (var kv in program.UserGlobalData)
{
var dt = kv.Value.DataType.BuildDataType(program.TypeFactory);
var item = new ImageMapItem((uint)dt.Size)
{
Address = kv.Key,
DataType = dt,
};
if (item.Size > 0)
{
program.ImageMap.AddItemWithSize(kv.Key, item);
}
else
{
program.ImageMap.AddItem(kv.Key, item);
}
}
program.DisassemblyFilename = sInput.DisassemblyFilename;
program.IntermediateFilename = sInput.IntermediateFilename;
program.OutputFilename = sInput.OutputFilename;
program.TypesFilename = sInput.TypesFilename;
program.GlobalsFilename = sInput.GlobalsFilename;
program.EnsureFilenames(sInput.Filename);
program.OnLoadedScript = sInput.OnLoadedScript;
if (sInput.Options != null)
{
program.Options.HeuristicScanning = sInput.Options.HeuristicScanning;
}
ProgramLoaded.Fire(this, new ProgramEventArgs(program));
return(program);
}
private string DetermineFilename(ImageMapItem item, ImageSegment seg)
{
return(FilenameBasedOnSegment(item.Address, seg));
}
private void LoadUserData(DecompilerInput_v2 sInput, Program program, UserData user)
{
if (sInput.UserProcedures != null)
{
user.Procedures = sInput.UserProcedures
.Select(sup =>
{
Address addr;
program.Architecture.TryParseAddress(sup.Address, out addr);
return new KeyValuePair<Address, Procedure_v1>(addr, sup);
})
.Where(kv => kv.Key != null)
.ToSortedList(kv => kv.Key, kv => kv.Value);
}
if (sInput.UserGlobalData != null)
{
user.Globals = sInput.UserGlobalData
.Select(sud =>
{
Address addr;
program.Architecture.TryParseAddress(sud.Address, out addr);
return new KeyValuePair<Address, GlobalDataItem_v2>(
addr,
sud);
})
.Where(kv => kv.Key != null)
.ToSortedList(kv => kv.Key, kv => kv.Value);
}
foreach (var kv in user.Globals)
{
var dt = kv.Value.DataType.BuildDataType(program.TypeFactory);
var item = new ImageMapItem((uint)dt.Size)
{
Address = kv.Key,
DataType = dt,
};
if (item.Size > 0)
{
program.ImageMap.AddItemWithSize(kv.Key, item);
}
else
{
program.ImageMap.AddItem(kv.Key, item);
}
}
user.OnLoadedScript = sInput.OnLoadedScript;
if (sInput.Options != null)
{
program.User.Heuristics.Add("shingle");
}
}
private void DumpTypedData(SegmentMap map, ImageMapItem item, Formatter stm)
{
ImageSegment segment;
if (!map.TryFindSegment(item.Address, out segment) || segment.MemoryArea == null)
return;
stm.Write(Block.GenerateName(item.Address));
stm.Write("\t");
ImageReader rdr = arch.CreateImageReader(segment.MemoryArea, item.Address);
item.DataType.Accept(new TypedDataDumper(rdr, item.Size, stm));
}
public GlobalDataItem_v2 ModifyUserGlobal(Address address, SerializedType dataType, string name)
{
GlobalDataItem_v2 gbl;
if (!User.Globals.TryGetValue(address, out gbl))
{
gbl = new GlobalDataItem_v2()
{
Address = address.ToString(),
};
User.Globals.Add(address, gbl);
}
gbl.Name = name;
gbl.DataType = dataType;
this.ImageMap.RemoveItem(address);
var tlDeser = CreateTypeLibraryDeserializer();
var dt = dataType.Accept(tlDeser);
var size = GetDataSize(address, dt);
var item = new ImageMapItem
{
Address = address,
Size = size,
Name = name,
DataType = dt,
};
if (size != 0)
this.ImageMap.AddItemWithSize(address, item);
else
this.ImageMap.AddItem(address, item);
return gbl;
}
/// <summary>
/// Seed the imagemap with image symbols
/// </summary>
public void BuildImageMap()
{
this.ImageMap = SegmentMap.CreateImageMap();
foreach (var sym in this.ImageSymbols.Values.Where(
s => s.Type == SymbolType.Data && s.Size != 0))
{
this.ImageMap.AddItemWithSize(
sym.Address,
new ImageMapItem
{
Address = sym.Address,
DataType = sym.DataType,
Size = sym.Size,
});
}
var tlDeser = CreateTypeLibraryDeserializer();
foreach (var kv in User.Globals)
{
var dt = kv.Value.DataType.Accept(tlDeser);
var item = new ImageMapItem((uint)dt.Size)
{
Address = kv.Key,
DataType = dt,
Name = kv.Value.Name,
};
if (item.Size > 0)
{
this.ImageMap.AddItemWithSize(kv.Key, item);
}
else
{
this.ImageMap.AddItem(kv.Key, item);
}
//$BUGBUG: what about x86 segmented binaries?
int offset = (int)kv.Key.ToLinear();
GlobalFields.Fields.Add(offset, dt, kv.Value.Name);
}
}
public MemSpanifyer(Program program, ImageMapItem item, Address addr)
{
this.program = program;
this.item = item;
this.addr = addr;
}
public MemSpanifyer(Program program, ImageMapItem item, Address addr)
{
this.program = program;
this.item = item;
this.addr = addr;
}
private SpanGenerator CreateSpanifier(ImageMapItem item, Address addr)
{
SpanGenerator sp;
var b = item as ImageMapBlock;
if (b != null)
{
sp = new AsmSpanifyer(program, instructions[b], addr);
}
else
{
sp = new MemSpanifyer(program, item, addr);
}
return sp;
}
public void LoadUserData(UserData_v3 sUser, Program program, UserData user)
{
if (sUser == null)
return;
user.OnLoadedScript = sUser.OnLoadedScript;
if (sUser.Procedures != null)
{
user.Procedures = sUser.Procedures
.Select(sup =>
{
Address addr;
program.Architecture.TryParseAddress(sup.Address, out addr);
return new KeyValuePair<Address, Procedure_v1>(addr, sup);
})
.Where(kv => kv.Key != null)
.ToSortedList(kv => kv.Key, kv => kv.Value);
}
if (sUser.Processor != null)
{
program.User.Processor = sUser.Processor.Name;
if (program.Architecture == null && !string.IsNullOrEmpty(program.User.Processor))
{
program.Architecture = services.RequireService<IConfigurationService>().GetArchitecture(program.User.Processor);
}
//program.Architecture.LoadUserOptions(); //$TODO
}
if (sUser.PlatformOptions != null)
{
program.User.Environment = sUser.PlatformOptions.Name;
if (program.Platform is DefaultPlatform && !string.IsNullOrEmpty(program.User.Environment))
{
program.Platform = services.RequireService<IConfigurationService>()
.GetEnvironment(program.User.Environment)
.Load(services, program.Architecture);
}
program.Platform.LoadUserOptions(LoadPlatformOptions(sUser.PlatformOptions.Options));
}
if (sUser.GlobalData != null)
{
user.Globals = sUser.GlobalData
.Select(sud =>
{
Address addr;
program.Architecture.TryParseAddress(sud.Address, out addr);
return new KeyValuePair<Address, GlobalDataItem_v2>(
addr,
sud);
})
.Where(kv => kv.Key != null)
.ToSortedList(kv => kv.Key, kv => kv.Value);
}
foreach (var kv in user.Globals)
{
var dt = kv.Value.DataType.BuildDataType(program.TypeFactory);
var item = new ImageMapItem((uint)dt.Size)
{
Address = kv.Key,
DataType = dt,
};
if (item.Size > 0)
{
program.ImageMap.AddItemWithSize(kv.Key, item);
}
else
{
program.ImageMap.AddItem(kv.Key, item);
}
}
if (sUser.Heuristics != null)
{
user.Heuristics.UnionWith(sUser.Heuristics.Select(h => h.Name));
}
}
private int SelectBgColor(ImageMapItem item)
{
if (item.DataType is UnknownType)
return -1;
//$TODO: colors should come from settings.
if (item.DataType is CodeType)
return System.Drawing.Color.Pink.ToArgb();
return 0x00C0C0FF;
}
/// <summary>
/// Count the number of lines a memory area subtends.
/// </summary>
/// <remarks>
/// We align mempry spans on 16-byte boundaries (//$REVIEW for now,
/// this should be user-adjustable) so if we have a memory span
/// straddling such a boundary, we have to account for it. E.g. the
/// span [01FC-0201] should be rendered:
/// <code>
/// 01FC 0C 0D 0F ....
/// 0200 00 01 ..
/// </code>
/// and therefore requires 2 lines even though the number of bytes is
/// less than 16.
/// </remarks>
/// <param name="item"></param>
/// <returns></returns>
private int CountMemoryLines(ImageMapItem item)
{
if (item.Size == 0)
return 0; //$TODO: this shouldn't ever happen!
var linStart = item.Address.ToLinear();
var linEnd = linStart + item.Size;
linStart = Align(linStart, BytesPerLine);
linEnd = Align(linEnd + (BytesPerLine - 1), BytesPerLine);
return (int)(linEnd - linStart) / BytesPerLine;
}
private BrushTheme GetBrushTheme(ImageMapItem item, bool selected)
{
if (selected)
return selectTheme;
if (item is ImageMapBlock)
return codeTheme;
if (item.DataType != null && !(item.DataType is UnknownType))
return dataTheme;
return defaultTheme;
}
private int SelectBgColor(ImageMapItem item)
{
if (item.DataType is UnknownType)
return -1;
if (item.DataType is CodeType) //$TODO: colors should come from settings.
return System.Drawing.Color.Pink.ToArgb();
throw new NotImplementedException();
}
public Program VisitInputFile(DecompilerInput_v2 sInput)
{
var bytes = loader.LoadImageBytes(sInput.Filename, 0);
var program = loader.LoadExecutable(sInput.Filename, bytes, null);
program.Filename = sInput.Filename;
if (sInput.UserProcedures != null)
{
program.UserProcedures = sInput.UserProcedures
.Select(sup =>{
Address addr;
program.Architecture.TryParseAddress(sup.Address, out addr);
return new KeyValuePair<Address, Procedure_v1>(addr, sup);
})
.Where(kv => kv.Key != null)
.ToSortedList(kv => kv.Key, kv => kv.Value);
}
if (sInput.UserGlobalData != null)
{
program.UserGlobalData = sInput.UserGlobalData
.Select(sud =>
{
Address addr;
program.Architecture.TryParseAddress(sud.Address, out addr);
return new KeyValuePair<Address, GlobalDataItem_v2>(
addr,
sud);
})
.Where(kv => kv.Key != null)
.ToSortedList(kv => kv.Key, kv => kv.Value);
}
foreach (var kv in program.UserGlobalData)
{
var dt = kv.Value.DataType.BuildDataType(program.TypeFactory);
var item = new ImageMapItem((uint)dt.Size)
{
Address = kv.Key,
DataType = dt,
};
if (item.Size > 0)
{
program.ImageMap.AddItemWithSize(kv.Key, item);
}
else
{
program.ImageMap.AddItem(kv.Key, item);
}
}
program.DisassemblyFilename = sInput.DisassemblyFilename;
program.IntermediateFilename = sInput.IntermediateFilename;
program.OutputFilename = sInput.OutputFilename;
program.TypesFilename = sInput.TypesFilename;
program.GlobalsFilename = sInput.GlobalsFilename;
program.EnsureFilenames(sInput.Filename);
program.OnLoadedScript = sInput.OnLoadedScript;
if (sInput.Options != null)
{
program.Options.HeuristicScanning = sInput.Options.HeuristicScanning;
}
ProgramLoaded.Fire(this, new ProgramEventArgs(program));
return program;
}
public void LoadUserData(UserData_v3 sUser, Program program, UserData user)
{
if (sUser == null)
{
return;
}
user.OnLoadedScript = sUser.OnLoadedScript;
if (sUser.Processor != null)
{
program.User.Processor = sUser.Processor.Name;
if (program.Architecture == null && !string.IsNullOrEmpty(program.User.Processor))
{
program.Architecture = Services.RequireService <IConfigurationService>().GetArchitecture(program.User.Processor);
}
//program.Architecture.LoadUserOptions(); //$TODO
}
if (sUser.Procedures != null)
{
user.Procedures = sUser.Procedures
.Select(sup =>
{
Address addr;
program.Architecture.TryParseAddress(sup.Address, out addr);
return(new KeyValuePair <Address, Procedure_v1>(addr, sup));
})
.Where(kv => kv.Key != null)
.ToSortedList(kv => kv.Key, kv => kv.Value);
}
if (sUser.PlatformOptions != null)
{
program.User.Environment = sUser.PlatformOptions.Name;
program.Platform.LoadUserOptions(LoadWeaklyTypedOptions(sUser.PlatformOptions.Options));
}
if (sUser.GlobalData != null)
{
user.Globals = sUser.GlobalData
.Select(sud =>
{
Address addr;
program.Architecture.TryParseAddress(sud.Address, out addr);
return(new KeyValuePair <Address, GlobalDataItem_v2>(
addr,
sud));
})
.Where(kv => kv.Key != null)
.ToSortedList(kv => kv.Key, kv => kv.Value);
}
var tlDeser = CreateTypeLibraryDeserializer();
foreach (var kv in user.Globals)
{
var dt = kv.Value.DataType.Accept(tlDeser);
var item = new ImageMapItem((uint)dt.Size)
{
Address = kv.Key,
DataType = dt,
Name = kv.Value.Name,
};
if (item.Size > 0)
{
program.ImageMap.AddItemWithSize(kv.Key, item);
}
else
{
program.ImageMap.AddItem(kv.Key, item);
}
//$BUGBUG: what about x86 segmented binaries?
int offset = (int)kv.Key.ToLinear();
program.GlobalFields.Fields.Add(offset, dt, kv.Value.Name);
}
if (sUser.Heuristics != null)
{
user.Heuristics.UnionWith(sUser.Heuristics.Select(h => h.Name));
}
program.EnvironmentMetadata = project.LoadedMetadata;
}
