/// <summary>
/// Writes the fixed argument to the provided output stream.
/// </summary>
/// <param name="writer">The output stream.</param>
/// <param name="provider">The object to use for obtaining metadata tokens for members in the tables stream.</param>
public void Write(IBinaryStreamWriter writer, ITypeCodedIndexProvider provider)
{
if (ArgumentType is SzArrayTypeSignature szArrayType)
{
WriteArray(szArrayType, writer, provider);
}
else
{
WriteSimple(writer, provider);
}
}
/// <inheritdoc />
public override void Write(IBinaryStreamWriter writer)
{
writer.WriteByte(Width);
writer.WriteByte((Height));
writer.WriteByte(ColorCount);
writer.WriteByte(Reserved);
writer.WriteUInt16(ColorPlanes);
writer.WriteUInt16(PixelBitCount);
writer.WriteUInt32(BytesInRes);
writer.WriteUInt16(Id);
}
/// <inheritdoc />
public void Write(IBinaryStreamWriter writer)
{
uint start = writer.FileOffset;
for (int i = 0; i < _items.Count; i++)
{
var current = _items[i];
writer.FileOffset = current.Segment.FileOffset - FileOffset + start;
current.Segment.Write(writer);
}
}
/// <inheritdoc />
public override void Write(MetadataBuffer buffer, IBinaryStreamWriter writer)
{
writer.WriteByte((byte)'.');
writer.WriteCompressedUInt32((uint)Attributes.Count);
foreach (var attribute in Attributes)
{
attribute.Write(buffer, writer);
}
base.Write(buffer, writer);
}
/// <summary>
/// Writes an index with the specified size to the stream.
/// </summary>
/// <param name="writer">The writer to use.</param>
/// <param name="indexSize">The size of the index.</param>
/// <param name="value">The value to write.</param>
public static void WriteIndex(this IBinaryStreamWriter writer, IndexSize indexSize, uint value)
{
if (indexSize == IndexSize.Short)
{
writer.WriteUInt16((ushort)value);
}
else
{
writer.WriteUInt32(value);
}
}
private void WriteExceptionHandler(IMetadataTokenProvider provider, IBinaryStreamWriter writer, CilExceptionHandler handler, bool useFatFormat)
{
if (handler.IsFat && !useFatFormat)
{
throw new InvalidOperationException("Can only serialize fat exception handlers in fat format.");
}
// Write handler type and boundaries.
if (useFatFormat)
{
writer.WriteUInt32((uint)handler.HandlerType);
writer.WriteUInt32((uint)handler.TryStart.Offset);
writer.WriteUInt32((uint)(handler.TryEnd.Offset - handler.TryStart.Offset));
writer.WriteUInt32((uint)handler.HandlerStart.Offset);
writer.WriteUInt32((uint)(handler.HandlerEnd.Offset - handler.HandlerStart.Offset));
}
else
{
writer.WriteUInt16((ushort)handler.HandlerType);
writer.WriteUInt16((ushort)handler.TryStart.Offset);
writer.WriteByte((byte)(handler.TryEnd.Offset - handler.TryStart.Offset));
writer.WriteUInt16((ushort)handler.HandlerStart.Offset);
writer.WriteByte((byte)(handler.HandlerEnd.Offset - handler.HandlerStart.Offset));
}
// Write handler type or filter start.
switch (handler.HandlerType)
{
case CilExceptionHandlerType.Exception:
{
var token = handler.ExceptionType switch
{
TypeReference typeReference => provider.GetTypeReferenceToken(typeReference),
TypeDefinition typeDefinition => provider.GetTypeDefinitionToken(typeDefinition),
TypeSpecification typeSpecification => provider.GetTypeSpecificationToken(typeSpecification),
_ => throw new ArgumentOutOfRangeException()
};
writer.WriteUInt32(token.ToUInt32());
break;
}
case CilExceptionHandlerType.Filter:
writer.WriteUInt32((uint)handler.FilterStart.Offset);
break;
case CilExceptionHandlerType.Finally:
case CilExceptionHandlerType.Fault:
writer.WriteUInt32(0);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <inheritdoc />
protected override void WriteContents(IBinaryStreamWriter writer, ITypeCodedIndexProvider provider)
{
writer.WriteByte((byte)Attributes);
if (IsGeneric)
{
writer.WriteCompressedUInt32((uint)GenericParameterCount);
}
WriteParametersAndReturnType(writer, provider);
}
/// <inheritdoc />
protected override void WriteContents(IBinaryStreamWriter writer, ITypeCodedIndexProvider provider)
{
writer.WriteByte((byte)ElementType);
writer.WriteByte((byte)(IsValueType ? ElementType.ValueType : ElementType.Class));
TypeSignature.WriteTypeDefOrRef(writer, provider, GenericType);
writer.WriteCompressedUInt32((uint)TypeArguments.Count);
for (int i = 0; i < TypeArguments.Count; i++)
{
TypeArguments[i].Write(writer, provider);
}
}
/// <summary>
/// Writes a collection of stream headers to an output stream.
/// </summary>
/// <param name="writer">The output stream to write to.</param>
/// <param name="headers">The headers to write.</param>
protected virtual void WriteStreamHeaders(IBinaryStreamWriter writer, IEnumerable <MetadataStreamHeader> headers)
{
foreach (var header in headers)
{
writer.WriteUInt32(header.Offset);
writer.WriteUInt32(header.Size);
writer.WriteAsciiString(header.Name);
writer.WriteByte(0);
writer.Align(4);
}
}
/// <inheritdoc />
public override void Write(IBinaryStreamWriter writer)
{
writer.WriteBytes(Code);
for (int i = 0; i < AddressFixups.Count; i++)
{
ApplyAddressFixup(writer, AddressFixups[i]);
}
writer.Offset = Offset + GetPhysicalSize();
}
/// <inheritdoc />
public override void Write(MetadataBuffer buffer, IBinaryStreamWriter writer)
{
writer.WriteByte(0x07);
writer.WriteCompressedUInt32((uint)Variables.Count);
foreach (var variable in Variables)
{
variable.Write(buffer, writer);
}
base.Write(buffer, writer);
}
/// <inheritdoc />
public override void Write(MetadataBuffer buffer, IBinaryStreamWriter writer)
{
writer.WriteByte((byte)Attributes);
writer.WriteCompressedUInt32((uint)Parameters.Count);
PropertyType.Write(buffer, writer);
foreach (var parameter in Parameters)
{
parameter.Write(buffer, writer);
}
base.Write(buffer, writer);
}
/// <inheritdoc />
protected override void WriteContents(IBinaryStreamWriter writer, ITypeCodedIndexProvider provider)
{
writer.WriteByte((byte)NativeType);
if (Size.HasValue)
{
writer.WriteCompressedUInt32((uint)Size.Value);
if (ArrayElementType.HasValue)
{
writer.WriteCompressedUInt32((uint)ArrayElementType);
}
}
}
private void WriteCode(MetadataBuffer buffer, IBinaryStreamWriter writer)
{
CalculateOffsets();
var builder = new DefaultOperandBuilder(this, buffer);
var assembler = new CilAssembler(builder, writer);
foreach (var instruction in Instructions)
{
assembler.Write(instruction);
}
}
/// <inheritdoc />
public override void Write(IBinaryStreamWriter writer)
{
if (Code.Length > 0x3F)
{
throw new ArgumentException("Code of a tiny method body cannot be 64 bytes or larger.");
}
byte flag = (byte)((byte)CilMethodBodyAttributes.Tiny | (Code.Length << 2));
writer.WriteByte(flag);
writer.WriteBytes(Code);
}
internal static void WriteFieldOrPropType(IBinaryStreamWriter writer, TypeSignature type)
{
switch (type.ElementType)
{
case ElementType.Boolean:
case ElementType.Char:
case ElementType.I1:
case ElementType.U1:
case ElementType.I2:
case ElementType.U2:
case ElementType.I4:
case ElementType.U4:
case ElementType.I8:
case ElementType.U8:
case ElementType.R4:
case ElementType.R8:
case ElementType.I:
case ElementType.U:
case ElementType.String:
writer.WriteByte((byte)type.ElementType);
break;
case ElementType.Object:
writer.WriteByte((byte)ElementType.Boxed);
break;
case ElementType.SzArray:
writer.WriteByte((byte)ElementType.SzArray);
var arrayType = (SzArrayTypeSignature)type;
WriteFieldOrPropType(writer, arrayType.BaseType);
break;
default:
if (type.IsTypeOf("System", "Type"))
{
writer.WriteByte((byte)ElementType.Type);
return;
}
var typeDef = type.Resolve();
if (typeDef != null && typeDef.IsEnum)
{
writer.WriteByte((byte)ElementType.Enum);
writer.WriteSerString(TypeNameBuilder.GetAssemblyQualifiedName(type));
return;
}
throw new ArgumentOutOfRangeException();
}
}
public override void Write(MetadataBuffer buffer, IBinaryStreamWriter writer)
{
writer.WriteByte((byte)ElementType);
writer.WriteByte((byte)(IsValueType ? ElementType.ValueType : ElementType.Class));
WriteTypeDefOrRef(buffer, writer, GenericType);
writer.WriteCompressedUInt32((uint)GenericArguments.Count);
foreach (var argument in GenericArguments)
{
argument.Write(buffer, writer);
}
}
+ sizeof(ulong); // FileDate
/// <inheritdoc />
public override void Write(IBinaryStreamWriter writer)
{
writer.WriteUInt32(Signature);
writer.WriteUInt32(DefaultStructVersion);
WriteVersion(writer, FileVersion);
WriteVersion(writer, ProductVersion);
writer.WriteUInt32((uint)FileFlagsMask);
writer.WriteUInt32((uint)FileFlags);
writer.WriteUInt32((uint)FileOS);
writer.WriteUInt32((uint)FileType);
writer.WriteUInt32((uint)FileSubType);
writer.WriteUInt64(FileDate);
}
/// <summary>
/// Creates a new CIL instruction encoder.
/// </summary>
/// <param name="writer">The output stream to write the encoded instructions to.</param>
/// <param name="operandBuilder">The object to use for creating raw operands.</param>
/// <param name="methodBodyName">The name of the method that is being serialized.</param>
/// <param name="errorListener">The object used for recording error listener.</param>
public CilAssembler(
IBinaryStreamWriter writer,
ICilOperandBuilder operandBuilder,
string methodBodyName,
IErrorListener errorListener)
{
_writer = writer ?? throw new ArgumentNullException(nameof(writer));
_errorListener = errorListener ?? throw new ArgumentNullException(nameof(errorListener));
_operandBuilder = operandBuilder ?? throw new ArgumentNullException(nameof(operandBuilder));
_diagnosticPrefix = !string.IsNullOrEmpty(methodBodyName)
? $"[In {methodBodyName}]: "
: null;
}
public override void Write(MetadataBuffer buffer, IBinaryStreamWriter writer)
{
writer.WriteByte((byte)NativeType);
writer.WriteByte((byte)ElementType);
if (ParameterIndex.HasValue)
{
writer.WriteCompressedUInt32((uint)ParameterIndex.Value);
if (NumberOfElements.HasValue)
{
writer.WriteCompressedUInt32((uint)NumberOfElements.Value);
}
}
}
/// <summary>
/// Writes an UTF8 string to the stream.
/// </summary>
/// <param name="writer">The writer to use.</param>
/// <param name="value">The string to write.</param>
public static void WriteSerString(this IBinaryStreamWriter writer, string value)
{
if (value == null)
{
writer.WriteByte(0xFF);
return;
}
var bytes = Encoding.UTF8.GetBytes(value);
writer.WriteCompressedUInt32((uint)bytes.Length);
writer.WriteBytes(bytes);
}
public override void Write(MetadataBuffer buffer, IBinaryStreamWriter writer)
{
writer.WriteUInt16(0x0001);
foreach (var argument in FixedArguments)
{
argument.Write(buffer, writer);
}
writer.WriteUInt16((ushort)NamedArguments.Count);
foreach (var argument in NamedArguments)
{
argument.Write(buffer, writer);
}
}
/// <inheritdoc />
public void Write(IBinaryStreamWriter writer)
{
foreach (var token in Items)
{
if (Type.HasFlag(VTableType.VTable32Bit))
{
writer.WriteUInt32(token.ToUInt32());
}
else
{
writer.WriteUInt64(token.ToUInt32());
}
}
}
/// <inheritdoc />
public override void Write(IBinaryStreamWriter writer)
{
foreach (var entry in Entries)
{
if (entry.IsDirectory)
{
WriteDirectory(writer, (IResourceDirectory)entry);
}
else
{
throw new ArgumentException("Directory table contains a data entry.");
}
}
}
/// <inheritdoc />
public override void Write(IBinaryStreamWriter writer)
{
uint codeSize = Code.GetPhysicalSize();
if (codeSize > 0x3F)
{
throw new ArgumentException("Code of a tiny method body cannot be 64 bytes or larger.");
}
byte flag = (byte)((byte)CilMethodBodyAttributes.Tiny | (codeSize << 2));
writer.WriteByte(flag);
Code.Write(writer);
}
private void WriteExportDirectoryHeader(IBinaryStreamWriter writer)
{
writer.WriteUInt32(_exportDirectory.ExportFlags);
writer.WriteUInt32(_exportDirectory.TimeDateStamp);
writer.WriteUInt16(_exportDirectory.MajorVersion);
writer.WriteUInt16(_exportDirectory.MinorVersion);
writer.WriteUInt32(_nameTableBuffer.GetNameRva(_exportDirectory.Name));
writer.WriteUInt32(_exportDirectory.BaseOrdinal);
writer.WriteUInt32((uint)_exportDirectory.Entries.Count);
writer.WriteUInt32((uint)_exportDirectory.Entries.Count(e => e.IsByName));
writer.WriteUInt32(_addressTableBuffer.Rva);
writer.WriteUInt32(_ordinalNamePointerTable.NamePointerTableRva);
writer.WriteUInt32(_ordinalNamePointerTable.OrdinalTableRva);
}
/// <inheritdoc />
protected override void WriteContents(IBinaryStreamWriter writer, ITypeCodedIndexProvider provider)
{
writer.WriteUInt16(CustomAttributeSignaturePrologue);
for (int i = 0; i < FixedArguments.Count; i++)
{
FixedArguments[i].Write(writer, provider);
}
writer.WriteUInt16((ushort)NamedArguments.Count);
for (int i = 0; i < NamedArguments.Count; i++)
{
NamedArguments[i].Write(writer, provider);
}
}
public override void Write(MetadataBuffer buffer, IBinaryStreamWriter writer)
{
if (ArgumentType.ElementType != ElementType.SzArray)
{
Elements[0].Write(buffer, writer);
}
else
{
writer.WriteUInt32((uint)Elements.Count);
foreach (var element in Elements)
{
element.Write(buffer, writer);
}
}
}
/// <inheritdoc />
public override void Write(IBinaryStreamWriter writer)
{
foreach (var module in _modules)
{
foreach (var member in module.Symbols)
{
if (member.IsImportByName)
{
WriteHintName(writer, member.Hint, member.Name);
}
}
WriteModuleName(writer, module);
}
}
/// <summary>
/// Writes a single index to the output stream.
/// </summary>
/// <param name="writer">The writer to use.</param>
/// <param name="value">The index to write.</param>
/// <param name="size"></param>
/// <exception cref="ArgumentOutOfRangeException"></exception>
public static void WriteIndex(this IBinaryStreamWriter writer, uint value, IndexSize size)
{
switch (size)
{
case IndexSize.Short:
writer.WriteUInt16((ushort)value);
break;
case IndexSize.Long:
writer.WriteUInt32(value);
break;
default:
throw new ArgumentOutOfRangeException(nameof(size), size, null);
}
}
protected static void WriteTypeDefOrRef(MetadataHeader header, IBinaryStreamWriter writer, ITypeDefOrRef type)
{
var encoder =
header.GetStream<TableStream>()
.GetIndexEncoder(CodedIndex.TypeDefOrRef);
writer.WriteCompressedUInt32(encoder.EncodeToken(type.MetadataToken));
}
/// <summary>
/// Rebuilds and writes the assembly to a specific binary stream.
/// </summary>
/// <param name="writer">The writer to write the image to.</param>
public void Write(IBinaryStreamWriter writer)
{
Write(new BuildingParameters(writer));
}
public BuildingParameters(IBinaryStreamWriter writer)
{
Writer = writer;
}
public X86Assembler(IBinaryStreamWriter writer)
{
if (writer == null)
throw new ArgumentNullException("writer");
_writer = writer;
}
public MsilAssembler(IOperandBuilder builder, IBinaryStreamWriter writer)
{
_builder = builder;
_writer = writer;
}
public WritingContext(WindowsAssembly assembly, IBinaryStreamWriter writer, BuildingContext buildingContext)
{
Assembly = assembly;
Writer = writer;
BuildingContext = buildingContext;
}