public Relocation(BinaryReaderX reader)
{
Offset = reader.ReadUInt16();
Type = (RelocationType)reader.ReadByte();
Section = reader.ReadByte();
Addend = reader.ReadUInt32();
}
internal Relocation(RelocationBlock relocBlock, long relocOffset, ushort relocValue)
{
block = relocBlock;
int reloc_type = relocValue >> 12;
int reloc_offset = relocValue & 0xFFF;
type = (RelocationType)reloc_type;
offset = Convert.ToUInt16(reloc_offset);
value = relocValue;
computed_rva = block.PageRVA;
switch (type)
{
case RelocationType.Absolute:
break;
case RelocationType.HighLow:
computed_rva += offset;
break;
case RelocationType.Dir64:
computed_rva += offset;
break;
case RelocationType.High:
case RelocationType.Low:
default:
computed_rva = 0;
break;
}
location = new StreamLocation(relocOffset,size);
}
public RelocationTable(DAT dat, string name, RelocationType type)
{
EndianBinaryReader reader = dat.reader;
int levelIndex = 0;
string[] levelList = DAT.levelList;
for (int i = 0; i < levelList.Length; i++)
{
if (levelList[i].ToLower().Equals(name.ToLower()))
{
levelIndex = i;
break;
}
}
RelocationTableReference rtref = new RelocationTableReference((byte)levelIndex, (byte)type);
//R3Loader.Loader.print("RtRef Pre (" + rtref.levelId + "," + rtref.relocationType + ")");
uint mask = dat.GetMask(rtref);
uint offset = dat.GetOffset(rtref);
//R3Loader.Loader.print("RtRef Post (" + rtref.levelId + "," + rtref.relocationType + ")");
/*dat.reader.BaseStream.Seek(offset, SeekOrigin.Begin);
* reader.SetMask(mask);
* byte[] dataNew = reader.ReadBytes(1000000);
* Util.ByteArrayToFile(name + "_" + type + ".data", dataNew);*/
dat.reader.BaseStream.Seek(offset, SeekOrigin.Begin);
reader.SetMask(mask);
reader.ReadUInt32();
Read(reader);
}
// Use this to automatically decide whether to load it from RT* file or from DAT
public RelocationTable(string path, DAT dat, string name, RelocationType type)
{
this.name = name;
this.type = type;
this.dat = dat;
/*string newPath = path;
* switch (type) {
* case RelocationType.RTB:
* newPath = Path.ChangeExtension(path, "rtb"); break;
* case RelocationType.RTP:
* newPath = Path.ChangeExtension(path, "rtp"); break;
* case RelocationType.RTS:
* newPath = Path.ChangeExtension(path, "rts"); break;
* case RelocationType.RTT:
* newPath = Path.ChangeExtension(path, "rtt"); break;
* case RelocationType.RTL:
* newPath = Path.ChangeExtension(path, "rtl"); break;
* case RelocationType.RTD:
* newPath = Path.ChangeExtension(path, "rtd"); break;
* case RelocationType.RTG:
* newPath = Path.ChangeExtension(path, "rtg"); break;
* case RelocationType.RTV:
* newPath = Path.ChangeExtension(path, "rtv"); break;
* }
* this.path = newPath;*/
this.path = path;
}
/// <summary>
/// Initializes a new instance of the <see cref="Relocation"/> class.
/// </summary>
/// <param name="symbol">The target symbol.</param>
/// <param name="offset">The offset relative to the start of at which the storage
/// unit to be relocated resides.</param>
/// <param name="addend">The constant used to compute the value of the relocatable field.</param>
/// <param name="type">The type of relocation compution to perform.</param>
public Relocation(Symbol symbol, long offset, long addend, RelocationType type)
{
TargetSymbol = symbol;
Offset = offset;
Addend = addend;
Type = type;
}
/// <summary>
/// Initializes a new instance of the <see cref="Relocation"/> class.
/// </summary>
/// <param name="symbol">The target symbol.</param>
/// <param name="offset">The offset relative to the start of at which the storage
/// unit to be relocated resides.</param>
/// <param name="addend">The constant used to compute the value of the relocatable field.</param>
/// <param name="type">The type of relocation compution to perform.</param>
public Relocation(Symbol symbol, long offset, long addend, RelocationType type)
{
TargetSymbol = symbol;
Offset = offset;
Addend = addend;
Type = type;
}
public Elf32Rel(Elf32_Rel *st)
{
Offset = st->r_offset;
Info = st->r_info;
Symbol = Info >> 8;
Type = (RelocationType)(byte)Info;
}
public Relocation_Entry(ushort offset, byte type, byte section, uint addend)
{
Offset = offset;
Type_Value = type;
Section = section;
Addend = addend;
Type = (RelocationType)type;
}
public Relocation(EndianBinaryReader reader)
{
Offset = reader.ReadInt32();
var info = reader.ReadUInt32();
SymbolTargetIndex = info >> 8;
Type = (RelocationType)(info & 0x000000FF);
}
public Relocation(byte[] data, int start, SymbolTable <uint> symbols)
{
Offset = CONVERTER.ToUInt32(data, start);
var info = CONVERTER.ToUInt32(data, start + 4);
var symbolTargetIndex = info >> 8;
Symbol = symbols.Entries.ElementAt((int)symbolTargetIndex);
Type = (RelocationType)(info & 0x000000FF);
}
/// <summary>
/// Creates a new relocation entry.
/// </summary>
/// <param name="type">The type of relocation to apply.</param>
/// <param name="offset">The offset within the page to apply the relocation on.</param>
/// <exception cref="ArgumentOutOfRangeException">Occurs when the offset does not indicate a valid offset within
/// the page.</exception>
public RelocationEntry(RelocationType type, int offset)
{
if (offset < 0)
{
throw new ArgumentOutOfRangeException(nameof(offset), "Offset cannot be negative.");
}
if (offset > 0xFFF)
{
throw new ArgumentOutOfRangeException(nameof(offset), "Offset cannot be larger than 0xFFF.");
}
_value = (ushort)(((byte)type << 12) | (offset & 0xFFF));
}
/// <summary>
/// Initializes a new instance of the <see cref="Relocation"/> class.
/// </summary>
/// <param name="symbol">The target symbol.</param>
/// <param name="section">The section in which the storage unit to be relocated resides.</param>
/// <param name="offset">The offset relative to the start of <paramref name="section"/> at which the storage
/// unit to be relocated resides.</param>
/// <param name="addend">The constant used to compute the value of the relocatable field.</param>
/// <param name="type">The type of relocation compution to perform.</param>
public Relocation(Symbol symbol, Section section, Int128 offset, Int128 addend, RelocationType type)
{
#region Contract
Contract.Requires<ArgumentNullException>(symbol != null);
Contract.Requires<ArgumentNullException>(section != null);
#endregion
this.targetSymbol = symbol;
this.section = section;
this.offset = offset;
this.addend = addend;
this.type = type;
}
private void ApplyRelocationBlock(Image image, long delta, IMAGE_BASE_RELOCATION *relocation)
{
byte * dest = image.BasePtr + relocation->VirtualAddress;
ushort *relocationInfo = (ushort *)((byte *)relocation + sizeof(IMAGE_BASE_RELOCATION));
for (int i = 0; i < (relocation->BlockSizeInclusive - sizeof(IMAGE_BASE_RELOCATION)) / 2; i++, relocationInfo++)
{
RelocationType type = (RelocationType)(*relocationInfo >> 12);
int offset = *relocationInfo & 0xFFF;
switch (type)
{
case RelocationType.Absolute:
// Skip relocation;
break;
case RelocationType.HighLow:
// Change complete 32-bit address.
int *patchAddressHighLow = (int *)(dest + offset);
if ((byte *)patchAddressHighLow < image.BasePtr || (byte *)patchAddressHighLow > image.BasePtr + image.Size)
{
throw new LoadFailedException("This DLL is damaged; relocation table references an illegal 32-bit offset.");
}
*patchAddressHighLow += (int)delta;
break;
case RelocationType.Dir64:
// Change complete 64-bit address.
long *patchAddress64 = (long *)(dest + offset);
if ((byte *)patchAddress64 < image.BasePtr || (byte *)patchAddress64 > image.BasePtr + image.Size)
{
throw new LoadFailedException("This DLL is damaged; relocation table references an illegal 64-bit offset.");
}
*patchAddress64 += delta;
break;
default:
throw new LoadFailedException(string.Format("This DLL requires unsupported address-relocation type {0} ({1})", type, (int)type));
}
}
}
internal Relocation(int offset, RelocationType type)
{
Offset = offset;
Type = type;
}
/// <summary>
/// Creates a new base relocation.
/// </summary>
/// <param name="type">The type of base relocation to apply.</param>
/// <param name="location">The location within the executable to apply the base relocation.</param>
public BaseRelocation(RelocationType type, ISegmentReference location)
{
Type = type;
Location = location ?? throw new ArgumentNullException(nameof(location));
}
private static string PadRelocName(RelocationType type) => type.ToString().PadRight(nameof(RelocationType.R_MIPS_HI16).Length);
/// <summary>
/// Init constructor of RelocationItem.
/// </summary>
public RelocationItem(RelocationType type, uint offset)
{
Type = type;
Offset = offset;
}
/// <summary>
/// Initializes a new instance of the <see cref="Relocation"/> class.
/// </summary>
/// <param name="symbol">The target symbol.</param>
/// <param name="section">The section in which the storage unit to be relocated resides.</param>
/// <param name="offset">The offset relative to the start of <paramref name="section"/> at which the storage
/// unit to be relocated resides.</param>
/// <param name="addend">The constant used to compute the value of the relocatable field.</param>
/// <param name="type">The type of relocation compution to perform.</param>
public Relocation(Symbol symbol, Section section, Int128 offset, Int128 addend, RelocationType type)
{
#region Contract
Contract.Requires <ArgumentNullException>(symbol != null);
Contract.Requires <ArgumentNullException>(section != null);
#endregion
this.targetSymbol = symbol;
this.section = section;
this.offset = offset;
this.addend = addend;
this.type = type;
}
