public MetadataWriter(AssemblyDefinition asm, MetadataRoot root,
AssemblyKind kind, TargetRuntime rt, BinaryWriter writer)
{
m_assembly = asm;
m_root = root;
m_runtime = rt;
m_imgWriter = new ImageWriter (this, kind, writer);
m_binaryWriter = m_imgWriter.GetTextWriter ();
m_stringCache = new Hashtable ();
m_stringWriter = new MemoryBinaryWriter (Encoding.UTF8);
m_stringWriter.Write ((byte) 0);
m_guidCache = new Hashtable ();
m_guidWriter = new MemoryBinaryWriter ();
m_usCache = new Hashtable ();
m_usWriter = new MemoryBinaryWriter (Encoding.Unicode);
m_usWriter.Write ((byte) 0);
m_blobCache = new Hashtable ();
m_blobWriter = new MemoryBinaryWriter ();
m_blobWriter.Write ((byte) 0);
m_tWriter = new MemoryBinaryWriter ();
m_tableWriter = new MetadataTableWriter (this, m_tWriter);
m_cilWriter = new MemoryBinaryWriter ();
m_fieldDataWriter = new MemoryBinaryWriter ();
m_resWriter = new MemoryBinaryWriter ();
}
public MetadataRowWriter (MetadataTableWriter mtwv)
{
m_binaryWriter = mtwv.GetWriter ();
m_root = mtwv.GetMetadataRoot ();
m_ciCache = new int [13];
m_counter = new Utilities.TableRowCounter (GetNumberOfRows);
}
public MetadataTableWriter (MetadataWriter mrv, MemoryBinaryWriter writer)
{
m_root = mrv.GetMetadataRoot ();
m_heap = m_root.Streams.TablesHeap;
m_binaryWriter = writer;
m_mrrw = new MetadataRowWriter (this);
}
public CodeWriter (ReflectionWriter reflectWriter, MemoryBinaryWriter writer)
{
m_reflectWriter = reflectWriter;
m_binaryWriter = writer;
m_codeWriter = new MemoryBinaryWriter ();
m_localSigCache = new Hashtable ();
}
public ResourceWriter(Image img, Section rsrc, MemoryBinaryWriter writer)
{
m_img = img;
m_rsrc = rsrc;
m_writer = writer;
m_dataEntries = new ArrayList ();
m_stringEntries = new ArrayList ();
}
public ResourceWriter(Image img, Section rsrc, MemoryBinaryWriter writer)
{
m_img = img;
m_rsrc = rsrc;
m_writer = writer;
m_dataEntries = new ArrayList();
m_stringEntries = new ArrayList();
}
public ImageWriter(MetadataWriter writer, AssemblyKind kind, BinaryWriter bw)
{
m_mdWriter= writer;
m_img = writer.GetMetadataRoot ().GetImage ();
m_kind = kind;
m_binaryWriter = bw;
m_textWriter = new MemoryBinaryWriter ();
m_textWriter.BaseStream.Position = 80;
m_relocWriter = new MemoryBinaryWriter ();
}
public ImageWriter(MetadataWriter writer, AssemblyKind kind, BinaryWriter bw)
{
m_mdWriter = writer;
m_img = writer.GetMetadataRoot().GetImage();
m_kind = kind;
m_binaryWriter = bw;
m_textWriter = new MemoryBinaryWriter();
m_textWriter.BaseStream.Position = 80;
m_relocWriter = new MemoryBinaryWriter();
}
public ReflectionWriter(ModuleDefinition mod)
{
m_mod = mod;
m_typeDefStack = new ArrayList ();
m_methodStack = new ArrayList ();
m_fieldStack = new ArrayList ();
m_genericParamStack = new ArrayList ();
m_typeSpecCache = new Hashtable ();
m_methodIndex = 1;
m_fieldIndex = 1;
m_paramIndex = 1;
m_eventIndex = 1;
m_propertyIndex = 1;
m_constWriter = new MemoryBinaryWriter ();
}
void Write (CustomAttrib.Elem elem, MemoryBinaryWriter writer) // TODO
{
if (elem.String)
elem.FieldOrPropType = ElementType.String;
else if (elem.Type)
elem.FieldOrPropType = ElementType.Type;
else if (elem.BoxedValueType)
Write (elem.FieldOrPropType);
switch (elem.FieldOrPropType) {
case ElementType.Boolean :
writer.Write ((byte) ((bool) elem.Value ? 1 : 0));
break;
case ElementType.Char :
writer.Write ((ushort) (char) elem.Value);
break;
case ElementType.R4 :
writer.Write ((float) elem.Value);
break;
case ElementType.R8 :
writer.Write ((double) elem.Value);
break;
case ElementType.I1 :
writer.Write ((sbyte) elem.Value);
break;
case ElementType.I2 :
writer.Write ((short) elem.Value);
break;
case ElementType.I4 :
writer.Write ((int) elem.Value);
break;
case ElementType.I8 :
writer.Write ((long) elem.Value);
break;
case ElementType.U1 :
writer.Write ((byte) elem.Value);
break;
case ElementType.U2 :
writer.Write ((ushort) elem.Value);
break;
case ElementType.U4 :
writer.Write ((uint) elem.Value);
break;
case ElementType.U8 :
writer.Write ((long) elem.Value);
break;
case ElementType.String :
case ElementType.Type :
string s = elem.Value as string;
if (s == null)
writer.Write ((byte) 0xff);
else if (s.Length == 0)
writer.Write ((byte) 0x00);
else
Write (s);
break;
case ElementType.Object :
if (elem.Value != null)
throw new NotSupportedException ("Unknown state");
writer.Write ((byte) 0xff);
break;
default :
throw new NotImplementedException ("WriteElem " + elem.FieldOrPropType.ToString ());
}
}
public SignatureWriter (MetadataWriter mdWriter)
{
m_mdWriter = mdWriter;
m_sigWriter = new MemoryBinaryWriter ();
}
void Write (CustomAttrib.NamedArg na, MemoryBinaryWriter writer)
{
if (na.Field)
writer.Write ((byte) 0x53);
else if (na.Property)
writer.Write ((byte) 0x54);
else
throw new MetadataFormatException ("Unknown kind of namedarg");
if (na.FixedArg.SzArray)
writer.Write ((byte) ElementType.SzArray);
if (na.FieldOrPropType == ElementType.Object)
writer.Write ((byte) ElementType.Boxed);
else
writer.Write ((byte) na.FieldOrPropType);
if (na.FieldOrPropType == ElementType.Enum)
Write (na.FixedArg.Elems [0].ElemType.FullName);
Write (na.FieldOrPropName);
Write (na.FixedArg, writer);
}
void Write (CustomAttrib.FixedArg fa, MemoryBinaryWriter writer)
{
if (fa.SzArray)
writer.Write (fa.NumElem);
foreach (CustomAttrib.Elem elem in fa.Elems)
Write (elem, writer);
}
void Write (CustomAttrib ca, MethodReference ctor, MemoryBinaryWriter writer)
{
if (ca == null)
return;
if (ca.Prolog != CustomAttrib.StdProlog)
return;
writer.Write (ca.Prolog);
for (int i = 0; i < ctor.Parameters.Count; i++)
Write (ca.FixedArgs [i], writer);
writer.Write (ca.NumNamed);
for (int i = 0; i < ca.NumNamed; i++)
Write (ca.NamedArgs [i], writer);
}
void CompressCustomAttribute (CustomAttrib ca, MethodReference ctor, MemoryBinaryWriter writer)
{
m_sigWriter.Empty ();
Write (ca, ctor, writer);
}
public MetadataRowWriter (MetadataTableWriter mtwv)
{
m_binaryWriter = mtwv.GetWriter ();
m_root = mtwv.GetMetadataRoot ();
m_ciCache = new int [<%= $coded_indexes.length %>];
public void Initialize()
{
Image img = m_img;
ResourceWriter resWriter = null;
uint sectAlign = img.PEOptionalHeader.NTSpecificFields.SectionAlignment;
uint fileAlign = img.PEOptionalHeader.NTSpecificFields.FileAlignment;
m_textSect = img.TextSection;
foreach (Section s in img.Sections)
{
if (s.Name == Section.Relocs)
{
m_relocSect = s;
}
else if (s.Name == Section.Resources)
{
m_rsrcSect = s;
m_rsrcWriter = new MemoryBinaryWriter();
resWriter = new ResourceWriter(img, m_rsrcSect, m_rsrcWriter);
resWriter.Write();
}
}
// size computations, fields setting, etc.
uint nbSects = (uint)img.Sections.Count;
img.PEFileHeader.NumberOfSections = (ushort)nbSects;
// build the reloc section data
uint relocSize = 12;
m_relocWriter.Write((uint)0);
m_relocWriter.Write(relocSize);
m_relocWriter.Write((ushort)0);
m_relocWriter.Write((ushort)0);
m_textSect.VirtualSize = (uint)m_textWriter.BaseStream.Length;
m_relocSect.VirtualSize = (uint)m_relocWriter.BaseStream.Length;
if (m_rsrcSect != null)
{
m_rsrcSect.VirtualSize = (uint)m_rsrcWriter.BaseStream.Length;
}
// start counting before sections headers
// section start + section header sixe * number of sections
uint headersEnd = 0x178 + 0x28 * nbSects;
uint fileOffset = headersEnd;
uint sectOffset = sectAlign;
uint imageSize = 0;
foreach (Section sect in img.Sections)
{
fileOffset = GetAligned(fileOffset, fileAlign);
sectOffset = GetAligned(sectOffset, sectAlign);
sect.PointerToRawData = new RVA(fileOffset);
sect.VirtualAddress = new RVA(sectOffset);
sect.SizeOfRawData = GetAligned(sect.VirtualSize, fileAlign);
fileOffset += sect.SizeOfRawData;
sectOffset += sect.SizeOfRawData;
imageSize += GetAligned(sect.SizeOfRawData, sectAlign);
}
if (m_textSect.VirtualAddress.Value != 0x2000)
{
throw new ImageFormatException("Wrong RVA for .text section");
}
if (resWriter != null)
{
resWriter.Patch();
}
img.PEOptionalHeader.StandardFields.CodeSize = GetAligned(
m_textSect.SizeOfRawData, fileAlign);
img.PEOptionalHeader.StandardFields.InitializedDataSize = m_textSect.SizeOfRawData;
if (m_rsrcSect != null)
{
img.PEOptionalHeader.StandardFields.InitializedDataSize += m_rsrcSect.SizeOfRawData;
}
img.PEOptionalHeader.StandardFields.BaseOfCode = m_textSect.VirtualAddress;
img.PEOptionalHeader.StandardFields.BaseOfData = m_relocSect.VirtualAddress;
imageSize += headersEnd;
img.PEOptionalHeader.NTSpecificFields.ImageSize = GetAligned(imageSize, sectAlign);
img.PEOptionalHeader.DataDirectories.BaseRelocationTable = new DataDirectory(
m_relocSect.VirtualAddress, m_relocSect.VirtualSize);
if (m_rsrcSect != null)
{
img.PEOptionalHeader.DataDirectories.ResourceTable = new DataDirectory(
m_rsrcSect.VirtualAddress, (uint)m_rsrcWriter.BaseStream.Length);
}
if (m_kind == AssemblyKind.Dll)
{
img.PEFileHeader.Characteristics = ImageCharacteristics.CILOnlyDll;
img.HintNameTable.RuntimeMain = HintNameTable.RuntimeMainDll;
img.PEOptionalHeader.NTSpecificFields.DLLFlags = 0x400;
}
else
{
img.PEFileHeader.Characteristics = ImageCharacteristics.CILOnlyExe;
img.HintNameTable.RuntimeMain = HintNameTable.RuntimeMainExe;
}
switch (m_kind)
{
case AssemblyKind.Dll:
case AssemblyKind.Console:
img.PEOptionalHeader.NTSpecificFields.SubSystem = SubSystem.WindowsCui;
break;
case AssemblyKind.Windows:
img.PEOptionalHeader.NTSpecificFields.SubSystem = SubSystem.WindowsGui;
break;
}
RVA importTable = new RVA(img.TextSection.VirtualAddress + m_mdWriter.ImportTablePosition);
img.PEOptionalHeader.DataDirectories.ImportTable = new DataDirectory(importTable, 0x57);
img.ImportTable.ImportLookupTable = new RVA((uint)importTable + 0x28);
img.ImportLookupTable.HintNameRVA = img.ImportAddressTable.HintNameTableRVA =
new RVA((uint)img.ImportTable.ImportLookupTable + 0x14);
img.ImportTable.Name = new RVA((uint)img.ImportLookupTable.HintNameRVA + 0xe);
}
void WriteSection(Section sect, MemoryBinaryWriter sectWriter)
{
sectWriter.MemoryStream.WriteTo(m_binaryWriter.BaseStream);
m_binaryWriter.Write(new byte [
sect.SizeOfRawData - sectWriter.BaseStream.Length]);
}
public void Write(MemoryBinaryWriter writer)
{
writer.MemoryStream.WriteTo(this.BaseStream);
}
public void Initialize()
{
Image img = m_img;
ResourceWriter resWriter = null;
uint sectAlign = img.PEOptionalHeader.NTSpecificFields.SectionAlignment;
uint fileAlign = img.PEOptionalHeader.NTSpecificFields.FileAlignment;
m_textSect = img.TextSection;
foreach (Section s in img.Sections) {
if (s.Name == Section.Relocs)
m_relocSect = s;
else if (s.Name == Section.Resources) {
m_rsrcSect = s;
m_rsrcWriter = new MemoryBinaryWriter ();
resWriter = new ResourceWriter (img, m_rsrcSect, m_rsrcWriter);
resWriter.Write ();
}
}
// size computations, fields setting, etc.
uint nbSects = (uint) img.Sections.Count;
img.PEFileHeader.NumberOfSections = (ushort) nbSects;
// build the reloc section data
uint relocSize = 12;
m_relocWriter.Write ((uint) 0);
m_relocWriter.Write (relocSize);
m_relocWriter.Write ((ushort) 0);
m_relocWriter.Write ((ushort) 0);
m_textSect.VirtualSize = (uint) m_textWriter.BaseStream.Length;
m_relocSect.VirtualSize = (uint) m_relocWriter.BaseStream.Length;
if (m_rsrcSect != null)
m_rsrcSect.VirtualSize = (uint) m_rsrcWriter.BaseStream.Length;
// start counting before sections headers
// section start + section header sixe * number of sections
uint headersEnd = 0x178 + 0x28 * nbSects;
uint fileOffset = headersEnd;
uint sectOffset = sectAlign;
uint imageSize = 0;
foreach (Section sect in img.Sections) {
fileOffset = GetAligned (fileOffset, fileAlign);
sectOffset = GetAligned (sectOffset, sectAlign);
sect.PointerToRawData = new RVA (fileOffset);
sect.VirtualAddress = new RVA (sectOffset);
sect.SizeOfRawData = GetAligned (sect.VirtualSize, fileAlign);
fileOffset += sect.SizeOfRawData;
sectOffset += sect.SizeOfRawData;
imageSize += GetAligned (sect.SizeOfRawData, sectAlign);
}
if (m_textSect.VirtualAddress.Value != 0x2000)
throw new ImageFormatException ("Wrong RVA for .text section");
if (resWriter != null)
resWriter.Patch ();
img.PEOptionalHeader.StandardFields.CodeSize = GetAligned (
m_textSect.SizeOfRawData, fileAlign);
img.PEOptionalHeader.StandardFields.InitializedDataSize = m_textSect.SizeOfRawData;
if (m_rsrcSect != null)
img.PEOptionalHeader.StandardFields.InitializedDataSize += m_rsrcSect.SizeOfRawData;
img.PEOptionalHeader.StandardFields.BaseOfCode = m_textSect.VirtualAddress;
img.PEOptionalHeader.StandardFields.BaseOfData = m_relocSect.VirtualAddress;
imageSize += headersEnd;
img.PEOptionalHeader.NTSpecificFields.ImageSize = GetAligned (imageSize, sectAlign);
img.PEOptionalHeader.DataDirectories.BaseRelocationTable = new DataDirectory (
m_relocSect.VirtualAddress, m_relocSect.VirtualSize);
if (m_rsrcSect != null)
img.PEOptionalHeader.DataDirectories.ResourceTable = new DataDirectory (
m_rsrcSect.VirtualAddress, (uint) m_rsrcWriter.BaseStream.Length);
if (m_kind == AssemblyKind.Dll) {
img.PEFileHeader.Characteristics = ImageCharacteristics.CILOnlyDll;
img.HintNameTable.RuntimeMain = HintNameTable.RuntimeMainDll;
img.PEOptionalHeader.NTSpecificFields.DLLFlags = 0x400;
} else {
img.PEFileHeader.Characteristics = ImageCharacteristics.CILOnlyExe;
img.HintNameTable.RuntimeMain = HintNameTable.RuntimeMainExe;
}
switch (m_kind) {
case AssemblyKind.Dll :
case AssemblyKind.Console :
img.PEOptionalHeader.NTSpecificFields.SubSystem = SubSystem.WindowsCui;
break;
case AssemblyKind.Windows :
img.PEOptionalHeader.NTSpecificFields.SubSystem = SubSystem.WindowsGui;
break;
}
RVA importTable = new RVA (img.TextSection.VirtualAddress + m_mdWriter.ImportTablePosition);
img.PEOptionalHeader.DataDirectories.ImportTable = new DataDirectory (importTable, 0x57);
img.ImportTable.ImportLookupTable = new RVA ((uint) importTable + 0x28);
img.ImportLookupTable.HintNameRVA = img.ImportAddressTable.HintNameTableRVA =
new RVA ((uint) img.ImportTable.ImportLookupTable + 0x14);
img.ImportTable.Name = new RVA ((uint) img.ImportLookupTable.HintNameRVA + 0xe);
}
void WriteMemStream(MemoryBinaryWriter writer)
{
m_binaryWriter.Write (writer);
m_binaryWriter.QuadAlign ();
}
void SetHeapSize(MetadataHeap heap, MemoryBinaryWriter data, byte flag)
{
if (data.BaseStream.Length > 65536) {
m_root.Streams.TablesHeap.HeapSizes |= flag;
heap.IndexSize = 4;
} else
heap.IndexSize = 2;
}
public MetadataRowWriter(MetadataTableWriter mtwv)
{
m_binaryWriter = mtwv.GetWriter ();
m_root = mtwv.GetMetadataRoot ();
m_ciCache = new Hashtable ();
}
static void PatchHeap (MemoryBinaryWriter heap_writer, MetadataHeap heap)
{
if (heap == null)
return;
heap_writer.BaseStream.Position = 0;
heap_writer.Write (heap.Data);
}
void WriteSection(Section sect, MemoryBinaryWriter sectWriter)
{
sectWriter.MemoryStream.WriteTo (m_binaryWriter.BaseStream);
m_binaryWriter.Write (new byte [
sect.SizeOfRawData - sectWriter.BaseStream.Length]);
}
void Initialize()
{
m_mdWriter = new MetadataWriter (
m_mod.Assembly,
m_mod.Image.MetadataRoot,
m_structureWriter.Assembly.Kind,
m_mod.Assembly.Runtime,
m_structureWriter.GetWriter ());
m_tableWriter = m_mdWriter.GetTableVisitor ();
m_rowWriter = m_tableWriter.GetRowVisitor () as MetadataRowWriter;
m_sigWriter = new SignatureWriter (m_mdWriter);
m_codeWriter = new CodeWriter (this, m_mdWriter.CilWriter);
m_typeDefStack = new ArrayList ();
m_methodStack = new ArrayList ();
m_fieldStack = new ArrayList ();
m_genericParamStack = new ArrayList ();
m_typeSpecCache = new Hashtable ();
m_methodIndex = 1;
m_fieldIndex = 1;
m_paramIndex = 1;
m_eventIndex = 1;
m_propertyIndex = 1;
m_constWriter = new MemoryBinaryWriter ();
}
public static SR.Assembly CreateReflectionAssembly (AssemblyDefinition asm, AppDomain domain)
{
using (MemoryBinaryWriter writer = new MemoryBinaryWriter ()) {
WriteAssembly (asm, writer);
return domain.Load (writer.ToArray ());
}
}
public byte [] CompressCustomAttribute (CustomAttrib ca, MethodReference ctor)
{
MemoryBinaryWriter writer = new MemoryBinaryWriter ();
CompressCustomAttribute (ca, ctor, writer);
return writer.ToArray ();
}
public static void SaveAssembly (AssemblyDefinition asm, out byte [] assembly)
{
MemoryBinaryWriter bw = new MemoryBinaryWriter ();
SaveAssembly (asm, bw.BaseStream);
assembly = bw.ToArray ();
}
public void Write(MemoryBinaryWriter writer)
{
writer.MemoryStream.WriteTo (this.BaseStream);
}
