private static void WritePEImage(
Stream peStream,
MetadataBuilder metadataBuilder,
BlobBuilder ilBuilder,
MethodDefinitionHandle entryPointHandle,
Blob mvidFixup = default(Blob),
byte[] privateKeyOpt = null)
{
var peBuilder = new ManagedPEBuilder(
entryPointHandle.IsNil ? PEHeaderBuilder.CreateLibraryHeader() : PEHeaderBuilder.CreateExecutableHeader(),
new MetadataRootBuilder(metadataBuilder),
ilBuilder,
entryPoint: entryPointHandle,
flags: CorFlags.ILOnly | (privateKeyOpt != null ? CorFlags.StrongNameSigned : 0),
deterministicIdProvider: content => s_contentId);
var peBlob = new BlobBuilder();
var contentId = peBuilder.Serialize(peBlob);
if (!mvidFixup.IsDefault)
{
new BlobWriter(mvidFixup).WriteGuid(contentId.Guid);
}
if (privateKeyOpt != null)
{
peBuilder.Sign(peBlob, content => SigningUtilities.CalculateRsaSignature(content, privateKeyOpt));
}
peBlob.WriteContentTo(peStream);
}
public void Baseline()
{
var mdBuilder = new MetadataBuilder();
mdBuilder.AddModule(0, default(StringHandle), default(GuidHandle), default(GuidHandle), default(GuidHandle));
var rootBuilder = new MetadataRootBuilder(mdBuilder);
var mdBlob = new BlobBuilder();
rootBuilder.Serialize(mdBlob, 0, 0);
// validate sizes table rows that reference guids:
using (var mdProvider = MetadataReaderProvider.FromMetadataImage(mdBlob.ToImmutableArray()))
{
var mdReader = mdProvider.GetMetadataReader();
Assert.Equal(2 + 3 * 2 + 2, mdReader.ModuleTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.TypeRefTable.RowSize);
Assert.Equal(4 + 2 + 2 + 2 + 2 + 2, mdReader.TypeDefTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.FieldTable.RowSize);
Assert.Equal(8 + 2 + 2 + 2, mdReader.MethodDefTable.RowSize);
Assert.Equal(4 + 2, mdReader.ParamTable.RowSize);
Assert.Equal(2 + 2, mdReader.InterfaceImplTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.MemberRefTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.ConstantTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.CustomAttributeTable.RowSize);
Assert.Equal(2 + 2, mdReader.FieldMarshalTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.DeclSecurityTable.RowSize);
Assert.Equal(6 + 2, mdReader.ClassLayoutTable.RowSize);
Assert.Equal(4 + 2, mdReader.FieldLayoutTable.RowSize);
Assert.Equal(2, mdReader.StandAloneSigTable.RowSize);
Assert.Equal(2 + 2, mdReader.EventMapTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.EventTable.RowSize);
Assert.Equal(2 + 2, mdReader.PropertyMapTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.PropertyTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.MethodSemanticsTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.MethodImplTable.RowSize);
Assert.Equal(2, mdReader.ModuleRefTable.RowSize);
Assert.Equal(2, mdReader.TypeSpecTable.RowSize);
Assert.Equal(2 + 2 + 2 + 2, mdReader.ImplMapTable.RowSize);
Assert.Equal(4 + 2, mdReader.FieldRvaTable.RowSize);
Assert.Equal(16 + 2 + 2 + 2, mdReader.AssemblyTable.RowSize);
Assert.Equal(12 + 2 + 2 + 2 + 2, mdReader.AssemblyRefTable.RowSize);
Assert.Equal(4 + 2 + 2, mdReader.FileTable.RowSize);
Assert.Equal(8 + 2 + 2 + 2, mdReader.ExportedTypeTable.RowSize);
Assert.Equal(8 + 2 + 2, mdReader.ManifestResourceTable.RowSize);
Assert.Equal(2 + 2, mdReader.NestedClassTable.RowSize);
Assert.Equal(4 + 2 + 2, mdReader.GenericParamTable.RowSize);
Assert.Equal(2 + 2, mdReader.MethodSpecTable.RowSize);
Assert.Equal(2 + 2, mdReader.GenericParamConstraintTable.RowSize);
Assert.Equal(2 + 2 + 2 + 2, mdReader.DocumentTable.RowSize);
Assert.Equal(2 + 2, mdReader.MethodDebugInformationTable.RowSize);
Assert.Equal(2 + 2 + 2 + 2 + 4 + 4, mdReader.LocalScopeTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.LocalVariableTable.RowSize);
Assert.Equal(2 + 2, mdReader.LocalConstantTable.RowSize);
Assert.Equal(2 + 2, mdReader.ImportScopeTable.RowSize);
Assert.Equal(2 + 2, mdReader.StateMachineMethodTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.CustomDebugInformationTable.RowSize);
}
}
public TypeSystemMetadataSerializer(
MetadataBuilder tables,
string metadataVersion,
bool isMinimalDelta)
: base(tables, CreateSizes(tables, EmptyRowCounts, isMinimalDelta, isStandaloneDebugMetadata: false), metadataVersion)
{
}
public StandaloneDebugMetadataSerializer(
MetadataBuilder builder,
ImmutableArray<int> typeSystemRowCounts,
MethodDefinitionHandle entryPoint,
bool isMinimalDelta)
: base(builder, CreateSizes(builder, typeSystemRowCounts, isMinimalDelta, isStandaloneDebugMetadata: true), DebugMetadataVersionString)
{
_entryPoint = entryPoint;
}
private static BlobBuilder BuildMetadataImage()
{
var mdBuilder = new MetadataBuilder();
mdBuilder.AddModule(0, default(StringHandle), default(GuidHandle), default(GuidHandle), default(GuidHandle));
var rootBuilder = new MetadataRootBuilder(mdBuilder, "v9.9.9.9");
var builder = new BlobBuilder();
rootBuilder.Serialize(builder, 0, 0);
return builder;
}
public void BasicValidation()
{
using (var peStream = new MemoryStream())
{
var ilBuilder = new BlobBuilder();
var metadataBuilder = new MetadataBuilder();
var entryPoint = BasicValidationEmit(metadataBuilder, ilBuilder);
WritePEImage(peStream, metadataBuilder, ilBuilder, entryPoint);
peStream.Position = 0;
VerifyPE(peStream);
}
}
private static void WritePEImage(Stream peStream, MetadataBuilder metadataBuilder, BlobBuilder ilBuilder, MethodDefinitionHandle entryPointHandle)
{
var mappedFieldDataBuilder = new BlobBuilder();
var managedResourceDataBuilder = new BlobBuilder();
var peBuilder = new PEBuilder(
machine: 0,
sectionAlignment: 0x2000,
fileAlignment: 0x200,
imageBase: 0x00400000,
majorLinkerVersion: 0x30, // (what is ref.emit using?)
minorLinkerVersion: 0,
majorOperatingSystemVersion: 4,
minorOperatingSystemVersion: 0,
majorImageVersion: 0,
minorImageVersion: 0,
majorSubsystemVersion: 4,
minorSubsystemVersion: 0,
subsystem: Subsystem.WindowsCui,
dllCharacteristics: DllCharacteristics.DynamicBase | DllCharacteristics.NxCompatible | DllCharacteristics.NoSeh | DllCharacteristics.TerminalServerAware,
imageCharacteristics: entryPointHandle.IsNil ? Characteristics.Dll : Characteristics.ExecutableImage,
sizeOfStackReserve: 0x00100000,
sizeOfStackCommit: 0x1000,
sizeOfHeapReserve: 0x00100000,
sizeOfHeapCommit: 0x1000);
var peDirectoriesBuilder = new PEDirectoriesBuilder();
peBuilder.AddManagedSections(
peDirectoriesBuilder,
new TypeSystemMetadataSerializer(metadataBuilder, "v4.0.30319", isMinimalDelta: false),
ilBuilder,
mappedFieldDataBuilder,
managedResourceDataBuilder,
nativeResourceSectionSerializer: null,
strongNameSignatureSize: 0,
entryPoint: entryPointHandle,
pdbPathOpt: null,
nativePdbContentId: default(ContentId),
portablePdbContentId: default(ContentId),
corFlags: CorFlags.ILOnly);
var peBlob = new BlobBuilder();
ContentId peContentId;
peBuilder.Serialize(peBlob, peDirectoriesBuilder, out peContentId);
peBlob.WriteContentTo(peStream);
}
public static byte[] BuildPEWithDebugDirectory(DebugDirectoryBuilder debugDirectoryBuilder)
{
var peStream = new MemoryStream();
var ilBuilder = new BlobBuilder();
var metadataBuilder = new MetadataBuilder();
var peBuilder = new ManagedPEBuilder(
PEHeaderBuilder.CreateLibraryHeader(),
new MetadataRootBuilder(metadataBuilder),
ilBuilder,
debugDirectoryBuilder: debugDirectoryBuilder);
var peImageBuilder = new BlobBuilder();
peBuilder.Serialize(peImageBuilder);
return peImageBuilder.ToArray();
}
/// <summary>
/// Creates a builder of a metadata root.
/// </summary>
/// <param name="tablesAndHeaps">
/// Builder populated with metadata entities stored in tables and values stored in heaps.
/// The entities and values will be enumerated when serializing the metadata root.
/// </param>
/// <param name="metadataVersion">
/// The version string written to the metadata header. The default value is "v4.0.30319".
/// </param>
/// <exception cref="ArgumentNullException"><paramref name="tablesAndHeaps"/> is null.</exception>
/// <exception cref="ArgumentException"><paramref name="metadataVersion"/> is too long (the number of bytes when UTF8-encoded must be less than 255).</exception>
public MetadataRootBuilder(MetadataBuilder tablesAndHeaps, string metadataVersion = null)
{
if (tablesAndHeaps == null)
{
Throw.ArgumentNull(nameof(tablesAndHeaps));
}
Debug.Assert(BlobUtilities.GetUTF8ByteCount(DefaultMetadataVersionString) == DefaultMetadataVersionString.Length);
int metadataVersionByteCount = metadataVersion != null ? BlobUtilities.GetUTF8ByteCount(metadataVersion) : DefaultMetadataVersionString.Length;
if (metadataVersionByteCount > MetadataSizes.MaxMetadataVersionByteCount)
{
Throw.InvalidArgument(SR.MetadataVersionTooLong, nameof(metadataVersion));
}
_tablesAndHeaps = tablesAndHeaps;
MetadataVersion = metadataVersion ?? DefaultMetadataVersionString;
_serializedMetadata = tablesAndHeaps.GetSerializedMetadata(EmptyRowCounts, metadataVersionByteCount, isStandaloneDebugMetadata: false);
}
/// <summary>
/// Creates a builder of a Portable PDB image.
/// </summary>
/// <param name="tablesAndHeaps">
/// Builder populated with debug metadata entities stored in tables and values stored in heaps.
/// The entities and values will be enumerated when serializing the Portable PDB image.
/// </param>
/// <param name="typeSystemRowCounts">
/// Row counts of all tables that the associated type-system metadata contain.
/// Each slot in the array corresponds to a table (<see cref="TableIndex"/>).
/// The length of the array must be equal to <see cref="MetadataTokens.TableCount"/>.
/// </param>
/// <param name="entryPoint">
/// Entry point method definition handle.
/// </param>
/// <param name="idProvider">
/// Function calculating id of content represented as a sequence of blobs.
/// If not specified a default function that ignores the content and returns current time-based content id is used
/// (<see cref="BlobContentId.GetTimeBasedProvider()"/>).
/// You must specify a deterministic function to produce a deterministic Portable PDB image.
/// </param>
/// <exception cref="ArgumentNullException"><paramref name="tablesAndHeaps"/> or <paramref name="typeSystemRowCounts"/> is null.</exception>
public PortablePdbBuilder(
MetadataBuilder tablesAndHeaps,
ImmutableArray<int> typeSystemRowCounts,
MethodDefinitionHandle entryPoint,
Func<IEnumerable<Blob>, BlobContentId> idProvider = null)
{
if (tablesAndHeaps == null)
{
Throw.ArgumentNull(nameof(tablesAndHeaps));
}
ValidateTypeSystemRowCounts(typeSystemRowCounts);
_builder = tablesAndHeaps;
_entryPoint = entryPoint;
Debug.Assert(BlobUtilities.GetUTF8ByteCount(MetadataVersion) == MetadataVersion.Length);
_serializedMetadata = tablesAndHeaps.GetSerializedMetadata(typeSystemRowCounts, MetadataVersion.Length, isStandaloneDebugMetadata: true);
IdProvider = idProvider ?? BlobContentId.GetTimeBasedProvider();
}
public void Complex()
{
using (var peStream = new MemoryStream())
{
var ilBuilder = new BlobBuilder();
var metadataBuilder = new MetadataBuilder();
Blob mvidFixup;
var entryPoint = ComplexEmit(metadataBuilder, ilBuilder, out mvidFixup);
WritePEImage(peStream, metadataBuilder, ilBuilder, entryPoint, mvidFixup);
VerifyPE(peStream);
}
}
public void Others()
{
var mdBuilder = new MetadataBuilder();
mdBuilder.SetCapacity(TableIndex.Constant, 0x10000);
mdBuilder.SetCapacity(TableIndex.CustomAttribute, 0x10000);
mdBuilder.SetCapacity(TableIndex.FieldMarshal, 0x10000);
mdBuilder.SetCapacity(TableIndex.EventMap, 0x10000);
mdBuilder.SetCapacity(TableIndex.PropertyMap, 0x10000);
mdBuilder.SetCapacity(TableIndex.MethodSemantics, 0x10000);
mdBuilder.SetCapacity(TableIndex.MethodImpl, 0x10000);
mdBuilder.SetCapacity(TableIndex.NestedClass, 0x10000);
mdBuilder.SetCapacity(TableIndex.CustomDebugInformation, 0x10000);
object one = 1;
for (int i = 0; i < 0x10000; i++)
{
mdBuilder.AddConstant(default(ParameterHandle), one);
mdBuilder.AddCustomAttribute(default(ParameterHandle), default(MethodDefinitionHandle), default(BlobHandle));
mdBuilder.AddMarshallingDescriptor(default(ParameterHandle), default(BlobHandle));
mdBuilder.AddEventMap(default(TypeDefinitionHandle), default(EventDefinitionHandle));
mdBuilder.AddPropertyMap(default(TypeDefinitionHandle), default(PropertyDefinitionHandle));
mdBuilder.AddMethodSemantics(default(EventDefinitionHandle), 0, default(MethodDefinitionHandle));
mdBuilder.AddMethodImplementation(default(TypeDefinitionHandle), default(MethodDefinitionHandle), default(MethodDefinitionHandle));
mdBuilder.AddNestedType(default(TypeDefinitionHandle), default(TypeDefinitionHandle));
mdBuilder.AddCustomDebugInformation(default(ParameterHandle), default(GuidHandle), default(BlobHandle));
}
mdBuilder.AddModule(0, default(StringHandle), default(GuidHandle), default(GuidHandle), default(GuidHandle));
var rootBuilder = new MetadataRootBuilder(mdBuilder);
var mdBlob = new BlobBuilder();
rootBuilder.Serialize(mdBlob, 0, 0);
// validate sizes table rows that reference guids:
using (var mdProvider = MetadataReaderProvider.FromMetadataImage(mdBlob.ToImmutableArray()))
{
var mdReader = mdProvider.GetMetadataReader();
Assert.Equal(2 + 3 * 2 + 2, mdReader.ModuleTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.TypeRefTable.RowSize);
Assert.Equal(4 + 2 + 2 + 2 + 2 + 2, mdReader.TypeDefTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.FieldTable.RowSize);
Assert.Equal(8 + 2 + 2 + 2, mdReader.MethodDefTable.RowSize);
Assert.Equal(4 + 2, mdReader.ParamTable.RowSize);
Assert.Equal(2 + 2, mdReader.InterfaceImplTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.MemberRefTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.ConstantTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.CustomAttributeTable.RowSize);
Assert.Equal(2 + 2, mdReader.FieldMarshalTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.DeclSecurityTable.RowSize);
Assert.Equal(6 + 2, mdReader.ClassLayoutTable.RowSize);
Assert.Equal(4 + 2, mdReader.FieldLayoutTable.RowSize);
Assert.Equal(2, mdReader.StandAloneSigTable.RowSize);
Assert.Equal(2 + 2, mdReader.EventMapTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.EventTable.RowSize);
Assert.Equal(2 + 2, mdReader.PropertyMapTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.PropertyTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.MethodSemanticsTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.MethodImplTable.RowSize);
Assert.Equal(2, mdReader.ModuleRefTable.RowSize);
Assert.Equal(2, mdReader.TypeSpecTable.RowSize);
Assert.Equal(2 + 2 + 2 + 2, mdReader.ImplMapTable.RowSize);
Assert.Equal(4 + 2, mdReader.FieldRvaTable.RowSize);
Assert.Equal(16 + 2 + 2 + 2, mdReader.AssemblyTable.RowSize);
Assert.Equal(12 + 2 + 2 + 2 + 2, mdReader.AssemblyRefTable.RowSize);
Assert.Equal(4 + 2 + 2, mdReader.FileTable.RowSize);
Assert.Equal(8 + 2 + 2 + 2, mdReader.ExportedTypeTable.RowSize);
Assert.Equal(8 + 2 + 2, mdReader.ManifestResourceTable.RowSize);
Assert.Equal(2 + 2, mdReader.NestedClassTable.RowSize);
Assert.Equal(4 + 2 + 2, mdReader.GenericParamTable.RowSize);
Assert.Equal(2 + 2, mdReader.MethodSpecTable.RowSize);
Assert.Equal(2 + 2, mdReader.GenericParamConstraintTable.RowSize);
Assert.Equal(2 + 2 + 2 + 2, mdReader.DocumentTable.RowSize);
Assert.Equal(2 + 2, mdReader.MethodDebugInformationTable.RowSize);
Assert.Equal(2 + 2 + 2 + 2 + 4 + 4, mdReader.LocalScopeTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.LocalVariableTable.RowSize);
Assert.Equal(2 + 2, mdReader.LocalConstantTable.RowSize);
Assert.Equal(2 + 2, mdReader.ImportScopeTable.RowSize);
Assert.Equal(2 + 2, mdReader.StateMachineMethodTable.RowSize);
Assert.Equal(2 + 2 + 2, mdReader.CustomDebugInformationTable.RowSize);
}
}
public unsafe void NativeResources()
{
var peStream = new MemoryStream();
var ilBuilder = new BlobBuilder();
var metadataBuilder = new MetadataBuilder();
var peBuilder = new ManagedPEBuilder(
PEHeaderBuilder.CreateLibraryHeader(),
new MetadataRootBuilder(metadataBuilder),
ilBuilder,
nativeResources: new TestResourceSectionBuilder(),
deterministicIdProvider: content => s_contentId);
var peBlob = new BlobBuilder();
var contentId = peBuilder.Serialize(peBlob);
peBlob.WriteContentTo(peStream);
peStream.Position = 0;
var peReader = new PEReader(peStream);
var sectionHeader = peReader.PEHeaders.SectionHeaders.Single(s => s.Name == ".rsrc");
var image = peReader.GetEntireImage();
var reader = new BlobReader(image.Pointer + sectionHeader.PointerToRawData, sectionHeader.SizeOfRawData);
Assert.Equal(0x12345678, reader.ReadInt32());
Assert.Equal(sectionHeader.PointerToRawData, reader.ReadInt32());
Assert.Equal(sectionHeader.VirtualAddress, reader.ReadInt32());
}
private static MethodDefinitionHandle BasicValidationEmit(MetadataBuilder metadata, BlobBuilder ilBuilder)
{
metadata.AddModule(
0,
metadata.GetOrAddString("ConsoleApplication.exe"),
metadata.GetOrAddGuid(Guid.NewGuid()),
default(GuidHandle),
default(GuidHandle));
metadata.AddAssembly(
metadata.GetOrAddString("ConsoleApplication"),
version: new Version(0, 0, 0, 0),
culture: default(StringHandle),
publicKey: default(BlobHandle),
flags: default(AssemblyFlags),
hashAlgorithm: AssemblyHashAlgorithm.Sha1);
var mscorlibAssemblyRef = metadata.AddAssemblyReference(
name: metadata.GetOrAddString("mscorlib"),
version: new Version(4, 0, 0, 0),
culture: default(StringHandle),
publicKeyOrToken: metadata.GetOrAddBlob(ImmutableArray.Create<byte>(0xB7, 0x7A, 0x5C, 0x56, 0x19, 0x34, 0xE0, 0x89)),
flags: default(AssemblyFlags),
hashValue: default(BlobHandle));
var systemObjectTypeRef = metadata.AddTypeReference(
mscorlibAssemblyRef,
metadata.GetOrAddString("System"),
metadata.GetOrAddString("Object"));
var systemConsoleTypeRefHandle = metadata.AddTypeReference(
mscorlibAssemblyRef,
metadata.GetOrAddString("System"),
metadata.GetOrAddString("Console"));
var consoleWriteLineSignature = new BlobBuilder();
new BlobEncoder(consoleWriteLineSignature).
MethodSignature().
Parameters(1,
returnType => returnType.Void(),
parameters => parameters.AddParameter().Type().String());
var consoleWriteLineMemberRef = metadata.AddMemberReference(
systemConsoleTypeRefHandle,
metadata.GetOrAddString("WriteLine"),
metadata.GetOrAddBlob(consoleWriteLineSignature));
var parameterlessCtorSignature = new BlobBuilder();
new BlobEncoder(parameterlessCtorSignature).
MethodSignature(isInstanceMethod: true).
Parameters(0, returnType => returnType.Void(), parameters => { });
var parameterlessCtorBlobIndex = metadata.GetOrAddBlob(parameterlessCtorSignature);
var objectCtorMemberRef = metadata.AddMemberReference(
systemObjectTypeRef,
metadata.GetOrAddString(".ctor"),
parameterlessCtorBlobIndex);
var mainSignature = new BlobBuilder();
new BlobEncoder(mainSignature).
MethodSignature().
Parameters(0, returnType => returnType.Void(), parameters => { });
var methodBodies = new MethodBodiesEncoder(ilBuilder);
var codeBuilder = new BlobBuilder();
var branchBuilder = new BranchBuilder();
InstructionEncoder il;
//
// Program::.ctor
//
int ctorBodyOffset;
il = new InstructionEncoder(codeBuilder);
// ldarg.0
il.LoadArgument(0);
// call instance void [mscorlib]System.Object::.ctor()
il.Call(objectCtorMemberRef);
// ret
il.OpCode(ILOpCode.Ret);
methodBodies.AddMethodBody().WriteInstructions(codeBuilder, out ctorBodyOffset);
codeBuilder.Clear();
//
// Program::Main
//
int mainBodyOffset;
il = new InstructionEncoder(codeBuilder, branchBuilder);
var endLabel = il.DefineLabel();
// .try
int tryOffset = il.Offset;
// ldstr "hello"
il.LoadString(metadata.GetOrAddUserString("hello"));
// call void [mscorlib]System.Console::WriteLine(string)
il.Call(consoleWriteLineMemberRef);
// leave.s END
il.Branch(ILOpCode.Leave, endLabel);
// .finally
int handlerOffset = il.Offset;
// ldstr "world"
il.LoadString(metadata.GetOrAddUserString("world"));
// call void [mscorlib]System.Console::WriteLine(string)
il.Call(consoleWriteLineMemberRef);
// .endfinally
il.OpCode(ILOpCode.Endfinally);
int handlerEnd = il.Offset;
// END:
il.MarkLabel(endLabel);
// ret
il.OpCode(ILOpCode.Ret);
var body = methodBodies.AddMethodBody(exceptionRegionCount: 1);
var eh = body.WriteInstructions(codeBuilder, branchBuilder, out mainBodyOffset);
eh.StartRegions();
eh.AddFinally(tryOffset, handlerOffset - tryOffset, handlerOffset, handlerEnd - handlerOffset);
eh.EndRegions();
codeBuilder.Clear();
branchBuilder.Clear();
var mainMethodDef = metadata.AddMethodDefinition(
MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig,
MethodImplAttributes.IL | MethodImplAttributes.Managed,
metadata.GetOrAddString("Main"),
metadata.GetOrAddBlob(mainSignature),
mainBodyOffset,
paramList: default(ParameterHandle));
var ctorDef = metadata.AddMethodDefinition(
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName,
MethodImplAttributes.IL | MethodImplAttributes.Managed,
metadata.GetOrAddString(".ctor"),
parameterlessCtorBlobIndex,
ctorBodyOffset,
paramList: default(ParameterHandle));
metadata.AddTypeDefinition(
default(TypeAttributes),
default(StringHandle),
metadata.GetOrAddString("<Module>"),
baseType: default(EntityHandle),
fieldList: MetadataTokens.FieldDefinitionHandle(1),
methodList: mainMethodDef);
metadata.AddTypeDefinition(
TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.AutoLayout | TypeAttributes.BeforeFieldInit,
metadata.GetOrAddString("ConsoleApplication"),
metadata.GetOrAddString("Program"),
systemObjectTypeRef,
fieldList: MetadataTokens.FieldDefinitionHandle(1),
methodList: mainMethodDef);
return mainMethodDef;
}
public unsafe void NativeResources_BadImpl()
{
var peStream = new MemoryStream();
var ilBuilder = new BlobBuilder();
var metadataBuilder = new MetadataBuilder();
var peBuilder = new ManagedPEBuilder(
PEHeaderBuilder.CreateLibraryHeader(),
new MetadataRootBuilder(metadataBuilder),
ilBuilder,
nativeResources: new BadResourceSectionBuilder(),
deterministicIdProvider: content => s_contentId);
var peBlob = new BlobBuilder();
Assert.Throws<NotImplementedException>(() => peBuilder.Serialize(peBlob));
}
private static MethodDefinitionHandle ComplexEmit(MetadataBuilder metadata, BlobBuilder ilBuilder)
{
metadata.AddModule(
0,
metadata.GetOrAddString("ConsoleApplication.exe"),
metadata.GetOrAddGuid(Guid.NewGuid()),
default(GuidHandle),
default(GuidHandle));
metadata.AddAssembly(
metadata.GetOrAddString("ConsoleApplication"),
version: new Version(0, 0, 0, 0),
culture: default(StringHandle),
publicKey: default(BlobHandle),
flags: default(AssemblyFlags),
hashAlgorithm: AssemblyHashAlgorithm.Sha1);
var mscorlibAssemblyRef = metadata.AddAssemblyReference(
name: metadata.GetOrAddString("mscorlib"),
version: new Version(4, 0, 0, 0),
culture: default(StringHandle),
publicKeyOrToken: metadata.GetOrAddBlob(ImmutableArray.Create<byte>(0xB7, 0x7A, 0x5C, 0x56, 0x19, 0x34, 0xE0, 0x89)),
flags: default(AssemblyFlags),
hashValue: default(BlobHandle));
// TypeRefs:
var systemObjectTypeRef = metadata.AddTypeReference(mscorlibAssemblyRef, metadata.GetOrAddString("System"), metadata.GetOrAddString("Object"));
var dictionaryTypeRef = metadata.AddTypeReference(mscorlibAssemblyRef, metadata.GetOrAddString("System.Collections.Generic"), metadata.GetOrAddString("Dictionary`2"));
var strignBuilderTypeRef = metadata.AddTypeReference(mscorlibAssemblyRef, metadata.GetOrAddString("System.Text"), metadata.GetOrAddString("StringBuilder"));
var typeTypeRef = metadata.AddTypeReference(mscorlibAssemblyRef, metadata.GetOrAddString("System"), metadata.GetOrAddString("Type"));
var int32TypeRef = metadata.AddTypeReference(mscorlibAssemblyRef, metadata.GetOrAddString("System"), metadata.GetOrAddString("Int32"));
var runtimeTypeHandleRef = metadata.AddTypeReference(mscorlibAssemblyRef, metadata.GetOrAddString("System"), metadata.GetOrAddString("RuntimeTypeHandle"));
var invalidOperationExceptionTypeRef = metadata.AddTypeReference(mscorlibAssemblyRef, metadata.GetOrAddString("System"), metadata.GetOrAddString("InvalidOperationException"));
// TypeDefs:
metadata.AddTypeDefinition(
default(TypeAttributes),
default(StringHandle),
metadata.GetOrAddString("<Module>"),
baseType: default(EntityHandle),
fieldList: MetadataTokens.FieldDefinitionHandle(1),
methodList: MetadataTokens.MethodDefinitionHandle(1));
var baseClassTypeDef = metadata.AddTypeDefinition(
TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.AutoLayout | TypeAttributes.BeforeFieldInit | TypeAttributes.Abstract,
metadata.GetOrAddString("Lib"),
metadata.GetOrAddString("BaseClass"),
systemObjectTypeRef,
fieldList: MetadataTokens.FieldDefinitionHandle(1),
methodList: MetadataTokens.MethodDefinitionHandle(1));
var derivedClassTypeDef = metadata.AddTypeDefinition(
TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.AutoLayout | TypeAttributes.BeforeFieldInit,
metadata.GetOrAddString("Lib"),
metadata.GetOrAddString("DerivedClass"),
baseClassTypeDef,
fieldList: MetadataTokens.FieldDefinitionHandle(4),
methodList: MetadataTokens.MethodDefinitionHandle(1));
// FieldDefs:
// Field1
var baseClassNumberFieldDef = metadata.AddFieldDefinition(
FieldAttributes.Private,
metadata.GetOrAddString("_number"),
metadata.GetOrAddBlob(BuildSignature(e => e.FieldSignature().Int32())));
// Field2
var baseClassNegativeFieldDef = metadata.AddFieldDefinition(
FieldAttributes.Assembly,
metadata.GetOrAddString("negative"),
metadata.GetOrAddBlob(BuildSignature(e => e.FieldSignature().Boolean())));
// Field3
var derivedClassSumCacheFieldDef = metadata.AddFieldDefinition(
FieldAttributes.Assembly,
metadata.GetOrAddString("_sumCache"),
metadata.GetOrAddBlob(BuildSignature(e =>
{
var inst = e.FieldSignature().GenericInstantiation(isValueType: false, typeRefDefSpec: dictionaryTypeRef, genericArgumentCount: 2);
inst.AddArgument().Int32();
inst.AddArgument().Object();
})));
// Field4
var derivedClassCountFieldDef = metadata.AddFieldDefinition(
FieldAttributes.Assembly,
metadata.GetOrAddString("_count"),
metadata.GetOrAddBlob(BuildSignature(e => e.FieldSignature().SZArray().Int32())));
// Field5
var derivedClassBCFieldDef = metadata.AddFieldDefinition(
FieldAttributes.Assembly,
metadata.GetOrAddString("_bc"),
metadata.GetOrAddBlob(BuildSignature(e => e.FieldSignature().TypeDefOrRefOrSpec(isValueType: false, typeRefDefSpec: baseClassTypeDef))));
var methodBodies = new MethodBodiesEncoder(ilBuilder);
var buffer = new BlobBuilder();
InstructionEncoder il;
//
// Foo
//
int fooBodyOffset;
il = new InstructionEncoder(buffer);
il.LoadString(metadata.GetOrAddUserString("asdsad"));
il.OpCode(ILOpCode.Newobj);
il.Token(invalidOperationExceptionTypeRef);
il.OpCode(ILOpCode.Throw);
methodBodies.AddMethodBody().WriteInstructions(buffer, out fooBodyOffset);
buffer.Clear();
// Method1
var derivedClassFooMethodDef = metadata.AddMethodDefinition(
MethodAttributes.PrivateScope | MethodAttributes.Private | MethodAttributes.HideBySig,
MethodImplAttributes.IL,
metadata.GetOrAddString("Foo"),
metadata.GetOrAddBlob(BuildSignature(e =>
e.MethodSignature(isInstanceMethod: true).Parameters(0, returnType => returnType.Void(), parameters => { }))),
fooBodyOffset,
default(ParameterHandle));
return default(MethodDefinitionHandle);
}
public MetadataSerializer(MetadataBuilder tables, MetadataSizes sizes, string metadataVersion)
{
_tables = tables;
_sizes = sizes;
_metadataVersion = metadataVersion;
}
internal static MetadataSizes CreateSizes(MetadataBuilder tables, ImmutableArray<int> externalRowCounts, bool isMinimalDelta, bool isStandaloneDebugMetadata)
{
tables.CompleteHeaps();
return new MetadataSizes(
tables.GetRowCounts(),
externalRowCounts,
tables.GetHeapSizes(),
isMinimalDelta,
isStandaloneDebugMetadata);
}
public void HeapOverflow_UserString()
{
string veryLargeString = new string('x', 0x00fffff0 / 2);
var builder1 = new MetadataBuilder();
Assert.Equal(0x70000001, MetadataTokens.GetToken(builder1.GetOrAddUserString(veryLargeString)));
// TODO: https://github.com/dotnet/roslyn/issues/9852
// Should throw: Assert.Throws<ImageFormatLimitationException>(() => builder1.GetOrAddUserString("123"));
// Assert.Equal(0x70fffff6, MetadataTokens.GetToken(builder1.GetOrAddUserString("12")));
// Assert.Equal(0x70fffff6, MetadataTokens.GetToken(builder1.GetOrAddUserString("12")));
Assert.Equal(0x70fffff6, MetadataTokens.GetToken(builder1.GetOrAddUserString(veryLargeString + "z")));
Assert.Throws<ImageFormatLimitationException>(() => builder1.GetOrAddUserString("12"));
var builder2 = new MetadataBuilder();
Assert.Equal(0x70000001, MetadataTokens.GetToken(builder2.GetOrAddUserString("123")));
Assert.Equal(0x70000009, MetadataTokens.GetToken(builder2.GetOrAddUserString(veryLargeString)));
Assert.Equal(0x70fffffe, MetadataTokens.GetToken(builder2.GetOrAddUserString("4"))); // TODO: should throw https://github.com/dotnet/roslyn/issues/9852
var builder3 = new MetadataBuilder(userStringHeapStartOffset: 0x00fffffe);
Assert.Equal(0x70ffffff, MetadataTokens.GetToken(builder3.GetOrAddUserString("1"))); // TODO: should throw https://github.com/dotnet/roslyn/issues/9852
var builder4 = new MetadataBuilder(userStringHeapStartOffset: 0x00fffff7);
Assert.Equal(0x70fffff8, MetadataTokens.GetToken(builder4.GetOrAddUserString("1"))); // 4B
Assert.Equal(0x70fffffc, MetadataTokens.GetToken(builder4.GetOrAddUserString("2"))); // 4B
var builder5 = new MetadataBuilder(userStringHeapStartOffset: 0x00fffff8);
Assert.Equal(0x70fffff9, MetadataTokens.GetToken(builder5.GetOrAddUserString("1"))); // 4B
Assert.Equal(0x70fffffd, MetadataTokens.GetToken(builder5.GetOrAddUserString("2"))); // 4B // TODO: should throw https://github.com/dotnet/roslyn/issues/9852
}
public void Add()
{
var builder = new MetadataBuilder();
builder.AddModule(default(Int32), default(StringHandle), default(GuidHandle), default(GuidHandle), default(GuidHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Module]);
builder.AddAssembly(default(StringHandle), default(Version), default(StringHandle), default(BlobHandle), default(AssemblyFlags), default(AssemblyHashAlgorithm));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Assembly]);
var assemblyReference = builder.AddAssemblyReference(default(StringHandle), default(Version), default(StringHandle), default(BlobHandle), default(AssemblyFlags), default(BlobHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.AssemblyRef]);
Assert.Equal(1, MetadataTokens.GetRowNumber(assemblyReference));
var typeDefinition = builder.AddTypeDefinition(default(TypeAttributes), default(StringHandle), default(StringHandle), default(EntityHandle), default(FieldDefinitionHandle), default(MethodDefinitionHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.TypeDef]);
Assert.Equal(1, MetadataTokens.GetRowNumber(typeDefinition));
builder.AddTypeLayout(default(TypeDefinitionHandle), default(UInt16), default(UInt32));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.ClassLayout]);
builder.AddInterfaceImplementation(MetadataTokens.TypeDefinitionHandle(1), MetadataTokens.TypeDefinitionHandle(1));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.InterfaceImpl]);
builder.AddNestedType(default(TypeDefinitionHandle), default(TypeDefinitionHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.NestedClass]);
var typeReference = builder.AddTypeReference(EntityHandle.ModuleDefinition, default(StringHandle), default(StringHandle));
Assert.Equal(1, MetadataTokens.GetRowNumber(typeReference));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.TypeRef]);
builder.AddTypeSpecification(default(BlobHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.TypeSpec]);
builder.AddStandaloneSignature(default(BlobHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.StandAloneSig]);
builder.AddProperty(default(PropertyAttributes), default(StringHandle), default(BlobHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Property]);
builder.AddPropertyMap(default(TypeDefinitionHandle), default(PropertyDefinitionHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.PropertyMap]);
builder.AddEvent(default(EventAttributes), default(StringHandle), MetadataTokens.TypeDefinitionHandle(1));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Event]);
builder.AddEventMap(default(TypeDefinitionHandle), default(EventDefinitionHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.EventMap]);
builder.AddConstant(MetadataTokens.FieldDefinitionHandle(1), default(Object));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Constant]);
builder.AddMethodSemantics(MetadataTokens.EventDefinitionHandle(1), default(UInt16), default(MethodDefinitionHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.MethodSemantics]);
builder.AddCustomAttribute(MetadataTokens.TypeDefinitionHandle(1), MetadataTokens.MethodDefinitionHandle(1), default(BlobHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.CustomAttribute]);
builder.AddMethodSpecification(MetadataTokens.MethodDefinitionHandle(1), default(BlobHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.MethodSpec]);
builder.AddModuleReference(default(StringHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.ModuleRef]);
builder.AddParameter(default(ParameterAttributes), default(StringHandle), default(Int32));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Param]);
var genericParameter = builder.AddGenericParameter(MetadataTokens.MethodDefinitionHandle(1), default(GenericParameterAttributes), default(StringHandle), default(Int32));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.GenericParam]);
Assert.Equal(1, MetadataTokens.GetRowNumber(genericParameter));
builder.AddGenericParameterConstraint(default(GenericParameterHandle), MetadataTokens.TypeDefinitionHandle(1));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.GenericParamConstraint]);
builder.AddFieldDefinition(default(FieldAttributes), default(StringHandle), default(BlobHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Field]);
builder.AddFieldLayout(default(FieldDefinitionHandle), default(Int32));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.FieldLayout]);
builder.AddMarshallingDescriptor(MetadataTokens.FieldDefinitionHandle(1), default(BlobHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.FieldMarshal]);
builder.AddFieldRelativeVirtualAddress(default(FieldDefinitionHandle), default(Int32));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.FieldRva]);
var methodDefinition = builder.AddMethodDefinition(default(MethodAttributes), default(MethodImplAttributes), default(StringHandle), default(BlobHandle), default(Int32), default(ParameterHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.MethodDef]);
Assert.Equal(1, MetadataTokens.GetRowNumber(methodDefinition));
builder.AddMethodImport(MetadataTokens.MethodDefinitionHandle(1), default(MethodImportAttributes), default(StringHandle), default(ModuleReferenceHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.ImplMap]);
builder.AddMethodImplementation(default(TypeDefinitionHandle), MetadataTokens.MethodDefinitionHandle(1), MetadataTokens.MethodDefinitionHandle(1));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.MethodImpl]);
var memberReference = builder.AddMemberReference(MetadataTokens.TypeDefinitionHandle(1), default(StringHandle), default(BlobHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.MemberRef]);
Assert.Equal(1, MetadataTokens.GetRowNumber(memberReference));
builder.AddManifestResource(default(ManifestResourceAttributes), default(StringHandle), MetadataTokens.AssemblyFileHandle(1), default(Int64));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.ManifestResource]);
builder.AddAssemblyFile(default(StringHandle), default(BlobHandle), default(Boolean));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.File]);
builder.AddExportedType(default(TypeAttributes), default(StringHandle), default(StringHandle), MetadataTokens.AssemblyFileHandle(1), default(Int32));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.ExportedType]);
builder.AddDeclarativeSecurityAttribute(MetadataTokens.TypeDefinitionHandle(1), default(DeclarativeSecurityAction), default(BlobHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.DeclSecurity]);
builder.AddEncLogEntry(MetadataTokens.TypeDefinitionHandle(1), default(EditAndContinueOperation));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.EncLog]);
builder.AddEncMapEntry(MetadataTokens.TypeDefinitionHandle(1));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.EncMap]);
var document = builder.AddDocument(default(BlobHandle), default(GuidHandle), default(BlobHandle), default(GuidHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Document]);
Assert.Equal(1, MetadataTokens.GetRowNumber(document));
builder.AddMethodDebugInformation(default(DocumentHandle), default(BlobHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.MethodDebugInformation]);
var localScope = builder.AddLocalScope(default(MethodDefinitionHandle), default(ImportScopeHandle), default(LocalVariableHandle), default(LocalConstantHandle), default(Int32), default(Int32));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.LocalScope]);
Assert.Equal(1, MetadataTokens.GetRowNumber(localScope));
var localVariable = builder.AddLocalVariable(default(LocalVariableAttributes), default(Int32), default(StringHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.LocalVariable]);
Assert.Equal(1, MetadataTokens.GetRowNumber(localVariable));
var localConstant = builder.AddLocalConstant(default(StringHandle), default(BlobHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.LocalConstant]);
Assert.Equal(1, MetadataTokens.GetRowNumber(localConstant));
var importScope = builder.AddImportScope(default(ImportScopeHandle), default(BlobHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.ImportScope]);
Assert.Equal(1, MetadataTokens.GetRowNumber(importScope));
builder.AddStateMachineMethod(default(MethodDefinitionHandle), default(MethodDefinitionHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.StateMachineMethod]);
builder.AddCustomDebugInformation(default(EntityHandle), default(GuidHandle), default(BlobHandle));
Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.CustomDebugInformation]);
}
public void BasicValidationSigned()
{
using (var peStream = new MemoryStream())
{
var ilBuilder = new BlobBuilder();
var metadataBuilder = new MetadataBuilder();
var entryPoint = BasicValidationEmit(metadataBuilder, ilBuilder);
WritePEImage(peStream, metadataBuilder, ilBuilder, entryPoint, privateKeyOpt: Misc.KeyPair);
VerifyPE(peStream, expectedSignature: new byte[]
{
0x58, 0xD4, 0xD7, 0x88, 0x3B, 0xF9, 0x19, 0x9F, 0x3A, 0x55, 0x8F, 0x1B, 0x88, 0xBE, 0xA8, 0x42,
0x09, 0x2B, 0xE3, 0xB4, 0xC7, 0x09, 0xD5, 0x96, 0x35, 0x50, 0x0F, 0x3C, 0x87, 0x95, 0x6A, 0x31,
0xA5, 0x5C, 0xC7, 0xE1, 0x14, 0x85, 0x8E, 0x63, 0xFC, 0xCF, 0x8F, 0x2A, 0x19, 0x27, 0xD5, 0x12,
0x88, 0x75, 0x20, 0xBB, 0xBE, 0xD0, 0xA3, 0x04, 0x2D, 0xD3, 0x44, 0x48, 0xCC, 0xD7, 0x36, 0xBA,
0x06, 0x86, 0x17, 0xE9, 0x0D, 0x8C, 0x9C, 0xD6, 0xBA, 0x75, 0x9E, 0x32, 0x0D, 0xCC, 0xC2, 0x8E,
0x80, 0xD5, 0x81, 0x71, 0xD2, 0x4A, 0x90, 0x43, 0xA0, 0x67, 0x20, 0x39, 0x0A, 0x9F, 0x61, 0x5B,
0x2F, 0x9F, 0xE5, 0x70, 0x42, 0xA8, 0x86, 0x61, 0x42, 0x94, 0xBD, 0x1E, 0x76, 0xDA, 0xB0, 0xF8,
0xA6, 0x37, 0x71, 0xD4, 0x7F, 0x12, 0xCD, 0x39, 0x27, 0x6C, 0x4D, 0x28, 0x03, 0x7D, 0xF8, 0x89
});
}
}
