private static void WriteFakeILWithBranches(BlobBuilder builder, ControlFlowBuilder branchBuilder, int size)
{
Assert.Equal(0, builder.Count);
const byte filling = 0x01;
int ilOffset = 0;
foreach (var branch in branchBuilder.Branches)
{
builder.WriteBytes(filling, branch.ILOffset - ilOffset);
Assert.Equal(branch.ILOffset, builder.Count);
builder.WriteByte((byte)branch.OpCode);
int operandSize = branch.OpCode.GetBranchOperandSize();
if (operandSize == 1)
{
builder.WriteSByte(-1);
}
else
{
builder.WriteInt32(-1);
}
ilOffset = branch.ILOffset + sizeof(byte) + operandSize;
}
builder.WriteBytes(filling, size - ilOffset);
Assert.Equal(size, builder.Count);
}
private static void WriteFakeILWithBranches(BlobBuilder builder, BranchBuilder branchBuilder, int size)
{
Assert.Equal(0, builder.Count);
const byte filling = 0x01;
int ilOffset = 0;
foreach (var branch in branchBuilder.Branches)
{
builder.WriteBytes(filling, branch.ILOffset - ilOffset);
Assert.Equal(branch.ILOffset, builder.Count);
builder.WriteByte(branch.ShortOpCode);
builder.WriteByte(0xff);
ilOffset = branch.ILOffset + 2;
}
builder.WriteBytes(filling, size - ilOffset);
Assert.Equal(size, builder.Count);
}
private void TestContentEquals(byte[] left, byte[] right)
{
var builder1 = new BlobBuilder(0);
builder1.WriteBytes(left);
var builder2 = new BlobBuilder(0);
builder2.WriteBytes(right);
bool expected = ByteSequenceComparer.Equals(left, right);
Assert.Equal(expected, builder1.ContentEquals(builder2));
}
/// <summary>
/// Write one entry in the "Debug Directory (Image Only)"
/// See https://msdn.microsoft.com/en-us/windows/hardware/gg463119.aspx
/// section 5.1.1 (pages 71-72).
/// </summary>
private static void WriteDebugTableEntry(
BlobBuilder writer,
byte[] stamp,
uint version, // major and minor version, combined
uint debugType,
uint sizeOfData,
uint addressOfRawData,
uint pointerToRawData)
{
writer.WriteUInt32(0); // characteristics
Debug.Assert(stamp.Length == 4);
writer.WriteBytes(stamp);
writer.WriteUInt32(version);
writer.WriteUInt32(debugType);
writer.WriteUInt32(sizeOfData);
writer.WriteUInt32(addressOfRawData);
writer.WriteUInt32(pointerToRawData);
}
public void WritePrimitive()
{
var writer = new BlobBuilder(17);
writer.WriteUInt32(0x11223344);
writer.WriteUInt16(0x5566);
writer.WriteByte(0x77);
writer.WriteUInt64(0x8899aabbccddeeff);
writer.WriteInt32(-1);
writer.WriteInt16(-2);
writer.WriteSByte(-3);
writer.WriteBoolean(true);
writer.WriteBoolean(false);
writer.WriteInt64(unchecked ((long)0xfedcba0987654321));
writer.WriteDateTime(new DateTime(0x1112223334445556));
writer.WriteDecimal(102030405060.70m);
writer.WriteDouble(double.NaN);
writer.WriteSingle(float.NegativeInfinity);
var guid = new Guid("01020304-0506-0708-090A-0B0C0D0E0F10");
writer.WriteBytes(guid.ToByteArray());
writer.WriteGuid(guid);
AssertEx.Equal(new byte[]
{
0x44, 0x33, 0x22, 0x11,
0x66, 0x55,
0x77,
0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99, 0x88,
0xff, 0xff, 0xff, 0xff,
0xfe, 0xff,
0xfd,
0x01,
0x00,
0x21, 0x43, 0x65, 0x87, 0x09, 0xBA, 0xDC, 0xFE,
0x56, 0x55, 0x44, 0x34, 0x33, 0x22, 0x12, 0x11,
0x02, 0xD6, 0xE0, 0x9A, 0x94, 0x47, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF,
0x00, 0x00, 0x80, 0xFF,
0x04, 0x03, 0x02, 0x01, 0x06, 0x05, 0x08, 0x07, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
0x04, 0x03, 0x02, 0x01, 0x06, 0x05, 0x08, 0x07, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10
}, writer.ToArray());
}
private GuidHandle GetOrAddGuid(Guid guid)
{
if (guid == Guid.Empty)
{
return(default(GuidHandle));
}
GuidHandle result;
if (_guids.TryGetValue(guid, out result))
{
return(result);
}
result = MetadataTokens.GuidHandle((_guidWriter.Count >> 4) + 1);
_guids.Add(guid, result);
_guidWriter.WriteBytes(guid.ToByteArray());
return(result);
}
internal static ImmutableArray <byte> CreateBlob(ArraySegment <byte> bytes)
{
if (bytes.Count < 200)
{
BlobBuilder pooledBlobBuilder = new BlobBuilder();
pooledBlobBuilder.WriteInt32(0);
pooledBlobBuilder.WriteBytes(bytes.Array, bytes.Offset, bytes.Count);
return(pooledBlobBuilder.ToImmutableArray());
}
using (BlobBuildingStream builder = BlobBuildingStream.GetInstance())
{
builder.WriteInt32(bytes.Count);
using (CountingDeflateStream deflater = new CountingDeflateStream(builder, CompressionLevel.Optimal, leaveOpen: true))
{
deflater.Write(bytes.Array, bytes.Offset, bytes.Count);
}
return(builder.ToImmutableArray());
}
}
public void LinkSuffix2()
{
var builder1 = new BlobBuilder(16);
builder1.WriteBytes(1, 16);
var builder2 = new BlobBuilder(16);
builder2.WriteBytes(2, 16);
builder1.LinkSuffix(builder2);
AssertEx.Equal(new byte[]
{
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02
}, builder1.ToArray());
Assert.Equal(32, builder1.Count);
Assert.Equal(16, builder2.Count);
}
public void TryOpenAssociatedPortablePdb_DuplicateEntries_Embedded()
{
var pdbBuilder1 = new BlobBuilder();
pdbBuilder1.WriteBytes(PortablePdbs.DocumentsPdb);
var pdbBuilder2 = new BlobBuilder();
pdbBuilder2.WriteByte(1);
var id = new BlobContentId(Guid.Parse("18091B06-32BB-46C2-9C3B-7C9389A2F6C6"), 0x12345678);
var ddBuilder = new DebugDirectoryBuilder();
ddBuilder.AddCodeViewEntry(@"/a/b/a.pdb", id, portablePdbVersion: 0x0100);
ddBuilder.AddReproducibleEntry();
ddBuilder.AddEmbeddedPortablePdbEntry(pdbBuilder1, portablePdbVersion: 0x0100);
ddBuilder.AddEmbeddedPortablePdbEntry(pdbBuilder2, portablePdbVersion: 0x0100);
var peStream = new MemoryStream(TestBuilders.BuildPEWithDebugDirectory(ddBuilder));
using (var reader = new PEReader(peStream))
{
string pathQueried = null;
Func <string, Stream> streamProvider = p =>
{
Assert.Null(pathQueried);
pathQueried = p;
return(null);
};
MetadataReaderProvider pdbProvider;
string pdbPath;
Assert.True(reader.TryOpenAssociatedPortablePdb(Path.Combine("pedir", "file.exe"), streamProvider, out pdbProvider, out pdbPath));
Assert.Equal(PathUtilities.CombinePathWithRelativePath("pedir", "a.pdb"), pathQueried);
Assert.Null(pdbPath);
Assert.Equal(13, pdbProvider.GetMetadataReader().Documents.Count);
}
}
private void WriteImportTable(BlobBuilder builder, int importTableRva, int importAddressTableRva)
{
int start = builder.Count;
int ilRVA = importTableRva + 40;
int hintRva = ilRVA + (Is32Bit ? 12 : 16);
int nameRva = hintRva + 12 + 2;
// Import table
builder.WriteUInt32((uint)ilRVA); // 4
builder.WriteUInt32(0); // 8
builder.WriteUInt32(0); // 12
builder.WriteUInt32((uint)nameRva); // 16
builder.WriteUInt32((uint)importAddressTableRva); // 20
builder.WriteBytes(0, 20); // 40
// Import Lookup table
if (Is32Bit)
{
builder.WriteUInt32((uint)hintRva); // 44
builder.WriteUInt32(0); // 48
builder.WriteUInt32(0); // 52
}
else
{
builder.WriteUInt64((uint)hintRva); // 48
builder.WriteUInt64(0); // 56
}
// Hint table
builder.WriteUInt16(0); // Hint 54|58
foreach (char ch in CorEntryPointName)
{
builder.WriteByte((byte)ch); // 65|69
}
builder.WriteByte(0); // 66|70
Debug.Assert(builder.Count - start == SizeOfImportTable);
}
public void WriteBytes2()
{
var writer = new BlobBuilder(4);
writer.WriteBytes(0xff, 0);
writer.WriteBytes(1, 4);
writer.WriteBytes(0xff, 0);
writer.WriteBytes(2, 10);
writer.WriteBytes(0xff, 0);
writer.WriteBytes(3, 1);
AssertEx.Equal(new byte[]
{
0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x03
}, writer.ToArray());
}
public void AddMethodBody_Reserved_Exceptions_Fat1()
{
var streamBuilder = new BlobBuilder(32);
var encoder = new MethodBodyStreamEncoder(streamBuilder);
streamBuilder.WriteBytes(0x01, 3);
var body = encoder.AddMethodBody(10, exceptionRegionCount: 699050);
Assert.Equal(4, body.Offset); // 4B aligned
var segment = body.Instructions.GetBytes();
Assert.Equal(16, segment.Offset); // +12 byte for the header
Assert.Equal(10, segment.Count);
Assert.Same(streamBuilder, body.ExceptionRegions.Builder);
new BlobWriter(body.Instructions).WriteBytes(0x02, 10);
AssertEx.Equal(new byte[]
{
0x01, 0x01, 0x01,
0x00, // padding
0x1B, 0x30, // flags
0x08, 0x00, // max stack
0x0A, 0x00, 0x00, 0x00, // code size
0x00, 0x00, 0x00, 0x00, // local sig
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
// exception table
0x00, 0x00, // padding
0x41, // kind
0xF4, 0xFF, 0xFF // size fo the table
}, streamBuilder.ToArray());
}
public void PermissionSetEncoder_AddPermission()
{
var b = new BlobBuilder();
var e = new PermissionSetEncoder(b);
Assert.Same(b, e.Builder);
var s = e.AddPermission("ABCD", ImmutableArray.Create <byte>(1, 2, 3));
Assert.Same(b, s.Builder);
AssertEx.Equal(new byte[] { 0x04, 0x41, 0x42, 0x43, 0x44, 0x03, 0x01, 0x02, 0x03 }, b.ToArray());
b.Clear();
var args = new BlobBuilder();
args.WriteBytes(new byte[] { 1, 2, 3 });
s = e.AddPermission("ABCD", args);
Assert.Same(b, s.Builder);
AssertEx.Equal(new byte[] { 0x04, 0x41, 0x42, 0x43, 0x44, 0x03, 0x01, 0x02, 0x03 }, b.ToArray());
b.Clear();
s = e.AddPermission("", ImmutableArray.Create <byte>());
AssertEx.Equal(new byte[] { 0x00, 0x00 }, b.ToArray());
b.Clear();
s = e.AddPermission("", new BlobBuilder());
AssertEx.Equal(new byte[] { 0x00, 0x00 }, b.ToArray());
b.Clear();
Assert.Throws <ArgumentNullException>(() => e.AddPermission(null, ImmutableArray.Create <byte>(1)));
Assert.Throws <ArgumentNullException>(() => e.AddPermission(null, args));
Assert.Throws <ArgumentNullException>(() => e.AddPermission("A", default(ImmutableArray <byte>)));
Assert.Throws <ArgumentNullException>(() => e.AddPermission("A", null));
}
public void TryOpenAssociatedPortablePdb_ExpectedExceptionFromStreamProvider_FallbackOnEmbedded_Invalid()
{
var pdbBuilder = new BlobBuilder();
pdbBuilder.WriteBytes(new byte[] { 0x01 });
var id = new BlobContentId(Guid.Parse("18091B06-32BB-46C2-9C3B-7C9389A2F6C6"), 0x12345678);
var ddBuilder = new DebugDirectoryBuilder();
ddBuilder.AddCodeViewEntry(@"/a/b/a.pdb", id, portablePdbVersion: 0x0100);
ddBuilder.AddEmbeddedPortablePdbEntry(pdbBuilder, portablePdbVersion: 0x0100);
var peStream = new MemoryStream(TestBuilders.BuildPEWithDebugDirectory(ddBuilder));
using (var reader = new PEReader(peStream))
{
MetadataReaderProvider pdbProvider;
string pdbPath;
// reports the first error:
Assert.Throws <IOException>(() =>
reader.TryOpenAssociatedPortablePdb(Path.Combine("pedir", "file.exe"), _ => { throw new IOException(); }, out pdbProvider, out pdbPath));
// reports the first error:
AssertEx.Throws <BadImageFormatException>(() =>
reader.TryOpenAssociatedPortablePdb(Path.Combine("pedir", "file.exe"), _ => { throw new BadImageFormatException("Bang!"); }, out pdbProvider, out pdbPath),
e => Assert.Equal("Bang!", e.Message));
// file doesn't exist, fall back to embedded without reporting FileNotFoundExeception
Assert.Throws <BadImageFormatException>(() =>
reader.TryOpenAssociatedPortablePdb(Path.Combine("pedir", "file.exe"), _ => { throw new FileNotFoundException(); }, out pdbProvider, out pdbPath));
Assert.Throws <BadImageFormatException>(() =>
reader.TryOpenAssociatedPortablePdb(Path.Combine("pedir", "file.exe"), _ => null, out pdbProvider, out pdbPath));
}
}
public void AddMethodBody_Reserved_Tiny1()
{
var streamBuilder = new BlobBuilder(32);
var encoder = new MethodBodyStreamEncoder(streamBuilder);
streamBuilder.WriteBytes(0x01, 3);
var body = encoder.AddMethodBody(10);
Assert.Equal(3, body.Offset);
var segment = body.Instructions.GetBytes();
Assert.Equal(4, segment.Offset); // +1 byte for the header
Assert.Equal(10, segment.Count);
Assert.Null(body.ExceptionRegions.Builder);
new BlobWriter(body.Instructions).WriteBytes(0x02, 10);
AssertEx.Equal(new byte[]
{
0x01, 0x01, 0x01,
0x2A, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02
}, streamBuilder.ToArray());
}
/// <summary>
/// Serializes .text section data into a specified <paramref name="builder"/>.
/// </summary>
/// <param name="builder">An empty builder to serialize section data to.</param>
/// <param name="relativeVirtualAddess">Relative virtual address of the section within the containing PE file.</param>
/// <param name="entryPointTokenOrRelativeVirtualAddress">Entry point token or RVA (<see cref="CorHeader.EntryPointTokenOrRelativeVirtualAddress"/>)</param>
/// <param name="corFlags">COR Flags (<see cref="CorHeader.Flags"/>).</param>
/// <param name="baseAddress">Base address of the PE image.</param>
/// <param name="metadataBuilder"><see cref="BlobBuilder"/> containing metadata. Must be populated with data. Linked into the <paramref name="builder"/> and can't be expanded afterwards.</param>
/// <param name="ilBuilder"><see cref="BlobBuilder"/> containing IL stream. Must be populated with data. Linked into the <paramref name="builder"/> and can't be expanded afterwards.</param>
/// <param name="mappedFieldDataBuilder"><see cref="BlobBuilder"/> containing mapped field data. Must be populated with data. Linked into the <paramref name="builder"/> and can't be expanded afterwards.</param>
/// <param name="resourceBuilder"><see cref="BlobBuilder"/> containing managed resource data. Must be populated with data. Linked into the <paramref name="builder"/> and can't be expanded afterwards.</param>
/// <param name="debugTableBuilderOpt"><see cref="BlobBuilder"/> containing debug table data. Must be populated with data. Linked into the <paramref name="builder"/> and can't be expanded afterwards.</param>
public void Serialize(
BlobBuilder builder,
int relativeVirtualAddess,
int entryPointTokenOrRelativeVirtualAddress,
CorFlags corFlags,
ulong baseAddress,
BlobBuilder metadataBuilder,
BlobBuilder ilBuilder,
BlobBuilder mappedFieldDataBuilder,
BlobBuilder resourceBuilder,
BlobBuilder debugTableBuilderOpt)
{
Debug.Assert(builder.Count == 0);
Debug.Assert(metadataBuilder.Count == MetadataSize);
Debug.Assert(metadataBuilder.Count % 4 == 0);
Debug.Assert(ilBuilder.Count == ILStreamSize);
Debug.Assert(mappedFieldDataBuilder.Count == MappedFieldDataSize);
Debug.Assert(resourceBuilder.Count == ResourceDataSize);
Debug.Assert(resourceBuilder.Count % 4 == 0);
// TODO: avoid recalculation
int importTableRva = GetImportTableDirectoryEntry(relativeVirtualAddess).RelativeVirtualAddress;
int importAddressTableRva = GetImportAddressTableDirectoryEntry(relativeVirtualAddess).RelativeVirtualAddress;
if (RequiresStartupStub)
{
WriteImportAddressTable(builder, importTableRva);
}
WriteCorHeader(builder, relativeVirtualAddess, entryPointTokenOrRelativeVirtualAddress, corFlags);
// IL:
ilBuilder.Align(4);
builder.LinkSuffix(ilBuilder);
// metadata:
builder.LinkSuffix(metadataBuilder);
// managed resources:
builder.LinkSuffix(resourceBuilder);
// strong name signature:
builder.WriteBytes(0, StrongNameSignatureSize);
if (debugTableBuilderOpt != null)
{
builder.LinkSuffix(debugTableBuilderOpt);
}
if (RequiresStartupStub)
{
WriteImportTable(builder, importTableRva, importAddressTableRva);
WriteNameTable(builder);
WriteRuntimeStartupStub(builder, importAddressTableRva, baseAddress);
}
// mapped field data:
builder.LinkSuffix(mappedFieldDataBuilder);
Debug.Assert(builder.Count == ComputeSizeOfTextSection());
}
private readonly static byte[] zeroStamp = new byte[4]; // four bytes of zero
/// <summary>
/// Write the entire "Debug Directory (Image Only)" along with data that it points to.
/// </summary>
internal void WriteDebugTable(BlobBuilder builder, PESectionLocation textSectionLocation, ContentId nativePdbContentId, ContentId portablePdbContentId)
{
Debug.Assert(builder.Count == 0);
int tableSize = ImageDebugDirectoryBaseSize;
Debug.Assert(tableSize != 0);
Debug.Assert(nativePdbContentId.IsDefault || portablePdbContentId.IsDefault);
Debug.Assert(!EmitPdb || (nativePdbContentId.IsDefault ^ portablePdbContentId.IsDefault));
int dataSize = ComputeSizeOfDebugDirectoryData();
if (EmitPdb)
{
const int IMAGE_DEBUG_TYPE_CODEVIEW = 2; // from PE spec
uint dataOffset = (uint)(ComputeOffsetToDebugTable() + tableSize);
WriteDebugTableEntry(builder,
stamp: nativePdbContentId.Stamp ?? portablePdbContentId.Stamp,
version: portablePdbContentId.IsDefault ? (uint)0 : ('P' << 24 | 'M' << 16 | 0x01 << 8 | 0x00),
debugType: IMAGE_DEBUG_TYPE_CODEVIEW,
sizeOfData: (uint)dataSize,
addressOfRawData: (uint)textSectionLocation.RelativeVirtualAddress + dataOffset, // RVA of the data
pointerToRawData: (uint)textSectionLocation.PointerToRawData + dataOffset); // position of the data in the PE stream
}
if (IsDeterministic)
{
const int IMAGE_DEBUG_TYPE_NO_TIMESTAMP = 16; // from PE spec
WriteDebugTableEntry(builder,
stamp: zeroStamp,
version: 0,
debugType: IMAGE_DEBUG_TYPE_NO_TIMESTAMP,
sizeOfData: 0,
addressOfRawData: 0,
pointerToRawData: 0);
}
// We should now have written all and precisely the data we said we'd write for the table entries.
Debug.Assert(builder.Count == tableSize);
// ====================
// The following is additional data beyond the debug directory at the offset `dataOffset`
// pointed to by the ImageDebugTypeCodeView entry.
if (EmitPdb)
{
builder.WriteByte((byte)'R');
builder.WriteByte((byte)'S');
builder.WriteByte((byte)'D');
builder.WriteByte((byte)'S');
// PDB id:
builder.WriteBytes(nativePdbContentId.Guid ?? portablePdbContentId.Guid);
// age
builder.WriteUInt32(1); // TODO: allow specify for native PDBs
// UTF-8 encoded zero-terminated path to PDB
int pathStart = builder.Count;
builder.WriteUTF8(PdbPathOpt, allowUnpairedSurrogates: true);
builder.WriteByte(0);
// padding:
builder.WriteBytes(0, Math.Max(0, MinPdbPath - (builder.Count - pathStart)));
}
// We should now have written all and precisely the data we said we'd write for the table and its data.
Debug.Assert(builder.Count == tableSize + dataSize);
}
public unsafe void TinyBody()
{
var bodyBuilder = new BlobBuilder();
var codeBuilder = new BlobBuilder();
var branchBuilder = new BranchBuilder();
var il = new InstructionEncoder(codeBuilder, branchBuilder);
var bodyEncoder = new MethodBodyEncoder(
bodyBuilder,
maxStack: 2,
exceptionRegionCount: 0,
localVariablesSignature: default(StandaloneSignatureHandle),
attributes: MethodBodyAttributes.None);
Assert.True(bodyEncoder.IsTiny(10));
Assert.True(bodyEncoder.IsTiny(63));
Assert.False(bodyEncoder.IsTiny(64));
codeBuilder.WriteBytes(1, 61);
var l1 = il.DefineLabel();
il.MarkLabel(l1);
Assert.Equal(61, branchBuilder.Labels.Single());
il.Branch(ILOpCode.Br, l1);
var brInfo = branchBuilder.Branches.Single();
Assert.Equal(61, brInfo.ILOffset);
Assert.Equal(l1, brInfo.Label);
Assert.Equal((byte)ILOpCode.Br_s, brInfo.ShortOpCode);
AssertEx.Equal(new byte[] { 1, (byte)ILOpCode.Br_s, unchecked((byte)-1) }, codeBuilder.ToArray(60, 3));
int bodyOffset;
bodyEncoder.WriteInstructions(codeBuilder, branchBuilder, out bodyOffset);
var bodyBytes = bodyBuilder.ToArray();
AssertEx.Equal(new byte[]
{
0xFE, // tiny header
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x2B, 0xFE
}, bodyBytes);
fixed (byte* bodyPtr = &bodyBytes[0])
{
var body = MethodBodyBlock.Create(new BlobReader(bodyPtr, bodyBytes.Length));
Assert.Equal(0, body.ExceptionRegions.Length);
Assert.Equal(default(StandaloneSignatureHandle), body.LocalSignature);
Assert.Equal(8, body.MaxStack);
Assert.Equal(bodyBytes.Length, body.Size);
var ilBytes = body.GetILBytes();
AssertEx.Equal(new byte[]
{
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x2B, 0xFE
}, ilBytes);
}
}
private static void WriteDirectory(Directory directory, BlobBuilder writer, uint offset, uint level, uint sizeOfDirectoryTree, int virtualAddressBase, BlobBuilder dataWriter)
{
writer.WriteUInt32(0); // Characteristics
writer.WriteUInt32(0); // Timestamp
writer.WriteUInt32(0); // Version
writer.WriteUInt16(directory.NumberOfNamedEntries);
writer.WriteUInt16(directory.NumberOfIdEntries);
uint n = (uint)directory.Entries.Count;
uint k = offset + 16 + n * 8;
for (int i = 0; i < n; i++)
{
int id;
string name;
uint nameOffset = (uint)dataWriter.Count + sizeOfDirectoryTree;
uint directoryOffset = k;
Directory subDir = directory.Entries[i] as Directory;
if (subDir != null)
{
id = subDir.ID;
name = subDir.Name;
if (level == 0)
{
k += SizeOfDirectory(subDir);
}
else
{
k += 16 + 8 * (uint)subDir.Entries.Count;
}
}
else
{
//EDMAURER write out an IMAGE_RESOURCE_DATA_ENTRY followed
//immediately by the data that it refers to. This results
//in a layout different than that produced by pulling the resources
//from an OBJ. In that case all of the data bits of a resource are
//contiguous in .rsrc$02. After processing these will end up at
//the end of .rsrc following all of the directory
//info and IMAGE_RESOURCE_DATA_ENTRYs
IWin32Resource r = (IWin32Resource)directory.Entries[i];
id = level == 0 ? r.TypeId : level == 1 ? r.Id : (int)r.LanguageId;
name = level == 0 ? r.TypeName : level == 1 ? r.Name : null;
dataWriter.WriteUInt32((uint)(virtualAddressBase + sizeOfDirectoryTree + 16 + dataWriter.Count));
byte[] data = new List <byte>(r.Data).ToArray();
dataWriter.WriteUInt32((uint)data.Length);
dataWriter.WriteUInt32(r.CodePage);
dataWriter.WriteUInt32(0);
dataWriter.WriteBytes(data);
while ((dataWriter.Count % 4) != 0)
{
dataWriter.WriteByte(0);
}
}
if (id >= 0)
{
writer.WriteInt32(id);
}
else
{
if (name == null)
{
name = string.Empty;
}
writer.WriteUInt32(nameOffset | 0x80000000);
dataWriter.WriteUInt16((ushort)name.Length);
dataWriter.WriteUTF16(name);
}
if (subDir != null)
{
writer.WriteUInt32(directoryOffset | 0x80000000);
}
else
{
writer.WriteUInt32(nameOffset);
}
}
k = offset + 16 + n * 8;
for (int i = 0; i < n; i++)
{
Directory subDir = directory.Entries[i] as Directory;
if (subDir != null)
{
WriteDirectory(subDir, writer, k, level + 1, sizeOfDirectoryTree, virtualAddressBase, dataWriter);
if (level == 0)
{
k += SizeOfDirectory(subDir);
}
else
{
k += 16 + 8 * (uint)subDir.Entries.Count;
}
}
}
}
public unsafe void FatBody()
{
var streamBuilder = new BlobBuilder();
var codeBuilder = new BlobBuilder();
var flowBuilder = new ControlFlowBuilder();
var il = new InstructionEncoder(codeBuilder, flowBuilder);
codeBuilder.WriteBytes(1, 62);
var l1 = il.DefineLabel();
il.MarkLabel(l1);
Assert.Equal(62, flowBuilder.Labels.Single());
il.Branch(ILOpCode.Br_s, l1);
var brInfo = flowBuilder.Branches.Single();
Assert.Equal(62, brInfo.ILOffset);
Assert.Equal(l1, brInfo.Label);
Assert.Equal(ILOpCode.Br_s, brInfo.OpCode);
AssertEx.Equal(new byte[] { 1, 1, (byte)ILOpCode.Br_s, unchecked((byte)-1) }, codeBuilder.ToArray(60, 4));
var streamEncoder = new MethodBodyStreamEncoder(streamBuilder);
int bodyOffset = streamEncoder.AddMethodBody(
il,
maxStack: 2,
localVariablesSignature: default(StandaloneSignatureHandle),
attributes: MethodBodyAttributes.None);
var bodyBytes = streamBuilder.ToArray();
AssertEx.Equal(new byte[]
{
0x03, 0x30, 0x02, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // fat header
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x2B, 0xFE
}, bodyBytes);
fixed (byte* bodyPtr = &bodyBytes[0])
{
var body = MethodBodyBlock.Create(new BlobReader(bodyPtr, bodyBytes.Length));
Assert.Equal(0, body.ExceptionRegions.Length);
Assert.Equal(default(StandaloneSignatureHandle), body.LocalSignature);
Assert.Equal(2, body.MaxStack);
Assert.Equal(bodyBytes.Length, body.Size);
var ilBytes = body.GetILBytes();
AssertEx.Equal(new byte[]
{
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x2B, 0xFE
}, ilBytes);
}
}
private void WritePESignature(BlobBuilder builder)
{
// MS-DOS stub (128 bytes)
builder.WriteBytes(s_dosHeader);
// PE Signature "PE\0\0"
builder.WriteUInt32(0x00004550);
}
/// <summary>
/// Output the section with a given name. For sections existent in the source MSIL PE file
/// (.text, optionally .rsrc and .reloc), we first copy the content of the input MSIL PE file
/// and then call the section serialization callback to emit the extra content after the input
/// section content.
/// </summary>
/// <param name="name">Section name</param>
/// <param name="location">RVA and file location where the section will be put</param>
/// <returns>Blob builder representing the section data</returns>
protected override BlobBuilder SerializeSection(string name, SectionLocation location)
{
BlobBuilder sectionDataBuilder = null;
int sectionStartRva = location.RelativeVirtualAddress;
int outputSectionIndex = _sections.Length - 1;
while (outputSectionIndex >= 0 && _sections[outputSectionIndex].Name != name)
{
outputSectionIndex--;
}
if (!_target.IsWindows)
{
if (outputSectionIndex > 0)
{
sectionStartRva = Math.Max(sectionStartRva, _sectionRVAs[outputSectionIndex - 1] + _sectionRawSizes[outputSectionIndex - 1]);
}
const int RVAAlign = 1 << RVABitsToMatchFilePos;
sectionStartRva = AlignmentHelper.AlignUp(sectionStartRva, RVAAlign);
int rvaAdjust = (location.PointerToRawData - sectionStartRva) & (RVAAlign - 1);
sectionStartRva += rvaAdjust;
location = new SectionLocation(sectionStartRva, location.PointerToRawData);
}
if (outputSectionIndex >= 0)
{
_sectionRVAs[outputSectionIndex] = sectionStartRva;
}
int inputSectionIndex = _peReader.PEHeaders.SectionHeaders.Count() - 1;
while (inputSectionIndex >= 0 && _peReader.PEHeaders.SectionHeaders[inputSectionIndex].Name != name)
{
inputSectionIndex--;
}
if (inputSectionIndex >= 0)
{
SectionHeader sectionHeader = _peReader.PEHeaders.SectionHeaders[inputSectionIndex];
int sectionOffset = (_peReader.IsLoadedImage ? sectionHeader.VirtualAddress : sectionHeader.PointerToRawData);
int rvaDelta = location.RelativeVirtualAddress - sectionHeader.VirtualAddress;
_sectionRvaDeltas.Add(new SectionRVADelta(
startRVA: sectionHeader.VirtualAddress,
endRVA: sectionHeader.VirtualAddress + Math.Max(sectionHeader.VirtualSize, sectionHeader.SizeOfRawData),
deltaRVA: rvaDelta));
int bytesToRead = Math.Min(sectionHeader.SizeOfRawData, sectionHeader.VirtualSize);
BlobReader inputSectionReader = _peReader.GetEntireImage().GetReader(sectionOffset, bytesToRead);
if (name == RsrcSectionName)
{
// There seems to be a bug in BlobBuilder - when we LinkSuffix to an empty blob builder,
// the blob data goes out of sync and WriteContentTo outputs garbage.
sectionDataBuilder = PEResourceHelper.Relocate(inputSectionReader, rvaDelta);
}
int alignedSize = sectionHeader.VirtualSize;
// When custom section data is present, align the section size to 4K to prevent
// pre-generated MSIL relocations from tampering with native relocations.
if (_customSections.Contains(name))
{
alignedSize = (alignedSize + 0xFFF) & ~0xFFF;
}
if (sectionDataBuilder != null)
{
if (alignedSize > bytesToRead)
{
// If the number of bytes read from the source PE file is less than the virtual size,
// zero pad to the end of virtual size before emitting extra section data
sectionDataBuilder.WriteBytes(0, alignedSize - bytesToRead);
}
location = new SectionLocation(
location.RelativeVirtualAddress + sectionDataBuilder.Count,
location.PointerToRawData + sectionDataBuilder.Count);
}
}
BlobBuilder extraData = _sectionBuilder.SerializeSection(name, location);
if (extraData != null)
{
if (sectionDataBuilder == null)
{
// See above - there's a bug due to which LinkSuffix to an empty BlobBuilder screws up the blob content.
sectionDataBuilder = extraData;
}
else
{
sectionDataBuilder.LinkSuffix(extraData);
}
}
// Make sure the section has at least 1 byte, otherwise the PE emitter goes mad,
// messes up the section map and corrups the output executable.
if (sectionDataBuilder == null)
{
sectionDataBuilder = new BlobBuilder();
}
if (sectionDataBuilder.Count == 0)
{
sectionDataBuilder.WriteByte(0);
}
if (outputSectionIndex >= 0)
{
_sectionRawSizes[outputSectionIndex] = sectionDataBuilder.Count;
}
return(sectionDataBuilder);
}
public void Link()
{
var builder1 = new BlobBuilder(16);
builder1.WriteByte(1);
var builder2 = new BlobBuilder(16);
builder2.WriteByte(2);
var builder3 = new BlobBuilder(16);
builder3.WriteByte(3);
var builder4 = new BlobBuilder(16);
builder4.WriteByte(4);
var builder5 = new BlobBuilder(16);
builder5.WriteByte(5);
builder2.LinkPrefix(builder1);
AssertEx.Equal(new byte[] { 1, 2 }, builder2.ToArray());
Assert.Throws<InvalidOperationException>(() => builder1.ToArray());
Assert.Throws<InvalidOperationException>(() => builder2.LinkPrefix(builder1));
Assert.Throws<InvalidOperationException>(() => builder1.WriteByte(0xff));
Assert.Throws<InvalidOperationException>(() => builder1.WriteBytes(1, 10));
Assert.Throws<InvalidOperationException>(() => builder1.WriteBytes(new byte[] { 1 }));
Assert.Throws<InvalidOperationException>(() => builder1.ReserveBytes(1));
Assert.Throws<InvalidOperationException>(() => builder1.GetBlobs());
Assert.Throws<InvalidOperationException>(() => builder1.ContentEquals(builder1));
Assert.Throws<InvalidOperationException>(() => builder1.WriteUTF16("str"));
Assert.Throws<InvalidOperationException>(() => builder1.WriteUTF8("str", allowUnpairedSurrogates: false));
builder2.LinkSuffix(builder3);
AssertEx.Equal(new byte[] { 1, 2, 3 }, builder2.ToArray());
Assert.Throws<InvalidOperationException>(() => builder3.LinkPrefix(builder5));
builder2.LinkPrefix(builder4);
AssertEx.Equal(new byte[] { 4, 1, 2, 3 }, builder2.ToArray());
Assert.Throws<InvalidOperationException>(() => builder4.LinkPrefix(builder5));
builder2.LinkSuffix(builder5);
AssertEx.Equal(new byte[] { 4, 1, 2, 3, 5 }, builder2.ToArray());
}
public void WriteBytes1()
{
var writer = new BlobBuilder(4);
writer.WriteBytes(new byte[] { 1, 2, 3, 4 });
writer.WriteBytes(new byte[] { });
writer.WriteBytes(new byte[] { }, 0, 0);
writer.WriteBytes(new byte[] { 5, 6, 7, 8 });
writer.WriteBytes(new byte[] { 9 });
writer.WriteBytes(new byte[] { 0x0a }, 0, 0);
writer.WriteBytes(new byte[] { 0x0b }, 0, 1);
writer.WriteBytes(new byte[] { 0x0c }, 1, 0);
writer.WriteBytes(new byte[] { 0x0d, 0x0e }, 1, 1);
AssertEx.Equal(new byte[]
{
0x01, 0x02, 0x03, 0x04,
0x05, 0x06, 0x07, 0x08,
0x09,
0x0b,
0x0e
}, writer.ToArray());
}
public void WriteBytes2()
{
var writer = new BlobBuilder(4);
writer.WriteBytes(0xff, 0);
writer.WriteBytes(1, 4);
writer.WriteBytes(0xff, 0);
writer.WriteBytes(2, 10);
writer.WriteBytes(0xff, 0);
writer.WriteBytes(3, 1);
AssertEx.Equal(new byte[]
{
0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x03
}, writer.ToArray());
}
public void WritePrimitive()
{
var writer = new BlobBuilder(17);
writer.WriteUInt32(0x11223344);
writer.WriteUInt16(0x5566);
writer.WriteByte(0x77);
writer.WriteUInt64(0x8899aabbccddeeff);
writer.WriteInt32(-1);
writer.WriteInt16(-2);
writer.WriteSByte(-3);
writer.WriteBoolean(true);
writer.WriteBoolean(false);
writer.WriteInt64(unchecked((long)0xfedcba0987654321));
writer.WriteDateTime(new DateTime(0x1112223334445556));
writer.WriteDecimal(102030405060.70m);
writer.WriteDouble(double.NaN);
writer.WriteSingle(float.NegativeInfinity);
var guid = new Guid("01020304-0506-0708-090A-0B0C0D0E0F10");
writer.WriteBytes(guid.ToByteArray());
writer.WriteGuid(guid);
AssertEx.Equal(new byte[]
{
0x44, 0x33, 0x22, 0x11,
0x66, 0x55,
0x77,
0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99, 0x88,
0xff, 0xff, 0xff, 0xff,
0xfe, 0xff,
0xfd,
0x01,
0x00,
0x21, 0x43, 0x65, 0x87, 0x09, 0xBA, 0xDC, 0xFE,
0x56, 0x55, 0x44, 0x34, 0x33, 0x22, 0x12, 0x11,
0x02, 0xD6, 0xE0, 0x9A, 0x94, 0x47, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF,
0x00, 0x00, 0x80, 0xFF,
0x04, 0x03, 0x02, 0x01, 0x06, 0x05, 0x08, 0x07, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
0x04, 0x03, 0x02, 0x01, 0x06, 0x05, 0x08, 0x07, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10
}, writer.ToArray());
}
public unsafe void Write_Errors()
{
var builder = new BlobBuilder(16);
Assert.Throws<ArgumentNullException>(() => builder.WriteUTF16((char[])null));
Assert.Throws<ArgumentNullException>(() => builder.WriteUTF16((string)null));
Assert.Throws<ArgumentNullException>(() => builder.WriteUTF8(null, allowUnpairedSurrogates: true));
Assert.Throws<ArgumentNullException>(() => builder.WriteUTF8(null, allowUnpairedSurrogates: true));
Assert.Throws<ArgumentNullException>(() => builder.TryWriteBytes((Stream)null, 0));
Assert.Throws<ArgumentNullException>(() => builder.WriteBytes(null));
Assert.Throws<ArgumentNullException>(() => builder.WriteBytes(null, 0, 0));
Assert.Throws<ArgumentNullException>(() => builder.WriteBytes((byte*)null, 0));
Assert.Throws<ArgumentNullException>(() => builder.WriteBytes(default(ImmutableArray<byte>)));
Assert.Throws<ArgumentNullException>(() => builder.WriteBytes(default(ImmutableArray<byte>), 0, 0));
var bw = default(BlobWriter);
Assert.Throws<ArgumentNullException>(() => builder.WriteContentTo(ref bw));
Assert.Throws<ArgumentNullException>(() => builder.WriteContentTo((Stream)null));
Assert.Throws<ArgumentNullException>(() => builder.WriteContentTo((BlobBuilder)null));
Assert.Throws<ArgumentOutOfRangeException>(() => builder.TryWriteBytes(new MemoryStream(), -1));
Assert.Throws<ArgumentOutOfRangeException>(() => builder.WriteBytes(0, -1));
Assert.Throws<ArgumentOutOfRangeException>(() => builder.WriteBytes(new byte[] { }, 1, 0));
Assert.Throws<ArgumentOutOfRangeException>(() => builder.WriteBytes(new byte[] { }, 0, 1));
Assert.Throws<ArgumentOutOfRangeException>(() => builder.WriteBytes(new byte[] { }, 0, -1));
Assert.Throws<ArgumentOutOfRangeException>(() => builder.WriteBytes(ImmutableArray<byte>.Empty, 1, 0));
Assert.Throws<ArgumentOutOfRangeException>(() => builder.WriteBytes(ImmutableArray<byte>.Empty, 0, 1));
Assert.Throws<ArgumentOutOfRangeException>(() => builder.WriteBytes(ImmutableArray<byte>.Empty, 1, -1));
}
internal void FixupBranches(BlobBuilder srcBuilder, BlobBuilder dstBuilder)
{
int srcOffset = 0;
var branch = _branches[0];
int branchIndex = 0;
int blobOffset = 0;
foreach (Blob blob in srcBuilder.GetBlobs())
{
Debug.Assert(blobOffset == 0 || blobOffset == 1 && blob.Buffer[blobOffset - 1] == 0xff);
while (true)
{
// copy bytes preceding the next branch, or till the end of the blob:
int chunkSize = Math.Min(branch.ILOffset - srcOffset, blob.Length - blobOffset);
dstBuilder.WriteBytes(blob.Buffer, blobOffset, chunkSize);
srcOffset += chunkSize;
blobOffset += chunkSize;
// there is no branch left in the blob:
if (blobOffset == blob.Length)
{
blobOffset = 0;
break;
}
Debug.Assert(blob.Buffer[blobOffset] == branch.ShortOpCode && (blobOffset + 1 == blob.Length || blob.Buffer[blobOffset + 1] == 0xff));
srcOffset += sizeof(byte) + sizeof(sbyte);
// write actual branch instruction:
int branchDistance;
if (branch.IsShortBranchDistance(_labels, out branchDistance))
{
dstBuilder.WriteByte(branch.ShortOpCode);
dstBuilder.WriteSByte((sbyte)branchDistance);
}
else
{
dstBuilder.WriteByte((byte)((ILOpCode)branch.ShortOpCode).GetLongBranch());
dstBuilder.WriteInt32(branchDistance);
}
// next branch:
branchIndex++;
if (branchIndex == _branches.Count)
{
branch = new BranchInfo(int.MaxValue, default(LabelHandle), 0);
}
else
{
branch = _branches[branchIndex];
}
// the branch starts at the very end and its operand is in the next blob:
if (blobOffset == blob.Length - 1)
{
blobOffset = 1;
break;
}
// skip fake branch instruction:
blobOffset += sizeof(byte) + sizeof(sbyte);
}
}
}
public void GetChunks_DestructingEnum()
{
for (int j = 1; j < 5; j++)
{
var builder = new BlobBuilder(16);
for (int i = 0; i < j; i++)
{
builder.WriteBytes((byte)i, 16);
}
int n = 0;
foreach (var chunk in builder.GetChunks())
{
n++;
}
Assert.Equal(j, n);
var chunks = new HashSet<BlobBuilder>();
foreach (var chunk in builder.GetChunks())
{
chunks.Add(chunk);
chunk.ClearChunk();
}
Assert.Equal(j, chunks.Count);
}
}
public void AddMethodBody_Reserved_Fat2()
{
var streamBuilder = new BlobBuilder(32);
var encoder = new MethodBodyStreamEncoder(streamBuilder);
streamBuilder.WriteBytes(0x01, 3);
var body = encoder.AddMethodBody(10, localVariablesSignature: MetadataTokens.StandaloneSignatureHandle(0xABCDEF));
Assert.Equal(4, body.Offset); // 4B aligned
var segment = body.Instructions.GetBytes();
Assert.Equal(16, segment.Offset); // +12 byte for the header
Assert.Equal(10, segment.Count);
Assert.Null(body.ExceptionRegions.Builder);
new BlobWriter(body.Instructions).WriteBytes(0x02, 10);
AssertEx.Equal(new byte[]
{
0x01, 0x01, 0x01,
0x00, // padding
0x13, 0x30,
0x08, 0x00, // max stack
0x0A, 0x00, 0x00, 0x00, // code size
0xEF, 0xCD, 0xAB, 0x11, // local sig
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02
}, streamBuilder.ToArray());
}
/// <exception cref="ArgumentNullException"><paramref name="destination"/> is null.</exception>
/// <exception cref="InvalidOperationException">Content is not available, the builder has been linked with another one.</exception>
public void WriteContentTo(BlobBuilder destination)
{
if (destination == null)
{
throw new ArgumentNullException(nameof(destination));
}
foreach (var chunk in GetChunks())
{
destination.WriteBytes(chunk._buffer, 0, chunk.Length);
}
}
public void LinkSuffix2()
{
var builder1 = new BlobBuilder(16);
builder1.WriteBytes(1, 16);
var builder2 = new BlobBuilder(16);
builder2.WriteBytes(2, 16);
builder1.LinkSuffix(builder2);
AssertEx.Equal(new byte[]
{
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02
}, builder1.ToArray());
Assert.Equal(32, builder1.Count);
Assert.Equal(16, builder2.Count);
}
public void AddMethodBody_Reserved_Fat1()
{
var streamBuilder = new BlobBuilder(32);
var encoder = new MethodBodyStreamEncoder(streamBuilder);
streamBuilder.WriteBytes(0x01, 3);
var body = encoder.AddMethodBody(10, maxStack: 9);
Assert.Equal(4, body.Offset); // 4B aligned
var segment = body.Instructions.GetBytes();
Assert.Equal(16, segment.Offset); // +12 byte for the header
Assert.Equal(10, segment.Count);
Assert.Null(body.ExceptionRegions.Builder);
new BlobWriter(body.Instructions).WriteBytes(0x02, 10);
AssertEx.Equal(new byte[]
{
0x01, 0x01, 0x01,
0x00, // padding
0x13, 0x30,
0x09, 0x00, // max stack
0x0A, 0x00, 0x00, 0x00, // code size
0x00, 0x00, 0x00, 0x00, // local sig
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02
}, streamBuilder.ToArray());
}
public unsafe void TinyBody()
{
var bodyBuilder = new BlobBuilder();
var codeBuilder = new BlobBuilder();
var branchBuilder = new BranchBuilder();
var il = new InstructionEncoder(codeBuilder, branchBuilder);
var bodyEncoder = new MethodBodyEncoder(
bodyBuilder,
maxStack: 2,
exceptionRegionCount: 0,
localVariablesSignature: default(StandaloneSignatureHandle),
attributes: MethodBodyAttributes.None);
Assert.True(bodyEncoder.IsTiny(10));
Assert.True(bodyEncoder.IsTiny(63));
Assert.False(bodyEncoder.IsTiny(64));
codeBuilder.WriteBytes(1, 61);
var l1 = il.DefineLabel();
il.MarkLabel(l1);
Assert.Equal(61, branchBuilder.Labels.Single());
il.Branch(ILOpCode.Br, l1);
var brInfo = branchBuilder.Branches.Single();
Assert.Equal(61, brInfo.ILOffset);
Assert.Equal(l1, brInfo.Label);
Assert.Equal((byte)ILOpCode.Br_s, brInfo.ShortOpCode);
AssertEx.Equal(new byte[] { 1, (byte)ILOpCode.Br_s, unchecked ((byte)-1) }, codeBuilder.ToArray(60, 3));
int bodyOffset;
bodyEncoder.WriteInstructions(codeBuilder, branchBuilder, out bodyOffset);
var bodyBytes = bodyBuilder.ToArray();
AssertEx.Equal(new byte[]
{
0xFE, // tiny header
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x2B, 0xFE
}, bodyBytes);
fixed(byte *bodyPtr = &bodyBytes[0])
{
var body = MethodBodyBlock.Create(new BlobReader(bodyPtr, bodyBytes.Length));
Assert.Equal(0, body.ExceptionRegions.Length);
Assert.Equal(default(StandaloneSignatureHandle), body.LocalSignature);
Assert.Equal(8, body.MaxStack);
Assert.Equal(bodyBytes.Length, body.Size);
var ilBytes = body.GetILBytes();
AssertEx.Equal(new byte[]
{
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x2B, 0xFE
}, ilBytes);
}
}
public void AddMethodBody_Reserved_Exceptions_Fat1()
{
var streamBuilder = new BlobBuilder(32);
var encoder = new MethodBodyStreamEncoder(streamBuilder);
streamBuilder.WriteBytes(0x01, 3);
var body = encoder.AddMethodBody(10, exceptionRegionCount: 699050);
Assert.Equal(4, body.Offset); // 4B aligned
var segment = body.Instructions.GetBytes();
Assert.Equal(16, segment.Offset); // +12 byte for the header
Assert.Equal(10, segment.Count);
Assert.Same(streamBuilder, body.ExceptionRegions.Builder);
new BlobWriter(body.Instructions).WriteBytes(0x02, 10);
AssertEx.Equal(new byte[]
{
0x01, 0x01, 0x01,
0x00, // padding
0x1B, 0x30, // flags
0x08, 0x00, // max stack
0x0A, 0x00, 0x00, 0x00, // code size
0x00, 0x00, 0x00, 0x00, // local sig
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
// exception table
0x00, 0x00, // padding
0x41, // kind
0xF4, 0xFF, 0xFF // size fo the table
}, streamBuilder.ToArray());
}
private void WriteDirectory(Directory directory, BlobBuilder writer, uint offset, uint level, uint sizeOfDirectoryTree, int virtualAddressBase, BlobBuilder dataWriter)
{
writer.WriteUInt32(0); // Characteristics
writer.WriteUInt32(0); // Timestamp
writer.WriteUInt32(0); // Version
writer.WriteUInt16(directory.NumberOfNamedEntries);
writer.WriteUInt16(directory.NumberOfIdEntries);
uint n = (uint)directory.Entries.Count;
uint k = offset + 16 + n * 8;
for (int i = 0; i < n; i++)
{
int id;
string name;
uint nameOffset = (uint)dataWriter.Position + sizeOfDirectoryTree;
uint directoryOffset = k;
Directory subDir = directory.Entries[i] as Directory;
if (subDir != null)
{
id = subDir.ID;
name = subDir.Name;
if (level == 0)
{
k += SizeOfDirectory(subDir);
}
else
{
k += 16 + 8 * (uint)subDir.Entries.Count;
}
}
else
{
//EDMAURER write out an IMAGE_RESOURCE_DATA_ENTRY followed
//immediately by the data that it refers to. This results
//in a layout different than that produced by pulling the resources
//from an OBJ. In that case all of the data bits of a resource are
//contiguous in .rsrc$02. After processing these will end up at
//the end of .rsrc following all of the directory
//info and IMAGE_RESOURCE_DATA_ENTRYs
IWin32Resource r = (IWin32Resource)directory.Entries[i];
id = level == 0 ? r.TypeId : level == 1 ? r.Id : (int)r.LanguageId;
name = level == 0 ? r.TypeName : level == 1 ? r.Name : null;
dataWriter.WriteUInt32((uint)(virtualAddressBase + sizeOfDirectoryTree + 16 + dataWriter.Position));
byte[] data = new List<byte>(r.Data).ToArray();
dataWriter.WriteUInt32((uint)data.Length);
dataWriter.WriteUInt32(r.CodePage);
dataWriter.WriteUInt32(0);
dataWriter.WriteBytes(data);
while ((dataWriter.Count % 4) != 0)
{
dataWriter.WriteByte(0);
}
}
if (id >= 0)
{
writer.WriteInt32(id);
}
else
{
if (name == null)
{
name = string.Empty;
}
writer.WriteUInt32(nameOffset | 0x80000000);
dataWriter.WriteUInt16((ushort)name.Length);
dataWriter.WriteUTF16(name);
}
if (subDir != null)
{
writer.WriteUInt32(directoryOffset | 0x80000000);
}
else
{
writer.WriteUInt32(nameOffset);
}
}
k = offset + 16 + n * 8;
for (int i = 0; i < n; i++)
{
Directory subDir = directory.Entries[i] as Directory;
if (subDir != null)
{
this.WriteDirectory(subDir, writer, k, level + 1, sizeOfDirectoryTree, virtualAddressBase, dataWriter);
if (level == 0)
{
k += SizeOfDirectory(subDir);
}
else
{
k += 16 + 8 * (uint)subDir.Entries.Count;
}
}
}
}
public unsafe void FatBody()
{
var streamBuilder = new BlobBuilder();
var codeBuilder = new BlobBuilder();
var flowBuilder = new ControlFlowBuilder();
var il = new InstructionEncoder(codeBuilder, flowBuilder);
codeBuilder.WriteBytes(1, 62);
var l1 = il.DefineLabel();
il.MarkLabel(l1);
Assert.Equal(62, flowBuilder.Labels.Single());
il.Branch(ILOpCode.Br_s, l1);
var brInfo = flowBuilder.Branches.Single();
Assert.Equal(62, brInfo.ILOffset);
Assert.Equal(l1, brInfo.Label);
Assert.Equal(ILOpCode.Br_s, brInfo.OpCode);
AssertEx.Equal(new byte[] { 1, 1, (byte)ILOpCode.Br_s, unchecked ((byte)-1) }, codeBuilder.ToArray(60, 4));
var streamEncoder = new MethodBodyStreamEncoder(streamBuilder);
int bodyOffset = streamEncoder.AddMethodBody(
il,
maxStack: 2,
localVariablesSignature: default(StandaloneSignatureHandle),
attributes: MethodBodyAttributes.None);
var bodyBytes = streamBuilder.ToArray();
AssertEx.Equal(new byte[]
{
0x03, 0x30, 0x02, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // fat header
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x2B, 0xFE
}, bodyBytes);
fixed(byte *bodyPtr = &bodyBytes[0])
{
var body = MethodBodyBlock.Create(new BlobReader(bodyPtr, bodyBytes.Length));
Assert.Equal(0, body.ExceptionRegions.Length);
Assert.Equal(default(StandaloneSignatureHandle), body.LocalSignature);
Assert.Equal(2, body.MaxStack);
Assert.Equal(bodyBytes.Length, body.Size);
var ilBytes = body.GetILBytes();
AssertEx.Equal(new byte[]
{
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x2B, 0xFE
}, ilBytes);
}
}
public override void Write(byte[] buffer, int offset, int count)
{
_builder.WriteBytes(buffer, offset, count);
}
public void PermissionSetEncoder_AddPermission()
{
var b = new BlobBuilder();
var e = new PermissionSetEncoder(b);
var s = e.AddPermission("ABCD", ImmutableArray.Create<byte>(1, 2, 3));
Assert.Same(b, s.Builder);
AssertEx.Equal(new byte[] { 0x04, 0x41, 0x42, 0x43, 0x44, 0x03, 0x01, 0x02, 0x03 }, b.ToArray());
b.Clear();
var args = new BlobBuilder();
args.WriteBytes(new byte[] { 1, 2, 3 });
s = e.AddPermission("ABCD", args);
Assert.Same(b, s.Builder);
AssertEx.Equal(new byte[] { 0x04, 0x41, 0x42, 0x43, 0x44, 0x03, 0x01, 0x02, 0x03 }, b.ToArray());
b.Clear();
s = e.AddPermission("", ImmutableArray.Create<byte>());
AssertEx.Equal(new byte[] { 0x00, 0x00 }, b.ToArray());
b.Clear();
s = e.AddPermission("", new BlobBuilder());
AssertEx.Equal(new byte[] { 0x00, 0x00 }, b.ToArray());
b.Clear();
Assert.Throws<ArgumentNullException>(() => e.AddPermission(null, ImmutableArray.Create<byte>(1)));
Assert.Throws<ArgumentNullException>(() => e.AddPermission(null, args));
Assert.Throws<ArgumentNullException>(() => e.AddPermission("A", default(ImmutableArray<byte>)));
Assert.Throws<ArgumentNullException>(() => e.AddPermission("A", null));
}
/// <summary>
/// Output the section with a given name. For sections existent in the source MSIL PE file
/// (.text, optionally .rsrc and .reloc), we first copy the content of the input MSIL PE file
/// and then call the section serialization callback to emit the extra content after the input
/// section content.
/// </summary>
/// <param name="name">Section name</param>
/// <param name="location">RVA and file location where the section will be put</param>
/// <returns>Blob builder representing the section data</returns>
protected override BlobBuilder SerializeSection(string name, SectionLocation location)
{
BlobBuilder sectionDataBuilder = null;
bool haveCustomSection = _customSections.Contains(name);
int sectionIndex = _peReader.PEHeaders.SectionHeaders.Count() - 1;
int sectionStartRva = location.RelativeVirtualAddress;
while (sectionIndex >= 0 && _peReader.PEHeaders.SectionHeaders[sectionIndex].Name != name)
{
sectionIndex--;
}
if (sectionIndex >= 0)
{
SectionHeader sectionHeader = _peReader.PEHeaders.SectionHeaders[sectionIndex];
int sectionOffset = (_peReader.IsLoadedImage ? sectionHeader.VirtualAddress : sectionHeader.PointerToRawData);
int rvaDelta = location.RelativeVirtualAddress - sectionHeader.VirtualAddress;
_sectionRvaDeltas.Add(new SectionRVADelta(
startRVA: sectionHeader.VirtualAddress,
endRVA: sectionHeader.VirtualAddress + Math.Max(sectionHeader.VirtualSize, sectionHeader.SizeOfRawData),
deltaRVA: rvaDelta));
unsafe
{
int bytesToRead = Math.Min(sectionHeader.SizeOfRawData, sectionHeader.VirtualSize);
BlobReader inputSectionReader = _peReader.GetEntireImage().GetReader(sectionOffset, bytesToRead);
if (name == ".rsrc")
{
// There seems to be a bug in BlobBuilder - when we LinkSuffix to an empty blob builder,
// the blob data goes out of sync and WriteContentTo outputs garbage.
sectionDataBuilder = PEResourceHelper.Relocate(inputSectionReader, rvaDelta);
}
else
{
sectionDataBuilder = new BlobBuilder();
sectionDataBuilder.WriteBytes(inputSectionReader.CurrentPointer, inputSectionReader.RemainingBytes);
int corHeaderRvaDelta = _peReader.PEHeaders.PEHeader.CorHeaderTableDirectory.RelativeVirtualAddress - sectionHeader.VirtualAddress;
if (corHeaderRvaDelta >= 0 && corHeaderRvaDelta < bytesToRead)
{
// Assume COR header resides in this section, deserialize it and store its location
_corHeaderFileOffset = location.PointerToRawData + corHeaderRvaDelta;
inputSectionReader.Offset = corHeaderRvaDelta;
_corHeaderBuilder = new CorHeaderBuilder(ref inputSectionReader);
}
}
int alignedSize = sectionHeader.VirtualSize;
// When custom section data is present, align the section size to 4K to prevent
// pre-generated MSIL relocations from tampering with native relocations.
if (_customSections.Contains(name))
{
alignedSize = (alignedSize + 0xFFF) & ~0xFFF;
}
if (alignedSize > bytesToRead)
{
// If the number of bytes read from the source PE file is less than the virtual size,
// zero pad to the end of virtual size before emitting extra section data
sectionDataBuilder.WriteBytes(0, alignedSize - bytesToRead);
}
location = new SectionLocation(
location.RelativeVirtualAddress + sectionDataBuilder.Count,
location.PointerToRawData + sectionDataBuilder.Count);
}
}
if (_sectionSerializer != null)
{
BlobBuilder extraData = _sectionSerializer(name, location, sectionStartRva);
if (extraData != null)
{
if (sectionDataBuilder == null)
{
// See above - there's a bug due to which LinkSuffix to an empty BlobBuilder screws up the blob content.
sectionDataBuilder = extraData;
}
else
{
sectionDataBuilder.LinkSuffix(extraData);
}
}
}
// Make sure the section has at least 1 byte, otherwise the PE emitter goes mad,
// messes up the section map and corrups the output executable.
if (sectionDataBuilder == null)
{
sectionDataBuilder = new BlobBuilder();
}
if (sectionDataBuilder.Count == 0)
{
sectionDataBuilder.WriteByte(0);
}
return(sectionDataBuilder);
}
/// <exception cref="InvalidOperationException" />
internal void CopyCodeAndFixupBranches(BlobBuilder srcBuilder, BlobBuilder dstBuilder)
{
var branch = _branches[0];
int branchIndex = 0;
// offset within the source builder
int srcOffset = 0;
// current offset within the current source blob
int srcBlobOffset = 0;
foreach (Blob srcBlob in srcBuilder.GetBlobs())
{
Debug.Assert(
srcBlobOffset == 0 ||
srcBlobOffset == 1 && srcBlob.Buffer[0] == 0xff ||
srcBlobOffset == 4 && srcBlob.Buffer[0] == 0xff && srcBlob.Buffer[1] == 0xff && srcBlob.Buffer[2] == 0xff && srcBlob.Buffer[3] == 0xff);
while (true)
{
// copy bytes preceding the next branch, or till the end of the blob:
int chunkSize = Math.Min(branch.ILOffset - srcOffset, srcBlob.Length - srcBlobOffset);
dstBuilder.WriteBytes(srcBlob.Buffer, srcBlobOffset, chunkSize);
srcOffset += chunkSize;
srcBlobOffset += chunkSize;
// there is no branch left in the blob:
if (srcBlobOffset == srcBlob.Length)
{
srcBlobOffset = 0;
break;
}
Debug.Assert(srcBlob.Buffer[srcBlobOffset] == (byte)branch.OpCode);
int operandSize = branch.OpCode.GetBranchOperandSize();
bool isShortInstruction = operandSize == 1;
// Note: the 4B operand is contiguous since we wrote it via BlobBuilder.WriteInt32()
Debug.Assert(
srcBlobOffset + 1 == srcBlob.Length ||
(isShortInstruction ?
srcBlob.Buffer[srcBlobOffset + 1] == 0xff :
BitConverter.ToUInt32(srcBlob.Buffer, srcBlobOffset + 1) == 0xffffffff));
// write branch opcode:
dstBuilder.WriteByte(srcBlob.Buffer[srcBlobOffset]);
// write branch operand:
int branchDistance;
bool isShortDistance = branch.IsShortBranchDistance(_labels, out branchDistance);
if (isShortInstruction && !isShortDistance)
{
// We could potentially implement algortihm that automatically fixes up the branch instructions as well to accomodate bigger distances,
// however an optimal algorithm would be rather complex (something like: calculate topological ordering of crossing branch instructions
// and then use fixed point to eliminate cycles). If the caller doesn't care about optimal IL size they can use long branches whenever the
// distance is unknown upfront. If they do they probably already implement more sophisticad algorithm for IL layout optimization already.
throw new InvalidOperationException(SR.Format(SR.DistanceBetweenInstructionAndLabelTooBig, branch.OpCode, srcOffset, branchDistance));
}
if (isShortInstruction)
{
dstBuilder.WriteSByte((sbyte)branchDistance);
}
else
{
dstBuilder.WriteInt32(branchDistance);
}
srcOffset += sizeof(byte) + operandSize;
// next branch:
branchIndex++;
if (branchIndex == _branches.Count)
{
branch = new BranchInfo(int.MaxValue, default(LabelHandle), 0);
}
else
{
branch = _branches[branchIndex];
}
// the branch starts at the very end and its operand is in the next blob:
if (srcBlobOffset == srcBlob.Length - 1)
{
srcBlobOffset = operandSize;
break;
}
// skip fake branch instruction:
srcBlobOffset += sizeof(byte) + operandSize;
}
}
}
protected override BlobBuilder SerializeSection(string name, SectionLocation location)
{
if (name == ".s2")
{
_dirBuilder.CopyrightTable = new DirectoryEntry(location.RelativeVirtualAddress + 5, 10);
}
var builder = new BlobBuilder();
builder.WriteBytes((byte)name[name.Length - 1], 10);
return builder;
}
public static ReadyToRunStandaloneMethodMetadata Compute(EcmaMethod wrappedMethod)
{
var metadataReader = wrappedMethod.MetadataReader;
var _module = wrappedMethod.Module;
var rva = wrappedMethod.MetadataReader.GetMethodDefinition(wrappedMethod.Handle).RelativeVirtualAddress;
var _methodBody = _module.PEReader.GetMethodBody(rva);
byte[] _alternateILStream = _methodBody.GetILBytes();
var exceptionRegions = _methodBody.ExceptionRegions;
ILExceptionRegion[] _exceptionRegions;
int length = exceptionRegions.Length;
if (length == 0)
{
_exceptionRegions = Array.Empty <ILExceptionRegion>();
}
else
{
_exceptionRegions = new ILExceptionRegion[length];
for (int i = 0; i < length; i++)
{
var exceptionRegion = exceptionRegions[i];
_exceptionRegions[i] = new ILExceptionRegion(
(ILExceptionRegionKind)exceptionRegion.Kind, // assumes that ILExceptionRegionKind and ExceptionRegionKind enums are in sync
exceptionRegion.TryOffset,
exceptionRegion.TryLength,
exceptionRegion.HandlerOffset,
exceptionRegion.HandlerLength,
MetadataTokens.GetToken(exceptionRegion.CatchType),
exceptionRegion.FilterOffset);
}
}
BlobReader localsBlob = default(BlobReader);
if (!_methodBody.LocalSignature.IsNil)
{
localsBlob = wrappedMethod.MetadataReader.GetBlobReader(wrappedMethod.MetadataReader.GetStandaloneSignature(_methodBody.LocalSignature).Signature);
}
AlternativeTypeRefProvider alternateTypes = new AlternativeTypeRefProvider();
EcmaSignatureEncoder <AlternativeTypeRefProvider> alternateEncoder = new EcmaSignatureEncoder <AlternativeTypeRefProvider>(alternateTypes);
Dictionary <int, int> _alternateNonTokenStrings = new Dictionary <int, int>();
BlobBuilder _alternateNonTypeRefStream = new BlobBuilder();
BlobBuilder _nonCodeAlternateBlob = new BlobBuilder();
{
// Generate alternate stream for exceptions.
_nonCodeAlternateBlob.WriteCompressedInteger(_exceptionRegions.Length);
for (int i = 0; i < _exceptionRegions.Length; i++)
{
var region = _exceptionRegions[i];
_nonCodeAlternateBlob.WriteCompressedInteger((int)region.Kind);
_nonCodeAlternateBlob.WriteCompressedInteger((int)region.TryOffset);
_nonCodeAlternateBlob.WriteCompressedInteger((int)region.TryLength);
_nonCodeAlternateBlob.WriteCompressedInteger((int)region.HandlerOffset);
_nonCodeAlternateBlob.WriteCompressedInteger((int)region.HandlerLength);
if (region.Kind == ILExceptionRegionKind.Catch)
{
int alternateToken = GetAlternateStreamToken(region.ClassToken);
int encodedToken = CodedIndex.TypeDefOrRefOrSpec(MetadataTokens.EntityHandle(alternateToken));
_nonCodeAlternateBlob.WriteCompressedInteger(encodedToken);
}
else if (region.Kind == ILExceptionRegionKind.Filter)
{
_nonCodeAlternateBlob.WriteCompressedInteger(region.FilterOffset);
}
}
if (localsBlob.Length == 0)
{
// No locals. Encode a 2 to indicate this
_nonCodeAlternateBlob.WriteByte(2);
}
else
{
_nonCodeAlternateBlob.WriteByte(_methodBody.LocalVariablesInitialized ? (byte)1 : (byte)0);
EcmaSignatureTranslator sigTranslator = new EcmaSignatureTranslator(localsBlob, _nonCodeAlternateBlob, GetAlternateStreamToken);
sigTranslator.ParseLocalsSignature();
}
}
ILTokenReplacer.Replace(_alternateILStream, GetAlternateStreamToken);
// Add all the streams together into the _nonCodeAlternateBlob
int expectedFinalSize = _nonCodeAlternateBlob.Count + _alternateILStream.Length + _alternateNonTypeRefStream.Count;
_nonCodeAlternateBlob.WriteBytes(_alternateILStream);
_nonCodeAlternateBlob.LinkSuffix(_alternateNonTypeRefStream);
Debug.Assert(expectedFinalSize == _nonCodeAlternateBlob.Count);
ReadyToRunStandaloneMethodMetadata methodBlock = new ReadyToRunStandaloneMethodMetadata();
methodBlock.ConstantData = _nonCodeAlternateBlob.ToArray();
methodBlock.TypeRefs = alternateTypes._alternateTypeRefStream.ToArray();
return(methodBlock);
///// HELPER FUNCTIONS
unsafe int GetAlternateStreamToken(int token)
{
if (token == 0 || !_alternateNonTokenStrings.TryGetValue(token, out int alternateToken))
{
var handle = MetadataTokens.Handle(token);
if (handle.Kind == HandleKind.TypeDefinition || handle.Kind == HandleKind.TypeReference)
{
EcmaType ecmaType = (EcmaType)wrappedMethod.Module.GetObject(MetadataTokens.EntityHandle(token));
alternateToken = MetadataTokens.GetToken(alternateTypes.GetTypeDefOrRefHandleForTypeDesc(ecmaType));
}
else
{
BlobBuilder blob = new BlobBuilder();
int flag = 0;
if (handle.Kind == HandleKind.UserString)
{
string strAlternate = metadataReader.GetUserString((UserStringHandle)handle);
flag = 0x70000000;
blob.WriteCompressedInteger(strAlternate.Length);
fixed(char *charData = strAlternate)
{
blob.WriteBytes((byte *)charData, strAlternate.Length * 2);
}
// TODO: consider encoding via wtf-8, or possibly utf-8
}
else if (handle.Kind == HandleKind.TypeSpecification)
{
flag = 0x1B000000;
var sigBlob = metadataReader.GetBlobReader(metadataReader.GetTypeSpecification((TypeSpecificationHandle)handle).Signature);
EcmaSignatureTranslator sigTranslator = new EcmaSignatureTranslator(sigBlob, blob, GetAlternateStreamToken);
sigTranslator.ParseType();
}
else if (handle.Kind == HandleKind.MemberReference)
{
flag = 0x0a000000;
var memberReference = metadataReader.GetMemberReference((MemberReferenceHandle)handle);
var sigBlob = metadataReader.GetBlobReader(memberReference.Signature);
EcmaSignatureTranslator sigTranslator = new EcmaSignatureTranslator(sigBlob, blob, GetAlternateStreamToken);
sigTranslator.ParseMemberRefSignature();
blob.WriteSerializedString(metadataReader.GetString(memberReference.Name));
blob.WriteCompressedInteger(CodedIndex.MemberRefParent(MetadataTokens.EntityHandle(GetAlternateStreamToken(MetadataTokens.GetToken(memberReference.Parent)))));
}
else if (handle.Kind == HandleKind.MethodDefinition)
{
flag = 0x0a000000;
var methodDefinition = metadataReader.GetMethodDefinition((MethodDefinitionHandle)handle);
var sigBlob = metadataReader.GetBlobReader(methodDefinition.Signature);
EcmaSignatureTranslator sigTranslator = new EcmaSignatureTranslator(sigBlob, blob, GetAlternateStreamToken);
sigTranslator.ParseMethodSignature();
blob.WriteSerializedString(metadataReader.GetString(methodDefinition.Name));
blob.WriteCompressedInteger(CodedIndex.MemberRefParent(MetadataTokens.EntityHandle(GetAlternateStreamToken(MetadataTokens.GetToken(methodDefinition.GetDeclaringType())))));
}
else if (handle.Kind == HandleKind.FieldDefinition)
{
flag = 0x0a000000;
var fieldDefinition = metadataReader.GetFieldDefinition((FieldDefinitionHandle)handle);
var sigBlob = metadataReader.GetBlobReader(fieldDefinition.Signature);
EcmaSignatureTranslator sigTranslator = new EcmaSignatureTranslator(sigBlob, blob, GetAlternateStreamToken);
sigTranslator.ParseFieldSignature();
blob.WriteSerializedString(metadataReader.GetString(fieldDefinition.Name));
blob.WriteCompressedInteger(CodedIndex.MemberRefParent(MetadataTokens.EntityHandle(GetAlternateStreamToken(MetadataTokens.GetToken(fieldDefinition.GetDeclaringType())))));
}
else if (handle.Kind == HandleKind.MethodSpecification)
{
flag = 0x2B000000;
var methodSpecification = metadataReader.GetMethodSpecification((MethodSpecificationHandle)handle);
var sigBlob = metadataReader.GetBlobReader(methodSpecification.Signature);
blob.WriteCompressedInteger(MetadataTokens.GetRowNumber(MetadataTokens.EntityHandle(GetAlternateStreamToken(MetadataTokens.GetToken(methodSpecification.Method)))));
EcmaSignatureTranslator sigTranslator = new EcmaSignatureTranslator(sigBlob, blob, GetAlternateStreamToken);
sigTranslator.ParseMethodSpecSignature();
}
else if (handle.Kind == HandleKind.StandaloneSignature)
{
flag = 0x11000000;
var reader = wrappedMethod.Module.MetadataReader;
var sigBlob = reader.GetBlobReader(reader.GetStandaloneSignature((StandaloneSignatureHandle)handle).Signature);
EcmaSignatureTranslator sigTranslator = new EcmaSignatureTranslator(sigBlob, blob, GetAlternateStreamToken);
sigTranslator.ParseMethodSignature();
}
_alternateNonTypeRefStream.WriteBytes(blob.ToArray());
alternateToken = (_alternateNonTokenStrings.Count + 1) | flag;
}
_alternateNonTokenStrings.Add(token, alternateToken);
}
return(alternateToken);
}
}
/// <exception cref="InvalidOperationException" />
internal void CopyCodeAndFixupBranches(BlobBuilder srcBuilder, BlobBuilder dstBuilder)
{
var branch = _branches[0];
int branchIndex = 0;
// offset within the source builder
int srcOffset = 0;
// current offset within the current source blob
int srcBlobOffset = 0;
foreach (Blob srcBlob in srcBuilder.GetBlobs())
{
Debug.Assert(
srcBlobOffset == 0 ||
srcBlobOffset == 1 && srcBlob.Buffer[0] == 0xff ||
srcBlobOffset == 4 && srcBlob.Buffer[0] == 0xff && srcBlob.Buffer[1] == 0xff && srcBlob.Buffer[2] == 0xff && srcBlob.Buffer[3] == 0xff);
while (true)
{
// copy bytes preceding the next branch, or till the end of the blob:
int chunkSize = Math.Min(branch.ILOffset - srcOffset, srcBlob.Length - srcBlobOffset);
dstBuilder.WriteBytes(srcBlob.Buffer, srcBlobOffset, chunkSize);
srcOffset += chunkSize;
srcBlobOffset += chunkSize;
// there is no branch left in the blob:
if (srcBlobOffset == srcBlob.Length)
{
srcBlobOffset = 0;
break;
}
Debug.Assert(srcBlob.Buffer[srcBlobOffset] == (byte)branch.OpCode);
int operandSize = branch.OpCode.GetBranchOperandSize();
bool isShortInstruction = operandSize == 1;
// Note: the 4B operand is contiguous since we wrote it via BlobBuilder.WriteInt32()
Debug.Assert(
srcBlobOffset + 1 == srcBlob.Length ||
(isShortInstruction ?
srcBlob.Buffer[srcBlobOffset + 1] == 0xff :
BitConverter.ToUInt32(srcBlob.Buffer, srcBlobOffset + 1) == 0xffffffff));
// write branch opcode:
dstBuilder.WriteByte(srcBlob.Buffer[srcBlobOffset]);
int branchDistance = branch.GetBranchDistance(_labels, branch.OpCode, srcOffset, isShortInstruction);
// write branch operand:
if (isShortInstruction)
{
dstBuilder.WriteSByte((sbyte)branchDistance);
}
else
{
dstBuilder.WriteInt32(branchDistance);
}
srcOffset += sizeof(byte) + operandSize;
// next branch:
branchIndex++;
if (branchIndex == _branches.Count)
{
branch = new BranchInfo(int.MaxValue, label: default, opCode: default);
public static void Write(
BlobBuilder writer,
IReadOnlyList <Instruction> il,
Func <string, StringHandle> getString,
IReadOnlyDictionary <Guid, EntityHandle> typeHandles,
IReadOnlyDictionary <ConstructorInfo, MemberReferenceHandle> ctorRefHandles,
IReadOnlyDictionary <FieldInfo, FieldDefinitionHandle> fieldHandles,
IReadOnlyDictionary <MethodInfo, MethodDefinitionHandle> methodHandles)
{
var targetOffsets = new ArrayMapper <int>();
//var offsetIndex = new Dictionary<int, int>();
for (var i = 0; i < il.Count; i++)
{
//offsetIndex.Add(il[i].Offset, i);
var opCode = il[i].OpCode;
opCode.WriteOpCode(writer.WriteByte);
switch (opCode.OperandType)
{
case OperandType.InlineNone:
break;
case OperandType.InlineSwitch:
var branches = (int[])il[i].Operand;
writer.WriteInt32(branches.Length);
for (var k = 0; k < branches.Length; k++)
{
var branchOffset = branches[k];
writer.WriteInt32(targetOffsets.Add(
branchOffset + il[i].Offset + opCode.Size + 4 * (branches.Length + 1)));
}
break;
case OperandType.ShortInlineBrTarget:
var offset8 = (sbyte)il[i].Operand;
// offset convention in IL: zero is at next instruction
writer.WriteSByte((sbyte)targetOffsets.Add(offset8 + il[i].Offset + opCode.Size + 1));
break;
case OperandType.InlineBrTarget:
var offset32 = (int)il[i].Operand;
// offset convention in IL: zero is at next instruction
writer.WriteInt32(targetOffsets.Add(offset32 + il[i].Offset + opCode.Size + 4));
break;
case OperandType.ShortInlineI:
if (opCode == OpCodes.Ldc_I4_S)
{
writer.WriteSByte((sbyte)il[i].Operand);
}
else
{
writer.WriteByte((byte)il[i].Operand);
}
break;
case OperandType.InlineI:
writer.WriteInt32((int)il[i].Operand);
break;
case OperandType.ShortInlineR:
writer.WriteSingle((float)il[i].Operand);
break;
case OperandType.InlineR:
writer.WriteDouble((double)il[i].Operand);
break;
case OperandType.InlineI8:
writer.WriteInt64((long)il[i].Operand);
break;
case OperandType.InlineSig:
writer.WriteBytes((byte[])il[i].Operand);
break;
case OperandType.InlineString:
writer.WriteInt32(MetadataTokens.GetToken(getString((string)il[i].Operand)));
break;
case OperandType.InlineType:
case OperandType.InlineTok:
case OperandType.InlineMethod:
case OperandType.InlineField:
switch (il[i].Operand)
{
case Type type:
writer.WriteInt32(MetadataTokens.GetToken(typeHandles[type.GUID]));
break;
case ConstructorInfo constructorInfo:
writer.WriteInt32(MetadataTokens.GetToken(ctorRefHandles[constructorInfo]));
break;
case FieldInfo fieldInfo:
writer.WriteInt32(MetadataTokens.GetToken(fieldHandles[fieldInfo]));
break;
case MethodInfo methodInfo:
writer.WriteInt32(MetadataTokens.GetToken(methodHandles[methodInfo]));
break;
default:
throw new NotSupportedException();
}
break;
case OperandType.ShortInlineVar:
var bLocalVariableInfo = il[i].Operand as LocalVariableInfo;
var bParameterInfo = il[i].Operand as ParameterInfo;
if (bLocalVariableInfo != null)
{
writer.WriteByte((byte)bLocalVariableInfo.LocalIndex);
}
else if (bParameterInfo != null)
{
writer.WriteByte((byte)bParameterInfo.Position);
}
else
{
throw new NotSupportedException();
}
break;
case OperandType.InlineVar:
var sLocalVariableInfo = il[i].Operand as LocalVariableInfo;
var sParameterInfo = il[i].Operand as ParameterInfo;
if (sLocalVariableInfo != null)
{
writer.WriteUInt16((ushort)sLocalVariableInfo.LocalIndex);
}
else if (sParameterInfo != null)
{
writer.WriteUInt16((ushort)sParameterInfo.Position);
}
else
{
throw new NotSupportedException();
}
break;
default:
throw new NotSupportedException();
}
}
}
/// <summary>
/// Output the section with a given name. For sections existent in the source MSIL PE file
/// (.text, optionally .rsrc and .reloc), we first copy the content of the input MSIL PE file
/// and then call the section serialization callback to emit the extra content after the input
/// section content.
/// </summary>
/// <param name="name">Section name</param>
/// <param name="location">RVA and file location where the section will be put</param>
/// <returns>Blob builder representing the section data</returns>
protected override BlobBuilder SerializeSection(string name, SectionLocation location)
{
BlobBuilder sectionDataBuilder = null;
int sectionStartRva = location.RelativeVirtualAddress;
int outputSectionIndex = _sections.Length - 1;
while (outputSectionIndex >= 0 && _sections[outputSectionIndex].Name != name)
{
outputSectionIndex--;
}
int injectedPadding = 0;
if (_customPESectionAlignment != 0)
{
if (outputSectionIndex > 0)
{
sectionStartRva = Math.Max(sectionStartRva, _sectionRVAs[outputSectionIndex - 1] + _sectionRawSizes[outputSectionIndex - 1]);
}
int newSectionStartRva = AlignmentHelper.AlignUp(sectionStartRva, _customPESectionAlignment);
int newSectionPointerToRawData = AlignmentHelper.AlignUp(location.PointerToRawData, _customPESectionAlignment);
if (newSectionPointerToRawData > location.PointerToRawData)
{
sectionDataBuilder = new BlobBuilder();
injectedPadding = newSectionPointerToRawData - location.PointerToRawData;
sectionDataBuilder.WriteBytes(1, injectedPadding);
}
sectionStartRva = newSectionStartRva;
location = new SectionLocation(sectionStartRva, newSectionPointerToRawData);
}
if (!_target.IsWindows)
{
const int RVAAlign = 1 << RVABitsToMatchFilePos;
if (outputSectionIndex > 0)
{
sectionStartRva = Math.Max(sectionStartRva, _sectionRVAs[outputSectionIndex - 1] + _sectionRawSizes[outputSectionIndex - 1]);
// when assembly is stored in a singlefile bundle, an additional skew is introduced
// as the streams inside the bundle are not necessarily page aligned as we do not
// know the actual page size on the target system.
// We may need one page gap of unused VA space before the next section starts.
// We will assume the page size is <= RVAAlign
sectionStartRva += RVAAlign;
}
sectionStartRva = AlignmentHelper.AlignUp(sectionStartRva, RVAAlign);
int rvaAdjust = (location.PointerToRawData - sectionStartRva) & (RVAAlign - 1);
sectionStartRva += rvaAdjust;
location = new SectionLocation(sectionStartRva, location.PointerToRawData);
}
if (outputSectionIndex >= 0)
{
_sectionRVAs[outputSectionIndex] = sectionStartRva;
_sectionPointerToRawData[outputSectionIndex] = location.PointerToRawData;
}
BlobBuilder extraData = _sectionBuilder.SerializeSection(name, location);
if (extraData != null)
{
if (sectionDataBuilder == null)
{
// See above - there's a bug due to which LinkSuffix to an empty BlobBuilder screws up the blob content.
sectionDataBuilder = extraData;
}
else
{
sectionDataBuilder.LinkSuffix(extraData);
}
}
// Make sure the section has at least 1 byte, otherwise the PE emitter goes mad,
// messes up the section map and corrups the output executable.
if (sectionDataBuilder == null)
{
sectionDataBuilder = new BlobBuilder();
}
if (sectionDataBuilder.Count == 0)
{
sectionDataBuilder.WriteByte(0);
}
int sectionRawSize = sectionDataBuilder.Count - injectedPadding;
if (_customPESectionAlignment != 0)
{
// Align the end of the section to the padding offset
int count = AlignmentHelper.AlignUp(sectionRawSize, _customPESectionAlignment);
sectionDataBuilder.WriteBytes(0, count - sectionRawSize);
sectionRawSize = count;
}
if (outputSectionIndex >= 0)
{
_sectionRawSizes[outputSectionIndex] = sectionRawSize;
}
return(sectionDataBuilder);
}
private void WriteImportTable(Stream peStream, int importTableRva, int importAddressTableRva)
{
var writer = new BlobBuilder(SizeOfImportTable);
int ilRVA = importTableRva + 40;
int hintRva = ilRVA + (_is32bit ? 12 : 16);
int nameRva = hintRva + 12 + 2;
// Import table
writer.WriteUInt32((uint)ilRVA); // 4
writer.WriteUInt32(0); // 8
writer.WriteUInt32(0); // 12
writer.WriteUInt32((uint)nameRva); // 16
writer.WriteUInt32((uint)importAddressTableRva); // 20
writer.WriteBytes(0, 20); // 40
// Import Lookup table
if (_is32bit)
{
writer.WriteUInt32((uint)hintRva); // 44
writer.WriteUInt32(0); // 48
writer.WriteUInt32(0); // 52
}
else
{
writer.WriteUInt64((uint)hintRva); // 48
writer.WriteUInt64(0); // 56
}
// Hint table
writer.WriteUInt16(0); // Hint 54|58
foreach (char ch in CorEntryPointName)
{
writer.WriteByte((byte)ch); // 65|69
}
writer.WriteByte(0); // 66|70
Debug.Assert(writer.Count == SizeOfImportTable);
writer.WriteContentTo(peStream);
}
public void GetBlobs()
{
var builder = new BlobBuilder(16);
builder.WriteBytes(1, 100);
var blobs = builder.GetBlobs().ToArray();
Assert.Equal(2, blobs.Length);
Assert.Equal(16, blobs[0].Length);
Assert.Equal(100 - 16, blobs[1].Length);
builder.WriteByte(1);
blobs = builder.GetBlobs().ToArray();
Assert.Equal(3, blobs.Length);
Assert.Equal(16, blobs[0].Length);
Assert.Equal(16, blobs[0].GetBytes().Array.Length);
Assert.Equal(100 - 16, blobs[1].Length);
Assert.Equal(100 - 16, blobs[1].GetBytes().Array.Length);
Assert.Equal(1, blobs[2].Length);
Assert.Equal(100 - 16, blobs[2].GetBytes().Array.Length);
builder.Clear();
blobs = builder.GetBlobs().ToArray();
Assert.Equal(1, blobs.Length);
Assert.Equal(0, blobs[0].Length);
// Clear uses the first buffer:
Assert.Equal(16, blobs[0].GetBytes().Array.Length);
}
/// <summary>
/// Serializes .text section data into a specified <paramref name="builder"/>.
/// </summary>
/// <param name="builder">An empty builder to serialize section data to.</param>
/// <param name="relativeVirtualAddess">Relative virtual address of the section within the containing PE file.</param>
/// <param name="entryPointTokenOrRelativeVirtualAddress">Entry point token or RVA (<see cref="CorHeader.EntryPointTokenOrRelativeVirtualAddress"/>)</param>
/// <param name="corFlags">COR Flags (<see cref="CorHeader.Flags"/>).</param>
/// <param name="baseAddress">Base address of the PE image.</param>
/// <param name="metadataBuilder"><see cref="BlobBuilder"/> containing metadata. Must be populated with data. Linked into the <paramref name="builder"/> and can't be expanded afterwards.</param>
/// <param name="ilBuilder"><see cref="BlobBuilder"/> containing IL stream. Must be populated with data. Linked into the <paramref name="builder"/> and can't be expanded afterwards.</param>
/// <param name="mappedFieldDataBuilder"><see cref="BlobBuilder"/> containing mapped field data. Must be populated with data. Linked into the <paramref name="builder"/> and can't be expanded afterwards.</param>
/// <param name="resourceBuilder"><see cref="BlobBuilder"/> containing managed resource data. Must be populated with data. Linked into the <paramref name="builder"/> and can't be expanded afterwards.</param>
/// <param name="debugTableBuilderOpt"><see cref="BlobBuilder"/> containing debug table data. Must be populated with data. Linked into the <paramref name="builder"/> and can't be expanded afterwards.</param>
public void Serialize(
BlobBuilder builder,
int relativeVirtualAddess,
int entryPointTokenOrRelativeVirtualAddress,
CorFlags corFlags,
ulong baseAddress,
BlobBuilder metadataBuilder,
BlobBuilder ilBuilder,
BlobBuilder mappedFieldDataBuilder,
BlobBuilder resourceBuilder,
BlobBuilder debugTableBuilderOpt)
{
Debug.Assert(builder.Count == 0);
Debug.Assert(metadataBuilder.Count == MetadataSize);
Debug.Assert(metadataBuilder.Count % 4 == 0);
Debug.Assert(ilBuilder.Count == ILStreamSize);
Debug.Assert(mappedFieldDataBuilder.Count == MappedFieldDataSize);
Debug.Assert(resourceBuilder.Count == ResourceDataSize);
Debug.Assert(resourceBuilder.Count % 4 == 0);
// TODO: avoid recalculation
int importTableRva = GetImportTableDirectoryEntry(relativeVirtualAddess).RelativeVirtualAddress;
int importAddressTableRva = GetImportAddressTableDirectoryEntry(relativeVirtualAddess).RelativeVirtualAddress;
if (RequiresStartupStub)
{
WriteImportAddressTable(builder, importTableRva);
}
WriteCorHeader(builder, relativeVirtualAddess, entryPointTokenOrRelativeVirtualAddress, corFlags);
// IL:
ilBuilder.Align(4);
builder.LinkSuffix(ilBuilder);
// metadata:
builder.LinkSuffix(metadataBuilder);
// managed resources:
builder.LinkSuffix(resourceBuilder);
// strong name signature:
builder.WriteBytes(0, StrongNameSignatureSize);
if (debugTableBuilderOpt != null)
{
builder.LinkSuffix(debugTableBuilderOpt);
}
if (RequiresStartupStub)
{
WriteImportTable(builder, importTableRva, importAddressTableRva);
WriteNameTable(builder);
WriteRuntimeStartupStub(builder, importAddressTableRva, baseAddress);
}
// mapped field data:
builder.LinkSuffix(mappedFieldDataBuilder);
Debug.Assert(builder.Count == ComputeSizeOfTextSection());
}
private void WriteImportTable(BlobBuilder builder, int importTableRva, int importAddressTableRva)
{
int start = builder.Count;
int ilRVA = importTableRva + 40;
int hintRva = ilRVA + (Is32Bit ? 12 : 16);
int nameRva = hintRva + 12 + 2;
// Import table
builder.WriteUInt32((uint)ilRVA); // 4
builder.WriteUInt32(0); // 8
builder.WriteUInt32(0); // 12
builder.WriteUInt32((uint)nameRva); // 16
builder.WriteUInt32((uint)importAddressTableRva); // 20
builder.WriteBytes(0, 20); // 40
// Import Lookup table
if (Is32Bit)
{
builder.WriteUInt32((uint)hintRva); // 44
builder.WriteUInt32(0); // 48
builder.WriteUInt32(0); // 52
}
else
{
builder.WriteUInt64((uint)hintRva); // 48
builder.WriteUInt64(0); // 56
}
// Hint table
builder.WriteUInt16(0); // Hint 54|58
foreach (char ch in CorEntryPointName)
{
builder.WriteByte((byte)ch); // 65|69
}
builder.WriteByte(0); // 66|70
Debug.Assert(builder.Count - start == SizeOfImportTable);
}
public unsafe void Write_Errors()
{
var builder = new BlobBuilder(16);
Assert.Throws <ArgumentNullException>(() => builder.WriteUTF16((char[])null));
Assert.Throws <ArgumentNullException>(() => builder.WriteUTF16((string)null));
Assert.Throws <ArgumentNullException>(() => builder.WriteUTF8(null, allowUnpairedSurrogates: true));
Assert.Throws <ArgumentNullException>(() => builder.WriteUTF8(null, allowUnpairedSurrogates: true));
Assert.Throws <ArgumentNullException>(() => builder.TryWriteBytes((Stream)null, 0));
Assert.Throws <ArgumentNullException>(() => builder.WriteBytes(null));
Assert.Throws <ArgumentNullException>(() => builder.WriteBytes(null, 0, 0));
Assert.Throws <ArgumentNullException>(() => builder.WriteBytes((byte *)null, 0));
Assert.Throws <ArgumentNullException>(() => builder.WriteBytes(default(ImmutableArray <byte>)));
Assert.Throws <ArgumentNullException>(() => builder.WriteBytes(default(ImmutableArray <byte>), 0, 0));
var bw = default(BlobWriter);
Assert.Throws <ArgumentNullException>(() => builder.WriteContentTo(ref bw));
Assert.Throws <ArgumentNullException>(() => builder.WriteContentTo((Stream)null));
Assert.Throws <ArgumentNullException>(() => builder.WriteContentTo((BlobBuilder)null));
Assert.Throws <ArgumentOutOfRangeException>(() => builder.TryWriteBytes(new MemoryStream(), -1));
Assert.Throws <ArgumentOutOfRangeException>(() => builder.WriteBytes(0, -1));
Assert.Throws <ArgumentOutOfRangeException>(() => builder.WriteBytes(new byte[] { }, 1, 0));
Assert.Throws <ArgumentOutOfRangeException>(() => builder.WriteBytes(new byte[] { }, 0, 1));
Assert.Throws <ArgumentOutOfRangeException>(() => builder.WriteBytes(new byte[] { }, 0, -1));
Assert.Throws <ArgumentOutOfRangeException>(() => builder.WriteBytes(ImmutableArray <byte> .Empty, 1, 0));
Assert.Throws <ArgumentOutOfRangeException>(() => builder.WriteBytes(ImmutableArray <byte> .Empty, 0, 1));
Assert.Throws <ArgumentOutOfRangeException>(() => builder.WriteBytes(ImmutableArray <byte> .Empty, 1, -1));
}
/// <summary>
/// Write one entry in the "Debug Directory (Image Only)"
/// See https://msdn.microsoft.com/en-us/windows/hardware/gg463119.aspx
/// section 5.1.1 (pages 71-72).
/// </summary>
private static void WriteDebugTableEntry(
BlobBuilder writer,
byte[] stamp,
uint version, // major and minor version, combined
uint debugType,
uint sizeOfData,
uint addressOfRawData,
uint pointerToRawData)
{
writer.WriteUInt32(0); // characteristics
Debug.Assert(stamp.Length == 4);
writer.WriteBytes(stamp);
writer.WriteUInt32(version);
writer.WriteUInt32(debugType);
writer.WriteUInt32(sizeOfData);
writer.WriteUInt32(addressOfRawData);
writer.WriteUInt32(pointerToRawData);
}
internal void FixupBranches(BlobBuilder srcBuilder, BlobBuilder dstBuilder)
{
int srcOffset = 0;
var branch = _branches[0];
int branchIndex = 0;
int blobOffset = 0;
foreach (Blob blob in srcBuilder.GetBlobs())
{
Debug.Assert(blobOffset == 0 || blobOffset == 1 && blob.Buffer[blobOffset - 1] == 0xff);
while (true)
{
// copy bytes preceding the next branch, or till the end of the blob:
int chunkSize = Math.Min(branch.ILOffset - srcOffset, blob.Length - blobOffset);
dstBuilder.WriteBytes(blob.Buffer, blobOffset, chunkSize);
srcOffset += chunkSize;
blobOffset += chunkSize;
// there is no branch left in the blob:
if (blobOffset == blob.Length)
{
blobOffset = 0;
break;
}
Debug.Assert(blob.Buffer[blobOffset] == branch.ShortOpCode && (blobOffset + 1 == blob.Length || blob.Buffer[blobOffset + 1] == 0xff));
srcOffset += sizeof(byte) + sizeof(sbyte);
// write actual branch instruction:
int branchDistance;
if (branch.IsShortBranchDistance(_labels, out branchDistance))
{
dstBuilder.WriteByte(branch.ShortOpCode);
dstBuilder.WriteSByte((sbyte)branchDistance);
}
else
{
dstBuilder.WriteByte((byte)((ILOpCode)branch.ShortOpCode).GetLongBranch());
dstBuilder.WriteInt32(branchDistance);
}
// next branch:
branchIndex++;
if (branchIndex == _branches.Count)
{
branch = new BranchInfo(int.MaxValue, default(LabelHandle), 0);
}
else
{
branch = _branches[branchIndex];
}
// the branch starts at the very end and its operand is in the next blob:
if (blobOffset == blob.Length - 1)
{
blobOffset = 1;
break;
}
// skip fake branch instruction:
blobOffset += sizeof(byte) + sizeof(sbyte);
}
}
}
private readonly static byte[] zeroStamp = new byte[4]; // four bytes of zero
/// <summary>
/// Write the entire "Debug Directory (Image Only)" along with data that it points to.
/// </summary>
internal void WriteDebugTable(BlobBuilder builder, PESectionLocation textSectionLocation, ContentId nativePdbContentId, ContentId portablePdbContentId)
{
Debug.Assert(builder.Count == 0);
int tableSize = ImageDebugDirectoryBaseSize;
Debug.Assert(tableSize != 0);
Debug.Assert(nativePdbContentId.IsDefault || portablePdbContentId.IsDefault);
Debug.Assert(!EmitPdb || (nativePdbContentId.IsDefault ^ portablePdbContentId.IsDefault));
int dataSize = ComputeSizeOfDebugDirectoryData();
if (EmitPdb)
{
const int IMAGE_DEBUG_TYPE_CODEVIEW = 2; // from PE spec
uint dataOffset = (uint)(ComputeOffsetToDebugTable() + tableSize);
WriteDebugTableEntry(builder,
stamp: nativePdbContentId.Stamp ?? portablePdbContentId.Stamp,
version: portablePdbContentId.IsDefault ? (uint)0 : ('P' << 24 | 'M' << 16 | 0x01 << 8 | 0x00),
debugType: IMAGE_DEBUG_TYPE_CODEVIEW,
sizeOfData: (uint)dataSize,
addressOfRawData: (uint)textSectionLocation.RelativeVirtualAddress + dataOffset, // RVA of the data
pointerToRawData: (uint)textSectionLocation.PointerToRawData + dataOffset); // position of the data in the PE stream
}
if (IsDeterministic)
{
const int IMAGE_DEBUG_TYPE_NO_TIMESTAMP = 16; // from PE spec
WriteDebugTableEntry(builder,
stamp: zeroStamp,
version: 0,
debugType: IMAGE_DEBUG_TYPE_NO_TIMESTAMP,
sizeOfData: 0,
addressOfRawData: 0,
pointerToRawData: 0);
}
// We should now have written all and precisely the data we said we'd write for the table entries.
Debug.Assert(builder.Count == tableSize);
// ====================
// The following is additional data beyond the debug directory at the offset `dataOffset`
// pointed to by the ImageDebugTypeCodeView entry.
if (EmitPdb)
{
builder.WriteByte((byte)'R');
builder.WriteByte((byte)'S');
builder.WriteByte((byte)'D');
builder.WriteByte((byte)'S');
// PDB id:
builder.WriteBytes(nativePdbContentId.Guid ?? portablePdbContentId.Guid);
// age
builder.WriteUInt32(1); // TODO: allow specify for native PDBs
// UTF-8 encoded zero-terminated path to PDB
int pathStart = builder.Count;
builder.WriteUTF8(PdbPathOpt, allowUnpairedSurrogates: true);
builder.WriteByte(0);
// padding:
builder.WriteBytes(0, Math.Max(0, MinPdbPath - (builder.Count - pathStart)));
}
// We should now have written all and precisely the data we said we'd write for the table and its data.
Debug.Assert(builder.Count == tableSize + dataSize);
}
/// <summary>
/// Output the section with a given name. For sections existent in the source MSIL PE file
/// (.text, optionally .rsrc and .reloc), we first copy the content of the input MSIL PE file
/// and then call the section serialization callback to emit the extra content after the input
/// section content.
/// </summary>
/// <param name="name">Section name</param>
/// <param name="location">RVA and file location where the section will be put</param>
/// <returns>Blob builder representing the section data</returns>
protected override BlobBuilder SerializeSection(string name, SectionLocation location)
{
BlobBuilder sectionDataBuilder = null;
int sectionStartRva = location.RelativeVirtualAddress;
int outputSectionIndex = _sections.Length - 1;
while (outputSectionIndex >= 0 && _sections[outputSectionIndex].Name != name)
{
outputSectionIndex--;
}
int injectedPadding = 0;
if (_customPESectionAlignment != 0)
{
if (outputSectionIndex > 0)
{
sectionStartRva = Math.Max(sectionStartRva, _sectionRVAs[outputSectionIndex - 1] + _sectionRawSizes[outputSectionIndex - 1]);
}
int newSectionStartRva = AlignmentHelper.AlignUp(sectionStartRva, _customPESectionAlignment);
int newSectionPointerToRawData = AlignmentHelper.AlignUp(location.PointerToRawData, _customPESectionAlignment);
if (newSectionPointerToRawData > location.PointerToRawData)
{
sectionDataBuilder = new BlobBuilder();
injectedPadding = newSectionPointerToRawData - location.PointerToRawData;
sectionDataBuilder.WriteBytes(1, injectedPadding);
}
sectionStartRva = newSectionStartRva;
location = new SectionLocation(sectionStartRva, newSectionPointerToRawData);
}
if (!_target.IsWindows)
{
if (outputSectionIndex > 0)
{
sectionStartRva = Math.Max(sectionStartRva, _sectionRVAs[outputSectionIndex - 1] + _sectionRawSizes[outputSectionIndex - 1]);
}
const int RVAAlign = 1 << RVABitsToMatchFilePos;
sectionStartRva = AlignmentHelper.AlignUp(sectionStartRva, RVAAlign);
int rvaAdjust = (location.PointerToRawData - sectionStartRva) & (RVAAlign - 1);
sectionStartRva += rvaAdjust;
location = new SectionLocation(sectionStartRva, location.PointerToRawData);
}
if (outputSectionIndex >= 0)
{
_sectionRVAs[outputSectionIndex] = sectionStartRva;
_sectionPointerToRawData[outputSectionIndex] = location.PointerToRawData;
}
BlobBuilder extraData = _sectionBuilder.SerializeSection(name, location);
if (extraData != null)
{
if (sectionDataBuilder == null)
{
// See above - there's a bug due to which LinkSuffix to an empty BlobBuilder screws up the blob content.
sectionDataBuilder = extraData;
}
else
{
sectionDataBuilder.LinkSuffix(extraData);
}
}
// Make sure the section has at least 1 byte, otherwise the PE emitter goes mad,
// messes up the section map and corrups the output executable.
if (sectionDataBuilder == null)
{
sectionDataBuilder = new BlobBuilder();
}
if (sectionDataBuilder.Count == 0)
{
sectionDataBuilder.WriteByte(0);
}
int sectionRawSize = sectionDataBuilder.Count - injectedPadding;
if (_customPESectionAlignment != 0)
{
// Align the end of the section to the padding offset
int count = AlignmentHelper.AlignUp(sectionRawSize, _customPESectionAlignment);
sectionDataBuilder.WriteBytes(0, count - sectionRawSize);
sectionRawSize = count;
}
if (outputSectionIndex >= 0)
{
_sectionRawSizes[outputSectionIndex] = sectionRawSize;
}
return(sectionDataBuilder);
}
/// <exception cref="InvalidOperationException" />
internal void CopyCodeAndFixupBranches(BlobBuilder srcBuilder, BlobBuilder dstBuilder)
{
var branch = _branches[0];
int branchIndex = 0;
// offset within the source builder
int srcOffset = 0;
// current offset within the current source blob
int srcBlobOffset = 0;
foreach (Blob srcBlob in srcBuilder.GetBlobs())
{
Debug.Assert(
srcBlobOffset == 0 ||
srcBlobOffset == 1 && srcBlob.Buffer[0] == 0xff ||
srcBlobOffset == 4 && srcBlob.Buffer[0] == 0xff && srcBlob.Buffer[1] == 0xff && srcBlob.Buffer[2] == 0xff && srcBlob.Buffer[3] == 0xff);
while (true)
{
// copy bytes preceding the next branch, or till the end of the blob:
int chunkSize = Math.Min(branch.ILOffset - srcOffset, srcBlob.Length - srcBlobOffset);
dstBuilder.WriteBytes(srcBlob.Buffer, srcBlobOffset, chunkSize);
srcOffset += chunkSize;
srcBlobOffset += chunkSize;
// there is no branch left in the blob:
if (srcBlobOffset == srcBlob.Length)
{
srcBlobOffset = 0;
break;
}
Debug.Assert(srcBlob.Buffer[srcBlobOffset] == (byte)branch.OpCode);
int operandSize = branch.OpCode.GetBranchOperandSize();
bool isShortInstruction = operandSize == 1;
// Note: the 4B operand is contiguous since we wrote it via BlobBuilder.WriteInt32()
Debug.Assert(
srcBlobOffset + 1 == srcBlob.Length ||
(isShortInstruction ?
srcBlob.Buffer[srcBlobOffset + 1] == 0xff :
BitConverter.ToUInt32(srcBlob.Buffer, srcBlobOffset + 1) == 0xffffffff));
// write branch opcode:
dstBuilder.WriteByte(srcBlob.Buffer[srcBlobOffset]);
// write branch operand:
int branchDistance;
bool isShortDistance = branch.IsShortBranchDistance(_labels, out branchDistance);
if (isShortInstruction && !isShortDistance)
{
// We could potentially implement algortihm that automatically fixes up the branch instructions as well to accomodate bigger distances,
// however an optimal algorithm would be rather complex (something like: calculate topological ordering of crossing branch instructions
// and then use fixed point to eliminate cycles). If the caller doesn't care about optimal IL size they can use long branches whenever the
// distance is unknown upfront. If they do they probably already implement more sophisticad algorithm for IL layout optimization already.
throw new InvalidOperationException(SR.Format(SR.DistanceBetweenInstructionAndLabelTooBig, branch.OpCode, srcOffset, branchDistance));
}
if (isShortInstruction)
{
dstBuilder.WriteSByte((sbyte)branchDistance);
}
else
{
dstBuilder.WriteInt32(branchDistance);
}
srcOffset += sizeof(byte) + operandSize;
// next branch:
branchIndex++;
if (branchIndex == _branches.Count)
{
branch = new BranchInfo(int.MaxValue, default(LabelHandle), 0);
}
else
{
branch = _branches[branchIndex];
}
// the branch starts at the very end and its operand is in the next blob:
if (srcBlobOffset == srcBlob.Length - 1)
{
srcBlobOffset = operandSize;
break;
}
// skip fake branch instruction:
srcBlobOffset += sizeof(byte) + operandSize;
}
}
}