public void BlobEncoder_MethodSignature()
{
var b = new BlobBuilder();
var e = new BlobEncoder(b);
var s = e.MethodSignature();
AssertEx.Equal(new byte[] { 0x00 }, b.ToArray());
Assert.Same(b, s.Builder);
Assert.False(s.HasVarArgs);
b.Clear();
s = e.MethodSignature(
convention: SignatureCallingConvention.StdCall,
genericParameterCount: 1234,
isInstanceMethod: true);
AssertEx.Equal(new byte[] { 0x32, 0x84, 0xD2 }, b.ToArray());
Assert.False(s.HasVarArgs);
b.Clear();
s = e.MethodSignature(
convention: SignatureCallingConvention.VarArgs,
genericParameterCount: 1,
isInstanceMethod: false);
AssertEx.Equal(new byte[] { 0x15, 0x01 }, b.ToArray());
Assert.True(s.HasVarArgs);
b.Clear();
Assert.Throws<ArgumentOutOfRangeException>(() => e.MethodSignature(genericParameterCount: -1));
Assert.Throws<ArgumentOutOfRangeException>(() => e.MethodSignature(genericParameterCount: ushort.MaxValue + 1));
}
public void BlobEncoder_MethodSpecificationSignature()
{
var b = new BlobBuilder();
var e = new BlobEncoder(b);
var s = e.MethodSpecificationSignature(genericArgumentCount: 0);
AssertEx.Equal(new byte[] { 0x0A, 0x00 }, b.ToArray());
Assert.Same(b, s.Builder);
b.Clear();
e.MethodSpecificationSignature(genericArgumentCount: 1234);
AssertEx.Equal(new byte[] { 0x0A, 0x84, 0xD2 }, b.ToArray());
b.Clear();
Assert.Throws<ArgumentOutOfRangeException>(() => e.MethodSpecificationSignature(genericArgumentCount: -1));
Assert.Throws<ArgumentOutOfRangeException>(() => e.MethodSpecificationSignature(genericArgumentCount: ushort.MaxValue + 1));
}
public void BlobEncoder_FieldSignature()
{
var b = new BlobBuilder();
var e = new BlobEncoder(b);
var s = e.FieldSignature();
AssertEx.Equal(new byte[] { 0x06 }, b.ToArray());
Assert.Same(b, s.Builder);
}
public void Add_Small()
{
var builder = new BlobBuilder();
var encoder = new ExceptionRegionEncoder(builder, hasSmallFormat: true);
encoder.Add(ExceptionRegionKind.Catch, 1, 2, 4, 5, catchType: MetadataTokens.TypeDefinitionHandle(1));
AssertEx.Equal(new byte[]
{
0x00, 0x00, // kind
0x01, 0x00, // try offset
0x02, // try length
0x04, 0x00, // handler offset
0x05, // handler length
0x01, 0x00, 0x00, 0x02 // catch type
}, builder.ToArray());
builder.Clear();
encoder.Add(ExceptionRegionKind.Filter, 0xffff, 0xff, 0xffff, 0xff, filterOffset: int.MaxValue);
AssertEx.Equal(new byte[]
{
0x01, 0x00, // kind
0xff, 0xff, // try offset
0xff, // try length
0xff, 0xff, // handler offset
0xff, // handler length
0xff, 0xff, 0xff, 0x7f // filter offset
}, builder.ToArray());
builder.Clear();
encoder.Add(ExceptionRegionKind.Fault, 0xffff, 0xff, 0xffff, 0xff);
AssertEx.Equal(new byte[]
{
0x04, 0x00, // kind
0xff, 0xff, // try offset
0xff, // try length
0xff, 0xff, // handler offset
0xff, // handler length
0x00, 0x00, 0x00, 0x00
}, builder.ToArray());
builder.Clear();
encoder.Add(ExceptionRegionKind.Finally, 0, 0, 0, 0);
AssertEx.Equal(new byte[]
{
0x02, 0x00, // kind
0x00, 0x00, // try offset
0x00, // try length
0x00, 0x00, // handler offset
0x00, // handler length
0x00, 0x00, 0x00, 0x00
}, builder.ToArray());
builder.Clear();
}
public void SerializeTableHeader()
{
var builder = new BlobBuilder();
builder.WriteByte(0xff);
ExceptionRegionEncoder.SerializeTableHeader(builder, ExceptionRegionEncoder.MaxSmallExceptionRegions, hasSmallRegions: true);
AssertEx.Equal(new byte[]
{
0xff, 0x00, 0x00, 0x00, // padding
0x01, // flags
0xf4, // size
0x00, 0x00
}, builder.ToArray());
builder.Clear();
builder.WriteByte(0xff);
ExceptionRegionEncoder.SerializeTableHeader(builder, ExceptionRegionEncoder.MaxExceptionRegions, hasSmallRegions: false);
AssertEx.Equal(new byte[]
{
0xff, 0x00, 0x00, 0x00, // padding
0x41, // flags
0xf4, 0xff, 0xff, // size
}, builder.ToArray());
}
public void CountClear()
{
var builder = new BlobBuilder();
Assert.Equal(0, builder.Count);
builder.WriteByte(1);
Assert.Equal(1, builder.Count);
builder.WriteInt32(4);
Assert.Equal(5, builder.Count);
builder.Clear();
Assert.Equal(0, builder.Count);
builder.WriteInt64(1);
Assert.Equal(8, builder.Count);
AssertEx.Equal(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, builder.ToArray());
}
public void LoadConstantI4()
{
var builder = new BlobBuilder();
var il = new InstructionEncoder(builder);
for (int i = -1; i < 9; i++)
{
il.LoadConstantI4(i);
}
il.LoadConstantI4(sbyte.MinValue);
il.LoadConstantI4(sbyte.MaxValue);
il.LoadConstantI4(-2);
il.LoadConstantI4(10);
il.LoadConstantI4(int.MinValue);
il.LoadConstantI4(int.MaxValue);
AssertEx.Equal(new byte[]
{
(byte)ILOpCode.Ldc_i4_m1,
(byte)ILOpCode.Ldc_i4_0,
(byte)ILOpCode.Ldc_i4_1,
(byte)ILOpCode.Ldc_i4_2,
(byte)ILOpCode.Ldc_i4_3,
(byte)ILOpCode.Ldc_i4_4,
(byte)ILOpCode.Ldc_i4_5,
(byte)ILOpCode.Ldc_i4_6,
(byte)ILOpCode.Ldc_i4_7,
(byte)ILOpCode.Ldc_i4_8,
(byte)ILOpCode.Ldc_i4_s, 0x80,
(byte)ILOpCode.Ldc_i4_s, 0x7F,
(byte)ILOpCode.Ldc_i4_s, 0xFE,
(byte)ILOpCode.Ldc_i4_s, 0x0A,
(byte)ILOpCode.Ldc_i4, 0x00, 0x00, 0x00, 0x80,
(byte)ILOpCode.Ldc_i4, 0xFF, 0xFF, 0xFF, 0x7F
}, builder.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);
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
}, 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 ToImmutableArray()
{
var builder = new BlobBuilder(16);
AssertEx.Equal(new byte[] { }, builder.ToArray(0, 0));
for (int i = 0; i < 13; i++)
{
builder.WriteByte((byte)i);
}
builder.WriteUInt32(0xaabbccdd);
AssertEx.Equal(new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0xDD, 0xCC, 0xBB, 0xAA }, builder.ToImmutableArray());
AssertEx.Equal(new byte[] { }, builder.ToImmutableArray(0, 0));
AssertEx.Equal(new byte[] { 0 }, builder.ToImmutableArray(0, 1));
AssertEx.Equal(new byte[] { 1 }, builder.ToImmutableArray(1, 1));
AssertEx.Equal(new byte[] { }, builder.ToImmutableArray(14, 0));
AssertEx.Equal(new byte[] { }, builder.ToImmutableArray(15, 0));
AssertEx.Equal(new byte[] { }, builder.ToImmutableArray(16, 0));
AssertEx.Equal(new byte[] { }, builder.ToImmutableArray(17, 0));
AssertEx.Equal(new byte[] { 0xdd }, builder.ToImmutableArray(13, 1));
AssertEx.Equal(new byte[] { 0xcc }, builder.ToImmutableArray(14, 1));
AssertEx.Equal(new byte[] { 0xbb }, builder.ToImmutableArray(15, 1));
AssertEx.Equal(new byte[] { 0xaa }, builder.ToImmutableArray(16, 1));
AssertEx.Equal(new byte[] { 0xdd, 0xcc }, builder.ToImmutableArray(13, 2));
AssertEx.Equal(new byte[] { 0xcc, 0xbb }, builder.ToImmutableArray(14, 2));
AssertEx.Equal(new byte[] { 0xbb, 0xaa }, builder.ToImmutableArray(15, 2));
AssertEx.Equal(new byte[] { 0xdd, 0xcc, 0xbb }, builder.ToImmutableArray(13, 3));
AssertEx.Equal(new byte[] { 0xcc, 0xbb, 0xaa }, builder.ToImmutableArray(14, 3));
AssertEx.Equal(new byte[] { 0xdd, 0xcc, 0xbb, 0xaa }, builder.ToImmutableArray(13, 4));
}
public byte[] GenerateAssemblyBytes()
{
var name = _currentAssembly.GetName();
var assemblyHandle = _metadataBuilder.AddAssembly(
GetString(name.Name),
name.Version,
GetString(name.CultureName),
GetBlob(name.GetPublicKey()),
_assemblyNameFlagsConvert(name.Flags),
_assemblyHashAlgorithmConvert(name.HashAlgorithm));
CreateReferencedAssemblies(_currentAssembly.GetReferencedAssemblies());
CreateCustomAttributes(assemblyHandle, _currentAssembly.GetCustomAttributesData());
CreateModules(_currentAssembly.GetModules());
CreateTypes(_currentAssembly.GetTypes());
var entryPoint = GetMethodDefinitionHandle(_currentAssembly.EntryPoint);
var metadataRootBuilder = new MetadataRootBuilder(_metadataBuilder);
var header = PEHeaderBuilder.CreateLibraryHeader();
var peBuilder = new ManagedPEBuilder(
header,
metadataRootBuilder,
_ilBuilder,
debugDirectoryBuilder: _debugDirectoryBuilder,
entryPoint: entryPoint);
var peImageBuilder = new BlobBuilder();
peBuilder.Serialize(peImageBuilder);
return(peImageBuilder.ToArray());
}
public void OpCode()
{
var builder = new BlobBuilder();
builder.WriteByte(0xff);
var il = new InstructionEncoder(builder);
Assert.Equal(1, il.Offset);
il.OpCode(ILOpCode.Add);
Assert.Equal(2, il.Offset);
builder.WriteByte(0xee);
Assert.Equal(3, il.Offset);
il.OpCode(ILOpCode.Arglist);
Assert.Equal(5, il.Offset);
builder.WriteByte(0xdd);
Assert.Equal(6, il.Offset);
il.OpCode(ILOpCode.Readonly);
Assert.Equal(8, il.Offset);
builder.WriteByte(0xcc);
Assert.Equal(9, il.Offset);
AssertEx.Equal(new byte[]
{
0xFF,
0x58,
0xEE,
0xFE, 0x00,
0xDD,
0xFE, 0x1E,
0xCC
}, builder.ToArray());
}
public void AddReproducibleEntry()
{
var b = new DebugDirectoryBuilder();
b.AddReproducibleEntry();
var blob = new BlobBuilder();
b.Serialize(blob, new SectionLocation(0x1000, 0x2000), 0x50);
var bytes = blob.ToArray();
AssertEx.Equal(new byte[]
{
0x00, 0x00, 0x00, 0x00, // Characteristics
0x00, 0x00, 0x00, 0x00, // Stamp
0x00, 0x00, 0x00, 0x00, // Version
0x10, 0x00, 0x00, 0x00, // Type
0x00, 0x00, 0x00, 0x00, // SizeOfData
0x00, 0x00, 0x00, 0x00, // AddressOfRawData
0x00, 0x00, 0x00, 0x00, // PointerToRawData
}, bytes);
using (var pinned = new PinnedBlob(bytes))
{
var actual = PEReader.ReadDebugDirectoryEntries(pinned.CreateReader(0, DebugDirectoryEntry.Size));
Assert.Equal(1, actual.Length);
Assert.Equal(0u, actual[0].Stamp);
Assert.Equal(0, actual[0].MajorVersion);
Assert.Equal(0, actual[0].MinorVersion);
Assert.Equal(DebugDirectoryEntryType.Reproducible, actual[0].Type);
Assert.False(actual[0].IsPortableCodeView);
Assert.Equal(0, actual[0].DataSize);
Assert.Equal(0, actual[0].DataRelativeVirtualAddress);
Assert.Equal(0, actual[0].DataPointer);
}
}
public void LoadConstantR4()
{
var builder = new BlobBuilder();
var il = new InstructionEncoder(builder);
il.LoadConstantR4(0.0f);
il.LoadConstantR4(float.MaxValue);
il.LoadConstantR4(float.MinValue);
il.LoadConstantR4(float.NaN);
il.LoadConstantR4(float.NegativeInfinity);
il.LoadConstantR4(float.PositiveInfinity);
il.LoadConstantR4(float.Epsilon);
AssertEx.Equal(new byte[]
{
(byte)ILOpCode.Ldc_r4, 0x00, 0x00, 0x00, 0x00,
(byte)ILOpCode.Ldc_r4, 0xFF, 0xFF, 0x7F, 0x7F,
(byte)ILOpCode.Ldc_r4, 0xFF, 0xFF, 0x7F, 0xFF,
(byte)ILOpCode.Ldc_r4, 0x00, 0x00, 0xC0, 0xFF,
(byte)ILOpCode.Ldc_r4, 0x00, 0x00, 0x80, 0xFF,
(byte)ILOpCode.Ldc_r4, 0x00, 0x00, 0x80, 0x7F,
(byte)ILOpCode.Ldc_r4, 0x01, 0x00, 0x00, 0x00
}, builder.ToArray());
}
public void LiteralEncoder_TaggedScalar()
{
var b = new BlobBuilder();
var e = new LiteralEncoder(b);
Assert.Same(b, e.Builder);
CustomAttributeElementTypeEncoder elementType;
ScalarEncoder scalar;
e.TaggedScalar(out elementType, out scalar);
AssertEx.Equal(new byte[0], b.ToArray());
Assert.Same(b, elementType.Builder);
Assert.Same(b, scalar.Builder);
b.Clear();
e.TaggedScalar(
et => Assert.Same(b, et.Builder),
s => Assert.Same(b, s.Builder));
Assert.Throws <ArgumentNullException>(() => e.TaggedScalar(null, s => { }));
Assert.Throws <ArgumentNullException>(() => e.TaggedScalar(et => { }, null));
}
public void LiteralEncoder_TaggedVector()
{
var b = new BlobBuilder();
var e = new LiteralEncoder(b);
Assert.Same(b, e.Builder);
CustomAttributeArrayTypeEncoder arrayType;
VectorEncoder vector;
e.TaggedVector(out arrayType, out vector);
AssertEx.Equal(new byte[0], b.ToArray());
Assert.Same(b, arrayType.Builder);
Assert.Same(b, vector.Builder);
b.Clear();
e.TaggedVector(
at => Assert.Same(b, at.Builder),
v => Assert.Same(b, v.Builder));
Assert.Throws <ArgumentNullException>(() => e.TaggedVector(null, v => { }));
Assert.Throws <ArgumentNullException>(() => e.TaggedVector(at => { }, null));
}
public void LoadConstantR8()
{
var builder = new BlobBuilder();
var il = new InstructionEncoder(builder);
il.LoadConstantR8(0.0);
il.LoadConstantR8(double.MaxValue);
il.LoadConstantR8(double.MinValue);
il.LoadConstantR8(double.NaN);
il.LoadConstantR8(double.NegativeInfinity);
il.LoadConstantR8(double.PositiveInfinity);
il.LoadConstantR8(double.Epsilon);
AssertEx.Equal(new byte[]
{
(byte)ILOpCode.Ldc_r8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
(byte)ILOpCode.Ldc_r8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0x7F,
(byte)ILOpCode.Ldc_r8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0xFF,
(byte)ILOpCode.Ldc_r8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF,
(byte)ILOpCode.Ldc_r8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF,
(byte)ILOpCode.Ldc_r8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x7F,
(byte)ILOpCode.Ldc_r8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}, builder.ToArray());
}
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());
}
public void Heaps()
{
var mdBuilder = new MetadataBuilder();
var g0 = mdBuilder.GetOrAddGuid(default(Guid));
Assert.True(g0.IsNil);
Assert.Equal(0, g0.Index);
var g1 = mdBuilder.GetOrAddGuid(new Guid("D39F3559-476A-4D1E-B6D2-88E66395230B"));
Assert.Equal(1, g1.Index);
var s0 = mdBuilder.GetOrAddString("");
Assert.False(s0.IsVirtual);
Assert.Equal(0, s0.GetWriterVirtualIndex());
var s1 = mdBuilder.GetOrAddString("foo");
Assert.True(s1.IsVirtual);
Assert.Equal(1, s1.GetWriterVirtualIndex());
var us0 = mdBuilder.GetOrAddUserString("");
Assert.Equal(1, us0.GetHeapOffset());
var us1 = mdBuilder.GetOrAddUserString("bar");
Assert.Equal(3, us1.GetHeapOffset());
var b0 = mdBuilder.GetOrAddBlob(new byte[0]);
Assert.Equal(0, b0.GetHeapOffset());
var b1 = mdBuilder.GetOrAddBlob(new byte[] { 1, 2 });
Assert.Equal(1, b1.GetHeapOffset());
mdBuilder.CompleteHeaps();
Assert.Equal(0, mdBuilder.SerializeHandle(g0));
Assert.Equal(1, mdBuilder.SerializeHandle(g1));
Assert.Equal(0, mdBuilder.SerializeHandle(s0));
Assert.Equal(1, mdBuilder.SerializeHandle(s1));
Assert.Equal(1, mdBuilder.SerializeHandle(us0));
Assert.Equal(3, mdBuilder.SerializeHandle(us1));
Assert.Equal(0, mdBuilder.SerializeHandle(b0));
Assert.Equal(1, mdBuilder.SerializeHandle(b1));
var heaps = new BlobBuilder();
mdBuilder.WriteHeapsTo(heaps);
AssertEx.Equal(new byte[]
{
// #String
0x00,
0x66, 0x6F, 0x6F, 0x00,
0x00, 0x00, 0x00,
// #US
0x00,
0x01, 0x00,
0x07, 0x62, 0x00, 0x61, 0x00, 0x72, 0x00, 0x00,
0x00,
// #Guid
0x59, 0x35, 0x9F, 0xD3, 0x6A, 0x47, 0x1E, 0x4D, 0xB6, 0xD2, 0x88, 0xE6, 0x63, 0x95, 0x23, 0x0B,
// #Blob
0x00, 0x02, 0x01, 0x02
}, heaps.ToArray());
}
public void WriteAlignPad()
{
var writer = new BlobBuilder(4);
writer.WriteByte(0x01);
writer.PadTo(2);
writer.WriteByte(0x02);
writer.Align(4);
writer.Align(4);
writer.WriteByte(0x03);
writer.Align(4);
writer.WriteByte(0x04);
writer.WriteByte(0x05);
writer.Align(8);
writer.WriteByte(0x06);
writer.Align(2);
writer.Align(1);
AssertEx.Equal(new byte[]
{
0x01, 0x00, 0x02, 0x00,
0x03, 0x00, 0x00, 0x00,
0x04, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x06, 0x00
}, writer.ToArray());
}
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 void Branch()
{
var builder = new BlobBuilder();
var il = new InstructionEncoder(builder, new ControlFlowBuilder());
var l = il.DefineLabel();
il.Branch(ILOpCode.Br_s, l);
il.Branch(ILOpCode.Brfalse_s, l);
il.Branch(ILOpCode.Brtrue_s, l);
il.Branch(ILOpCode.Beq_s, l);
il.Branch(ILOpCode.Bge_s, l);
il.Branch(ILOpCode.Bgt_s, l);
il.Branch(ILOpCode.Ble_s, l);
il.Branch(ILOpCode.Blt_s, l);
il.Branch(ILOpCode.Bne_un_s, l);
il.Branch(ILOpCode.Bge_un_s, l);
il.Branch(ILOpCode.Bgt_un_s, l);
il.Branch(ILOpCode.Ble_un_s, l);
il.Branch(ILOpCode.Blt_un_s, l);
il.Branch(ILOpCode.Leave_s, l);
il.Branch(ILOpCode.Br, l);
il.Branch(ILOpCode.Brfalse, l);
il.Branch(ILOpCode.Brtrue, l);
il.Branch(ILOpCode.Beq, l);
il.Branch(ILOpCode.Bge, l);
il.Branch(ILOpCode.Bgt, l);
il.Branch(ILOpCode.Ble, l);
il.Branch(ILOpCode.Blt, l);
il.Branch(ILOpCode.Bne_un, l);
il.Branch(ILOpCode.Bge_un, l);
il.Branch(ILOpCode.Bgt_un, l);
il.Branch(ILOpCode.Ble_un, l);
il.Branch(ILOpCode.Blt_un, l);
il.Branch(ILOpCode.Leave, l);
AssertEx.Equal(new byte[]
{
(byte)ILOpCode.Br_s, 0xff,
(byte)ILOpCode.Brfalse_s, 0xff,
(byte)ILOpCode.Brtrue_s, 0xff,
(byte)ILOpCode.Beq_s, 0xff,
(byte)ILOpCode.Bge_s, 0xff,
(byte)ILOpCode.Bgt_s, 0xff,
(byte)ILOpCode.Ble_s, 0xff,
(byte)ILOpCode.Blt_s, 0xff,
(byte)ILOpCode.Bne_un_s, 0xff,
(byte)ILOpCode.Bge_un_s, 0xff,
(byte)ILOpCode.Bgt_un_s, 0xff,
(byte)ILOpCode.Ble_un_s, 0xff,
(byte)ILOpCode.Blt_un_s, 0xff,
(byte)ILOpCode.Leave_s, 0xff,
(byte)ILOpCode.Br, 0xff, 0xff, 0xff, 0xff,
(byte)ILOpCode.Brfalse, 0xff, 0xff, 0xff, 0xff,
(byte)ILOpCode.Brtrue, 0xff, 0xff, 0xff, 0xff,
(byte)ILOpCode.Beq, 0xff, 0xff, 0xff, 0xff,
(byte)ILOpCode.Bge, 0xff, 0xff, 0xff, 0xff,
(byte)ILOpCode.Bgt, 0xff, 0xff, 0xff, 0xff,
(byte)ILOpCode.Ble, 0xff, 0xff, 0xff, 0xff,
(byte)ILOpCode.Blt, 0xff, 0xff, 0xff, 0xff,
(byte)ILOpCode.Bne_un, 0xff, 0xff, 0xff, 0xff,
(byte)ILOpCode.Bge_un, 0xff, 0xff, 0xff, 0xff,
(byte)ILOpCode.Bgt_un, 0xff, 0xff, 0xff, 0xff,
(byte)ILOpCode.Ble_un, 0xff, 0xff, 0xff, 0xff,
(byte)ILOpCode.Blt_un, 0xff, 0xff, 0xff, 0xff,
(byte)ILOpCode.Leave, 0xff, 0xff, 0xff, 0xff,
}, builder.ToArray());
}
public static byte[] Slice(this BlobBuilder bytes, int start, int end)
{
return(Slice(bytes.ToArray(), start, end));
}
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 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 WriteUTF8_Substring()
{
var writer = new BlobBuilder(4);
writer.WriteUTF8("abc", 0, 0, allowUnpairedSurrogates: true, prependSize: false);
AssertEx.Equal(new byte[0], writer.ToArray());
writer.Clear();
writer.WriteUTF8("abc", 0, 1, allowUnpairedSurrogates: true, prependSize: false);
AssertEx.Equal(new[] { (byte)'a' }, writer.ToArray());
writer.Clear();
writer.WriteUTF8("abc", 0, 2, allowUnpairedSurrogates: true, prependSize: false);
AssertEx.Equal(new[] { (byte)'a', (byte)'b' }, writer.ToArray());
writer.Clear();
writer.WriteUTF8("abc", 0, 3, allowUnpairedSurrogates: true, prependSize: false);
AssertEx.Equal(new[] { (byte)'a', (byte)'b', (byte)'c' }, writer.ToArray());
writer.Clear();
writer.WriteUTF8("abc", 1, 0, allowUnpairedSurrogates: true, prependSize: false);
AssertEx.Equal(new byte[0], writer.ToArray());
writer.Clear();
writer.WriteUTF8("abc", 1, 1, allowUnpairedSurrogates: true, prependSize: false);
AssertEx.Equal(new[] { (byte)'b' }, writer.ToArray());
writer.Clear();
writer.WriteUTF8("abc", 1, 2, allowUnpairedSurrogates: true, prependSize: false);
AssertEx.Equal(new[] { (byte)'b', (byte)'c' }, writer.ToArray());
writer.Clear();
writer.WriteUTF8("abc", 2, 1, allowUnpairedSurrogates: true, prependSize: false);
AssertEx.Equal(new[] { (byte)'c' }, writer.ToArray());
writer.Clear();
}
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 WriteUTF8_ReplaceUnpairedSurrogates()
{
var writer = new BlobBuilder(4);
writer.WriteUTF8("a", allowUnpairedSurrogates: false);
writer.WriteUTF8("", allowUnpairedSurrogates: false);
writer.WriteUTF8("bc", allowUnpairedSurrogates: false);
writer.WriteUTF8("d", allowUnpairedSurrogates: false);
writer.WriteUTF8("", allowUnpairedSurrogates: false);
writer.WriteUTF8(Encoding.UTF8.GetString(new byte[]
{
0x00,
0xC2, 0x80,
0xE1, 0x88, 0xB4
}), allowUnpairedSurrogates: false);
writer.WriteUTF8("\0\ud800", allowUnpairedSurrogates: false); // hi surrogate
writer.WriteUTF8("\0\udc00", allowUnpairedSurrogates: false); // lo surrogate
writer.WriteUTF8("\0\ud800\udc00", allowUnpairedSurrogates: false); // pair
writer.WriteUTF8("\0\udc00\ud800", allowUnpairedSurrogates: false); // lo + hi
AssertEx.Equal(new byte[]
{
(byte)'a',
(byte)'b', (byte)'c',
(byte)'d',
0x00, 0xC2, 0x80, 0xE1, 0x88, 0xB4,
0x00, 0xEF, 0xBF, 0xBD,
0x00, 0xEF, 0xBF, 0xBD,
0x00, 0xF0, 0x90, 0x80, 0x80,
0x00, 0xEF, 0xBF, 0xBD, 0xEF, 0xBF, 0xBD
}, writer.ToArray());
}
public void WriteSerializedString()
{
var writer = new BlobBuilder(4);
writer.WriteSerializedString("");
writer.WriteSerializedString("a");
writer.WriteSerializedString(null);
writer.WriteSerializedString("");
writer.WriteSerializedString("\ud800"); // hi surrogate
writer.WriteSerializedString("\udc00"); // lo surrogate
writer.WriteSerializedString("\ud800\udc00"); // pair
writer.WriteSerializedString("\udc00\ud800"); // lo + hi
writer.WriteSerializedString("\u1234");
AssertEx.Equal(new byte[]
{
0x00,
0x01, 0x61,
0xff,
0x00,
0x03, 0xED, 0xA0, 0x80,
0x03, 0xED, 0xB0, 0x80,
0x04, 0xF0, 0x90, 0x80, 0x80,
0x06, 0xED, 0xB0, 0x80, 0xED, 0xA0, 0x80,
0x03, 0xE1, 0x88, 0xB4
}, writer.ToArray());
}
public void WriteUTF16()
{
var writer = new BlobBuilder(4);
writer.WriteUTF16("");
writer.WriteUTF16("a");
writer.WriteUTF16("");
writer.WriteUTF16(new char[0]);
writer.WriteUTF16(new char[] { '\ud800' }); // hi surrogate
writer.WriteUTF16("\udc00"); // lo surrogate
writer.WriteUTF16("\ud800\udc00"); // pair
writer.WriteUTF16(new char[] { '\udc00', '\ud800' }); // lo + hi
writer.WriteUTF16("\u1234");
AssertEx.Equal(new byte[]
{
0x61, 0x00,
0x00, 0xD8,
0x00, 0xDC,
0x00, 0xD8, 0x00, 0xDC,
0x00, 0xDC, 0x00, 0xD8,
0x34, 0x12
}, writer.ToArray());
}
public byte[] GenerateAssemblyBytes()
{
if (_currentAssembly.EntryPoint != null)
{
// See "<Module>" type definition below.
throw new NotSupportedException("Entry point is not supported.");
}
var name = _currentAssembly.GetName();
var assemblyPublicKey = name.GetPublicKey();
var assemblyHandle = _metadataBuilder.AddAssembly(
GetString(name.Name),
name.Version,
GetString(name.CultureName),
assemblyPublicKey.Length > 0 ? GetBlob(name.GetPublicKey()) : default(BlobHandle),
ConvertGeneratedAssemblyNameFlags(name),
ConvertAssemblyHashAlgorithm(name.HashAlgorithm));
// Add "<Module>" type definition *before* any type definition.
//
// TODO: [osman] methodList argument should be as following:
//
// methodList: entryPoint.IsNil ? MetadataTokens.MethodDefinitionHandle(1) : entryPoint
//
// But, in order to work above code, we need to serialize
// entry point *without* serializing any type definition.
// This is not needed for libraries since they don't have any entry point.
_metadataBuilder.AddTypeDefinition(
default(TypeAttributes),
default(StringHandle),
GetString("<Module>"),
default(EntityHandle),
MetadataTokens.FieldDefinitionHandle(1),
MetadataTokens.MethodDefinitionHandle(1));
CreateReferencedAssemblies(_currentAssembly.GetReferencedAssemblies());
CreateCustomAttributes(assemblyHandle, _currentAssembly.GetCustomAttributesData());
CreateModules(_currentAssembly.GetModules());
CreateTypes(_currentAssembly.GetTypes());
var entryPoint = GetMethodDefinitionHandle(_currentAssembly.EntryPoint);
var metadataRootBuilder = new MetadataRootBuilder(_metadataBuilder);
// Without Characteristics.ExecutableImage flag, .NET runtime refuses
// to load an assembly even it's a DLL. PEHeaderBuilder.CreateLibraryHeader
// does not set this flag. So, we set it explicitly.
var header = new PEHeaderBuilder(imageCharacteristics: Characteristics.ExecutableImage |
(entryPoint.IsNil ? Characteristics.Dll : 0));
var peBuilder = new ManagedPEBuilder(
header,
metadataRootBuilder,
_ilBuilder,
debugDirectoryBuilder: _debugDirectoryBuilder,
entryPoint: entryPoint);
var peImageBuilder = new BlobBuilder();
peBuilder.Serialize(peImageBuilder);
return(peImageBuilder.ToArray());
}
public void SignatureTypeEncoder_PrimitiveType()
{
var b = new BlobBuilder();
var e = new SignatureTypeEncoder(b);
Assert.Same(b, e.Builder);
e.PrimitiveType(PrimitiveTypeCode.Boolean);
AssertEx.Equal(new byte[] { 0x02 }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveTypeCode.Char);
AssertEx.Equal(new byte[] { 0x03 }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveTypeCode.SByte);
AssertEx.Equal(new byte[] { 0x04 }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveTypeCode.Byte);
AssertEx.Equal(new byte[] { 0x05 }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveTypeCode.Int16);
AssertEx.Equal(new byte[] { 0x06 }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveTypeCode.UInt16);
AssertEx.Equal(new byte[] { 0x07 }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveTypeCode.Int32);
AssertEx.Equal(new byte[] { 0x08 }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveTypeCode.UInt32);
AssertEx.Equal(new byte[] { 0x09 }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveTypeCode.Int64);
AssertEx.Equal(new byte[] { 0x0A }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveTypeCode.UInt64);
AssertEx.Equal(new byte[] { 0x0B }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveTypeCode.Single);
AssertEx.Equal(new byte[] { 0x0C }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveTypeCode.Double);
AssertEx.Equal(new byte[] { 0x0D }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveTypeCode.String);
AssertEx.Equal(new byte[] { 0x0E }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveTypeCode.IntPtr);
AssertEx.Equal(new byte[] { 0x18 }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveTypeCode.UIntPtr);
AssertEx.Equal(new byte[] { 0x19 }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveTypeCode.Object);
AssertEx.Equal(new byte[] { 0x1C }, b.ToArray());
b.Clear();
Assert.Throws <ArgumentOutOfRangeException>(() => e.PrimitiveType(PrimitiveTypeCode.Void));
Assert.Throws <ArgumentOutOfRangeException>(() => e.PrimitiveType(PrimitiveTypeCode.TypedReference));
Assert.Throws <ArgumentOutOfRangeException>(() => e.PrimitiveType((PrimitiveTypeCode)255));
}
public void AddFinallyFaultFilterRegions()
{
var code = new BlobBuilder();
var flow = new ControlFlowBuilder();
var il = new InstructionEncoder(code, flow);
var l1 = il.DefineLabel();
var l2 = il.DefineLabel();
var l3 = il.DefineLabel();
var l4 = il.DefineLabel();
var l5 = il.DefineLabel();
il.MarkLabel(l1);
Assert.Equal(0, il.Offset);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l2);
Assert.Equal(1, il.Offset);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l3);
Assert.Equal(3, il.Offset);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l4);
Assert.Equal(6, il.Offset);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l5);
Assert.Equal(10, il.Offset);
flow.AddFaultRegion(l1, l2, l3, l4);
flow.AddFinallyRegion(l1, l2, l3, l4);
flow.AddFilterRegion(l1, l2, l3, l4, l5);
var builder = new BlobBuilder();
builder.WriteByte(0xff);
flow.SerializeExceptionTable(builder);
AssertEx.Equal(new byte[]
{
0xFF, 0x00, 0x00, 0x00, // padding
0x01, // flag
(byte)(builder.Count - 4), // size
0x00, 0x00, // reserved
0x04, 0x00, // kind
0x00, 0x00, // try offset
0x01, // try length
0x03, 0x00, // handler offset
0x03, // handler length
0x00, 0x00, 0x00, 0x00, // catch type or filter offset
0x02, 0x00, // kind
0x00, 0x00, // try offset
0x01, // try length
0x03, 0x00, // handler offset
0x03, // handler length
0x00, 0x00, 0x00, 0x00, // catch type or filter offset
0x01, 0x00, // kind
0x00, 0x00, // try offset
0x01, // try length
0x03, 0x00, // handler offset
0x03, // handler length
0x0A, 0x00, 0x00, 0x00 // catch type or filter offset
}, builder.ToArray());
}
public void ArrayShapeEncoder_Shape()
{
var b = new BlobBuilder();
var e = new ArrayShapeEncoder(b);
Assert.Same(b, e.Builder);
e.Shape(ushort.MaxValue, ImmutableArray <int> .Empty, ImmutableArray <int> .Empty);
AssertEx.Equal(new byte[]
{
0xC0, 0x00, 0xFF, 0xFF,
0x00,
0x00
}, b.ToArray());
b.Clear();
e.Shape(3, ImmutableArray.Create(0x0A), ImmutableArray <int> .Empty);
AssertEx.Equal(new byte[]
{
0x03,
0x01, 0x0A,
0x00
}, b.ToArray());
b.Clear();
e.Shape(3, ImmutableArray.Create(0x0A, 0x0B), ImmutableArray.Create(0x02, 0x03));
AssertEx.Equal(new byte[]
{
0x03,
0x02, 0x0A, 0x0B,
0x02, 0x04, 0x06
}, b.ToArray());
b.Clear();
e.Shape(3, ImmutableArray <int> .Empty, ImmutableArray.Create(-2, -1));
AssertEx.Equal(new byte[]
{
0x03,
0x00,
0x02, 0x7D, 0x7F
}, b.ToArray());
b.Clear();
e.Shape(3, ImmutableArray.Create(BlobWriterImpl.MaxCompressedIntegerValue), ImmutableArray.Create(BlobWriterImpl.MinSignedCompressedIntegerValue, BlobWriterImpl.MaxSignedCompressedIntegerValue));
AssertEx.Equal(new byte[]
{
0x03,
0x01, 0xDF, 0xFF, 0xFF, 0xFF,
0x02, 0xC0, 0x00, 0x00, 0x01, 0xDF, 0xFF, 0xFF, 0xFE
}, b.ToArray());
b.Clear();
Assert.Throws <ArgumentNullException>(() => e.Shape(1, default(ImmutableArray <int>), ImmutableArray <int> .Empty));
Assert.Throws <ArgumentOutOfRangeException>(() => e.Shape(0, ImmutableArray <int> .Empty, ImmutableArray <int> .Empty));
Assert.Throws <ArgumentOutOfRangeException>(() => e.Shape(-1, ImmutableArray <int> .Empty, ImmutableArray <int> .Empty));
Assert.Throws <ArgumentOutOfRangeException>(() => e.Shape(ushort.MaxValue + 1, ImmutableArray <int> .Empty, ImmutableArray <int> .Empty));
Assert.Throws <ArgumentOutOfRangeException>(() => e.Shape(1, ImmutableArray.Create(1, 2, 3), ImmutableArray <int> .Empty));
Assert.Throws <ArgumentOutOfRangeException>(() => e.Shape(1, ImmutableArray <int> .Empty, ImmutableArray.Create(1, 2, 3)));
Assert.Throws <ArgumentOutOfRangeException>(() => e.Shape(1, ImmutableArray.Create(-1), ImmutableArray <int> .Empty));
Assert.Throws <ArgumentOutOfRangeException>(() => e.Shape(1, ImmutableArray.Create(BlobWriterImpl.MaxCompressedIntegerValue + 1), ImmutableArray <int> .Empty));
Assert.Throws <ArgumentOutOfRangeException>(() => e.Shape(1, ImmutableArray <int> .Empty, ImmutableArray.Create(BlobWriterImpl.MinSignedCompressedIntegerValue - 1)));
Assert.Throws <ArgumentOutOfRangeException>(() => e.Shape(1, ImmutableArray <int> .Empty, ImmutableArray.Create(BlobWriterImpl.MaxSignedCompressedIntegerValue + 1)));
}
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 AddMethodBody_Reserved_Tiny_Empty()
{
var streamBuilder = new BlobBuilder();
var encoder = new MethodBodyStreamEncoder(streamBuilder);
var body = encoder.AddMethodBody(0);
Assert.Equal(0, body.Offset);
var segment = body.Instructions.GetBytes();
Assert.Equal(1, segment.Offset); // +1 byte for the header
Assert.Equal(0, segment.Count);
Assert.Null(body.ExceptionRegions.Builder);
AssertEx.Equal(new byte[]
{
0x02
}, streamBuilder.ToArray());
}
public void Headers()
{
var mdBuilder = new MetadataBuilder();
var pdbBuilder = new PortablePdbBuilder(
mdBuilder,
MetadataRootBuilder.EmptyRowCounts,
MetadataTokens.MethodDefinitionHandle(0x123456),
_ => new BlobContentId(new Guid("44332211-6655-8877-AA99-010203040506"), 0xFFEEDDCC));
var builder = new BlobBuilder();
pdbBuilder.Serialize(builder);
AssertEx.Equal(new byte[]
{
// signature:
0x42, 0x53, 0x4A, 0x42,
// major version (1)
0x01, 0x00,
// minor version (1)
0x01, 0x00,
// reserved (0)
0x00, 0x00, 0x00, 0x00,
// padded version length:
0x0C, 0x00, 0x00, 0x00,
// padded version:
(byte)'P', (byte)'D', (byte)'B', (byte)' ', (byte)'v', (byte)'1', (byte)'.', (byte)'0', 0x00, 0x00, 0x00, 0x00,
// flags (0):
0x00, 0x00,
// stream count:
0x06, 0x00,
// stream headers (offset, size, padded name)
0x7C, 0x00, 0x00, 0x00,
0x20, 0x00, 0x00, 0x00,
(byte)'#', (byte)'P', (byte)'d', (byte)'b', 0x00, 0x00, 0x00, 0x00,
0x9C, 0x00, 0x00, 0x00,
0x1C, 0x00, 0x00, 0x00,
(byte)'#', (byte)'~', 0x00, 0x00,
0xB8, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00,
(byte)'#', (byte)'S', (byte)'t', (byte)'r', (byte)'i', (byte)'n', (byte)'g', (byte)'s', 0x00, 0x00, 0x00, 0x00,
0xBC, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00,
(byte)'#', (byte)'U', (byte)'S', 0x00,
0xC0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
(byte)'#', (byte)'G', (byte)'U', (byte)'I', (byte)'D', 0x00, 0x00, 0x00,
0xC0, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00,
(byte)'#', (byte)'B', (byte)'l', (byte)'o', (byte)'b', 0x00, 0x00, 0x00,
// --------
// #Pdb
// --------
// PDB ID
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0xAA, 0x99, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
0xCC, 0xDD, 0xEE, 0xFF,
// EntryPoint
0x56, 0x34, 0x12, 0x06,
// ReferencedTypeSystemTables
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// TypeSystemTableRows (empty)
// --------
// #~
// --------
// Reserved (0)
0x00, 0x00, 0x00, 0x00,
// Major Version (2)
0x02,
// Minor Version (0)
0x00,
// Heap Sizes
0x00,
// Reserved (1)
0x01,
// Present tables
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// Sorted tables
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// Rows (empty)
// Tables (empty)
// Padding and alignment
0x00, 0x00, 0x00, 0x00,
// --------
// #Strings
// --------
0x00, 0x00, 0x00, 0x00,
// --------
// #US
// --------
0x00, 0x00, 0x00, 0x00,
// --------
// #GUID
// --------
// --------
// #Blob
// --------
0x00, 0x00, 0x00, 0x00,
}, builder.ToArray());
}
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());
}
public unsafe void TinyBody()
{
var streamBuilder = new BlobBuilder();
var codeBuilder = new BlobBuilder();
var flowBuilder = new ControlFlowBuilder();
var il = new InstructionEncoder(codeBuilder, flowBuilder);
codeBuilder.WriteBytes(1, 61);
var l1 = il.DefineLabel();
il.MarkLabel(l1);
Assert.Equal(61, flowBuilder.Labels.Single());
il.Branch(ILOpCode.Br_s, l1);
var brInfo = flowBuilder.Branches.Single();
Assert.Equal(61, brInfo.ILOffset);
Assert.Equal(l1, brInfo.Label);
Assert.Equal(ILOpCode.Br_s, brInfo.OpCode);
AssertEx.Equal(new byte[] { 1, (byte)ILOpCode.Br_s, unchecked ((byte)-1) }, codeBuilder.ToArray(60, 3));
var streamEncoder = new MethodBodyStreamEncoder(streamBuilder);
int bodyOffset = streamEncoder.AddMethodBody(
il,
maxStack: 2,
localVariablesSignature: default,
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_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 void ToArray2()
{
var builder = new BlobBuilder(16);
AssertEx.Equal(new byte[] { }, builder.ToArray(0, 0));
for (int i = 0; i < 34; i++)
{
builder.WriteByte((byte)i);
}
AssertEx.Equal(new byte[]
{
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
0x20, 0x21
}, builder.ToArray());
AssertEx.Equal(new byte[]
{
0x0E, 0x0F,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
0x20, 0x21
}, builder.ToArray(0x0e, 20));
AssertEx.Equal(new byte[] { 0x0E }, builder.ToArray(0x0e, 1));
AssertEx.Equal(new byte[] { 0x0E, 0x0F }, builder.ToArray(0x0e, 2));
AssertEx.Equal(new byte[] { 0x0E, 0x0F, 0x10 }, builder.ToArray(0x0e, 3));
AssertEx.Equal(new byte[] { 0x0E, 0x0F, 0x10, 0x11 }, builder.ToArray(0x0e, 4));
AssertEx.Equal(new byte[] { 0x1E }, builder.ToArray(0x1e, 1));
AssertEx.Equal(new byte[] { 0x1E, 0x1F }, builder.ToArray(0x1e, 2));
AssertEx.Equal(new byte[] { 0x1E, 0x1F, 0x20 }, builder.ToArray(0x1e, 3));
AssertEx.Equal(new byte[] { 0x1E, 0x1F, 0x20, 0x21 }, builder.ToArray(0x1e, 4));
}
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 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 void Branches1()
{
var flowBuilder = new ControlFlowBuilder();
var l0 = flowBuilder.AddLabel();
var l64 = flowBuilder.AddLabel();
var l255 = flowBuilder.AddLabel();
flowBuilder.MarkLabel(0, l0);
flowBuilder.MarkLabel(64, l64);
flowBuilder.MarkLabel(255, l255);
flowBuilder.AddBranch(0, l255, ILOpCode.Bge);
flowBuilder.AddBranch(16, l0, ILOpCode.Bge_un_s); // blob boundary
flowBuilder.AddBranch(33, l255, ILOpCode.Ble); // blob boundary
flowBuilder.AddBranch(38, l0, ILOpCode.Ble_un_s); // branches immediately next to each other
flowBuilder.AddBranch(40, l255, ILOpCode.Blt); // branches immediately next to each other
flowBuilder.AddBranch(46, l64, ILOpCode.Blt_un_s);
flowBuilder.AddBranch(254, l0, ILOpCode.Brfalse); // long branch at the end
var dstBuilder = new BlobBuilder();
var srcBuilder = new BlobBuilder(capacity: 17);
WriteFakeILWithBranches(srcBuilder, flowBuilder, size: 259);
flowBuilder.CopyCodeAndFixupBranches(srcBuilder, dstBuilder);
AssertEx.Equal(new byte[]
{
(byte)ILOpCode.Bge, 0xFA, 0x00, 0x00, 0x00,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
(byte)ILOpCode.Bge_un_s, 0xEE,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
(byte)ILOpCode.Ble, 0xD9, 0x00, 0x00, 0x00,
(byte)ILOpCode.Ble_un_s, 0xD8,
(byte)ILOpCode.Blt, 0xD2, 0x00, 0x00, 0x00,
0x01,
(byte)ILOpCode.Blt_un_s, 0x10,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
(byte)ILOpCode.Brfalse, 0xFD, 0xFE, 0xFF, 0xFF,
}, dstBuilder.ToArray());
}
public void LinkPrefix1()
{
var builder1 = new BlobBuilder(16);
builder1.WriteByte(1);
builder1.WriteByte(2);
builder1.WriteByte(3);
var builder2 = new BlobBuilder(16);
builder2.WriteByte(4);
builder1.LinkPrefix(builder2);
AssertEx.Equal(new byte[] { 4, 1, 2, 3 }, builder1.ToArray());
Assert.Equal(4, builder1.Count);
Assert.Equal(1, builder2.Count);
}
public void AddMethodBody_Reserved_Tiny_AttributesIgnored()
{
var streamBuilder = new BlobBuilder();
var encoder = new MethodBodyStreamEncoder(streamBuilder);
var body = encoder.AddMethodBody(10, attributes: MethodBodyAttributes.None);
new BlobWriter(body.Instructions).WriteBytes(0x02, 10);
AssertEx.Equal(new byte[]
{
0x2A, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02
}, streamBuilder.ToArray());
}
public void CustomAttributeElementTypeEncoder_PrimitiveType()
{
var b = new BlobBuilder();
var e = new CustomAttributeElementTypeEncoder(b);
Assert.Same(b, e.Builder);
e.PrimitiveType(PrimitiveSerializationTypeCode.Boolean);
AssertEx.Equal(new byte[] { 0x02 }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveSerializationTypeCode.Char);
AssertEx.Equal(new byte[] { 0x03 }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveSerializationTypeCode.SByte);
AssertEx.Equal(new byte[] { 0x04 }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveSerializationTypeCode.Byte);
AssertEx.Equal(new byte[] { 0x05 }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveSerializationTypeCode.Int16);
AssertEx.Equal(new byte[] { 0x06 }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveSerializationTypeCode.UInt16);
AssertEx.Equal(new byte[] { 0x07 }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveSerializationTypeCode.Int32);
AssertEx.Equal(new byte[] { 0x08 }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveSerializationTypeCode.UInt32);
AssertEx.Equal(new byte[] { 0x09 }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveSerializationTypeCode.Int64);
AssertEx.Equal(new byte[] { 0x0A }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveSerializationTypeCode.UInt64);
AssertEx.Equal(new byte[] { 0x0B }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveSerializationTypeCode.Single);
AssertEx.Equal(new byte[] { 0x0C }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveSerializationTypeCode.Double);
AssertEx.Equal(new byte[] { 0x0D }, b.ToArray());
b.Clear();
e.PrimitiveType(PrimitiveSerializationTypeCode.String);
AssertEx.Equal(new byte[] { 0x0E }, b.ToArray());
b.Clear();
Assert.Throws <ArgumentOutOfRangeException>(() => e.PrimitiveType((PrimitiveSerializationTypeCode)255));
}
public void Heaps_StartOffsets()
{
var mdBuilder = new MetadataBuilder(
userStringHeapStartOffset: 0x10,
stringHeapStartOffset: 0x20,
blobHeapStartOffset: 0x30,
guidHeapStartOffset: 0x40);
var g = mdBuilder.GetOrAddGuid(new Guid("D39F3559-476A-4D1E-B6D2-88E66395230B"));
Assert.Equal(5, g.Index);
var s0 = mdBuilder.GetOrAddString("");
Assert.False(s0.IsVirtual);
Assert.Equal(0, s0.GetWriterVirtualIndex());
var s1 = mdBuilder.GetOrAddString("foo");
Assert.True(s1.IsVirtual);
Assert.Equal(1, s1.GetWriterVirtualIndex());
var us0 = mdBuilder.GetOrAddUserString("");
Assert.Equal(0x11, us0.GetHeapOffset());
var us1 = mdBuilder.GetOrAddUserString("bar");
Assert.Equal(0x13, us1.GetHeapOffset());
var b0 = mdBuilder.GetOrAddBlob(new byte[0]);
Assert.Equal(0, b0.GetHeapOffset());
var b1 = mdBuilder.GetOrAddBlob(new byte[] { 1, 2 });
Assert.Equal(0x31, b1.GetHeapOffset());
mdBuilder.CompleteHeaps();
Assert.Equal(5, mdBuilder.SerializeHandle(g));
Assert.Equal(0, mdBuilder.SerializeHandle(s0));
Assert.Equal(0x21, mdBuilder.SerializeHandle(s1));
Assert.Equal(0x11, mdBuilder.SerializeHandle(us0));
Assert.Equal(0x13, mdBuilder.SerializeHandle(us1));
Assert.Equal(0, mdBuilder.SerializeHandle(b0));
Assert.Equal(0x31, mdBuilder.SerializeHandle(b1));
var heaps = new BlobBuilder();
mdBuilder.WriteHeapsTo(heaps);
AssertEx.Equal(new byte[]
{
// #String
0x00,
0x66, 0x6F, 0x6F, 0x00,
0x00, 0x00, 0x00,
// #US
0x00,
0x01, 0x00,
0x07, 0x62, 0x00, 0x61, 0x00, 0x72, 0x00, 0x00,
0x00,
// #Guid
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x59, 0x35, 0x9F, 0xD3, 0x6A, 0x47, 0x1E, 0x4D, 0xB6, 0xD2, 0x88, 0xE6, 0x63, 0x95, 0x23, 0x0B,
// #Blob
0x00, 0x02, 0x01, 0x02
}, heaps.ToArray());
Assert.Throws <ArgumentNullException>(() => mdBuilder.GetOrAddString(null));
}
public void SignatureTypeEncoder_Primitives()
{
var b = new BlobBuilder();
var e = new SignatureTypeEncoder(b);
Assert.Same(b, e.Builder);
e.Boolean();
AssertEx.Equal(new byte[] { 0x02 }, b.ToArray());
b.Clear();
e.Char();
AssertEx.Equal(new byte[] { 0x03 }, b.ToArray());
b.Clear();
e.SByte();
AssertEx.Equal(new byte[] { 0x04 }, b.ToArray());
b.Clear();
e.Byte();
AssertEx.Equal(new byte[] { 0x05 }, b.ToArray());
b.Clear();
e.Int16();
AssertEx.Equal(new byte[] { 0x06 }, b.ToArray());
b.Clear();
e.UInt16();
AssertEx.Equal(new byte[] { 0x07 }, b.ToArray());
b.Clear();
e.Int32();
AssertEx.Equal(new byte[] { 0x08 }, b.ToArray());
b.Clear();
e.UInt32();
AssertEx.Equal(new byte[] { 0x09 }, b.ToArray());
b.Clear();
e.Int64();
AssertEx.Equal(new byte[] { 0x0A }, b.ToArray());
b.Clear();
e.UInt64();
AssertEx.Equal(new byte[] { 0x0B }, b.ToArray());
b.Clear();
e.Single();
AssertEx.Equal(new byte[] { 0x0C }, b.ToArray());
b.Clear();
e.Double();
AssertEx.Equal(new byte[] { 0x0D }, b.ToArray());
b.Clear();
e.String();
AssertEx.Equal(new byte[] { 0x0E }, b.ToArray());
b.Clear();
e.IntPtr();
AssertEx.Equal(new byte[] { 0x18 }, b.ToArray());
b.Clear();
e.UIntPtr();
AssertEx.Equal(new byte[] { 0x19 }, b.ToArray());
b.Clear();
e.Object();
AssertEx.Equal(new byte[] { 0x1C }, b.ToArray());
b.Clear();
}
public void AddCatchRegions()
{
var code = new BlobBuilder();
var flow = new ControlFlowBuilder();
var il = new InstructionEncoder(code, flow);
var l1 = il.DefineLabel();
var l2 = il.DefineLabel();
var l3 = il.DefineLabel();
var l4 = il.DefineLabel();
var l5 = il.DefineLabel();
il.MarkLabel(l1);
Assert.Equal(0, il.Offset);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l2);
Assert.Equal(1, il.Offset);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l3);
Assert.Equal(3, il.Offset);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l4);
Assert.Equal(6, il.Offset);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.OpCode(ILOpCode.Nop);
il.MarkLabel(l5);
Assert.Equal(10, il.Offset);
flow.AddCatchRegion(l1, l2, l3, l4, MetadataTokens.TypeDefinitionHandle(1));
flow.AddCatchRegion(l1, l2, l3, l4, MetadataTokens.TypeSpecificationHandle(2));
flow.AddCatchRegion(l1, l2, l3, l4, MetadataTokens.TypeReferenceHandle(3));
var builder = new BlobBuilder();
flow.SerializeExceptionTable(builder);
AssertEx.Equal(new byte[]
{
0x01, // flag
(byte)builder.Count, // size
0x00, 0x00, // reserved
0x00, 0x00, // kind
0x00, 0x00, // try offset
0x01, // try length
0x03, 0x00, // handler offset
0x03, // handler length
0x01, 0x00, 0x00, 0x02, // catch type or filter offset
0x00, 0x00, // kind
0x00, 0x00, // try offset
0x01, // try length
0x03, 0x00, // handler offset
0x03, // handler length
0x02, 0x00, 0x00, 0x1B, // catch type or filter offset
0x00, 0x00, // kind
0x00, 0x00, // try offset
0x01, // try length
0x03, 0x00, // handler offset
0x03, // handler length
0x03, 0x00, 0x00, 0x01, // catch type or filter offset
}, builder.ToArray());
}
public void LinkSuffix_Empty3()
{
var builder1 = new BlobBuilder(16);
builder1.ReserveBytes(16);
builder1.ReserveBytes(0);
var builder2 = new BlobBuilder(16);
builder2.ReserveBytes(16);
builder2.ReserveBytes(0);
builder1.LinkSuffix(builder2);
AssertEx.Equal(new byte[]
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}, builder1.ToArray());
Assert.Equal(32, builder1.Count);
Assert.Equal(16, builder2.Count);
}
public void Branches1()
{
var branchBuilder = new BranchBuilder();
var l0 = branchBuilder.AddLabel();
var l64 = branchBuilder.AddLabel();
var l255 = branchBuilder.AddLabel();
branchBuilder.MarkLabel(0, l0);
branchBuilder.MarkLabel(64, l64);
branchBuilder.MarkLabel(255, l255);
branchBuilder.AddBranch(0, l255, (byte)ILOpCode.Bge_s);
branchBuilder.AddBranch(16, l0, (byte)ILOpCode.Bge_un_s); // blob boundary
branchBuilder.AddBranch(33, l255, (byte)ILOpCode.Ble_s); // blob boundary
branchBuilder.AddBranch(35, l0, (byte)ILOpCode.Ble_un_s); // branches immediately next to each other
branchBuilder.AddBranch(37, l255, (byte)ILOpCode.Blt_s); // branches immediately next to each other
branchBuilder.AddBranch(40, l64, (byte)ILOpCode.Blt_un_s);
branchBuilder.AddBranch(254, l0, (byte)ILOpCode.Brfalse_s); // long branch at the end
var dstBuilder = new BlobBuilder();
var srcBuilder = new BlobBuilder(size: 17);
WriteFakeILWithBranches(srcBuilder, branchBuilder, size: 256);
branchBuilder.FixupBranches(srcBuilder, dstBuilder);
AssertEx.Equal(new byte[]
{
(byte)ILOpCode.Bge, 0xFA, 0x00, 0x00, 0x00,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
(byte)ILOpCode.Bge_un_s, 0xEE,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
(byte)ILOpCode.Ble, 0xD9, 0x00, 0x00, 0x00,
(byte)ILOpCode.Ble_un_s, 0xDB,
(byte)ILOpCode.Blt, 0xD5, 0x00, 0x00, 0x00,
0x01,
(byte)ILOpCode.Blt_un_s, 0x16,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01,
(byte)ILOpCode.Brfalse, 0xFD, 0xFE, 0xFF, 0xFF,
}, dstBuilder.ToArray());
}
private static void TestCompressedSignedInteger(byte[] expected, int value)
{
var writer = new BlobWriter(4);
writer.WriteCompressedSignedInteger(value);
AssertEx.Equal(expected, writer.ToArray());
var builder = new BlobBuilder();
builder.WriteCompressedSignedInteger(value);
AssertEx.Equal(expected, builder.ToArray());
}
public void ReserveBytes1()
{
var builder = new BlobBuilder(16);
var writer0 = new BlobWriter(builder.ReserveBytes(0));
var writer1 = new BlobWriter(builder.ReserveBytes(1));
var writer2 = new BlobWriter(builder.ReserveBytes(2));
Assert.Equal(3, builder.Count);
AssertEx.Equal(new byte[] { 0, 0, 0 }, builder.ToArray());
Assert.Equal(0, writer0.Length);
Assert.Equal(0, writer0.RemainingBytes);
writer1.WriteBoolean(true);
Assert.Equal(1, writer1.Length);
Assert.Equal(0, writer1.RemainingBytes);
writer2.WriteByte(1);
Assert.Equal(2, writer2.Length);
Assert.Equal(1, writer2.RemainingBytes);
}
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 override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
if (relocsOnly)
{
return(new ObjectData(Array.Empty <byte>(), null, 1, null));
}
if (!_emissionCompleted)
{
foreach (ISignatureEmitter emitter in _signatureEmitters)
{
emitter.MaterializeSignature();
}
_emissionCompleted = true;
}
MetadataBuilder metadataBuilder = new MetadataBuilder();
string manifestMetadataAssemblyName = "ManifestMetadata";
metadataBuilder.AddAssembly(
metadataBuilder.GetOrAddString(manifestMetadataAssemblyName),
new Version(0, 0, 0, 0),
culture: default(StringHandle),
publicKey: default(BlobHandle),
flags: default(AssemblyFlags),
hashAlgorithm: AssemblyHashAlgorithm.None);
metadataBuilder.AddModule(
0,
metadataBuilder.GetOrAddString(manifestMetadataAssemblyName),
default(GuidHandle), default(GuidHandle), default(GuidHandle));
// Module type
metadataBuilder.AddTypeDefinition(
default(TypeAttributes),
default(StringHandle),
metadataBuilder.GetOrAddString("<Module>"),
baseType: default(EntityHandle),
fieldList: MetadataTokens.FieldDefinitionHandle(1),
methodList: MetadataTokens.MethodDefinitionHandle(1));
foreach (var idAndAssemblyName in _moduleIdToAssemblyNameMap.OrderBy(x => x.Key))
{
AssemblyName assemblyName = idAndAssemblyName.Value;
AssemblyFlags assemblyFlags = 0;
byte[] publicKeyOrToken;
if ((assemblyName.Flags & AssemblyNameFlags.PublicKey) != 0)
{
assemblyFlags |= AssemblyFlags.PublicKey;
publicKeyOrToken = assemblyName.GetPublicKey();
}
else
{
publicKeyOrToken = assemblyName.GetPublicKeyToken();
}
if ((assemblyName.Flags & AssemblyNameFlags.Retargetable) != 0)
{
assemblyFlags |= AssemblyFlags.Retargetable;
}
AssemblyReferenceHandle newHandle = metadataBuilder.AddAssemblyReference(
name: metadataBuilder.GetOrAddString(assemblyName.Name),
version: assemblyName.Version,
culture: metadataBuilder.GetOrAddString(assemblyName.CultureName),
publicKeyOrToken: metadataBuilder.GetOrAddBlob(publicKeyOrToken),
flags: assemblyFlags,
hashValue: default(BlobHandle) /* TODO */);
}
MetadataRootBuilder metadataRootBuilder = new MetadataRootBuilder(metadataBuilder);
BlobBuilder metadataBlobBuilder = new BlobBuilder();
metadataRootBuilder.Serialize(metadataBlobBuilder, methodBodyStreamRva: 0, mappedFieldDataStreamRva: 0);
return(new ObjectData(
data: metadataBlobBuilder.ToArray(),
relocs: Array.Empty <Relocation>(),
alignment: 1,
definedSymbols: new ISymbolDefinitionNode[] { this }));
}
public void ScalarEncoder_Constant()
{
var b = new BlobBuilder();
var e = new ScalarEncoder(b);
Assert.Same(b, e.Builder);
e.Constant(null);
AssertEx.Equal(new byte[] { 0xff }, b.ToArray());
b.Clear();
e.Constant("");
AssertEx.Equal(new byte[] { 0x00 }, b.ToArray());
b.Clear();
e.Constant("abc");
AssertEx.Equal(new byte[] { 0x03, 0x61, 0x62, 0x63 }, b.ToArray());
b.Clear();
e.Constant("\ud800"); // unpaired surrogate
AssertEx.Equal(new byte[] { 0x03, 0xED, 0xA0, 0x80 }, b.ToArray());
b.Clear();
e.Constant(true);
AssertEx.Equal(new byte[] { 0x01 }, b.ToArray());
b.Clear();
e.Constant(HandleKind.UserString);
AssertEx.Equal(new byte[] { 0x70 }, b.ToArray());
b.Clear();
e.Constant((byte)0xAB);
AssertEx.Equal(new byte[] { 0xAB }, b.ToArray());
b.Clear();
e.Constant((sbyte)0x12);
AssertEx.Equal(new byte[] { 0x12 }, b.ToArray());
b.Clear();
e.Constant((ushort)0xABCD);
AssertEx.Equal(new byte[] { 0xCD, 0xAB }, b.ToArray());
b.Clear();
e.Constant((short)0x1234);
AssertEx.Equal(new byte[] { 0x34, 0x12 }, b.ToArray());
b.Clear();
e.Constant((char)0xABCD);
AssertEx.Equal(new byte[] { 0xCD, 0xAB }, b.ToArray());
b.Clear();
e.Constant(0xABCD);
AssertEx.Equal(new byte[] { 0xCD, 0xAB, 0x00, 0x00 }, b.ToArray());
b.Clear();
e.Constant((uint)0xABCD);
AssertEx.Equal(new byte[] { 0xCD, 0xAB, 0x00, 0x00 }, b.ToArray());
b.Clear();
e.Constant(0x1122334455667788);
AssertEx.Equal(new byte[] { 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11 }, b.ToArray());
b.Clear();
e.Constant(0xAABBCCDDEEFF1122);
AssertEx.Equal(new byte[] { 0x22, 0x11, 0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA }, b.ToArray());
b.Clear();
e.Constant(0.1f);
AssertEx.Equal(new byte[] { 0xCD, 0xCC, 0xCC, 0x3D }, b.ToArray());
b.Clear();
e.Constant(0.1);
AssertEx.Equal(new byte[] { 0x9A, 0x99, 0x99, 0x99, 0x99, 0x99, 0xB9, 0x3F }, b.ToArray());
b.Clear();
}
public void CountClear()
{
var builder = new BlobBuilder();
Assert.Equal(0, builder.Count);
builder.WriteByte(1);
Assert.Equal(1, builder.Count);
builder.WriteInt32(4);
Assert.Equal(5, builder.Count);
builder.Clear();
Assert.Equal(0, builder.Count);
builder.WriteInt64(1);
Assert.Equal(8, builder.Count);
AssertEx.Equal(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, builder.ToArray());
}
public void CustomAttributeElementTypeEncoder_Primitives()
{
var b = new BlobBuilder();
var e = new CustomAttributeElementTypeEncoder(b);
Assert.Same(b, e.Builder);
e.Boolean();
AssertEx.Equal(new byte[] { 0x02 }, b.ToArray());
b.Clear();
e.Char();
AssertEx.Equal(new byte[] { 0x03 }, b.ToArray());
b.Clear();
e.SByte();
AssertEx.Equal(new byte[] { 0x04 }, b.ToArray());
b.Clear();
e.Byte();
AssertEx.Equal(new byte[] { 0x05 }, b.ToArray());
b.Clear();
e.Int16();
AssertEx.Equal(new byte[] { 0x06 }, b.ToArray());
b.Clear();
e.UInt16();
AssertEx.Equal(new byte[] { 0x07 }, b.ToArray());
b.Clear();
e.Int32();
AssertEx.Equal(new byte[] { 0x08 }, b.ToArray());
b.Clear();
e.UInt32();
AssertEx.Equal(new byte[] { 0x09 }, b.ToArray());
b.Clear();
e.Int64();
AssertEx.Equal(new byte[] { 0x0A }, b.ToArray());
b.Clear();
e.UInt64();
AssertEx.Equal(new byte[] { 0x0B }, b.ToArray());
b.Clear();
e.Single();
AssertEx.Equal(new byte[] { 0x0C }, b.ToArray());
b.Clear();
e.Double();
AssertEx.Equal(new byte[] { 0x0D }, b.ToArray());
b.Clear();
e.String();
AssertEx.Equal(new byte[] { 0x0E }, b.ToArray());
b.Clear();
}
