internal static void WriteModule(StrongNameKeyPair keyPair, byte[] publicKey, ModuleBuilder moduleBuilder,
PEFileKinds fileKind, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine,
ResourceSection resources, int entryPointToken, Stream stream)
{
if (stream == null)
{
string fileName = moduleBuilder.FullyQualifiedName;
bool mono = System.Type.GetType("Mono.Runtime") != null;
if (mono)
{
try
{
// Mono mmaps the file, so unlink the previous version since it may be in use
File.Delete(fileName);
}
catch { }
}
using (FileStream fs = new FileStream(fileName, FileMode.Create))
{
WriteModuleImpl(keyPair, publicKey, moduleBuilder, fileKind, portableExecutableKind, imageFileMachine, resources, entryPointToken, fs);
}
// if we're running on Mono, mark the module as executable by using a Mono private API extension
if (mono)
{
File.SetAttributes(fileName, (FileAttributes)(unchecked((int)0x80000000)));
}
}
else
{
WriteModuleImpl(keyPair, publicKey, moduleBuilder, fileKind, portableExecutableKind, imageFileMachine, resources, entryPointToken, stream);
}
}
private static byte[] EmitHelloWorldConsoleExeAssembly(PortableExecutableKinds peKind, ImageFileMachine machine)
{
byte[] bytes;
var asmName = new AssemblyName { Name = "Dummy" + Guid.NewGuid() };
var asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
asmName,
System.Reflection.Emit.AssemblyBuilderAccess.Save);
var modBuilder = asmBuilder.DefineDynamicModule(asmName.Name, asmName.Name + ".exe");
var programTypeBuilder = modBuilder.DefineType("Program");
var mainMethodBuilder = programTypeBuilder.DefineMethod("Main", MethodAttributes.Static, typeof(void), Type.EmptyTypes);
var il = mainMethodBuilder.GetILGenerator();
il.EmitWriteLine("Hello, World!");
il.Emit(OpCodes.Ret);
asmBuilder.SetEntryPoint(mainMethodBuilder);
programTypeBuilder.CreateType();
asmBuilder.Save(asmName.Name + ".exe", peKind, machine);
try
{
bytes = File.ReadAllBytes(asmName.Name + ".exe");
}
finally
{
File.Delete(asmName.Name);
}
return bytes;
}
internal AssemblyGen(AssemblyName name, string outDir, string outFileExtension, bool isDebuggable,
PortableExecutableKinds peKind, ImageFileMachine machine) {
ContractUtils.RequiresNotNull(name, "name");
#if SILVERLIGHT // AssemblyBuilderAccess.RunAndSave, Environment.CurrentDirectory
_myAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run);
_myModule = _myAssembly.DefineDynamicModule(name.Name, isDebuggable);
#else
if (outFileExtension == null) {
outFileExtension = ".dll";
}
if (outDir != null) {
try {
outDir = Path.GetFullPath(outDir);
} catch (Exception) {
throw Error.InvalidOutputDir();
}
try {
Path.Combine(outDir, name.Name + outFileExtension);
} catch (ArgumentException) {
throw Error.InvalidAsmNameOrExtension();
}
_outFileName = name.Name + outFileExtension;
_outDir = outDir;
}
// mark the assembly transparent so that it works in partial trust:
CustomAttributeBuilder[] attributes = new CustomAttributeBuilder[] {
new CustomAttributeBuilder(typeof(SecurityTransparentAttribute).GetConstructor(Type.EmptyTypes), new object[0])
};
if (outDir != null) {
#if CLR4
_myAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.RunAndSave, outDir, false, attributes);
#else
//The API DefineDynamicAssembly is obsolete in Dev10.
_myAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.RunAndSave, outDir,
null, null, null, null, false, attributes);
#endif
_myModule = _myAssembly.DefineDynamicModule(name.Name, _outFileName, isDebuggable);
} else {
_myAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run, attributes);
_myModule = _myAssembly.DefineDynamicModule(name.Name, isDebuggable);
}
_myAssembly.DefineVersionInfoResource();
#endif
_machine = machine;
_peKind = peKind;
_isDebuggable = isDebuggable;
if (isDebuggable) {
SetDebuggableAttributes();
}
}
internal static void WriteModule(StrongNameKeyPair keyPair, byte[] publicKey, ModuleBuilder moduleBuilder,
PEFileKinds fileKind, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine,
ResourceSection resources, int entryPointToken, Stream stream)
{
if (stream == null)
{
using (FileStream fs = new FileStream(moduleBuilder.FullyQualifiedName, FileMode.Create))
{
WriteModuleImpl(keyPair, publicKey, moduleBuilder, fileKind, portableExecutableKind, imageFileMachine, resources, entryPointToken, fs);
}
}
else
{
WriteModuleImpl(keyPair, publicKey, moduleBuilder, fileKind, portableExecutableKind, imageFileMachine, resources, entryPointToken, stream);
}
}
private static byte[] EmitLibraryAssembly(PortableExecutableKinds peKind, ImageFileMachine machine)
{
byte[] bytes;
var asmName = new AssemblyName { Name = "Dummy" + Guid.NewGuid() };
var asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
asmName,
System.Reflection.Emit.AssemblyBuilderAccess.Save);
asmBuilder.Save(asmName.Name, peKind, machine);
try
{
bytes = File.ReadAllBytes(asmName.Name);
}
finally
{
File.Delete(asmName.Name);
}
return bytes;
}
public CompilerOptions(){
this.autoRef = true;
this.PEFileKind = PEFileKinds.ConsoleApplication;
this.PEKindFlags = PortableExecutableKinds.ILOnly;
this.PEMachineArchitecture = ImageFileMachine.I386;
this.fFast = true;
this.fPrint = true;
this.nWarningLevel = 4;
this.SourceFileNames = new ArrayList();
this.ImportFileNames = new ArrayList();
this.ManagedResourceFileNames = new Hashtable(10);
this.ManagedResources = new Hashtable(10);
this.Defines = new Hashtable();
string libpath = System.Environment.GetEnvironmentVariable("LIB");
if (libpath != null)
this.libpath = libpath;
else
this.libpath = "";
}
internal static void WriteModule(StrongNameKeyPair keyPair, byte[] publicKey, ModuleBuilder moduleBuilder,
PEFileKinds fileKind, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine,
ResourceSection resources, int entryPointToken, Stream stream)
{
if (stream == null)
{
using (FileStream fs = new FileStream(moduleBuilder.FullyQualifiedName, FileMode.Create))
{
WriteModuleImpl(keyPair, publicKey, moduleBuilder, fileKind, portableExecutableKind, imageFileMachine, resources, entryPointToken, fs);
}
// if we're running on Mono, mark the module as executable by using a Mono private API extension
if (System.Type.GetType("Mono.Runtime") != null)
{
File.SetAttributes(moduleBuilder.FullyQualifiedName, (FileAttributes)(unchecked((int)0x80000000)));
}
}
else
{
WriteModuleImpl(keyPair, publicKey, moduleBuilder, fileKind, portableExecutableKind, imageFileMachine, resources, entryPointToken, stream);
}
}
public AssemblyGen(string moduleName, string outDir, string outFile, bool emitDebugInfo,
bool staticTypes, PortableExecutableKinds peKind, ImageFileMachine machine)
{
this.outFileName = outFile;
this.outDir = outDir;
this.emitDebugInfo = emitDebugInfo;
this.staticTypes = staticTypes;
this.peKind = peKind;
this.machine = machine;
AssemblyName asmname = new AssemblyName();
AppDomain domain = System.Threading.Thread.GetDomain();
asmname.Name = Path.GetFileNameWithoutExtension(outFileName);
if (outFileName == null) {
myAssembly = domain.DefineDynamicAssembly(
asmname,
AssemblyBuilderAccess.Run,
outDir,
null);
myModule = myAssembly.DefineDynamicModule(moduleName);
} else {
myAssembly = domain.DefineDynamicAssembly(
asmname,
AssemblyBuilderAccess.RunAndSave,
outDir,
null);
myModule = myAssembly.DefineDynamicModule(outFileName, outFileName, emitDebugInfo);
}
myAssembly.DefineVersionInfoResource();
if (emitDebugInfo) SetDebuggableAttributes();
}
public void Save(string assemblyFileName, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
{
SaveImpl(assemblyFileName, null, portableExecutableKind, imageFileMachine);
}
private void SaveImpl(string assemblyFileName, Stream streamOrNull, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
{
ModuleBuilder manifestModule = null;
foreach (ModuleBuilder moduleBuilder in modules)
{
moduleBuilder.SetIsSaved();
moduleBuilder.PopulatePropertyAndEventTables();
if (manifestModule == null &&
string.Compare(moduleBuilder.fileName, assemblyFileName, StringComparison.OrdinalIgnoreCase) == 0)
{
manifestModule = moduleBuilder;
}
}
if (manifestModule == null)
{
manifestModule = DefineDynamicModule("RefEmit_OnDiskManifestModule", assemblyFileName, false);
}
AssemblyTable.Record assemblyRecord = new AssemblyTable.Record();
assemblyRecord.HashAlgId = (int)hashAlgorithm;
assemblyRecord.Name = manifestModule.Strings.Add(name);
assemblyRecord.MajorVersion = majorVersion;
assemblyRecord.MinorVersion = minorVersion;
assemblyRecord.BuildNumber = buildVersion;
assemblyRecord.RevisionNumber = revisionVersion;
if (publicKey != null)
{
assemblyRecord.PublicKey = manifestModule.Blobs.Add(ByteBuffer.Wrap(publicKey));
assemblyRecord.Flags = (int)(flags | AssemblyNameFlags.PublicKey);
}
else
{
assemblyRecord.Flags = (int)(flags & ~AssemblyNameFlags.PublicKey);
}
if (culture != null)
{
assemblyRecord.Culture = manifestModule.Strings.Add(culture);
}
manifestModule.AssemblyTable.AddRecord(assemblyRecord);
ResourceSection unmanagedResources = versionInfo != null || win32icon != null || win32manifest != null || win32resources != null
? new ResourceSection()
: null;
if (versionInfo != null)
{
versionInfo.SetName(GetName());
versionInfo.SetFileName(assemblyFileName);
foreach (CustomAttributeBuilder cab in customAttributes)
{
// .NET doesn't support copying blob custom attributes into the version info
if (!cab.HasBlob || universe.DecodeVersionInfoAttributeBlobs)
{
versionInfo.SetAttribute(this, cab);
}
}
ByteBuffer versionInfoData = new ByteBuffer(512);
versionInfo.Write(versionInfoData);
unmanagedResources.AddVersionInfo(versionInfoData);
}
if (win32icon != null)
{
unmanagedResources.AddIcon(win32icon);
}
if (win32manifest != null)
{
unmanagedResources.AddManifest(win32manifest, fileKind == PEFileKinds.Dll ? (ushort)2 : (ushort)1);
}
if (win32resources != null)
{
unmanagedResources.ExtractResources(win32resources);
}
foreach (CustomAttributeBuilder cab in customAttributes)
{
// we intentionally don't filter out the version info (pseudo) custom attributes (to be compatible with .NET)
manifestModule.SetCustomAttribute(0x20000001, cab);
}
manifestModule.AddDeclarativeSecurity(0x20000001, declarativeSecurity);
foreach (TypeForwarder fwd in typeForwarders)
{
manifestModule.AddTypeForwarder(fwd.Type, fwd.IncludeNested);
}
foreach (ResourceFile resfile in resourceFiles)
{
if (resfile.Writer != null)
{
resfile.Writer.Generate();
resfile.Writer.Close();
}
int fileToken = AddFile(manifestModule, resfile.FileName, 1 /*ContainsNoMetaData*/);
ManifestResourceTable.Record rec = new ManifestResourceTable.Record();
rec.Offset = 0;
rec.Flags = (int)resfile.Attributes;
rec.Name = manifestModule.Strings.Add(resfile.Name);
rec.Implementation = fileToken;
manifestModule.ManifestResource.AddRecord(rec);
}
int entryPointToken = 0;
foreach (ModuleBuilder moduleBuilder in modules)
{
moduleBuilder.FillAssemblyRefTable();
moduleBuilder.EmitResources();
if (moduleBuilder != manifestModule)
{
int fileToken;
if (entryPoint != null && entryPoint.Module == moduleBuilder)
{
ModuleWriter.WriteModule(null, null, moduleBuilder, fileKind, portableExecutableKind, imageFileMachine, moduleBuilder.unmanagedResources, entryPoint.MetadataToken);
entryPointToken = fileToken = AddFile(manifestModule, moduleBuilder.fileName, 0 /*ContainsMetaData*/);
}
else
{
ModuleWriter.WriteModule(null, null, moduleBuilder, fileKind, portableExecutableKind, imageFileMachine, moduleBuilder.unmanagedResources, 0);
fileToken = AddFile(manifestModule, moduleBuilder.fileName, 0 /*ContainsMetaData*/);
}
moduleBuilder.ExportTypes(fileToken, manifestModule);
}
}
foreach (Module module in addedModules)
{
int fileToken = AddFile(manifestModule, module.FullyQualifiedName, 0 /*ContainsMetaData*/);
module.ExportTypes(fileToken, manifestModule);
}
if (entryPointToken == 0 && entryPoint != null)
{
entryPointToken = entryPoint.MetadataToken;
}
// finally, write the manifest module
ModuleWriter.WriteModule(keyPair, publicKey, manifestModule, fileKind, portableExecutableKind, imageFileMachine, unmanagedResources ?? manifestModule.unmanagedResources, entryPointToken, streamOrNull);
}
public virtual void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
throw new NotSupportedException();
}
private static void WriteModuleImpl(StrongNameKeyPair keyPair, byte[] publicKey, ModuleBuilder moduleBuilder,
PEFileKinds fileKind, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine,
ResourceSection resources, int entryPointToken, Stream stream)
{
moduleBuilder.ApplyUnmanagedExports(imageFileMachine);
moduleBuilder.FixupMethodBodyTokens();
moduleBuilder.ModuleTable.Add(0, moduleBuilder.Strings.Add(moduleBuilder.moduleName), moduleBuilder.Guids.Add(moduleBuilder.ModuleVersionId), 0, 0);
if (moduleBuilder.UserStrings.IsEmpty)
{
// for compat with Ref.Emit, if there aren't any user strings, we add one
moduleBuilder.UserStrings.Add(" ");
}
if (resources != null)
{
resources.Finish();
}
PEWriter writer = new PEWriter(stream);
writer.Headers.OptionalHeader.FileAlignment = (uint)moduleBuilder.__FileAlignment;
switch (imageFileMachine)
{
case ImageFileMachine.I386:
writer.Headers.FileHeader.Machine = IMAGE_FILE_HEADER.IMAGE_FILE_MACHINE_I386;
writer.Headers.FileHeader.Characteristics |= IMAGE_FILE_HEADER.IMAGE_FILE_32BIT_MACHINE;
writer.Headers.OptionalHeader.SizeOfStackReserve = moduleBuilder.GetStackReserve(0x100000);
break;
case ImageFileMachine.ARM:
writer.Headers.FileHeader.Machine = IMAGE_FILE_HEADER.IMAGE_FILE_MACHINE_ARM;
writer.Headers.FileHeader.Characteristics |= IMAGE_FILE_HEADER.IMAGE_FILE_32BIT_MACHINE;
writer.Headers.OptionalHeader.SizeOfStackReserve = moduleBuilder.GetStackReserve(0x100000);
break;
case ImageFileMachine.AMD64:
writer.Headers.FileHeader.Machine = IMAGE_FILE_HEADER.IMAGE_FILE_MACHINE_AMD64;
writer.Headers.FileHeader.Characteristics |= IMAGE_FILE_HEADER.IMAGE_FILE_LARGE_ADDRESS_AWARE;
writer.Headers.FileHeader.SizeOfOptionalHeader = 0xF0;
writer.Headers.OptionalHeader.Magic = IMAGE_OPTIONAL_HEADER.IMAGE_NT_OPTIONAL_HDR64_MAGIC;
writer.Headers.OptionalHeader.SizeOfStackReserve = moduleBuilder.GetStackReserve(0x400000);
writer.Headers.OptionalHeader.SizeOfStackCommit = 0x4000;
writer.Headers.OptionalHeader.SizeOfHeapCommit = 0x2000;
break;
case ImageFileMachine.IA64:
writer.Headers.FileHeader.Machine = IMAGE_FILE_HEADER.IMAGE_FILE_MACHINE_IA64;
writer.Headers.FileHeader.Characteristics |= IMAGE_FILE_HEADER.IMAGE_FILE_LARGE_ADDRESS_AWARE;
writer.Headers.FileHeader.SizeOfOptionalHeader = 0xF0;
writer.Headers.OptionalHeader.Magic = IMAGE_OPTIONAL_HEADER.IMAGE_NT_OPTIONAL_HDR64_MAGIC;
writer.Headers.OptionalHeader.SizeOfStackReserve = moduleBuilder.GetStackReserve(0x400000);
writer.Headers.OptionalHeader.SizeOfStackCommit = 0x4000;
writer.Headers.OptionalHeader.SizeOfHeapCommit = 0x2000;
break;
default:
throw new ArgumentOutOfRangeException("imageFileMachine");
}
if (fileKind == PEFileKinds.Dll)
{
writer.Headers.FileHeader.Characteristics |= IMAGE_FILE_HEADER.IMAGE_FILE_DLL;
}
switch (fileKind)
{
case PEFileKinds.WindowApplication:
writer.Headers.OptionalHeader.Subsystem = IMAGE_OPTIONAL_HEADER.IMAGE_SUBSYSTEM_WINDOWS_GUI;
break;
default:
writer.Headers.OptionalHeader.Subsystem = IMAGE_OPTIONAL_HEADER.IMAGE_SUBSYSTEM_WINDOWS_CUI;
break;
}
writer.Headers.OptionalHeader.DllCharacteristics = (ushort)moduleBuilder.__DllCharacteristics;
CliHeader cliHeader = new CliHeader();
cliHeader.Cb = 0x48;
cliHeader.MajorRuntimeVersion = 2;
cliHeader.MinorRuntimeVersion = moduleBuilder.MDStreamVersion < 0x20000 ? (ushort)0 : (ushort)5;
if ((portableExecutableKind & PortableExecutableKinds.ILOnly) != 0)
{
cliHeader.Flags |= CliHeader.COMIMAGE_FLAGS_ILONLY;
}
if ((portableExecutableKind & PortableExecutableKinds.Required32Bit) != 0)
{
cliHeader.Flags |= CliHeader.COMIMAGE_FLAGS_32BITREQUIRED;
}
if ((portableExecutableKind & PortableExecutableKinds.Preferred32Bit) != 0)
{
cliHeader.Flags |= CliHeader.COMIMAGE_FLAGS_32BITREQUIRED | CliHeader.COMIMAGE_FLAGS_32BITPREFERRED;
}
if (keyPair != null)
{
cliHeader.Flags |= CliHeader.COMIMAGE_FLAGS_STRONGNAMESIGNED;
}
if (moduleBuilder.IsPseudoToken(entryPointToken))
{
entryPointToken = moduleBuilder.ResolvePseudoToken(entryPointToken);
}
cliHeader.EntryPointToken = (uint)entryPointToken;
moduleBuilder.Strings.Freeze();
moduleBuilder.UserStrings.Freeze();
moduleBuilder.Guids.Freeze();
moduleBuilder.Blobs.Freeze();
MetadataWriter mw = new MetadataWriter(moduleBuilder, stream);
moduleBuilder.Tables.Freeze(mw);
TextSection code = new TextSection(writer, cliHeader, moduleBuilder, ComputeStrongNameSignatureLength(publicKey));
// Export Directory
if (code.ExportDirectoryLength != 0)
{
writer.Headers.OptionalHeader.DataDirectory[0].VirtualAddress = code.ExportDirectoryRVA;
writer.Headers.OptionalHeader.DataDirectory[0].Size = code.ExportDirectoryLength;
}
// Import Directory
if (code.ImportDirectoryLength != 0)
{
writer.Headers.OptionalHeader.DataDirectory[1].VirtualAddress = code.ImportDirectoryRVA;
writer.Headers.OptionalHeader.DataDirectory[1].Size = code.ImportDirectoryLength;
}
// Import Address Table Directory
if (code.ImportAddressTableLength != 0)
{
writer.Headers.OptionalHeader.DataDirectory[12].VirtualAddress = code.ImportAddressTableRVA;
writer.Headers.OptionalHeader.DataDirectory[12].Size = code.ImportAddressTableLength;
}
// COM Descriptor Directory
writer.Headers.OptionalHeader.DataDirectory[14].VirtualAddress = code.ComDescriptorRVA;
writer.Headers.OptionalHeader.DataDirectory[14].Size = code.ComDescriptorLength;
// Debug Directory
if (code.DebugDirectoryLength != 0)
{
writer.Headers.OptionalHeader.DataDirectory[6].VirtualAddress = code.DebugDirectoryRVA;
writer.Headers.OptionalHeader.DataDirectory[6].Size = code.DebugDirectoryLength;
}
// we need to start by computing the number of sections, because code.PointerToRawData depends on that
writer.Headers.FileHeader.NumberOfSections = 1;
if (moduleBuilder.initializedData.Length != 0)
{
// .sdata
writer.Headers.FileHeader.NumberOfSections++;
}
if (resources != null)
{
// .rsrc
writer.Headers.FileHeader.NumberOfSections++;
}
if (imageFileMachine != ImageFileMachine.ARM)
{
// .reloc
writer.Headers.FileHeader.NumberOfSections++;
}
SectionHeader text = new SectionHeader();
text.Name = ".text";
text.VirtualAddress = code.BaseRVA;
text.VirtualSize = (uint)code.Length;
text.PointerToRawData = code.PointerToRawData;
text.SizeOfRawData = writer.ToFileAlignment((uint)code.Length);
text.Characteristics = SectionHeader.IMAGE_SCN_CNT_CODE | SectionHeader.IMAGE_SCN_MEM_EXECUTE | SectionHeader.IMAGE_SCN_MEM_READ;
SectionHeader sdata = new SectionHeader();
sdata.Name = ".sdata";
sdata.VirtualAddress = text.VirtualAddress + writer.ToSectionAlignment(text.VirtualSize);
sdata.VirtualSize = (uint)moduleBuilder.initializedData.Length;
sdata.PointerToRawData = text.PointerToRawData + text.SizeOfRawData;
sdata.SizeOfRawData = writer.ToFileAlignment((uint)moduleBuilder.initializedData.Length);
sdata.Characteristics = SectionHeader.IMAGE_SCN_CNT_INITIALIZED_DATA | SectionHeader.IMAGE_SCN_MEM_READ | SectionHeader.IMAGE_SCN_MEM_WRITE;
SectionHeader rsrc = new SectionHeader();
rsrc.Name = ".rsrc";
rsrc.VirtualAddress = sdata.VirtualAddress + writer.ToSectionAlignment(sdata.VirtualSize);
rsrc.PointerToRawData = sdata.PointerToRawData + sdata.SizeOfRawData;
rsrc.VirtualSize = resources == null ? 0 : (uint)resources.Length;
rsrc.SizeOfRawData = writer.ToFileAlignment(rsrc.VirtualSize);
rsrc.Characteristics = SectionHeader.IMAGE_SCN_MEM_READ | SectionHeader.IMAGE_SCN_CNT_INITIALIZED_DATA;
if (rsrc.SizeOfRawData != 0)
{
// Resource Directory
writer.Headers.OptionalHeader.DataDirectory[2].VirtualAddress = rsrc.VirtualAddress;
writer.Headers.OptionalHeader.DataDirectory[2].Size = rsrc.VirtualSize;
}
SectionHeader reloc = new SectionHeader();
reloc.Name = ".reloc";
reloc.VirtualAddress = rsrc.VirtualAddress + writer.ToSectionAlignment(rsrc.VirtualSize);
if (imageFileMachine != ImageFileMachine.ARM)
{
reloc.VirtualSize = ((uint)moduleBuilder.unmanagedExports.Count + 1) * 12;
}
reloc.PointerToRawData = rsrc.PointerToRawData + rsrc.SizeOfRawData;
reloc.SizeOfRawData = writer.ToFileAlignment(reloc.VirtualSize);
reloc.Characteristics = SectionHeader.IMAGE_SCN_MEM_READ | SectionHeader.IMAGE_SCN_CNT_INITIALIZED_DATA | SectionHeader.IMAGE_SCN_MEM_DISCARDABLE;
if (reloc.SizeOfRawData != 0)
{
// Base Relocation Directory
writer.Headers.OptionalHeader.DataDirectory[5].VirtualAddress = reloc.VirtualAddress;
writer.Headers.OptionalHeader.DataDirectory[5].Size = reloc.VirtualSize;
}
writer.Headers.OptionalHeader.SizeOfCode = text.SizeOfRawData;
writer.Headers.OptionalHeader.SizeOfInitializedData = sdata.SizeOfRawData + rsrc.SizeOfRawData + reloc.SizeOfRawData;
writer.Headers.OptionalHeader.SizeOfUninitializedData = 0;
writer.Headers.OptionalHeader.SizeOfImage = reloc.VirtualAddress + writer.ToSectionAlignment(reloc.VirtualSize);
writer.Headers.OptionalHeader.SizeOfHeaders = text.PointerToRawData;
writer.Headers.OptionalHeader.BaseOfCode = code.BaseRVA;
writer.Headers.OptionalHeader.BaseOfData = sdata.VirtualAddress;
writer.Headers.OptionalHeader.ImageBase = (ulong)moduleBuilder.__ImageBase;
if (imageFileMachine == ImageFileMachine.IA64)
{
// apparently for IA64 AddressOfEntryPoint points to the address of the entry point
// (i.e. there is an additional layer of indirection), so we add the offset to the pointer
writer.Headers.OptionalHeader.AddressOfEntryPoint = code.StartupStubRVA + 0x20;
}
else if (imageFileMachine != ImageFileMachine.ARM)
{
writer.Headers.OptionalHeader.AddressOfEntryPoint = code.StartupStubRVA;
}
writer.WritePEHeaders();
writer.WriteSectionHeader(text);
if (sdata.SizeOfRawData != 0)
{
writer.WriteSectionHeader(sdata);
}
if (rsrc.SizeOfRawData != 0)
{
writer.WriteSectionHeader(rsrc);
}
if (reloc.SizeOfRawData != 0)
{
writer.WriteSectionHeader(reloc);
}
stream.Seek(text.PointerToRawData, SeekOrigin.Begin);
code.Write(mw, sdata.VirtualAddress);
if (sdata.SizeOfRawData != 0)
{
stream.Seek(sdata.PointerToRawData, SeekOrigin.Begin);
mw.Write(moduleBuilder.initializedData);
}
if (rsrc.SizeOfRawData != 0)
{
stream.Seek(rsrc.PointerToRawData, SeekOrigin.Begin);
resources.Write(mw, rsrc.VirtualAddress);
}
if (reloc.SizeOfRawData != 0)
{
stream.Seek(reloc.PointerToRawData, SeekOrigin.Begin);
code.WriteRelocations(mw);
}
// file alignment
stream.SetLength(reloc.PointerToRawData + reloc.SizeOfRawData);
// do the strong naming
if (keyPair != null)
{
StrongName(stream, keyPair, writer.HeaderSize, text.PointerToRawData, code.StrongNameSignatureRVA - text.VirtualAddress + text.PointerToRawData, code.StrongNameSignatureLength);
}
if (moduleBuilder.symbolWriter != null)
{
moduleBuilder.WriteSymbolTokenMap();
moduleBuilder.symbolWriter.Close();
}
}
[System.Security.SecurityCritical] // auto-generated
internal void DefineNativeResource(PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
{
string strResourceFileName = m_moduleData.m_strResourceFileName;
byte[] resourceBytes = m_moduleData.m_resourceBytes;
if (strResourceFileName != null)
{
DefineNativeResourceFile(GetNativeHandle(),
strResourceFileName,
(int)portableExecutableKind, (int)imageFileMachine);
}
else
if (resourceBytes != null)
{
DefineNativeResourceBytes(GetNativeHandle(),
resourceBytes, resourceBytes.Length,
(int)portableExecutableKind, (int)imageFileMachine);
}
}
public AssemblyGen(string moduleName,
string outDir,
string outFile,
AssemblyGenAttributes generationAttributes,
PortableExecutableKinds peKind,
ImageFileMachine machine)
{
Contract.Requires(!String.IsNullOrEmpty(moduleName), "moduleName", "Module name cannot be a null reference or an empty string.");
Contract.Requires(outFile != null || !SaveAndReloadAssemblies, "outFile", "SaveAssemblies mode requires non-null output file name.");
_genAttrs = generationAttributes;
AssemblyName asmname = new AssemblyName();
AppDomain domain = AppDomain.CurrentDomain; //System.Threading.Thread.GetDomain();
_machine = machine;
_peKind = peKind;
_outFileName = outFile;
#if SILVERLIGHT // AssemblyBuilderAccess.RunAndSave, Environment.CurrentDirectory
asmname.Name = moduleName;
_myAssembly = domain.DefineDynamicAssembly(asmname, AssemblyBuilderAccess.Run);
_myModule = _myAssembly.DefineDynamicModule(moduleName, EmitDebugInfo);
#else
try {
outDir = Path.GetFullPath(String.IsNullOrEmpty(outDir) ? Environment.CurrentDirectory : outDir);
} catch (Exception e) {
throw new ArgumentException("Invalid output directory", e);
}
if (SaveAndReloadAssemblies
#if PEVERIFY
|| VerifyAssemblies
#endif
) {
_outDir = outDir;
}
if (moduleName == "ironscheme.boot.new")
{
_outDir = outDir = Path.Combine(outDir, "build");
_outFileName = "ironscheme.boot.dll";
}
// SymbolWriter fails on Mono for some reason
if (SaveAndReloadAssemblies) {
asmname.Name = moduleName == "ironscheme.boot.new" ? "ironscheme.boot" : moduleName;
if (File.Exists("DEVELOPMENT.snk"))
{
asmname.KeyPair = new StrongNameKeyPair(File.ReadAllBytes("DEVELOPMENT.snk"));
}
asmname.Version = new Version("1.0.0.0");
#pragma warning disable 0618
_myAssembly = domain.DefineDynamicAssembly(asmname, moduleName == "ironscheme.boot.new" ? AssemblyBuilderAccess.Save : AssemblyBuilderAccess.Save, outDir, null);
#pragma warning restore 0618
_myModule = _myAssembly.DefineDynamicModule( moduleName == "ironscheme.boot.new" ? "ironscheme.boot.dll" : _outFileName,
_outFileName, EmitDebugInfo);
} else {
asmname.Name = moduleName;
_myAssembly = domain.DefineDynamicAssembly(asmname, AssemblyBuilderAccess.Run);
_myModule = _myAssembly.DefineDynamicModule(moduleName, EmitDebugInfo);
}
_myAssembly.DefineVersionInfoResource();
#endif
if (EmitDebugInfo) SetDebuggableAttributes();
}
void GetPEKind (out PortableExecutableKinds peKind, out ImageFileMachine machine) {
ModuleHandle.GetPEKind (out peKind, out machine);
}
internal static void WriteModule(StrongNameKeyPair keyPair, byte[] publicKey, ModuleBuilder moduleBuilder,
PEFileKinds fileKind, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine,
ResourceSection resources, int entryPointToken)
{
WriteModule(keyPair, publicKey, moduleBuilder, fileKind, portableExecutableKind, imageFileMachine, resources, entryPointToken, null);
}
protected virtual ModuleHandle GetModuleHandleImpl() => ModuleHandle.EmptyHandle; // Not an api but declared protected because of Reflection.Core/Corelib divide (when built by NativeAOT)
public virtual void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
throw NotImplemented.ByDesign;
}
public sealed override void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
peKind = PortableExecutableKinds.NotAPortableExecutableImage;
machine = default;
}
internal AssemblyGen(AssemblyName name, string outDir, string outFileExtension, bool isDebuggable,
PortableExecutableKinds peKind, ImageFileMachine machine)
{
ContractUtils.RequiresNotNull(name, "name");
#if SILVERLIGHT // AssemblyBuilderAccess.RunAndSave, Environment.CurrentDirectory
_myAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run);
_myModule = _myAssembly.DefineDynamicModule(name.Name, isDebuggable);
#else
if (outFileExtension == null)
{
outFileExtension = ".dll";
}
if (outDir != null)
{
try {
outDir = Path.GetFullPath(outDir);
} catch (Exception) {
throw Error.InvalidOutputDir();
}
try {
Path.Combine(outDir, name.Name + outFileExtension);
} catch (ArgumentException) {
throw Error.InvalidAsmNameOrExtension();
}
_outFileName = name.Name + outFileExtension;
_outDir = outDir;
}
// mark the assembly transparent so that it works in partial trust:
CustomAttributeBuilder[] attributes = new CustomAttributeBuilder[] {
new CustomAttributeBuilder(typeof(SecurityTransparentAttribute).GetConstructor(Type.EmptyTypes), new object[0]),
#if !CLR2
new CustomAttributeBuilder(typeof(SecurityRulesAttribute).GetConstructor(new[] { typeof(SecurityRuleSet) }), new object[] { SecurityRuleSet.Level1 }),
#endif
};
if (outDir != null)
{
#if !CLR2
_myAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.RunAndSave, outDir, false, attributes);
#else
//The API DefineDynamicAssembly is obsolete in Dev10.
_myAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.RunAndSave, outDir,
null, null, null, null, false, attributes);
#endif
_myModule = _myAssembly.DefineDynamicModule(name.Name, _outFileName, isDebuggable);
}
else
{
_myAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run, attributes);
_myModule = _myAssembly.DefineDynamicModule(name.Name, isDebuggable);
}
_myAssembly.DefineVersionInfoResource();
#endif
_machine = machine;
_peKind = peKind;
_isDebuggable = isDebuggable;
if (isDebuggable)
{
SetDebuggableAttributes();
}
}
private void SaveImpl(string assemblyFileName, Stream streamOrNull, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
{
ModuleBuilder manifestModule = null;
foreach (ModuleBuilder moduleBuilder in modules)
{
moduleBuilder.PopulatePropertyAndEventTables();
if (manifestModule == null &&
string.Compare(moduleBuilder.fileName, assemblyFileName, StringComparison.OrdinalIgnoreCase) == 0)
{
manifestModule = moduleBuilder;
}
}
if (manifestModule == null)
{
manifestModule = DefineDynamicModule("RefEmit_OnDiskManifestModule", assemblyFileName, false);
}
AssemblyTable.Record assemblyRecord = new AssemblyTable.Record();
assemblyRecord.HashAlgId = (int)hashAlgorithm;
assemblyRecord.Name = manifestModule.Strings.Add(name);
assemblyRecord.MajorVersion = majorVersion;
assemblyRecord.MinorVersion = minorVersion;
assemblyRecord.BuildNumber = buildVersion;
assemblyRecord.RevisionNumber = revisionVersion;
if (publicKey != null)
{
assemblyRecord.PublicKey = manifestModule.Blobs.Add(ByteBuffer.Wrap(publicKey));
assemblyRecord.Flags = (int)(flags | AssemblyNameFlags.PublicKey);
}
else
{
assemblyRecord.Flags = (int)(flags & ~AssemblyNameFlags.PublicKey);
}
if (culture != null)
{
assemblyRecord.Culture = manifestModule.Strings.Add(culture);
}
int token = 0x20000000 + manifestModule.AssemblyTable.AddRecord(assemblyRecord);
#pragma warning disable 618
// this values are obsolete, but we already know that so we disable the warning
System.Security.Permissions.SecurityAction requestMinimum = System.Security.Permissions.SecurityAction.RequestMinimum;
System.Security.Permissions.SecurityAction requestOptional = System.Security.Permissions.SecurityAction.RequestOptional;
System.Security.Permissions.SecurityAction requestRefuse = System.Security.Permissions.SecurityAction.RequestRefuse;
#pragma warning restore 618
if (requiredPermissions != null)
{
manifestModule.AddDeclarativeSecurity(token, requestMinimum, requiredPermissions);
}
if (optionalPermissions != null)
{
manifestModule.AddDeclarativeSecurity(token, requestOptional, optionalPermissions);
}
if (refusedPermissions != null)
{
manifestModule.AddDeclarativeSecurity(token, requestRefuse, refusedPermissions);
}
if (versionInfo != null)
{
versionInfo.SetName(GetName());
versionInfo.SetFileName(assemblyFileName);
foreach (CustomAttributeBuilder cab in customAttributes)
{
// .NET doesn't support copying blob custom attributes into the version info
if (!cab.HasBlob)
{
versionInfo.SetAttribute(cab);
}
}
ByteBuffer versionInfoData = new ByteBuffer(512);
versionInfo.Write(versionInfoData);
if (unmanagedResources == null)
{
unmanagedResources = new ResourceSection();
}
unmanagedResources.AddVersionInfo(versionInfoData);
}
foreach (CustomAttributeBuilder cab in customAttributes)
{
// we intentionally don't filter out the version info (pseudo) custom attributes (to be compatible with .NET)
manifestModule.SetCustomAttribute(0x20000001, cab);
}
manifestModule.AddDeclarativeSecurity(0x20000001, declarativeSecurity);
foreach (Type type in typeForwarders)
{
manifestModule.AddTypeForwarder(type);
}
foreach (ResourceFile resfile in resourceFiles)
{
int fileToken = AddFile(manifestModule, resfile.FileName, 1 /*ContainsNoMetaData*/);
ManifestResourceTable.Record rec = new ManifestResourceTable.Record();
rec.Offset = 0;
rec.Flags = (int)resfile.Attributes;
rec.Name = manifestModule.Strings.Add(resfile.Name);
rec.Implementation = fileToken;
manifestModule.ManifestResource.AddRecord(rec);
}
int entryPointToken = 0;
foreach (ModuleBuilder moduleBuilder in modules)
{
moduleBuilder.FillAssemblyRefTable();
if (moduleBuilder != manifestModule)
{
int fileToken;
if (entryPoint != null && entryPoint.Module == moduleBuilder)
{
ModuleWriter.WriteModule(null, null, moduleBuilder, fileKind, portableExecutableKind, imageFileMachine, moduleBuilder.unmanagedResources, entryPoint.MetadataToken);
entryPointToken = fileToken = AddFile(manifestModule, moduleBuilder.fileName, 0 /*ContainsMetaData*/);
}
else
{
ModuleWriter.WriteModule(null, null, moduleBuilder, fileKind, portableExecutableKind, imageFileMachine, moduleBuilder.unmanagedResources, 0);
fileToken = AddFile(manifestModule, moduleBuilder.fileName, 0 /*ContainsMetaData*/);
}
moduleBuilder.ExportTypes(fileToken, manifestModule);
}
}
foreach (Module module in addedModules)
{
int fileToken = AddFile(manifestModule, module.FullyQualifiedName, 0 /*ContainsMetaData*/);
module.ExportTypes(fileToken, manifestModule);
}
if (entryPointToken == 0 && entryPoint != null)
{
entryPointToken = entryPoint.MetadataToken;
}
// finally, write the manifest module
ModuleWriter.WriteModule(keyPair, publicKey, manifestModule, fileKind, portableExecutableKind, imageFileMachine, unmanagedResources ?? manifestModule.unmanagedResources, entryPointToken, streamOrNull);
}
public void Save(string assemblyFileName, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
{
SaveImpl(assemblyFileName, null, portableExecutableKind, imageFileMachine);
}
protected virtual void SaveModule(PortableExecutableKinds pekind, ImageFileMachine machine)
{
Report.RuntimeMissingSupport(Location.Null, "-target:module");
}
internal static extern void GetPEKind (IntPtr module, out PortableExecutableKinds peKind, out ImageFileMachine machine);
public virtual void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
// This API was made virtual in V4. Code compiled against V2 might use
// "call" rather than "callvirt" to call it.
// This makes sure those code still works.
RuntimeModule rtModule = this as RuntimeModule;
if (rtModule != null)
rtModule.GetPEKind(out peKind, out machine);
throw new NotImplementedException();
}
private static void WriteModuleImpl(StrongNameKeyPair keyPair, byte[] publicKey, ModuleBuilder moduleBuilder,
PEFileKinds fileKind, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine,
ResourceSection resources, int entryPointToken, Stream stream)
{
moduleBuilder.ApplyUnmanagedExports(imageFileMachine);
moduleBuilder.FixupMethodBodyTokens();
int moduleVersionIdIndex = moduleBuilder.Guids.Add(moduleBuilder.GetModuleVersionIdOrEmpty());
moduleBuilder.ModuleTable.Add(0, moduleBuilder.Strings.Add(moduleBuilder.moduleName), moduleVersionIdIndex, 0, 0);
if (moduleBuilder.UserStrings.IsEmpty)
{
// for compat with Ref.Emit, if there aren't any user strings, we add one
moduleBuilder.UserStrings.Add(" ");
}
if (resources != null)
{
resources.Finish();
}
PEWriter writer = new PEWriter(stream);
writer.Headers.OptionalHeader.FileAlignment = (uint)moduleBuilder.__FileAlignment;
switch (imageFileMachine)
{
case ImageFileMachine.I386:
writer.Headers.FileHeader.Machine = IMAGE_FILE_HEADER.IMAGE_FILE_MACHINE_I386;
writer.Headers.FileHeader.Characteristics |= IMAGE_FILE_HEADER.IMAGE_FILE_32BIT_MACHINE;
writer.Headers.OptionalHeader.SizeOfStackReserve = moduleBuilder.GetStackReserve(0x100000);
break;
case ImageFileMachine.ARM:
writer.Headers.FileHeader.Machine = IMAGE_FILE_HEADER.IMAGE_FILE_MACHINE_ARM;
writer.Headers.FileHeader.Characteristics |= IMAGE_FILE_HEADER.IMAGE_FILE_32BIT_MACHINE | IMAGE_FILE_HEADER.IMAGE_FILE_LARGE_ADDRESS_AWARE;
writer.Headers.OptionalHeader.SizeOfStackReserve = moduleBuilder.GetStackReserve(0x100000);
writer.Headers.OptionalHeader.SectionAlignment = 0x1000;
break;
case ImageFileMachine.AMD64:
writer.Headers.FileHeader.Machine = IMAGE_FILE_HEADER.IMAGE_FILE_MACHINE_AMD64;
writer.Headers.FileHeader.Characteristics |= IMAGE_FILE_HEADER.IMAGE_FILE_LARGE_ADDRESS_AWARE;
writer.Headers.FileHeader.SizeOfOptionalHeader = 0xF0;
writer.Headers.OptionalHeader.Magic = IMAGE_OPTIONAL_HEADER.IMAGE_NT_OPTIONAL_HDR64_MAGIC;
writer.Headers.OptionalHeader.SizeOfStackReserve = moduleBuilder.GetStackReserve(0x400000);
writer.Headers.OptionalHeader.SizeOfStackCommit = 0x4000;
writer.Headers.OptionalHeader.SizeOfHeapCommit = 0x2000;
break;
case ImageFileMachine.IA64:
writer.Headers.FileHeader.Machine = IMAGE_FILE_HEADER.IMAGE_FILE_MACHINE_IA64;
writer.Headers.FileHeader.Characteristics |= IMAGE_FILE_HEADER.IMAGE_FILE_LARGE_ADDRESS_AWARE;
writer.Headers.FileHeader.SizeOfOptionalHeader = 0xF0;
writer.Headers.OptionalHeader.Magic = IMAGE_OPTIONAL_HEADER.IMAGE_NT_OPTIONAL_HDR64_MAGIC;
writer.Headers.OptionalHeader.SizeOfStackReserve = moduleBuilder.GetStackReserve(0x400000);
writer.Headers.OptionalHeader.SizeOfStackCommit = 0x4000;
writer.Headers.OptionalHeader.SizeOfHeapCommit = 0x2000;
break;
default:
throw new ArgumentOutOfRangeException("imageFileMachine");
}
if (fileKind == PEFileKinds.Dll)
{
writer.Headers.FileHeader.Characteristics |= IMAGE_FILE_HEADER.IMAGE_FILE_DLL;
}
switch (fileKind)
{
case PEFileKinds.WindowApplication:
writer.Headers.OptionalHeader.Subsystem = IMAGE_OPTIONAL_HEADER.IMAGE_SUBSYSTEM_WINDOWS_GUI;
break;
default:
writer.Headers.OptionalHeader.Subsystem = IMAGE_OPTIONAL_HEADER.IMAGE_SUBSYSTEM_WINDOWS_CUI;
break;
}
writer.Headers.OptionalHeader.DllCharacteristics = (ushort)moduleBuilder.__DllCharacteristics;
CliHeader cliHeader = new CliHeader();
cliHeader.Cb = 0x48;
cliHeader.MajorRuntimeVersion = 2;
cliHeader.MinorRuntimeVersion = moduleBuilder.MDStreamVersion < 0x20000 ? (ushort)0 : (ushort)5;
if ((portableExecutableKind & PortableExecutableKinds.ILOnly) != 0)
{
cliHeader.Flags |= CliHeader.COMIMAGE_FLAGS_ILONLY;
}
if ((portableExecutableKind & PortableExecutableKinds.Required32Bit) != 0)
{
cliHeader.Flags |= CliHeader.COMIMAGE_FLAGS_32BITREQUIRED;
}
if ((portableExecutableKind & PortableExecutableKinds.Preferred32Bit) != 0)
{
cliHeader.Flags |= CliHeader.COMIMAGE_FLAGS_32BITREQUIRED | CliHeader.COMIMAGE_FLAGS_32BITPREFERRED;
}
if (keyPair != null)
{
cliHeader.Flags |= CliHeader.COMIMAGE_FLAGS_STRONGNAMESIGNED;
}
if (ModuleBuilder.IsPseudoToken(entryPointToken))
{
entryPointToken = moduleBuilder.ResolvePseudoToken(entryPointToken);
}
cliHeader.EntryPointToken = (uint)entryPointToken;
moduleBuilder.Strings.Freeze();
moduleBuilder.UserStrings.Freeze();
moduleBuilder.Guids.Freeze();
moduleBuilder.Blobs.Freeze();
var mw = new ModuleBuilderMetadataWriter(moduleBuilder, stream);
moduleBuilder.Tables.Freeze(mw);
TextSection code = new TextSection(writer, cliHeader, moduleBuilder, ComputeStrongNameSignatureLength(publicKey));
// Export Directory
if (code.ExportDirectoryLength != 0)
{
writer.Headers.OptionalHeader.DataDirectory[0].VirtualAddress = code.ExportDirectoryRVA;
writer.Headers.OptionalHeader.DataDirectory[0].Size = code.ExportDirectoryLength;
}
// Import Directory
if (code.ImportDirectoryLength != 0)
{
writer.Headers.OptionalHeader.DataDirectory[1].VirtualAddress = code.ImportDirectoryRVA;
writer.Headers.OptionalHeader.DataDirectory[1].Size = code.ImportDirectoryLength;
}
// Import Address Table Directory
if (code.ImportAddressTableLength != 0)
{
writer.Headers.OptionalHeader.DataDirectory[12].VirtualAddress = code.ImportAddressTableRVA;
writer.Headers.OptionalHeader.DataDirectory[12].Size = code.ImportAddressTableLength;
}
// COM Descriptor Directory
writer.Headers.OptionalHeader.DataDirectory[14].VirtualAddress = code.ComDescriptorRVA;
writer.Headers.OptionalHeader.DataDirectory[14].Size = code.ComDescriptorLength;
// Debug Directory
if (code.DebugDirectoryLength != 0)
{
writer.Headers.OptionalHeader.DataDirectory[6].VirtualAddress = code.DebugDirectoryRVA;
writer.Headers.OptionalHeader.DataDirectory[6].Size = code.DebugDirectoryLength;
}
// Set the PE File timestamp
writer.Headers.FileHeader.TimeDateStamp = moduleBuilder.GetTimeDateStamp();
// we need to start by computing the number of sections, because code.PointerToRawData depends on that
writer.Headers.FileHeader.NumberOfSections = 2;
if (moduleBuilder.initializedData.Length != 0)
{
// .sdata
writer.Headers.FileHeader.NumberOfSections++;
}
if (resources != null)
{
// .rsrc
writer.Headers.FileHeader.NumberOfSections++;
}
SectionHeader text = new SectionHeader();
text.Name = ".text";
text.VirtualAddress = code.BaseRVA;
text.VirtualSize = (uint)code.Length;
text.PointerToRawData = code.PointerToRawData;
text.SizeOfRawData = writer.ToFileAlignment((uint)code.Length);
text.Characteristics = SectionHeader.IMAGE_SCN_CNT_CODE | SectionHeader.IMAGE_SCN_MEM_EXECUTE | SectionHeader.IMAGE_SCN_MEM_READ;
SectionHeader sdata = new SectionHeader();
sdata.Name = ".sdata";
sdata.VirtualAddress = text.VirtualAddress + writer.ToSectionAlignment(text.VirtualSize);
sdata.VirtualSize = (uint)moduleBuilder.initializedData.Length;
sdata.PointerToRawData = text.PointerToRawData + text.SizeOfRawData;
sdata.SizeOfRawData = writer.ToFileAlignment((uint)moduleBuilder.initializedData.Length);
sdata.Characteristics = SectionHeader.IMAGE_SCN_CNT_INITIALIZED_DATA | SectionHeader.IMAGE_SCN_MEM_READ | SectionHeader.IMAGE_SCN_MEM_WRITE;
SectionHeader rsrc = new SectionHeader();
rsrc.Name = ".rsrc";
rsrc.VirtualAddress = sdata.VirtualAddress + writer.ToSectionAlignment(sdata.VirtualSize);
rsrc.PointerToRawData = sdata.PointerToRawData + sdata.SizeOfRawData;
rsrc.VirtualSize = resources == null ? 0 : (uint)resources.Length;
rsrc.SizeOfRawData = writer.ToFileAlignment(rsrc.VirtualSize);
rsrc.Characteristics = SectionHeader.IMAGE_SCN_MEM_READ | SectionHeader.IMAGE_SCN_CNT_INITIALIZED_DATA;
if (rsrc.SizeOfRawData != 0)
{
// Resource Directory
writer.Headers.OptionalHeader.DataDirectory[2].VirtualAddress = rsrc.VirtualAddress;
writer.Headers.OptionalHeader.DataDirectory[2].Size = rsrc.VirtualSize;
}
SectionHeader reloc = new SectionHeader();
reloc.Name = ".reloc";
reloc.VirtualAddress = rsrc.VirtualAddress + writer.ToSectionAlignment(rsrc.VirtualSize);
reloc.VirtualSize = code.PackRelocations();
reloc.PointerToRawData = rsrc.PointerToRawData + rsrc.SizeOfRawData;
reloc.SizeOfRawData = writer.ToFileAlignment(reloc.VirtualSize);
reloc.Characteristics = SectionHeader.IMAGE_SCN_MEM_READ | SectionHeader.IMAGE_SCN_CNT_INITIALIZED_DATA | SectionHeader.IMAGE_SCN_MEM_DISCARDABLE;
if (reloc.SizeOfRawData != 0)
{
// Base Relocation Directory
writer.Headers.OptionalHeader.DataDirectory[5].VirtualAddress = reloc.VirtualAddress;
writer.Headers.OptionalHeader.DataDirectory[5].Size = reloc.VirtualSize;
}
writer.Headers.OptionalHeader.SizeOfCode = text.SizeOfRawData;
writer.Headers.OptionalHeader.SizeOfInitializedData = sdata.SizeOfRawData + rsrc.SizeOfRawData + reloc.SizeOfRawData;
writer.Headers.OptionalHeader.SizeOfUninitializedData = 0;
writer.Headers.OptionalHeader.SizeOfImage = reloc.VirtualAddress + writer.ToSectionAlignment(reloc.VirtualSize);
writer.Headers.OptionalHeader.SizeOfHeaders = text.PointerToRawData;
writer.Headers.OptionalHeader.BaseOfCode = code.BaseRVA;
writer.Headers.OptionalHeader.BaseOfData = sdata.VirtualAddress;
writer.Headers.OptionalHeader.ImageBase = (ulong)moduleBuilder.__ImageBase;
if (imageFileMachine == ImageFileMachine.IA64)
{
// apparently for IA64 AddressOfEntryPoint points to the address of the entry point
// (i.e. there is an additional layer of indirection), so we add the offset to the pointer
writer.Headers.OptionalHeader.AddressOfEntryPoint = code.StartupStubRVA + 0x20;
}
else
{
writer.Headers.OptionalHeader.AddressOfEntryPoint = code.StartupStubRVA + writer.Thumb;
}
var timeDateStampPosition = writer.WritePEHeaders();
writer.WriteSectionHeader(text);
if (sdata.SizeOfRawData != 0)
{
writer.WriteSectionHeader(sdata);
}
if (rsrc.SizeOfRawData != 0)
{
writer.WriteSectionHeader(rsrc);
}
if (reloc.SizeOfRawData != 0)
{
writer.WriteSectionHeader(reloc);
}
stream.Seek(text.PointerToRawData, SeekOrigin.Begin);
uint guidHeapOffset;
code.Write(mw, sdata.VirtualAddress, out guidHeapOffset);
if (sdata.SizeOfRawData != 0)
{
stream.Seek(sdata.PointerToRawData, SeekOrigin.Begin);
mw.Write(moduleBuilder.initializedData);
}
if (rsrc.SizeOfRawData != 0)
{
stream.Seek(rsrc.PointerToRawData, SeekOrigin.Begin);
resources.Write(mw, rsrc.VirtualAddress);
}
if (reloc.SizeOfRawData != 0)
{
stream.Seek(reloc.PointerToRawData, SeekOrigin.Begin);
code.WriteRelocations(mw);
}
// file alignment
stream.SetLength(reloc.PointerToRawData + reloc.SizeOfRawData);
if (moduleBuilder.symbolWriter != null)
{
moduleBuilder.WriteSymbolTokenMap();
moduleBuilder.symbolWriter.Close();
}
// if we don't have a guid or timestamp, generate one based on the contents of the assembly
if (moduleBuilder.universe.Deterministic &&
(moduleBuilder.GetModuleVersionIdOrEmpty() == Guid.Empty || moduleBuilder.GetTimeDateStamp() == 0 || moduleBuilder.symbolWriter != null))
{
uint timestamp;
Guid guid = GenerateModuleVersionIdAndPseudoTimestamp(stream, out timestamp);
if (moduleBuilder.GetModuleVersionIdOrEmpty() == Guid.Empty)
{
// patch the MVID in the GUID stream
stream.Position = guidHeapOffset + (moduleVersionIdIndex - 1) * 16;
stream.Write(guid.ToByteArray(), 0, 16);
moduleBuilder.__SetModuleVersionId(guid);
}
if (moduleBuilder.GetTimeDateStamp() == 0)
{
// patch the TimeDateStamp in IMAGE_FILE_HEADER
stream.Position = timeDateStampPosition;
stream.Write(BitConverter.GetBytes(timestamp), 0, 4);
moduleBuilder.SetTimeDateStamp(timestamp);
}
if (moduleBuilder.symbolWriter != null)
{
stream.Position = code.DebugDirectoryRVA - code.BaseRVA + code.PointerToRawData;
code.PatchDebugDirectory(mw);
}
}
// do the strong naming
if (keyPair != null)
{
StrongName(stream, keyPair, writer.HeaderSize, text.PointerToRawData, code.StrongNameSignatureRVA - text.VirtualAddress + text.PointerToRawData, code.StrongNameSignatureLength);
}
}
internal static ProcessorArchitecture CalculateProcArchIndex(PortableExecutableKinds pek, ImageFileMachine ifm, AssemblyNameFlags flags)
{
if (((uint)flags & 0xF0) == 0x70)
return ProcessorArchitecture.None;
if ((pek & System.Reflection.PortableExecutableKinds.PE32Plus) == System.Reflection.PortableExecutableKinds.PE32Plus)
{
switch (ifm)
{
case System.Reflection.ImageFileMachine.IA64:
return ProcessorArchitecture.IA64;
case System.Reflection.ImageFileMachine.AMD64:
return ProcessorArchitecture.Amd64;
case System.Reflection.ImageFileMachine.I386:
if ((pek & System.Reflection.PortableExecutableKinds.ILOnly) == System.Reflection.PortableExecutableKinds.ILOnly)
return ProcessorArchitecture.MSIL;
break;
}
}
else
{
if (ifm == System.Reflection.ImageFileMachine.I386)
{
if ((pek & System.Reflection.PortableExecutableKinds.Required32Bit) == System.Reflection.PortableExecutableKinds.Required32Bit)
return ProcessorArchitecture.X86;
if ((pek & System.Reflection.PortableExecutableKinds.ILOnly) == System.Reflection.PortableExecutableKinds.ILOnly)
return ProcessorArchitecture.MSIL;
return ProcessorArchitecture.X86;
}
if (ifm == System.Reflection.ImageFileMachine.ARM)
{
return ProcessorArchitecture.Arm;
}
}
return ProcessorArchitecture.None;
}
void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
RuntimeModule.GetPEKind(_impl, out peKind, out machine);
}
public override void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
peKind = 0;
if ((cliHeader.Flags & CliHeader.COMIMAGE_FLAGS_ILONLY) != 0)
{
peKind |= PortableExecutableKinds.ILOnly;
}
switch (cliHeader.Flags & (CliHeader.COMIMAGE_FLAGS_32BITREQUIRED | CliHeader.COMIMAGE_FLAGS_32BITPREFERRED))
{
case CliHeader.COMIMAGE_FLAGS_32BITREQUIRED:
peKind |= PortableExecutableKinds.Required32Bit;
break;
case CliHeader.COMIMAGE_FLAGS_32BITREQUIRED | CliHeader.COMIMAGE_FLAGS_32BITPREFERRED:
peKind |= PortableExecutableKinds.Preferred32Bit;
break;
default:
// COMIMAGE_FLAGS_32BITPREFERRED by itself is illegal, so we ignore it
// (not setting any flag is ok)
break;
}
if (peFile.OptionalHeader.Magic == IMAGE_OPTIONAL_HEADER.IMAGE_NT_OPTIONAL_HDR64_MAGIC)
{
peKind |= PortableExecutableKinds.PE32Plus;
}
machine = (ImageFileMachine)peFile.FileHeader.Machine;
}
public override void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
throw new MissingModuleException(this);
}
public AssemblyGen(string moduleName,
string outDir,
string outFile,
AssemblyGenAttributes generationAttributes,
PortableExecutableKinds peKind,
ImageFileMachine machine)
{
Contract.Requires(!String.IsNullOrEmpty(moduleName), "moduleName", "Module name cannot be a null reference or an empty string.");
Contract.Requires(outFile != null || !SaveAndReloadAssemblies, "outFile", "SaveAssemblies mode requires non-null output file name.");
_genAttrs = generationAttributes;
AssemblyName asmname = new AssemblyName();
AppDomain domain = AppDomain.CurrentDomain; //System.Threading.Thread.GetDomain();
_machine = machine;
_peKind = peKind;
_outFileName = outFile;
#if SILVERLIGHT // AssemblyBuilderAccess.RunAndSave, Environment.CurrentDirectory
asmname.Name = moduleName;
_myAssembly = domain.DefineDynamicAssembly(asmname, AssemblyBuilderAccess.Run);
_myModule = _myAssembly.DefineDynamicModule(moduleName, EmitDebugInfo);
#else
try {
outDir = Path.GetFullPath(String.IsNullOrEmpty(outDir) ? Environment.CurrentDirectory : outDir);
} catch (Exception e) {
throw new ArgumentException("Invalid output directory", e);
}
if (SaveAndReloadAssemblies
#if PEVERIFY
|| VerifyAssemblies
#endif
)
{
_outDir = outDir;
}
if (moduleName == "ironscheme.boot.new")
{
_outDir = outDir = Path.Combine(outDir, "build");
_outFileName = "ironscheme.boot.dll";
}
// SymbolWriter fails on Mono for some reason
if (SaveAndReloadAssemblies)
{
asmname.Name = moduleName == "ironscheme.boot.new" ? "ironscheme.boot" : moduleName;
if (File.Exists("DEVELOPMENT.snk"))
{
asmname.KeyPair = new StrongNameKeyPair(File.ReadAllBytes("DEVELOPMENT.snk"));
}
asmname.Version = new Version("1.0.0.0");
#pragma warning disable 0618
_myAssembly = domain.DefineDynamicAssembly(asmname, moduleName == "ironscheme.boot.new" ? AssemblyBuilderAccess.Save : AssemblyBuilderAccess.Save, outDir, null);
#pragma warning restore 0618
_myModule = _myAssembly.DefineDynamicModule(moduleName == "ironscheme.boot.new" ? "ironscheme.boot.dll" : _outFileName,
_outFileName, EmitDebugInfo);
}
else
{
asmname.Name = moduleName;
_myAssembly = domain.DefineDynamicAssembly(asmname, AssemblyBuilderAccess.Run);
_myModule = _myAssembly.DefineDynamicModule(moduleName, EmitDebugInfo);
}
_myAssembly.DefineVersionInfoResource();
#endif
if (EmitDebugInfo)
{
SetDebuggableAttributes();
}
}
internal void SetProcArchIndex(PortableExecutableKinds pek, ImageFileMachine ifm)
{
ProcessorArchitecture = CalculateProcArchIndex(pek, ifm, _Flags);
}
// making this internal, used by Module.GetPEKind
internal void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
int _peKind;
int _machine;
_GetPEKind(out _peKind, out _machine);
peKind = (PortableExecutableKinds)_peKind;
machine = (ImageFileMachine)_machine;
}
public override void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
ModuleHandle.GetPEKind(this, out peKind, out machine);
}
public sealed override void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
throw new PlatformNotSupportedException();
}
public virtual void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
throw new NotSupportedException();
}
public void __Save(Stream stream, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
{
if (!stream.CanRead || !stream.CanWrite || !stream.CanSeek || stream.Position != 0)
{
throw new ArgumentException("Stream must support read/write/seek and current position must be zero.", "stream");
}
if (modules.Count != 1)
{
throw new NotSupportedException("Saving to a stream is only supported for single module assemblies.");
}
SaveImpl(modules[0].fileName, stream, portableExecutableKind, imageFileMachine);
}
public override void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
UnderlyingModule.GetPEKind(out peKind, out machine);
}
private void SaveImpl(string assemblyFileName, Stream streamOrNull, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
{
ModuleBuilder manifestModule = null;
foreach (ModuleBuilder moduleBuilder in modules)
{
moduleBuilder.SetIsSaved();
moduleBuilder.PopulatePropertyAndEventTables();
if (manifestModule == null
&& string.Compare(moduleBuilder.fileName, assemblyFileName, StringComparison.OrdinalIgnoreCase) == 0)
{
manifestModule = moduleBuilder;
}
}
if (manifestModule == null)
{
manifestModule = DefineDynamicModule("RefEmit_OnDiskManifestModule", assemblyFileName, false);
}
AssemblyTable.Record assemblyRecord = new AssemblyTable.Record();
assemblyRecord.HashAlgId = (int)hashAlgorithm;
assemblyRecord.Name = manifestModule.Strings.Add(name);
assemblyRecord.MajorVersion = majorVersion;
assemblyRecord.MinorVersion = minorVersion;
assemblyRecord.BuildNumber = buildVersion;
assemblyRecord.RevisionNumber = revisionVersion;
if (publicKey != null)
{
assemblyRecord.PublicKey = manifestModule.Blobs.Add(ByteBuffer.Wrap(publicKey));
assemblyRecord.Flags = (int)(flags | AssemblyNameFlags.PublicKey);
}
else
{
assemblyRecord.Flags = (int)(flags & ~AssemblyNameFlags.PublicKey);
}
if (culture != null)
{
assemblyRecord.Culture = manifestModule.Strings.Add(culture);
}
manifestModule.AssemblyTable.AddRecord(assemblyRecord);
ResourceSection unmanagedResources = versionInfo != null || win32icon != null || win32manifest != null || win32resources != null
? new ResourceSection()
: null;
if (versionInfo != null)
{
versionInfo.SetName(GetName());
versionInfo.SetFileName(assemblyFileName);
foreach (CustomAttributeBuilder cab in customAttributes)
{
// .NET doesn't support copying blob custom attributes into the version info
if (!cab.HasBlob || universe.DecodeVersionInfoAttributeBlobs)
{
versionInfo.SetAttribute(this, cab);
}
}
ByteBuffer versionInfoData = new ByteBuffer(512);
versionInfo.Write(versionInfoData);
unmanagedResources.AddVersionInfo(versionInfoData);
}
if (win32icon != null)
{
unmanagedResources.AddIcon(win32icon);
}
if (win32manifest != null)
{
unmanagedResources.AddManifest(win32manifest, fileKind == PEFileKinds.Dll ? (ushort)2 : (ushort)1);
}
if (win32resources != null)
{
unmanagedResources.ExtractResources(win32resources);
}
foreach (CustomAttributeBuilder cab in customAttributes)
{
// we intentionally don't filter out the version info (pseudo) custom attributes (to be compatible with .NET)
manifestModule.SetCustomAttribute(0x20000001, cab);
}
manifestModule.AddDeclarativeSecurity(0x20000001, declarativeSecurity);
foreach (TypeForwarder fwd in typeForwarders)
{
manifestModule.AddTypeForwarder(fwd.Type, fwd.IncludeNested);
}
foreach (ResourceFile resfile in resourceFiles)
{
if (resfile.Writer != null)
{
resfile.Writer.Generate();
resfile.Writer.Close();
}
int fileToken = AddFile(manifestModule, resfile.FileName, 1 /*ContainsNoMetaData*/);
ManifestResourceTable.Record rec = new ManifestResourceTable.Record();
rec.Offset = 0;
rec.Flags = (int)resfile.Attributes;
rec.Name = manifestModule.Strings.Add(resfile.Name);
rec.Implementation = fileToken;
manifestModule.ManifestResource.AddRecord(rec);
}
int entryPointToken = 0;
foreach (ModuleBuilder moduleBuilder in modules)
{
moduleBuilder.FillAssemblyRefTable();
moduleBuilder.EmitResources();
if (moduleBuilder != manifestModule)
{
int fileToken;
if (entryPoint != null && entryPoint.Module == moduleBuilder)
{
ModuleWriter.WriteModule(null, null, moduleBuilder, fileKind, portableExecutableKind, imageFileMachine, moduleBuilder.unmanagedResources, entryPoint.MetadataToken);
entryPointToken = fileToken = AddFile(manifestModule, moduleBuilder.fileName, 0 /*ContainsMetaData*/);
}
else
{
ModuleWriter.WriteModule(null, null, moduleBuilder, fileKind, portableExecutableKind, imageFileMachine, moduleBuilder.unmanagedResources, 0);
fileToken = AddFile(manifestModule, moduleBuilder.fileName, 0 /*ContainsMetaData*/);
}
moduleBuilder.ExportTypes(fileToken, manifestModule);
}
}
foreach (Module module in addedModules)
{
int fileToken = AddFile(manifestModule, module.FullyQualifiedName, 0 /*ContainsMetaData*/);
module.ExportTypes(fileToken, manifestModule);
}
if (entryPointToken == 0 && entryPoint != null)
{
entryPointToken = entryPoint.MetadataToken;
}
// finally, write the manifest module
ModuleWriter.WriteModule(keyPair, publicKey, manifestModule, fileKind, portableExecutableKind, imageFileMachine, unmanagedResources ?? manifestModule.unmanagedResources, entryPointToken, streamOrNull);
}
protected override void SaveModule(PortableExecutableKinds pekind, ImageFileMachine machine)
{
module.Builder.__Save(pekind, machine);
}
public virtual void GetPEKind (out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
throw CreateNIE ();
}
internal static extern void GetPEKind(IntPtr module, out PortableExecutableKinds peKind, out ImageFileMachine machine);
public override void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
ModuleHandle.GetPEKind(GetNativeHandle(), out peKind, out machine);
}
public virtual void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
throw CreateNIE();
}
internal void SetProcArchIndex(PortableExecutableKinds pek, ImageFileMachine ifm)
{
ProcessorArchitecture = CalculateProcArchIndex(pek, ifm, _Flags);
}
[System.Security.SecurityCritical] // auto-generated
internal void Save(String fileName, bool isAssemblyFile, PortableExecutableKinds portableExecutableKind,
ImageFileMachine imageFileMachine)
{
// This is a helper called by AssemblyBuilder save to save information for the persistable modules.
if (m_moduleData.m_embeddedRes != null)
{
// There are embedded resources for this module
ResWriterData resWriter;
// Add each resource content into the to be saved PE file
for (resWriter = m_moduleData.m_embeddedRes; resWriter != null; resWriter = resWriter.m_nextResWriter)
{
if (resWriter.m_resWriter != null)
resWriter.m_resWriter.Generate();
byte[] resBytes = new byte[resWriter.m_memoryStream.Length];
resWriter.m_memoryStream.Flush();
resWriter.m_memoryStream.Position = 0;
resWriter.m_memoryStream.Read(resBytes, 0, resBytes.Length);
AddResource(GetNativeHandle(),
resWriter.m_strName,
resBytes,
resBytes.Length,
m_moduleData.FileToken,
(int)resWriter.m_attribute,
(int)portableExecutableKind,
(int)imageFileMachine);
}
}
DefineNativeResource(portableExecutableKind, imageFileMachine);
PEFileKinds pekind = isAssemblyFile ? ContainingAssemblyBuilder.m_assemblyData.m_peFileKind : PEFileKinds.Dll;
SavePEFile(GetNativeHandle(), fileName, m_EntryPoint.Token, (int)pekind, isAssemblyFile);
m_moduleData.m_isSaved = true;
}
public override void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
throw new MissingModuleException(this);
}
private void SaveNoLock(String assemblyFileName,
PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
{
int i;
int size;
Type type;
TypeBuilder typeBuilder;
ModuleBuilder modBuilder;
String strModFileName;
ModuleBuilder assemblyModule;
ResWriterData tempRes;
int[] tkAttrs = null;
int[] tkAttrs2 = null;
ModuleBuilder onDiskAssemblyModule;
BCLDebug.Log("DYNIL", "## DYNIL LOGGING: AssemblyBuilder.Save( " + assemblyFileName + " )");
String tmpVersionFile = null;
try
{
if (m_assemblyData.m_iCABuilder != 0)
{
tkAttrs = new int[m_assemblyData.m_iCABuilder];
}
if (m_assemblyData.m_iCAs != 0)
{
tkAttrs2 = new int[m_assemblyData.m_iCAs];
}
if (m_assemblyData.m_isSaved == true)
{
// assembly has been saved before!
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
Environment.GetResourceString(ResId.InvalidOperation_AssemblyHasBeenSaved),
nGetSimpleName()));
}
if ((m_assemblyData.m_access & AssemblyBuilderAccess.Save) != AssemblyBuilderAccess.Save)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CantSaveTransientAssembly"));
}
if (assemblyFileName == null)
{
throw new ArgumentNullException("assemblyFileName");
}
if (assemblyFileName.Length == 0)
{
throw new ArgumentException(Environment.GetResourceString("Argument_EmptyFileName"), "assemblyFileName");
}
if (!String.Equals(assemblyFileName, Path.GetFileName(assemblyFileName)))
{
throw new ArgumentException(Environment.GetResourceString("Argument_NotSimpleFileName"), "assemblyFileName");
}
// Check if assembly info is supposed to be stored with one of the module files.
assemblyModule = m_assemblyData.FindModuleWithFileName(assemblyFileName);
if (assemblyModule != null)
{
m_assemblyData.SetOnDiskAssemblyModule(assemblyModule);
}
// If assembly is to be stored alone, then no file name should conflict with it.
// This check will ensure resource file names are different assembly file name.
//
if (assemblyModule == null)
{
m_assemblyData.CheckFileNameConflict(assemblyFileName);
}
if (m_assemblyData.m_strDir == null)
{
// set it to current directory
m_assemblyData.m_strDir = Environment.CurrentDirectory;
}
else if (Directory.Exists(m_assemblyData.m_strDir) == false)
{
throw new ArgumentException(String.Format(CultureInfo.InvariantCulture,
Environment.GetResourceString("Argument_InvalidDirectory"),
m_assemblyData.m_strDir));
}
// after this point, assemblyFileName is the full path name.
assemblyFileName = Path.Combine(m_assemblyData.m_strDir, assemblyFileName);
assemblyFileName = Path.GetFullPath(assemblyFileName);
// Check caller has the right to create the assembly file itself.
new FileIOPermission(FileIOPermissionAccess.Write | FileIOPermissionAccess.Append, assemblyFileName).Demand();
// 1. setup/create the IMetaDataAssemblyEmit for the on disk version
if (assemblyModule != null)
{
// prepare saving CAs on assembly def. We need to introduce the MemberRef for
// the CA's type first of all. This is for the case the we have embedded manifest.
// We need to introduce these MRs before we call PreSave where we will snap
// into a ondisk metadata. If we do it after this, the ondisk metadata will
// not contain the proper MRs.
//
for (i = 0; i < m_assemblyData.m_iCABuilder; i++)
{
tkAttrs[i] = m_assemblyData.m_CABuilders[i].PrepareCreateCustomAttributeToDisk(
assemblyModule);
}
for (i = 0; i < m_assemblyData.m_iCAs; i++)
{
tkAttrs2[i] = assemblyModule.InternalGetConstructorToken(m_assemblyData.m_CACons[i], true).Token;
}
assemblyModule.PreSave(assemblyFileName, portableExecutableKind, imageFileMachine);
}
nPrepareForSavingManifestToDisk(assemblyModule);
// This function will return the embedded manifest module, an already exposed ModuleBuilder
// created by user, or make the stand alone manifest module exposed through managed code.
//
onDiskAssemblyModule = m_assemblyData.GetOnDiskAssemblyModule();
if (assemblyModule == null)
{
// This is for introducing the MRs for CA's type. This case is for stand alone
// manifest. We need to wait till nPrepareForSavingManifestToDisk is called.
// That will trigger the creation of the on-disk stand alone manifest module.
//
for (i = 0; i < m_assemblyData.m_iCABuilder; i++)
{
tkAttrs[i] = m_assemblyData.m_CABuilders[i].PrepareCreateCustomAttributeToDisk(
onDiskAssemblyModule);
}
for (i = 0; i < m_assemblyData.m_iCAs; i++)
{
tkAttrs2[i] = onDiskAssemblyModule.InternalGetConstructorToken(m_assemblyData.m_CACons[i], true).Token;
}
}
// 2. save all of the persistable modules contained by this AssemblyBuilder except the module that is going to contain
// Assembly information
//
// 3. create the file list in the manifest and track the file token. If it is embedded assembly,
// the assembly file should not be on the file list.
//
size = m_assemblyData.m_moduleBuilderList.Count;
for (i = 0; i < size; i++)
{
ModuleBuilder mBuilder = (ModuleBuilder)m_assemblyData.m_moduleBuilderList[i];
if (mBuilder.IsTransient() == false && mBuilder != assemblyModule)
{
strModFileName = mBuilder.m_moduleData.m_strFileName;
if (m_assemblyData.m_strDir != null)
{
strModFileName = Path.Combine(m_assemblyData.m_strDir, strModFileName);
strModFileName = Path.GetFullPath(strModFileName);
}
// Check caller has the right to create the Module file itself.
new FileIOPermission(FileIOPermissionAccess.Write | FileIOPermissionAccess.Append, strModFileName).Demand();
mBuilder.m_moduleData.m_tkFile = nSaveToFileList(mBuilder.m_moduleData.m_strFileName);
mBuilder.PreSave(strModFileName, portableExecutableKind, imageFileMachine);
mBuilder.Save(strModFileName, false, portableExecutableKind, imageFileMachine);
// Cannot set the hash value when creating the file since the file token
// is needed to created the entries for the embedded resources in the
// module and the resources need to be there before you figure the hash.
nSetHashValue(mBuilder.m_moduleData.m_tkFile, strModFileName);
}
}
// 4. Add the public ComType
for (i = 0; i < m_assemblyData.m_iPublicComTypeCount; i++)
{
type = m_assemblyData.m_publicComTypeList[i];
if (type is System.RuntimeType)
{
modBuilder = m_assemblyData.FindModuleWithName(type.Module.m_moduleData.m_strModuleName);
if (modBuilder != assemblyModule)
{
DefineNestedComType(type, modBuilder.m_moduleData.m_tkFile, type.MetadataTokenInternal);
}
}
else
{
// Could assert that "type" is a TypeBuilder, but next statement throws if it isn't.
typeBuilder = (TypeBuilder)type;
modBuilder = (ModuleBuilder)type.Module;
if (modBuilder != assemblyModule)
{
DefineNestedComType(type, modBuilder.m_moduleData.m_tkFile, typeBuilder.MetadataTokenInternal);
}
}
}
// 5. write AssemblyDef's CAs
for (i = 0; i < m_assemblyData.m_iCABuilder; i++)
{
m_assemblyData.m_CABuilders[i].CreateCustomAttribute(
onDiskAssemblyModule,
AssemblyBuilderData.m_tkAssembly, // This is the AssemblyDef token
tkAttrs[i], true);
}
for (i = 0; i < m_assemblyData.m_iCAs; i++)
{
TypeBuilder.InternalCreateCustomAttribute(
AssemblyBuilderData.m_tkAssembly, // This is the AssemblyDef token
tkAttrs2[i],
m_assemblyData.m_CABytes[i],
onDiskAssemblyModule, // pass in the in-memory assembly module
true);
}
// 6. write security permission requests to the manifest.
if (m_assemblyData.m_RequiredPset != null || m_assemblyData.m_OptionalPset != null || m_assemblyData.m_RefusedPset != null)
{
// Translate sets into internal encoding (uses standard binary serialization).
byte[] required = null;
byte[] optional = null;
byte[] refused = null;
if (m_assemblyData.m_RequiredPset != null)
{
required = m_assemblyData.m_RequiredPset.EncodeXml();
}
if (m_assemblyData.m_OptionalPset != null)
{
optional = m_assemblyData.m_OptionalPset.EncodeXml();
}
if (m_assemblyData.m_RefusedPset != null)
{
refused = m_assemblyData.m_RefusedPset.EncodeXml();
}
nSavePermissionRequests(required, optional, refused);
}
// 7. Save the stand alone managed resources
size = m_assemblyData.m_resWriterList.Count;
for (i = 0; i < size; i++)
{
tempRes = null;
try
{
tempRes = (ResWriterData)m_assemblyData.m_resWriterList[i];
// If the user added an existing resource to the manifest, the
// corresponding ResourceWriter will be null.
if (tempRes.m_resWriter != null)
{
// Check caller has the right to create the Resource file itself.
new FileIOPermission(FileIOPermissionAccess.Write | FileIOPermissionAccess.Append, tempRes.m_strFullFileName).Demand();
}
}
finally
{
if (tempRes != null && tempRes.m_resWriter != null)
{
tempRes.m_resWriter.Close();
}
}
// Add entry to manifest for this stand alone resource
nAddStandAloneResource(tempRes.m_strName, tempRes.m_strFileName, tempRes.m_strFullFileName, (int)tempRes.m_attribute);
}
// Save now!!
if (assemblyModule == null)
{
// Stand alone manifest
if (m_assemblyData.m_entryPointModule != null)
{
nSaveManifestToDisk(assemblyFileName, m_assemblyData.m_entryPointModule.m_moduleData.m_tkFile, (int)m_assemblyData.m_peFileKind,
(int)portableExecutableKind, (int)imageFileMachine);
}
else
{
nSaveManifestToDisk(assemblyFileName, 0, (int)m_assemblyData.m_peFileKind,
(int)portableExecutableKind, (int)imageFileMachine);
}
}
else
{
// embedded manifest
// If the module containing the entry point is not the manifest file, we need to
// let the manifest file point to the module which contains the entry point.
//
//
//
//
if (m_assemblyData.m_entryPointModule != null && m_assemblyData.m_entryPointModule != assemblyModule)
{
assemblyModule.m_EntryPoint = new MethodToken(m_assemblyData.m_entryPointModule.m_moduleData.m_tkFile);
}
assemblyModule.Save(assemblyFileName, true, portableExecutableKind, imageFileMachine);
}
m_assemblyData.m_isSaved = true;
}
finally
{
if (tmpVersionFile != null)
{
// Delete file.
System.IO.File.Delete(tmpVersionFile);
}
}
}
void Save (string assemblyFileName, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
{
this.peKind = portableExecutableKind;
this.machine = imageFileMachine;
if ((peKind & PortableExecutableKinds.PE32Plus) != 0 || (peKind & PortableExecutableKinds.Unmanaged32Bit) != 0)
throw new NotImplementedException (peKind.ToString ());
if (machine == ImageFileMachine.IA64 || machine == ImageFileMachine.AMD64)
throw new NotImplementedException (machine.ToString ());
if (resource_writers != null) {
foreach (IResourceWriter writer in resource_writers) {
writer.Generate ();
writer.Close ();
}
}
// Create a main module if not already created
ModuleBuilder mainModule = null;
if (modules != null) {
foreach (ModuleBuilder module in modules)
if (module.FullyQualifiedName == assemblyFileName)
mainModule = module;
}
if (mainModule == null)
mainModule = DefineDynamicModule ("RefEmit_OnDiskManifestModule", assemblyFileName);
if (!is_module_only)
mainModule.IsMain = true;
/*
* Create a new entry point if the one specified
* by the user is in another module.
*/
if ((entry_point != null) && entry_point.DeclaringType.Module != mainModule) {
Type[] paramTypes;
if (entry_point.GetParametersCount () == 1)
paramTypes = new Type [] { typeof (string) };
else
paramTypes = Type.EmptyTypes;
MethodBuilder mb = mainModule.DefineGlobalMethod ("__EntryPoint$", MethodAttributes.Static|MethodAttributes.PrivateScope, entry_point.ReturnType, paramTypes);
ILGenerator ilgen = mb.GetILGenerator ();
if (paramTypes.Length == 1)
ilgen.Emit (OpCodes.Ldarg_0);
ilgen.Emit (OpCodes.Tailcall);
ilgen.Emit (OpCodes.Call, entry_point);
ilgen.Emit (OpCodes.Ret);
entry_point = mb;
}
if (version_res != null)
DefineVersionInfoResourceImpl (assemblyFileName);
if (sn != null) {
// runtime needs to value to embed it into the assembly
public_key = sn.PublicKey;
}
foreach (ModuleBuilder module in modules)
if (module != mainModule)
module.Save ();
// Write out the main module at the end, because it needs to
// contain the hash of the other modules
mainModule.Save ();
if ((sn != null) && (sn.CanSign)) {
sn.Sign (System.IO.Path.Combine (this.AssemblyDir, assemblyFileName));
}
created = true;
}
public void GetPEKind(out PortableExecutableKinds& peKindout, ImageFileMachine& machine)
{
}
public override void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
InternalModule.GetPEKind(out peKind, out machine);
}
public abstract override void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine);
[System.Security.SecurityCritical] // auto-generated
internal void PreSave(String fileName,
PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
{
if (m_moduleData.m_isSaved == true)
{
// can only save once
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
Environment.GetResourceString("InvalidOperation_ModuleHasBeenSaved"),
m_moduleData.m_strModuleName));
}
if (m_moduleData.m_fGlobalBeenCreated == false && m_moduleData.m_fHasGlobal == true)
throw new NotSupportedException(Environment.GetResourceString("NotSupported_GlobalFunctionNotBaked"));
TypeBuilder typeBuilder;
foreach (Type item in m_TypeBuilderDict.Values)
{
if (item is TypeBuilder)
{
typeBuilder = (TypeBuilder)item;
}
else
{
EnumBuilder enumBuilder = (EnumBuilder)item;
typeBuilder = enumBuilder.m_typeBuilder;
}
if (!typeBuilder.IsCreated())
{
// cannot save to PE file without creating all of the types first
throw new NotSupportedException(String.Format(CultureInfo.InvariantCulture,
Environment.GetResourceString("NotSupported_NotAllTypesAreBaked"),
typeBuilder.FullName));
}
}
PreSavePEFile(GetNativeHandle(), (int)portableExecutableKind, (int)imageFileMachine);
}
public void Save()
{
PortableExecutableKinds pekind = PortableExecutableKinds.ILOnly;
ImageFileMachine machine;
switch (Compiler.Settings.Platform)
{
case Platform.X86:
pekind |= PortableExecutableKinds.Required32Bit;
machine = ImageFileMachine.I386;
break;
case Platform.X64:
pekind |= PortableExecutableKinds.PE32Plus;
machine = ImageFileMachine.AMD64;
break;
case Platform.IA64:
machine = ImageFileMachine.IA64;
break;
case Platform.AnyCPU32Preferred:
#if STATIC
pekind |= PortableExecutableKinds.Preferred32Bit;
machine = ImageFileMachine.I386;
break;
#else
throw new NotSupportedException();
#endif
case Platform.Arm:
#if STATIC
machine = ImageFileMachine.ARM;
break;
#else
throw new NotSupportedException();
#endif
case Platform.AnyCPU:
default:
machine = ImageFileMachine.I386;
break;
}
Compiler.TimeReporter.Start(TimeReporter.TimerType.OutputSave);
try {
if (Compiler.Settings.Target == Target.Module)
{
SaveModule(pekind, machine);
}
else
{
Builder.Save(module.Builder.ScopeName, pekind, machine);
}
} catch (Exception e) {
Report.Error(16, "Could not write to file `" + name + "', cause: " + e.Message);
}
Compiler.TimeReporter.Stop(TimeReporter.TimerType.OutputSave);
// Save debug symbols file
if (symbol_writer != null && Compiler.Report.Errors == 0)
{
// TODO: it should run in parallel
Compiler.TimeReporter.Start(TimeReporter.TimerType.DebugSave);
var filename = file_name + ".mdb";
try {
// We mmap the file, so unlink the previous version since it may be in use
File.Delete(filename);
} catch {
// We can safely ignore
}
module.WriteDebugSymbol(symbol_writer);
using (FileStream fs = new FileStream(filename, FileMode.Create, FileAccess.Write)) {
symbol_writer.CreateSymbolFile(module.Builder.ModuleVersionId, fs);
}
Compiler.TimeReporter.Stop(TimeReporter.TimerType.DebugSave);
}
}
[System.Security.SecuritySafeCritical] // auto-generated
internal static void GetPEKind(RuntimeModule module, out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
int lKind, lMachine;
GetPEKind(module.GetNativeHandle(), out lKind, out lMachine);
peKind = (PortableExecutableKinds)lKind;
machine = (ImageFileMachine)lMachine;
}
internal void SetProcArchIndex(PortableExecutableKinds pek, ImageFileMachine ifm)
{
#pragma warning disable SYSLIB0037 // AssemblyName.ProcessorArchitecture is obsolete
ProcessorArchitecture = CalculateProcArchIndex(pek, ifm, _flags);
#pragma warning restore SYSLIB0037
}
