PHXH
/
obfuz
mirror of https://github.com/focus-creative-games/obfuz
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
obfuz/Plugins/dnlib/DotNet/Writer/Metadata.cs

3843 lines
125 KiB
C#
Raw Blame History

// dnlib: See LICENSE.txt for more info
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using dnlib.DotNet.Emit;
using dnlib.DotNet.MD;
using dnlib.DotNet.Pdb;
using dnlib.DotNet.Pdb.Portable;
using dnlib.IO;
using dnlib.PE;
namespace dnlib.DotNet.Writer {
/// <summary>
/// <see cref="Metadata"/> flags
/// </summary>
[Flags]
public enum MetadataFlags : uint {
/// <summary>
/// Preserves all rids in the <c>TypeRef</c> table
/// </summary>
PreserveTypeRefRids = 1,
/// <summary>
/// Preserves all rids in the <c>TypeDef</c> table
/// </summary>
PreserveTypeDefRids = 2,
/// <summary>
/// Preserves all rids in the <c>Field</c> table
/// </summary>
PreserveFieldRids = 4,
/// <summary>
/// Preserves all rids in the <c>Method</c> table
/// </summary>
PreserveMethodRids = 8,
/// <summary>
/// Preserves all rids in the <c>Param</c> table
/// </summary>
PreserveParamRids = 0x10,
/// <summary>
/// Preserves all rids in the <c>MemberRef</c> table
/// </summary>
PreserveMemberRefRids = 0x20,
/// <summary>
/// Preserves all rids in the <c>StandAloneSig</c> table
/// </summary>
PreserveStandAloneSigRids = 0x40,
/// <summary>
/// Preserves all rids in the <c>Event</c> table
/// </summary>
PreserveEventRids = 0x80,
/// <summary>
/// Preserves all rids in the <c>Property</c> table
/// </summary>
PreservePropertyRids = 0x100,
/// <summary>
/// Preserves all rids in the <c>TypeSpec</c> table
/// </summary>
PreserveTypeSpecRids = 0x200,
/// <summary>
/// Preserves all rids in the <c>MethodSpec</c> table
/// </summary>
PreserveMethodSpecRids = 0x400,
/// <summary>
/// Preserves all method rids, i.e., <c>Method</c>, <c>MemberRef</c> and
/// <c>MethodSpec</c> rids.
/// </summary>
PreserveAllMethodRids = PreserveMethodRids | PreserveMemberRefRids | PreserveMethodSpecRids,
/// <summary>
/// Preserves all rids in the following tables: <c>TypeRef</c>, <c>TypeDef</c>,
/// <c>Field</c>, <c>Method</c>, <c>Param</c>, <c>MemberRef</c>, <c>StandAloneSig</c>,
/// <c>Event</c>, <c>Property</c>, <c>TypeSpec</c>, <c>MethodSpec</c>
/// </summary>
PreserveRids = PreserveTypeRefRids |
PreserveTypeDefRids |
PreserveFieldRids |
PreserveMethodRids |
PreserveParamRids |
PreserveMemberRefRids |
PreserveStandAloneSigRids |
PreserveEventRids |
PreservePropertyRids |
PreserveTypeSpecRids |
PreserveMethodSpecRids,
/// <summary>
/// Preserves all offsets in the #Strings heap (the original #Strings heap will be saved
/// in the new file). Type names, field names, and other non-user strings are stored
/// in the #Strings heap.
/// </summary>
PreserveStringsOffsets = 0x800,
/// <summary>
/// Preserves all offsets in the #US heap (the original #US heap will be saved
/// in the new file). User strings (referenced by the ldstr instruction) are stored in
/// the #US heap.
/// </summary>
PreserveUSOffsets = 0x1000,
/// <summary>
/// Preserves all offsets in the #Blob heap (the original #Blob heap will be saved
/// in the new file). Custom attributes, signatures and other blobs are stored in the
/// #Blob heap.
/// </summary>
PreserveBlobOffsets = 0x2000,
/// <summary>
/// Preserves the extra data that is present after the original signature in the #Blob
/// heap. This extra data shouldn't be present but might be present if an obfuscator
/// has added this extra data and is eg. using it to decrypt stuff.
/// </summary>
PreserveExtraSignatureData = 0x4000,
/// <summary>
/// Preserves as much as possible
/// </summary>
PreserveAll = PreserveRids | PreserveStringsOffsets | PreserveUSOffsets |
PreserveBlobOffsets | PreserveExtraSignatureData,
/// <summary>
/// The original method body's max stack field should be used and a new one should not
/// be calculated.
/// </summary>
KeepOldMaxStack = 0x8000,
/// <summary>
/// Always create the #GUID heap even if it's empty
/// </summary>
AlwaysCreateGuidHeap = 0x10000,
/// <summary>
/// Always create the #Strings heap even if it's empty
/// </summary>
AlwaysCreateStringsHeap = 0x20000,
/// <summary>
/// Always create the #US heap even if it's empty
/// </summary>
AlwaysCreateUSHeap = 0x40000,
/// <summary>
/// Always create the #Blob heap even if it's empty
/// </summary>
AlwaysCreateBlobHeap = 0x80000,
/// <summary>
/// DEPRECATED:
/// Sort the InterfaceImpl table the same way Roslyn sorts it. Roslyn doesn't sort it
/// according to the ECMA spec, see https://github.com/dotnet/roslyn/issues/3905
/// </summary>
RoslynSortInterfaceImpl = 0x100000,
/// <summary>
/// Don't write method bodies
/// </summary>
NoMethodBodies = 0x200000,
/// <summary>
/// Don't write .NET resources
/// </summary>
NoDotNetResources = 0x400000,
/// <summary>
/// Don't write field data
/// </summary>
NoFieldData = 0x800000,
/// <summary>
/// Serialized type names stored in custom attributes are optimized if the types
/// exist in the core library (eg. mscorlib/System.Private.CoreLib).
/// Instead of storing type-name + assembly-name, only type-name is stored. This results in
/// slightly smaller assemblies.
/// <br/>
/// <br/>
/// If it's a type in the current module, the type name is optimized and no assembly name is stored in the custom attribute.
/// <br/>
/// <br/>
/// This is disabled by default. It's safe to enable if the reference core assembly
/// is the same as the runtime core assembly (eg. it's mscorlib.dll and .NET Framework,
/// but not .NET Core / .NET Standard).
/// </summary>
OptimizeCustomAttributeSerializedTypeNames = 0x1000000,
}
/// <summary>
/// Metadata heaps event args
/// </summary>
public readonly struct MetadataHeapsAddedEventArgs {
/// <summary>
/// Gets the metadata writer
/// </summary>
public Metadata Metadata { get; }
/// <summary>
/// Gets all heaps
/// </summary>
public List<IHeap> Heaps { get; }
/// <summary>
/// Constructor
/// </summary>
/// <param name="metadata">Metadata writer</param>
/// <param name="heaps">All heaps</param>
public MetadataHeapsAddedEventArgs(Metadata metadata, List<IHeap> heaps) {
Metadata = metadata ?? throw new ArgumentNullException(nameof(metadata));
Heaps = heaps ?? throw new ArgumentNullException(nameof(heaps));
}
}
/// <summary>
/// <see cref="Metadata"/> options
/// </summary>
public sealed class MetadataOptions {
MetadataHeaderOptions metadataHeaderOptions;
MetadataHeaderOptions debugMetadataHeaderOptions;
TablesHeapOptions tablesHeapOptions;
List<IHeap> customHeaps;
/// <summary>
/// Gets/sets the <see cref="MetadataHeader"/> options. This is never <c>null</c>.
/// </summary>
public MetadataHeaderOptions MetadataHeaderOptions {
get => metadataHeaderOptions ??= new MetadataHeaderOptions();
set => metadataHeaderOptions = value;
}
/// <summary>
/// Gets/sets the debug (portable PDB) <see cref="MetadataHeader"/> options. This is never <c>null</c>.
/// </summary>
public MetadataHeaderOptions DebugMetadataHeaderOptions {
get => debugMetadataHeaderOptions ??= MetadataHeaderOptions.CreatePortablePdbV1_0();
set => debugMetadataHeaderOptions = value;
}
/// <summary>
/// Gets/sets the <see cref="TablesHeap"/> options. This is never <c>null</c>.
/// </summary>
public TablesHeapOptions TablesHeapOptions {
get => tablesHeapOptions ??= new TablesHeapOptions();
set => tablesHeapOptions = value;
}
/// <summary>
/// Gets/sets the debug (portable PDB) <see cref="TablesHeap"/> options. This is never <c>null</c>.
/// </summary>
public TablesHeapOptions DebugTablesHeapOptions {
get => tablesHeapOptions ??= TablesHeapOptions.CreatePortablePdbV1_0();
set => tablesHeapOptions = value;
}
/// <summary>
/// Various options
/// </summary>
public MetadataFlags Flags;
/// <summary>
/// Extra heaps to add to the metadata. Also see <see cref="MetadataHeapsAdded"/> and <see cref="PreserveHeapOrder(ModuleDef, bool)"/>
/// </summary>
public List<IHeap> CustomHeaps => customHeaps ??= new List<IHeap>();
/// <summary>
/// Raised after all heaps have been added. The caller can sort the list if needed
/// </summary>
public event EventHandler2<MetadataHeapsAddedEventArgs> MetadataHeapsAdded;
internal void RaiseMetadataHeapsAdded(MetadataHeapsAddedEventArgs e) => MetadataHeapsAdded?.Invoke(e.Metadata, e);
/// <summary>
/// Preserves the original order of heaps, and optionally adds all custom heaps to <see cref="CustomHeaps"/>.
/// </summary>
/// <param name="module">Original module with the heaps</param>
/// <param name="addCustomHeaps">If true, all custom streams are added to <see cref="CustomHeaps"/></param>
public void PreserveHeapOrder(ModuleDef module, bool addCustomHeaps) {
if (module is null)
throw new ArgumentNullException(nameof(module));
if (module is ModuleDefMD mod) {
if (addCustomHeaps) {
var otherStreams = mod.Metadata.AllStreams.Where(a => a.GetType() == typeof(CustomDotNetStream)).Select(a => new DataReaderHeap(a));
CustomHeaps.AddRange(otherStreams.OfType<IHeap>());
}
var streamToOrder = new Dictionary<DotNetStream, int>(mod.Metadata.AllStreams.Count);
for (int i = 0, order = 0; i < mod.Metadata.AllStreams.Count; i++) {
var stream = mod.Metadata.AllStreams[i];
if (stream.StartOffset == 0)
continue;
streamToOrder.Add(stream, order++);
}
var nameToOrder = new Dictionary<string, int>(mod.Metadata.AllStreams.Count, StringComparer.Ordinal);
for (int i = 0, order = 0; i < mod.Metadata.AllStreams.Count; i++) {
var stream = mod.Metadata.AllStreams[i];
if (stream.StartOffset == 0)
continue;
bool isKnownStream = stream is BlobStream || stream is GuidStream ||
stream is PdbStream || stream is StringsStream || stream is TablesStream || stream is USStream;
if (!nameToOrder.ContainsKey(stream.Name) || isKnownStream)
nameToOrder[stream.Name] = order;
order++;
}
MetadataHeapsAdded += (s, e) => {
e.Heaps.Sort((a, b) => {
int oa = GetOrder(streamToOrder, nameToOrder, a);
int ob = GetOrder(streamToOrder, nameToOrder, b);
int c = oa - ob;
if (c != 0)
return c;
return StringComparer.Ordinal.Compare(a.Name, b.Name);
});
};
}
}
static int GetOrder(Dictionary<DotNetStream, int> streamToOrder, Dictionary<string, int> nameToOrder, IHeap heap) {
if (heap is DataReaderHeap drHeap && drHeap.OptionalOriginalStream is DotNetStream dnHeap && streamToOrder.TryGetValue(dnHeap, out int order))
return order;
if (nameToOrder.TryGetValue(heap.Name, out order))
return order;
return int.MaxValue;
}
/// <summary>
/// Default constructor
/// </summary>
public MetadataOptions() {
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="flags">Flags</param>
public MetadataOptions(MetadataFlags flags) => Flags = flags;
/// <summary>
/// Constructor
/// </summary>
/// <param name="mdhOptions">Meta data header options</param>
public MetadataOptions(MetadataHeaderOptions mdhOptions) => metadataHeaderOptions = mdhOptions;
/// <summary>
/// Constructor
/// </summary>
/// <param name="mdhOptions">Meta data header options</param>
/// <param name="flags">Flags</param>
public MetadataOptions(MetadataHeaderOptions mdhOptions, MetadataFlags flags) {
Flags = flags;
metadataHeaderOptions = mdhOptions;
}
}
sealed class DataWriterContext {
public readonly MemoryStream OutStream;
public readonly DataWriter Writer;
public DataWriterContext() {
OutStream = new MemoryStream();
Writer = new DataWriter(OutStream);
}
}
/// <summary>
/// Portable PDB metadata kind
/// </summary>
public enum DebugMetadataKind {
/// <summary>
/// No debugging metadata
/// </summary>
None,
/// <summary>
/// Standalone / embedded portable PDB metadata
/// </summary>
Standalone,
}
/// <summary>
/// Metadata writer event args
/// </summary>
public readonly struct MetadataWriterEventArgs {
/// <summary>
/// Gets the metadata writer
/// </summary>
public Metadata Metadata { get; }
/// <summary>
/// Gets the event
/// </summary>
public MetadataEvent Event { get; }
/// <summary>
/// Constructor
/// </summary>
/// <param name="metadata">Writer</param>
/// <param name="event">Event</param>
public MetadataWriterEventArgs(Metadata metadata, MetadataEvent @event) {
Metadata = metadata ?? throw new ArgumentNullException(nameof(metadata));
Event = @event;
}
}
/// <summary>
/// Metadata writer progress event args
/// </summary>
public readonly struct MetadataProgressEventArgs {
/// <summary>
/// Gets the metadata writer
/// </summary>
public Metadata Metadata { get; }
/// <summary>
/// Gets the progress, 0.0 - 1.0
/// </summary>
public double Progress { get; }
/// <summary>
/// Constructor
/// </summary>
/// <param name="metadata">Writer</param>
/// <param name="progress">Progress, 0.0 - 1.0</param>
public MetadataProgressEventArgs(Metadata metadata, double progress) {
if (progress < 0 || progress > 1)
throw new ArgumentOutOfRangeException(nameof(progress));
Metadata = metadata ?? throw new ArgumentNullException(nameof(metadata));
Progress = progress;
}
}
/// <summary>
/// .NET meta data
/// </summary>
public abstract class Metadata : IReuseChunk, ISignatureWriterHelper, ITokenProvider, ICustomAttributeWriterHelper, IPortablePdbCustomDebugInfoWriterHelper, IWriterError2 {
uint length;
FileOffset offset;
RVA rva;
readonly MetadataOptions options;
ILogger logger;
readonly MetadataErrorContext errorContext;
readonly NormalMetadata debugMetadata;
readonly bool isStandaloneDebugMetadata;
internal readonly ModuleDef module;
internal readonly UniqueChunkList<ByteArrayChunk> constants;
internal readonly MethodBodyChunks methodBodies;
internal readonly NetResources netResources;
internal readonly MetadataHeader metadataHeader;
internal readonly PdbHeap pdbHeap;
internal readonly TablesHeap tablesHeap;
internal readonly StringsHeap stringsHeap;
internal readonly USHeap usHeap;
internal readonly GuidHeap guidHeap;
internal readonly BlobHeap blobHeap;
internal TypeDef[] allTypeDefs;
internal readonly Rows<ModuleDef> moduleDefInfos = new Rows<ModuleDef>();
internal readonly SortedRows<InterfaceImpl, RawInterfaceImplRow> interfaceImplInfos = new SortedRows<InterfaceImpl, RawInterfaceImplRow>();
internal readonly SortedRows<IHasConstant, RawConstantRow> hasConstantInfos = new SortedRows<IHasConstant, RawConstantRow>();
internal readonly SortedRows<CustomAttribute, RawCustomAttributeRow> customAttributeInfos = new SortedRows<CustomAttribute, RawCustomAttributeRow>();
internal readonly SortedRows<IHasFieldMarshal, RawFieldMarshalRow> fieldMarshalInfos = new SortedRows<IHasFieldMarshal, RawFieldMarshalRow>();
internal readonly SortedRows<DeclSecurity, RawDeclSecurityRow> declSecurityInfos = new SortedRows<DeclSecurity, RawDeclSecurityRow>();
internal readonly SortedRows<TypeDef, RawClassLayoutRow> classLayoutInfos = new SortedRows<TypeDef, RawClassLayoutRow>();
internal readonly SortedRows<FieldDef, RawFieldLayoutRow> fieldLayoutInfos = new SortedRows<FieldDef, RawFieldLayoutRow>();
internal readonly Rows<TypeDef> eventMapInfos = new Rows<TypeDef>();
internal readonly Rows<TypeDef> propertyMapInfos = new Rows<TypeDef>();
internal readonly SortedRows<MethodDef, RawMethodSemanticsRow> methodSemanticsInfos = new SortedRows<MethodDef, RawMethodSemanticsRow>();
internal readonly SortedRows<MethodDef, RawMethodImplRow> methodImplInfos = new SortedRows<MethodDef, RawMethodImplRow>();
internal readonly Rows<ModuleRef> moduleRefInfos = new Rows<ModuleRef>();
internal readonly SortedRows<IMemberForwarded, RawImplMapRow> implMapInfos = new SortedRows<IMemberForwarded, RawImplMapRow>();
internal readonly SortedRows<FieldDef, RawFieldRVARow> fieldRVAInfos = new SortedRows<FieldDef, RawFieldRVARow>();
internal readonly Rows<AssemblyDef> assemblyInfos = new Rows<AssemblyDef>();
internal readonly Rows<AssemblyRef> assemblyRefInfos = new Rows<AssemblyRef>();
internal readonly Rows<FileDef> fileDefInfos = new Rows<FileDef>();
internal readonly Rows<ExportedType> exportedTypeInfos = new Rows<ExportedType>();
internal readonly Rows<Resource> manifestResourceInfos = new Rows<Resource>();
internal readonly SortedRows<TypeDef, RawNestedClassRow> nestedClassInfos = new SortedRows<TypeDef, RawNestedClassRow>();
internal readonly SortedRows<GenericParam, RawGenericParamRow> genericParamInfos = new SortedRows<GenericParam, RawGenericParamRow>();
internal readonly SortedRows<GenericParamConstraint, RawGenericParamConstraintRow> genericParamConstraintInfos = new SortedRows<GenericParamConstraint, RawGenericParamConstraintRow>();
internal readonly Dictionary<MethodDef, MethodBody> methodToBody = new Dictionary<MethodDef, MethodBody>();
internal readonly Dictionary<MethodDef, NativeMethodBody> methodToNativeBody = new Dictionary<MethodDef, NativeMethodBody>();
internal readonly Dictionary<EmbeddedResource, DataReaderChunk> embeddedResourceToByteArray = new Dictionary<EmbeddedResource, DataReaderChunk>();
readonly Dictionary<FieldDef, ByteArrayChunk> fieldToInitialValue = new Dictionary<FieldDef, ByteArrayChunk>();
readonly Rows<PdbDocument> pdbDocumentInfos = new Rows<PdbDocument>();
bool methodDebugInformationInfosUsed;
readonly SortedRows<PdbScope, RawLocalScopeRow> localScopeInfos = new SortedRows<PdbScope, RawLocalScopeRow>();
readonly Rows<PdbLocal> localVariableInfos = new Rows<PdbLocal>();
readonly Rows<PdbConstant> localConstantInfos = new Rows<PdbConstant>();
readonly Rows<PdbImportScope> importScopeInfos = new Rows<PdbImportScope>();
readonly SortedRows<PdbCustomDebugInfo, RawStateMachineMethodRow> stateMachineMethodInfos = new SortedRows<PdbCustomDebugInfo, RawStateMachineMethodRow>();
readonly SortedRows<PdbCustomDebugInfo, RawCustomDebugInformationRow> customDebugInfos = new SortedRows<PdbCustomDebugInfo, RawCustomDebugInformationRow>();
readonly List<DataWriterContext> binaryWriterContexts = new List<DataWriterContext>();
readonly List<SerializerMethodContext> serializerMethodContexts = new List<SerializerMethodContext>();
readonly List<MethodDef> exportedMethods = new List<MethodDef>();
/// <summary>
/// Raised at various times when writing the metadata
/// </summary>
public event EventHandler2<MetadataWriterEventArgs> MetadataEvent;
/// <summary>
/// Raised when the progress is updated
/// </summary>
public event EventHandler2<MetadataProgressEventArgs> ProgressUpdated;
/// <summary>
/// Gets/sets the logger
/// </summary>
public ILogger Logger {
get => logger;
set => logger = value;
}
/// <summary>
/// Gets the module
/// </summary>
public ModuleDef Module => module;
/// <summary>
/// Gets the constants
/// </summary>
public UniqueChunkList<ByteArrayChunk> Constants => constants;
/// <summary>
/// Gets the method body chunks
/// </summary>
public MethodBodyChunks MethodBodyChunks => methodBodies;
/// <summary>
/// Gets the .NET resources
/// </summary>
public NetResources NetResources => netResources;
/// <summary>
/// Gets the MD header
/// </summary>
public MetadataHeader MetadataHeader => metadataHeader;
/// <summary>
/// Gets the tables heap. Access to this heap is not recommended, but is useful if you
/// want to add random table entries.
/// </summary>
public TablesHeap TablesHeap => tablesHeap;
/// <summary>
/// Gets the #Strings heap. Access to this heap is not recommended, but is useful if you
/// want to add random strings.
/// </summary>
public StringsHeap StringsHeap => stringsHeap;
/// <summary>
/// Gets the #US heap. Access to this heap is not recommended, but is useful if
/// you want to add random user strings.
/// </summary>
public USHeap USHeap => usHeap;
/// <summary>
/// Gets the #GUID heap. Access to this heap is not recommended, but is useful if you
/// want to add random GUIDs.
/// </summary>
public GuidHeap GuidHeap => guidHeap;
/// <summary>
/// Gets the #Blob heap. Access to this heap is not recommended, but is useful if you
/// want to add random blobs.
/// </summary>
public BlobHeap BlobHeap => blobHeap;
/// <summary>
/// Gets the #Pdb heap. It's only used if it's portable PDB metadata
/// </summary>
public PdbHeap PdbHeap => pdbHeap;
/// <summary>
/// Gets all exported methods
/// </summary>
public List<MethodDef> ExportedMethods => exportedMethods;
/// <summary>
/// The public key that should be used instead of the one in <see cref="AssemblyDef"/>.
/// </summary>
internal byte[] AssemblyPublicKey { get; set; }
internal sealed class SortedRows<T, TRow> where T : class where TRow : struct {
public List<Info> infos = new List<Info>();
Dictionary<T, uint> toRid = new Dictionary<T, uint>();
bool isSorted;
public struct Info {
public readonly T data;
public /*readonly*/ TRow row;
public Info(T data, ref TRow row) {
this.data = data;
this.row = row;
}
}
public void Add(T data, TRow row) {
if (isSorted)
throw new ModuleWriterException($"Adding a row after it's been sorted. Table: {row.GetType()}");
infos.Add(new Info(data, ref row));
toRid[data] = (uint)toRid.Count + 1;
}
public void Sort(Comparison<Info> comparison) {
infos.Sort(CreateComparison(comparison));
toRid.Clear();
for (int i = 0; i < infos.Count; i++)
toRid[infos[i].data] = (uint)i + 1;
isSorted = true;
}
Comparison<Info> CreateComparison(Comparison<Info> comparison) =>
(a, b) => {
int c = comparison(a, b);
if (c != 0)
return c;
// Make sure it's a stable sort
return toRid[a.data].CompareTo(toRid[b.data]);
};
public uint Rid(T data) => toRid[data];
public bool TryGetRid(T data, out uint rid) {
if (data is null) {
rid = 0;
return false;
}
return toRid.TryGetValue(data, out rid);
}
}
internal sealed class Rows<T> where T : class {
Dictionary<T, uint> dict = new Dictionary<T, uint>();
public int Count => dict.Count;
public bool TryGetRid(T value, out uint rid) {
if (value is null) {
rid = 0;
return false;
}
return dict.TryGetValue(value, out rid);
}
public bool Exists(T value) => dict.ContainsKey(value);
public void Add(T value, uint rid) => dict.Add(value, rid);
public uint Rid(T value) => dict[value];
public void SetRid(T value, uint rid) => dict[value] = rid;
}
/// <summary>
/// Creates a <see cref="Metadata"/> instance
/// </summary>
/// <param name="module">Module</param>
/// <param name="constants">Constants list</param>
/// <param name="methodBodies">Method bodies list</param>
/// <param name="netResources">.NET resources list</param>
/// <param name="options">Options</param>
/// <param name="debugKind">Debug metadata kind</param>
/// <returns>A new <see cref="Metadata"/> instance</returns>
public static Metadata Create(ModuleDef module, UniqueChunkList<ByteArrayChunk> constants, MethodBodyChunks methodBodies, NetResources netResources, MetadataOptions options = null, DebugMetadataKind debugKind = DebugMetadataKind.None) {
if (options is null)
options = new MetadataOptions();
if ((options.Flags & MetadataFlags.PreserveRids) != 0 && module is ModuleDefMD)
return new PreserveTokensMetadata(module, constants, methodBodies, netResources, options, debugKind, false);
return new NormalMetadata(module, constants, methodBodies, netResources, options, debugKind, false);
}
/// <inheritdoc/>
public FileOffset FileOffset => offset;
/// <inheritdoc/>
public RVA RVA => rva;
/// <summary>
/// Gets the <see cref="MetadataFlags.PreserveTypeRefRids"/> bit
/// </summary>
public bool PreserveTypeRefRids => (options.Flags & MetadataFlags.PreserveTypeRefRids) != 0;
/// <summary>
/// Gets the <see cref="MetadataFlags.PreserveTypeDefRids"/> bit
/// </summary>
public bool PreserveTypeDefRids => (options.Flags & MetadataFlags.PreserveTypeDefRids) != 0;
/// <summary>
/// Gets the <see cref="MetadataFlags.PreserveFieldRids"/> bit
/// </summary>
public bool PreserveFieldRids => (options.Flags & MetadataFlags.PreserveFieldRids) != 0;
/// <summary>
/// Gets the <see cref="MetadataFlags.PreserveMethodRids"/> bit
/// </summary>
public bool PreserveMethodRids => (options.Flags & MetadataFlags.PreserveMethodRids) != 0;
/// <summary>
/// Gets the <see cref="MetadataFlags.PreserveParamRids"/> bit
/// </summary>
public bool PreserveParamRids => (options.Flags & MetadataFlags.PreserveParamRids) != 0;
/// <summary>
/// Gets the <see cref="MetadataFlags.PreserveMemberRefRids"/> bit
/// </summary>
public bool PreserveMemberRefRids => (options.Flags & MetadataFlags.PreserveMemberRefRids) != 0;
/// <summary>
/// Gets the <see cref="MetadataFlags.PreserveStandAloneSigRids"/> bit
/// </summary>
public bool PreserveStandAloneSigRids => (options.Flags & MetadataFlags.PreserveStandAloneSigRids) != 0;
/// <summary>
/// Gets the <see cref="MetadataFlags.PreserveEventRids"/> bit
/// </summary>
public bool PreserveEventRids => (options.Flags & MetadataFlags.PreserveEventRids) != 0;
/// <summary>
/// Gets the <see cref="MetadataFlags.PreservePropertyRids"/> bit
/// </summary>
public bool PreservePropertyRids => (options.Flags & MetadataFlags.PreservePropertyRids) != 0;
/// <summary>
/// Gets the <see cref="MetadataFlags.PreserveTypeSpecRids"/> bit
/// </summary>
public bool PreserveTypeSpecRids => (options.Flags & MetadataFlags.PreserveTypeSpecRids) != 0;
/// <summary>
/// Gets the <see cref="MetadataFlags.PreserveMethodSpecRids"/> bit
/// </summary>
public bool PreserveMethodSpecRids => (options.Flags & MetadataFlags.PreserveMethodSpecRids) != 0;
/// <summary>
/// Gets/sets the <see cref="MetadataFlags.PreserveStringsOffsets"/> bit
/// </summary>
public bool PreserveStringsOffsets {
get => (options.Flags & MetadataFlags.PreserveStringsOffsets) != 0;
set {
if (value)
options.Flags |= MetadataFlags.PreserveStringsOffsets;
else
options.Flags &= ~MetadataFlags.PreserveStringsOffsets;
}
}
/// <summary>
/// Gets/sets the <see cref="MetadataFlags.PreserveUSOffsets"/> bit
/// </summary>
public bool PreserveUSOffsets {
get => (options.Flags & MetadataFlags.PreserveUSOffsets) != 0;
set {
if (value)
options.Flags |= MetadataFlags.PreserveUSOffsets;
else
options.Flags &= ~MetadataFlags.PreserveUSOffsets;
}
}
/// <summary>
/// Gets/sets the <see cref="MetadataFlags.PreserveBlobOffsets"/> bit
/// </summary>
public bool PreserveBlobOffsets {
get => (options.Flags & MetadataFlags.PreserveBlobOffsets) != 0;
set {
if (value)
options.Flags |= MetadataFlags.PreserveBlobOffsets;
else
options.Flags &= ~MetadataFlags.PreserveBlobOffsets;
}
}
/// <summary>
/// Gets/sets the <see cref="MetadataFlags.PreserveExtraSignatureData"/> bit
/// </summary>
public bool PreserveExtraSignatureData {
get => (options.Flags & MetadataFlags.PreserveExtraSignatureData) != 0;
set {
if (value)
options.Flags |= MetadataFlags.PreserveExtraSignatureData;
else
options.Flags &= ~MetadataFlags.PreserveExtraSignatureData;
}
}
/// <summary>
/// Gets/sets the <see cref="MetadataFlags.KeepOldMaxStack"/> bit
/// </summary>
public bool KeepOldMaxStack {
get => (options.Flags & MetadataFlags.KeepOldMaxStack) != 0;
set {
if (value)
options.Flags |= MetadataFlags.KeepOldMaxStack;
else
options.Flags &= ~MetadataFlags.KeepOldMaxStack;
}
}
/// <summary>
/// Gets/sets the <see cref="MetadataFlags.AlwaysCreateGuidHeap"/> bit
/// </summary>
public bool AlwaysCreateGuidHeap {
get => (options.Flags & MetadataFlags.AlwaysCreateGuidHeap) != 0;
set {
if (value)
options.Flags |= MetadataFlags.AlwaysCreateGuidHeap;
else
options.Flags &= ~MetadataFlags.AlwaysCreateGuidHeap;
}
}
/// <summary>
/// Gets/sets the <see cref="MetadataFlags.AlwaysCreateStringsHeap"/> bit
/// </summary>
public bool AlwaysCreateStringsHeap {
get => (options.Flags & MetadataFlags.AlwaysCreateStringsHeap) != 0;
set {
if (value)
options.Flags |= MetadataFlags.AlwaysCreateStringsHeap;
else
options.Flags &= ~MetadataFlags.AlwaysCreateStringsHeap;
}
}
/// <summary>
/// Gets/sets the <see cref="MetadataFlags.AlwaysCreateUSHeap"/> bit
/// </summary>
public bool AlwaysCreateUSHeap {
get => (options.Flags & MetadataFlags.AlwaysCreateUSHeap) != 0;
set {
if (value)
options.Flags |= MetadataFlags.AlwaysCreateUSHeap;
else
options.Flags &= ~MetadataFlags.AlwaysCreateUSHeap;
}
}
/// <summary>
/// Gets/sets the <see cref="MetadataFlags.AlwaysCreateBlobHeap"/> bit
/// </summary>
public bool AlwaysCreateBlobHeap {
get => (options.Flags & MetadataFlags.AlwaysCreateBlobHeap) != 0;
set {
if (value)
options.Flags |= MetadataFlags.AlwaysCreateBlobHeap;
else
options.Flags &= ~MetadataFlags.AlwaysCreateBlobHeap;
}
}
/// <summary>
/// Gets/sets the <see cref="MetadataFlags.RoslynSortInterfaceImpl"/> bit
/// </summary>
public bool RoslynSortInterfaceImpl {
get => (options.Flags & MetadataFlags.RoslynSortInterfaceImpl) != 0;
set {
if (value)
options.Flags |= MetadataFlags.RoslynSortInterfaceImpl;
else
options.Flags &= ~MetadataFlags.RoslynSortInterfaceImpl;
}
}
/// <summary>
/// Gets/sets the <see cref="MetadataFlags.NoMethodBodies"/> bit
/// </summary>
public bool NoMethodBodies {
get => (options.Flags & MetadataFlags.NoMethodBodies) != 0;
set {
if (value)
options.Flags |= MetadataFlags.NoMethodBodies;
else
options.Flags &= ~MetadataFlags.NoMethodBodies;
}
}
/// <summary>
/// Gets/sets the <see cref="MetadataFlags.NoDotNetResources"/> bit
/// </summary>
public bool NoDotNetResources {
get => (options.Flags & MetadataFlags.NoDotNetResources) != 0;
set {
if (value)
options.Flags |= MetadataFlags.NoDotNetResources;
else
options.Flags &= ~MetadataFlags.NoDotNetResources;
}
}
/// <summary>
/// Gets/sets the <see cref="MetadataFlags.NoFieldData"/> bit
/// </summary>
public bool NoFieldData {
get => (options.Flags & MetadataFlags.NoFieldData) != 0;
set {
if (value)
options.Flags |= MetadataFlags.NoFieldData;
else
options.Flags &= ~MetadataFlags.NoFieldData;
}
}
/// <summary>
/// Gets/sets the <see cref="MetadataFlags.OptimizeCustomAttributeSerializedTypeNames"/> bit
/// </summary>
public bool OptimizeCustomAttributeSerializedTypeNames {
get => (options.Flags & MetadataFlags.OptimizeCustomAttributeSerializedTypeNames) != 0;
set {
if (value)
options.Flags |= MetadataFlags.OptimizeCustomAttributeSerializedTypeNames;
else
options.Flags &= ~MetadataFlags.OptimizeCustomAttributeSerializedTypeNames;
}
}
/// <summary>
/// If <c>true</c>, use the original Field RVAs. If it has no RVA, assume it's a new
/// field value and create a new Field RVA.
/// </summary>
internal bool KeepFieldRVA { get; set; }
/// <summary>
/// Gets the number of methods that will be written.
/// </summary>
protected abstract int NumberOfMethods { get; }
internal Metadata(ModuleDef module, UniqueChunkList<ByteArrayChunk> constants, MethodBodyChunks methodBodies, NetResources netResources, MetadataOptions options, DebugMetadataKind debugKind, bool isStandaloneDebugMetadata) {
this.module = module;
this.constants = constants;
this.methodBodies = methodBodies;
this.netResources = netResources;
this.options = options ?? new MetadataOptions();
metadataHeader = new MetadataHeader(isStandaloneDebugMetadata ? this.options.DebugMetadataHeaderOptions : this.options.MetadataHeaderOptions);
tablesHeap = new TablesHeap(this, isStandaloneDebugMetadata ? this.options.DebugTablesHeapOptions : this.options.TablesHeapOptions);
stringsHeap = new StringsHeap();
usHeap = new USHeap();
guidHeap = new GuidHeap();
blobHeap = new BlobHeap();
pdbHeap = new PdbHeap();
errorContext = new MetadataErrorContext();
this.isStandaloneDebugMetadata = isStandaloneDebugMetadata;
switch (debugKind) {
case DebugMetadataKind.None:
break;
case DebugMetadataKind.Standalone:
Debug.Assert(!isStandaloneDebugMetadata);
//TODO: Refactor this into a smaller class
debugMetadata = new NormalMetadata(module, constants, methodBodies, netResources, options, DebugMetadataKind.None, true);
break;
default:
throw new ArgumentOutOfRangeException(nameof(debugKind));
}
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="module">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetRid(ModuleDef module) {
moduleDefInfos.TryGetRid(module, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="tr">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public abstract uint GetRid(TypeRef tr);
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="td">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public abstract uint GetRid(TypeDef td);
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="fd">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public abstract uint GetRid(FieldDef fd);
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="md">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public abstract uint GetRid(MethodDef md);
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="pd">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public abstract uint GetRid(ParamDef pd);
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="ii">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetRid(InterfaceImpl ii) {
interfaceImplInfos.TryGetRid(ii, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="mr">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public abstract uint GetRid(MemberRef mr);
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="hc">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetConstantRid(IHasConstant hc) {
hasConstantInfos.TryGetRid(hc, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="ca">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetCustomAttributeRid(CustomAttribute ca) {
customAttributeInfos.TryGetRid(ca, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="hfm">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetFieldMarshalRid(IHasFieldMarshal hfm) {
fieldMarshalInfos.TryGetRid(hfm, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="ds">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetRid(DeclSecurity ds) {
declSecurityInfos.TryGetRid(ds, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="td">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetClassLayoutRid(TypeDef td) {
classLayoutInfos.TryGetRid(td, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="fd">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetFieldLayoutRid(FieldDef fd) {
fieldLayoutInfos.TryGetRid(fd, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="sas">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public abstract uint GetRid(StandAloneSig sas);
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="td">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetEventMapRid(TypeDef td) {
eventMapInfos.TryGetRid(td, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="ed">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public abstract uint GetRid(EventDef ed);
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="td">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetPropertyMapRid(TypeDef td) {
propertyMapInfos.TryGetRid(td, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="pd">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public abstract uint GetRid(PropertyDef pd);
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="md">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetMethodSemanticsRid(MethodDef md) {
methodSemanticsInfos.TryGetRid(md, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="mr">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetRid(ModuleRef mr) {
moduleRefInfos.TryGetRid(mr, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="ts">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public abstract uint GetRid(TypeSpec ts);
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="mf">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetImplMapRid(IMemberForwarded mf) {
implMapInfos.TryGetRid(mf, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="fd">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetFieldRVARid(FieldDef fd) {
fieldRVAInfos.TryGetRid(fd, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="asm">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetRid(AssemblyDef asm) {
assemblyInfos.TryGetRid(asm, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="asmRef">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetRid(AssemblyRef asmRef) {
assemblyRefInfos.TryGetRid(asmRef, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="fd">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetRid(FileDef fd) {
fileDefInfos.TryGetRid(fd, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="et">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetRid(ExportedType et) {
exportedTypeInfos.TryGetRid(et, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="resource">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetManifestResourceRid(Resource resource) {
manifestResourceInfos.TryGetRid(resource, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="td">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetNestedClassRid(TypeDef td) {
nestedClassInfos.TryGetRid(td, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="gp">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetRid(GenericParam gp) {
genericParamInfos.TryGetRid(gp, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="ms">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public abstract uint GetRid(MethodSpec ms);
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="gpc">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetRid(GenericParamConstraint gpc) {
genericParamConstraintInfos.TryGetRid(gpc, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="doc">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetRid(PdbDocument doc) {
if (debugMetadata is null)
return 0;
debugMetadata.pdbDocumentInfos.TryGetRid(doc, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="scope">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetRid(PdbScope scope) {
if (debugMetadata is null)
return 0;
debugMetadata.localScopeInfos.TryGetRid(scope, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="local">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetRid(PdbLocal local) {
if (debugMetadata is null)
return 0;
debugMetadata.localVariableInfos.TryGetRid(local, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="constant">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetRid(PdbConstant constant) {
if (debugMetadata is null)
return 0;
debugMetadata.localConstantInfos.TryGetRid(constant, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="importScope">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetRid(PdbImportScope importScope) {
if (debugMetadata is null)
return 0;
debugMetadata.importScopeInfos.TryGetRid(importScope, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="asyncMethod">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetStateMachineMethodRid(PdbAsyncMethodCustomDebugInfo asyncMethod) {
if (debugMetadata is null)
return 0;
debugMetadata.stateMachineMethodInfos.TryGetRid(asyncMethod, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="iteratorMethod">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetStateMachineMethodRid(PdbIteratorMethodCustomDebugInfo iteratorMethod) {
if (debugMetadata is null)
return 0;
debugMetadata.stateMachineMethodInfos.TryGetRid(iteratorMethod, out uint rid);
return rid;
}
/// <summary>
/// Gets the new rid
/// </summary>
/// <param name="cdi">Value</param>
/// <returns>Its new rid or <c>0</c></returns>
public uint GetCustomDebugInfoRid(PdbCustomDebugInfo cdi) {
if (debugMetadata is null)
return 0;
debugMetadata.customDebugInfos.TryGetRid(cdi, out uint rid);
return rid;
}
/// <summary>
/// Gets the <see cref="MethodBody"/>
/// </summary>
/// <param name="md">Method</param>
/// <returns>The <see cref="MethodBody"/> or <c>null</c> if <paramref name="md"/> is
/// <c>null</c> or not a method defined in this module.</returns>
public MethodBody GetMethodBody(MethodDef md) {
if (md is null)
return null;
methodToBody.TryGetValue(md, out var mb);
return mb;
}
/// <summary>
/// Gets a method's local variable signature token
/// </summary>
/// <param name="md">Method</param>
/// <returns>Locals sig token or <c>0</c></returns>
public uint GetLocalVarSigToken(MethodDef md) => GetMethodBody(md)?.LocalVarSigTok ?? 0;
/// <summary>
/// Gets the <see cref="DataReaderChunk"/> where the resource data will be stored
/// </summary>
/// <param name="er">Embedded resource</param>
/// <returns>A <see cref="DataReaderChunk"/> instance or <c>null</c> if <paramref name="er"/>
/// is invalid</returns>
public DataReaderChunk GetChunk(EmbeddedResource er) {
if (er is null)
return null;
embeddedResourceToByteArray.TryGetValue(er, out var chunk);
return chunk;
}
/// <summary>
/// Gets the <see cref="ByteArrayChunk"/> where the initial value is stored
/// </summary>
/// <param name="fd">Field</param>
/// <returns>A <see cref="ByteArrayChunk"/> instance or <c>null</c> if <paramref name="fd"/>
/// is invalid</returns>
public ByteArrayChunk GetInitialValueChunk(FieldDef fd) {
if (fd is null)
return null;
fieldToInitialValue.TryGetValue(fd, out var chunk);
return chunk;
}
ILogger GetLogger() => logger ?? DummyLogger.ThrowModuleWriterExceptionOnErrorInstance;
/// <summary>
/// Called when an error is detected
/// </summary>
/// <param name="message">Error message</param>
/// <param name="args">Optional message arguments</param>
protected void Error(string message, params object[] args) {
errorContext.Append("Error", ref message, ref args);
GetLogger().Log(this, LoggerEvent.Error, message, args);
}
/// <summary>
/// Called to warn of something
/// </summary>
/// <param name="message">Warning message</param>
/// <param name="args">Optional message arguments</param>
protected void Warning(string message, params object[] args) {
errorContext.Append("Warning", ref message, ref args);
GetLogger().Log(this, LoggerEvent.Warning, message, args);
}
/// <summary>
/// Raises <see cref="MetadataEvent"/>
/// </summary>
/// <param name="evt">Event</param>
protected void OnMetadataEvent(MetadataEvent evt) {
errorContext.Event = evt;
RaiseProgress(evt, 0);
MetadataEvent?.Invoke(this, new MetadataWriterEventArgs(this, evt));
}
static readonly double[] eventToProgress = new double[(int)Writer.MetadataEvent.EndCreateTables - (int)Writer.MetadataEvent.BeginCreateTables + 1 + 1] {
0, // BeginCreateTables
0.00134240009466231,// AllocateTypeDefRids
0.00257484711254305,// AllocateMemberDefRids
0.0762721800615359, // MemberDefRidsAllocated
0.196633787905108, // MemberDefsInitialized
0.207788892253819, // BeforeSortTables
0.270543867900699, // MostTablesSorted
0.451478814851716, // MemberDefCustomAttributesWritten
0.451478949929206, // BeginAddResources
0.454664752528583, // EndAddResources
0.454664887606073, // BeginWriteMethodBodies
0.992591810143725, // EndWriteMethodBodies
0.999984331011171, // OnAllTablesSorted
1, // EndCreateTables
1,// An extra one so we can get the next base progress without checking the index
};
/// <summary>
/// Raises the progress event
/// </summary>
/// <param name="evt">Base event</param>
/// <param name="subProgress">Sub progress</param>
protected void RaiseProgress(MetadataEvent evt, double subProgress) {
subProgress = Math.Min(1, Math.Max(0, subProgress));
var baseProgress = eventToProgress[(int)evt];
var nextProgress = eventToProgress[(int)evt + 1];
var progress = baseProgress + (nextProgress - baseProgress) * subProgress;
progress = Math.Min(1, Math.Max(0, progress));
ProgressUpdated?.Invoke(this, new MetadataProgressEventArgs(this, progress));
}
/// <summary>
/// Creates the .NET metadata tables
/// </summary>
public void CreateTables() {
OnMetadataEvent(Writer.MetadataEvent.BeginCreateTables);
if (module.Types.Count == 0 || module.Types[0] is null)
throw new ModuleWriterException("Missing global <Module> type");
if (module is ModuleDefMD moduleDefMD) {
if (PreserveStringsOffsets)
stringsHeap.Populate(moduleDefMD.StringsStream);
if (PreserveUSOffsets)
usHeap.Populate(moduleDefMD.USStream);
if (PreserveBlobOffsets)
blobHeap.Populate(moduleDefMD.BlobStream);
}
Create();
}
/// <summary>
/// Updates each <c>Method</c> row's <c>RVA</c> column if it has any code
/// </summary>
void UpdateMethodRvas() {
foreach (var kv in methodToBody) {
var method = kv.Key;
var body = kv.Value;
uint rid = GetRid(method);
var row = tablesHeap.MethodTable[rid];
row = new RawMethodRow((uint)body.RVA, row.ImplFlags, row.Flags, row.Name, row.Signature, row.ParamList);
tablesHeap.MethodTable[rid] = row;
}
foreach (var kv in methodToNativeBody) {
var method = kv.Key;
var body = kv.Value;
uint rid = GetRid(method);
var row = tablesHeap.MethodTable[rid];
row = new RawMethodRow((uint)body.RVA, row.ImplFlags, row.Flags, row.Name, row.Signature, row.ParamList);
tablesHeap.MethodTable[rid] = row;
}
}
/// <summary>
/// Updates the <c>FieldRVA</c> rows
/// </summary>
void UpdateFieldRvas() {
foreach (var kv in fieldToInitialValue) {
var field = kv.Key;
var iv = kv.Value;
uint rid = fieldRVAInfos.Rid(field);
var row = tablesHeap.FieldRVATable[rid];
row = new RawFieldRVARow((uint)iv.RVA, row.Field);
tablesHeap.FieldRVATable[rid] = row;
}
}
void Create() {
Debug.Assert(!isStandaloneDebugMetadata);
Initialize();
allTypeDefs = GetAllTypeDefs();
OnMetadataEvent(Writer.MetadataEvent.AllocateTypeDefRids);
AllocateTypeDefRids();
OnMetadataEvent(Writer.MetadataEvent.AllocateMemberDefRids);
AllocateMemberDefRids();
OnMetadataEvent(Writer.MetadataEvent.MemberDefRidsAllocated);
AddModule(module);
AddPdbDocuments();
InitializeMethodDebugInformation();
InitializeTypeDefsAndMemberDefs();
OnMetadataEvent(Writer.MetadataEvent.MemberDefsInitialized);
InitializeVTableFixups();
AddExportedTypes();
InitializeEntryPoint();
if (module.Assembly is not null)
AddAssembly(module.Assembly, AssemblyPublicKey);
OnMetadataEvent(Writer.MetadataEvent.BeforeSortTables);
SortTables();
InitializeGenericParamConstraintTable();
OnMetadataEvent(Writer.MetadataEvent.MostTablesSorted);
WriteTypeDefAndMemberDefCustomAttributesAndCustomDebugInfos();
OnMetadataEvent(Writer.MetadataEvent.MemberDefCustomAttributesWritten);
OnMetadataEvent(Writer.MetadataEvent.BeginAddResources);
AddResources(module.Resources);
OnMetadataEvent(Writer.MetadataEvent.EndAddResources);
OnMetadataEvent(Writer.MetadataEvent.BeginWriteMethodBodies);
WriteMethodBodies();
OnMetadataEvent(Writer.MetadataEvent.EndWriteMethodBodies);
BeforeSortingCustomAttributes();
InitializeCustomAttributeAndCustomDebugInfoTables();
OnMetadataEvent(Writer.MetadataEvent.OnAllTablesSorted);
EverythingInitialized();
OnMetadataEvent(Writer.MetadataEvent.EndCreateTables);
}
/// <summary>
/// Initializes all <c>TypeDef</c>, <c>Field</c>, <c>Method</c>, <c>Event</c>,
/// <c>Property</c> and <c>Param</c> rows. Other tables that are related to these six
/// tables are also updated. No custom attributes are written yet, though. Method bodies
/// aren't written either.
/// </summary>
void InitializeTypeDefsAndMemberDefs() {
int count;
int numTypes = allTypeDefs.Length;
int typeNum = 0;
int notifyNum = 0;
const int numNotifyEvents = 5;
int notifyAfter = numTypes / numNotifyEvents;
foreach (var type in allTypeDefs) {
using var _ = errorContext.SetSource(type);
if (typeNum++ == notifyAfter && notifyNum < numNotifyEvents) {
RaiseProgress(Writer.MetadataEvent.MemberDefRidsAllocated, (double)typeNum / numTypes);
notifyNum++;
notifyAfter = (int)((double)numTypes / numNotifyEvents * (notifyNum + 1));
}
if (type is null) {
Error("TypeDef is null");
continue;
}
uint typeRid = GetRid(type);
var typeRow = tablesHeap.TypeDefTable[typeRid];
typeRow = new RawTypeDefRow((uint)type.Attributes, stringsHeap.Add(type.Name), stringsHeap.Add(type.Namespace), type.BaseType is null ? 0 : AddTypeDefOrRef(type.BaseType), typeRow.FieldList, typeRow.MethodList);
tablesHeap.TypeDefTable[typeRid] = typeRow;
AddGenericParams(new MDToken(Table.TypeDef, typeRid), type.GenericParameters);
AddDeclSecurities(new MDToken(Table.TypeDef, typeRid), type.DeclSecurities);
AddInterfaceImpls(typeRid, type.Interfaces);
AddClassLayout(type);
AddNestedType(type, type.DeclaringType);
var fields = type.Fields;
count = fields.Count;
for (int i = 0; i < count; i++) {
var field = fields[i];
if (field is null) {
Error("Field is null");
continue;
}
using var __ = errorContext.SetSource(field);
uint rid = GetRid(field);
var row = new RawFieldRow((ushort)field.Attributes, stringsHeap.Add(field.Name), GetSignature(field.Signature));
tablesHeap.FieldTable[rid] = row;
AddFieldLayout(field);
AddFieldMarshal(new MDToken(Table.Field, rid), field);
AddFieldRVA(field);
AddImplMap(new MDToken(Table.Field, rid), field);
AddConstant(new MDToken(Table.Field, rid), field);
}
var methods = type.Methods;
count = methods.Count;
for (int i = 0; i < count; i++) {
var method = methods[i];
if (method is null) {
Error("Method is null");
continue;
}
using var __ = errorContext.SetSource(method);
if (method.ExportInfo is not null)
ExportedMethods.Add(method);
uint rid = GetRid(method);
var row = tablesHeap.MethodTable[rid];
row = new RawMethodRow(row.RVA, (ushort)method.ImplAttributes, (ushort)method.Attributes, stringsHeap.Add(method.Name), GetSignature(method.Signature), row.ParamList);
tablesHeap.MethodTable[rid] = row;
AddGenericParams(new MDToken(Table.Method, rid), method.GenericParameters);
AddDeclSecurities(new MDToken(Table.Method, rid), method.DeclSecurities);
AddImplMap(new MDToken(Table.Method, rid), method);
AddMethodImpls(method, method.Overrides);
var paramDefs = method.ParamDefs;
int count2 = paramDefs.Count;
for (int j = 0; j < count2; j++) {
var pd = paramDefs[j];
if (pd is null) {
Error("Param is null");
continue;
}
uint pdRid = GetRid(pd);
var pdRow = new RawParamRow((ushort)pd.Attributes, pd.Sequence, stringsHeap.Add(pd.Name));
tablesHeap.ParamTable[pdRid] = pdRow;
AddConstant(new MDToken(Table.Param, pdRid), pd);
AddFieldMarshal(new MDToken(Table.Param, pdRid), pd);
}
}
var events = type.Events;
count = events.Count;
for (int i = 0; i < count; i++) {
var evt = events[i];
if (evt is null) {
Error("Event is null");
continue;
}
using var __ = errorContext.SetSource(evt);
uint rid = GetRid(evt);
var row = new RawEventRow((ushort)evt.Attributes, stringsHeap.Add(evt.Name), AddTypeDefOrRef(evt.EventType));
tablesHeap.EventTable[rid] = row;
AddMethodSemantics(evt);
}
var properties = type.Properties;
count = properties.Count;
for (int i = 0; i < count; i++) {
var prop = properties[i];
if (prop is null) {
Error("Property is null");
continue;
}
using var __ = errorContext.SetSource(prop);
uint rid = GetRid(prop);
var row = new RawPropertyRow((ushort)prop.Attributes, stringsHeap.Add(prop.Name), GetSignature(prop.Type));
tablesHeap.PropertyTable[rid] = row;
AddConstant(new MDToken(Table.Property, rid), prop);
AddMethodSemantics(prop);
}
}
}
/// <summary>
/// Writes <c>TypeDef</c>, <c>Field</c>, <c>Method</c>, <c>Event</c>,
/// <c>Property</c> and <c>Param</c> custom attributes and custom debug infos.
/// </summary>
void WriteTypeDefAndMemberDefCustomAttributesAndCustomDebugInfos() {
int count;
int numTypes = allTypeDefs.Length;
int typeNum = 0;
int notifyNum = 0;
const int numNotifyEvents = 5;
int notifyAfter = numTypes / numNotifyEvents;
uint rid;
foreach (var type in allTypeDefs) {
using var _ = errorContext.SetSource(type);
if (typeNum++ == notifyAfter && notifyNum < numNotifyEvents) {
RaiseProgress(Writer.MetadataEvent.MostTablesSorted, (double)typeNum / numTypes);
notifyNum++;
notifyAfter = (int)((double)numTypes / numNotifyEvents * (notifyNum + 1));
}
if (type is null)
continue;
if (type.HasCustomAttributes || type.HasCustomDebugInfos) {
rid = GetRid(type);
AddCustomAttributes(Table.TypeDef, rid, type);
AddCustomDebugInformationList(Table.TypeDef, rid, type);
}
var fields = type.Fields;
count = fields.Count;
for (int i = 0; i < count; i++) {
var field = fields[i];
if (field is null)
continue;
if (field.HasCustomAttributes || field.HasCustomDebugInfos) {
rid = GetRid(field);
AddCustomAttributes(Table.Field, rid, field);
AddCustomDebugInformationList(Table.Field, rid, field);
}
}
var methods = type.Methods;
count = methods.Count;
for (int i = 0; i < count; i++) {
var method = methods[i];
if (method is null)
continue;
using var __ = errorContext.SetSource(method);
if (method.HasCustomAttributes) {
rid = GetRid(method);
AddCustomAttributes(Table.Method, rid, method);
// Method custom debug info is added later when writing method bodies
}
var paramDefs = method.ParamDefs;
int count2 = paramDefs.Count;
for (int j = 0; j < count2; j++) {
var pd = paramDefs[j];
if (pd is null)
continue;
if (pd.HasCustomAttributes || pd.HasCustomDebugInfos) {
rid = GetRid(pd);
AddCustomAttributes(Table.Param, rid, pd);
AddCustomDebugInformationList(Table.Param, rid, pd);
}
}
}
var events = type.Events;
count = events.Count;
for (int i = 0; i < count; i++) {
var evt = events[i];
if (evt is null)
continue;
if (evt.HasCustomAttributes || evt.HasCustomDebugInfos) {
rid = GetRid(evt);
AddCustomAttributes(Table.Event, rid, evt);
AddCustomDebugInformationList(Table.Event, rid, evt);
}
}
var properties = type.Properties;
count = properties.Count;
for (int i = 0; i < count; i++) {
var prop = properties[i];
if (prop is null)
continue;
if (prop.HasCustomAttributes || prop.HasCustomDebugInfos) {
rid = GetRid(prop);
AddCustomAttributes(Table.Property, rid, prop);
AddCustomDebugInformationList(Table.Property, rid, prop);
}
}
}
}
/// <summary>
/// Adds the tokens of all methods in all vtables, if any
/// </summary>
void InitializeVTableFixups() {
var fixups = module.VTableFixups;
if (fixups is null || fixups.VTables.Count == 0)
return;
using var _ = errorContext.SetSource("vtable fixups");
foreach (var vtable in fixups) {
if (vtable is null) {
Error("VTable is null");
continue;
}
foreach (var method in vtable) {
if (method is null)
continue;
AddMDTokenProvider(method);
}
}
}
void AddExportedTypes() {
using var _ = errorContext.SetSource("exported types");
var exportedTypes = module.ExportedTypes;
int count = exportedTypes.Count;
for (int i = 0; i < count; i++)
AddExportedType(exportedTypes[i]);
}
/// <summary>
/// Adds the entry point. It's only needed if it's a <see cref="FileDef"/> since if it's
/// a <see cref="MethodDef"/>, it will have already been added.
/// </summary>
void InitializeEntryPoint() {
using var _ = errorContext.SetSource("entry point");
if (module.ManagedEntryPoint is FileDef epFile)
AddFile(epFile);
}
/// <summary>
/// Sorts all unsorted tables except <c>GenericParamConstraint</c> and <c>CustomAttribute</c>
/// </summary>
void SortTables() {
classLayoutInfos.Sort((a, b) => a.row.Parent.CompareTo(b.row.Parent));
hasConstantInfos.Sort((a, b) => a.row.Parent.CompareTo(b.row.Parent));
declSecurityInfos.Sort((a, b) => a.row.Parent.CompareTo(b.row.Parent));
fieldLayoutInfos.Sort((a, b) => a.row.Field.CompareTo(b.row.Field));
fieldMarshalInfos.Sort((a, b) => a.row.Parent.CompareTo(b.row.Parent));
fieldRVAInfos.Sort((a, b) => a.row.Field.CompareTo(b.row.Field));
implMapInfos.Sort((a, b) => a.row.MemberForwarded.CompareTo(b.row.MemberForwarded));
methodImplInfos.Sort((a, b) => a.row.Class.CompareTo(b.row.Class));
methodSemanticsInfos.Sort((a, b)=> a.row.Association.CompareTo(b.row.Association));
nestedClassInfos.Sort((a, b) => a.row.NestedClass.CompareTo(b.row.NestedClass));
genericParamInfos.Sort((a, b) => {
if (a.row.Owner != b.row.Owner)
return a.row.Owner.CompareTo(b.row.Owner);
return a.row.Number.CompareTo(b.row.Number);
});
interfaceImplInfos.Sort((a, b) => a.row.Class.CompareTo(b.row.Class));
tablesHeap.ClassLayoutTable.IsSorted = true;
tablesHeap.ConstantTable.IsSorted = true;
tablesHeap.DeclSecurityTable.IsSorted = true;
tablesHeap.FieldLayoutTable.IsSorted = true;
tablesHeap.FieldMarshalTable.IsSorted = true;
tablesHeap.FieldRVATable.IsSorted = true;
tablesHeap.GenericParamTable.IsSorted = true;
tablesHeap.ImplMapTable.IsSorted = true;
tablesHeap.InterfaceImplTable.IsSorted = true;
tablesHeap.MethodImplTable.IsSorted = true;
tablesHeap.MethodSemanticsTable.IsSorted = true;
tablesHeap.NestedClassTable.IsSorted = true;
// These two are also sorted
tablesHeap.EventMapTable.IsSorted = true;
tablesHeap.PropertyMapTable.IsSorted = true;
foreach (var info in classLayoutInfos.infos) tablesHeap.ClassLayoutTable.Create(info.row);
foreach (var info in hasConstantInfos.infos) tablesHeap.ConstantTable.Create(info.row);
foreach (var info in declSecurityInfos.infos) tablesHeap.DeclSecurityTable.Create(info.row);
foreach (var info in fieldLayoutInfos.infos) tablesHeap.FieldLayoutTable.Create(info.row);
foreach (var info in fieldMarshalInfos.infos) tablesHeap.FieldMarshalTable.Create(info.row);
foreach (var info in fieldRVAInfos.infos) tablesHeap.FieldRVATable.Create(info.row);
foreach (var info in genericParamInfos.infos) tablesHeap.GenericParamTable.Create(info.row);
foreach (var info in implMapInfos.infos) tablesHeap.ImplMapTable.Create(info.row);
foreach (var info in interfaceImplInfos.infos) tablesHeap.InterfaceImplTable.Create(info.row);
foreach (var info in methodImplInfos.infos) tablesHeap.MethodImplTable.Create(info.row);
foreach (var info in methodSemanticsInfos.infos) tablesHeap.MethodSemanticsTable.Create(info.row);
foreach (var info in nestedClassInfos.infos) tablesHeap.NestedClassTable.Create(info.row);
foreach (var info in interfaceImplInfos.infos) {
if (info.data.HasCustomAttributes || info.data.HasCustomDebugInfos) {
uint rid = interfaceImplInfos.Rid(info.data);
AddCustomAttributes(Table.InterfaceImpl, rid, info.data);
AddCustomDebugInformationList(Table.InterfaceImpl, rid, info.data);
}
}
foreach (var info in declSecurityInfos.infos) {
if (info.data.HasCustomAttributes || info.data.HasCustomDebugInfos) {
uint rid = declSecurityInfos.Rid(info.data);
AddCustomAttributes(Table.DeclSecurity, rid, info.data);
AddCustomDebugInformationList(Table.DeclSecurity, rid, info.data);
}
}
foreach (var info in genericParamInfos.infos) {
if (info.data.HasCustomAttributes || info.data.HasCustomDebugInfos) {
uint rid = genericParamInfos.Rid(info.data);
AddCustomAttributes(Table.GenericParam, rid, info.data);
AddCustomDebugInformationList(Table.GenericParam, rid, info.data);
}
}
}
/// <summary>
/// Initializes the <c>GenericParamConstraint</c> table
/// </summary>
void InitializeGenericParamConstraintTable() {
foreach (var type in allTypeDefs) {
if (type is null)
continue;
using var _ = errorContext.SetSource(type);
AddGenericParamConstraints(type.GenericParameters);
var methods = type.Methods;
int count = methods.Count;
for (int i = 0; i < count; i++) {
var method = methods[i];
if (method is null)
continue;
using var __ = errorContext.SetSource(method);
AddGenericParamConstraints(method.GenericParameters);
}
}
genericParamConstraintInfos.Sort((a, b) => a.row.Owner.CompareTo(b.row.Owner));
tablesHeap.GenericParamConstraintTable.IsSorted = true;
foreach (var info in genericParamConstraintInfos.infos)
tablesHeap.GenericParamConstraintTable.Create(info.row);
foreach (var info in genericParamConstraintInfos.infos) {
if (info.data.HasCustomAttributes || info.data.HasCustomDebugInfos) {
uint rid = genericParamConstraintInfos.Rid(info.data);
AddCustomAttributes(Table.GenericParamConstraint, rid, info.data);
AddCustomDebugInformationList(Table.GenericParamConstraint, rid, info.data);
}
}
}
/// <summary>
/// Inserts all custom attribute / custom debug info rows in the tables and sort them
/// </summary>
void InitializeCustomAttributeAndCustomDebugInfoTables() {
customAttributeInfos.Sort((a, b) => a.row.Parent.CompareTo(b.row.Parent));
tablesHeap.CustomAttributeTable.IsSorted = true;
foreach (var info in customAttributeInfos.infos)
tablesHeap.CustomAttributeTable.Create(info.row);
if (debugMetadata is not null) {
debugMetadata.stateMachineMethodInfos.Sort((a, b) => a.row.MoveNextMethod.CompareTo(b.row.MoveNextMethod));
debugMetadata.tablesHeap.StateMachineMethodTable.IsSorted = true;
foreach (var info in debugMetadata.stateMachineMethodInfos.infos)
debugMetadata.tablesHeap.StateMachineMethodTable.Create(info.row);
debugMetadata.customDebugInfos.Sort((a, b) => a.row.Parent.CompareTo(b.row.Parent));
debugMetadata.tablesHeap.CustomDebugInformationTable.IsSorted = true;
foreach (var info in debugMetadata.customDebugInfos.infos)
debugMetadata.tablesHeap.CustomDebugInformationTable.Create(info.row);
}
}
struct MethodScopeDebugInfo {
public uint MethodRid;
public PdbScope Scope;
public uint ScopeStart;
public uint ScopeLength;
}
/// <summary>
/// Writes all method bodies
/// </summary>
void WriteMethodBodies() {
Debug.Assert(!isStandaloneDebugMetadata);
if (NoMethodBodies)
return;
int numMethods = NumberOfMethods;
int methodNum = 0;
int notifyNum = 0;
// Writing method bodies is the most expensive part and takes the longest
const int numNotifyEvents = 40;
int notifyAfter = numMethods / numNotifyEvents;
var debugMetadata = this.debugMetadata;
var methodBodies = this.methodBodies;
var methodToBody = this.methodToBody;
List<MethodScopeDebugInfo> methodScopeDebugInfos;
List<PdbScope> scopeStack;
SerializerMethodContext serializerMethodContext;
if (debugMetadata is null) {
methodScopeDebugInfos = null;
scopeStack = null;
serializerMethodContext = null;
}
else {
methodScopeDebugInfos = new List<MethodScopeDebugInfo>();
scopeStack = new List<PdbScope>();
serializerMethodContext = AllocSerializerMethodContext();
}
bool keepMaxStack = KeepOldMaxStack;
var writer = new MethodBodyWriter(this);
foreach (var type in allTypeDefs) {
if (type is null)
continue;
using var _ = errorContext.SetSource(type);
var methods = type.Methods;
for (int i = 0; i < methods.Count; i++) {
var method = methods[i];
if (method is null)
continue;
using var __ = errorContext.SetSource(method);
if (methodNum++ == notifyAfter && notifyNum < numNotifyEvents) {
RaiseProgress(Writer.MetadataEvent.BeginWriteMethodBodies, (double)methodNum / numMethods);
notifyNum++;
notifyAfter = (int)((double)numMethods / numNotifyEvents * (notifyNum + 1));
}
uint localVarSigTok = 0;
var cilBody = method.Body;
if (cilBody is not null) {
if (!(cilBody.Instructions.Count == 0 && cilBody.Variables.Count == 0)) {
writer.Reset(cilBody, keepMaxStack || cilBody.KeepOldMaxStack);
writer.Write();
var origRva = method.RVA;
uint origSize = cilBody.MetadataBodySize;
var mb = methodBodies.Add(new MethodBody(writer.Code, writer.ExtraSections, writer.LocalVarSigTok), origRva, origSize);
methodToBody[method] = mb;
localVarSigTok = writer.LocalVarSigTok;
}
}
else {
var nativeBody = method.NativeBody;
if (nativeBody is not null)
methodToNativeBody[method] = nativeBody;
else if (method.MethodBody is not null)
Error("Unsupported method body");
}
if (debugMetadata is not null) {
uint rid = GetRid(method);
if (cilBody is not null) {
var pdbMethod = cilBody.PdbMethod;
if (pdbMethod is not null) {
// We don't need to write empty scopes
if (!IsEmptyRootScope(cilBody, pdbMethod.Scope)) {
serializerMethodContext.SetBody(method);
scopeStack.Add(pdbMethod.Scope);
while (scopeStack.Count > 0) {
var scope = scopeStack[scopeStack.Count - 1];
scopeStack.RemoveAt(scopeStack.Count - 1);
scopeStack.AddRange(scope.Scopes);
uint scopeStart = serializerMethodContext.GetOffset(scope.Start);
uint scopeEnd = serializerMethodContext.GetOffset(scope.End);
methodScopeDebugInfos.Add(new MethodScopeDebugInfo() {
MethodRid = rid,
Scope = scope,
ScopeStart = scopeStart,
ScopeLength = scopeEnd - scopeStart,
});
}
}
}
}
// Always add CDIs even if it has no managed method body
AddCustomDebugInformationList(method, rid, localVarSigTok);
}
}
}
if (debugMetadata is not null) {
methodScopeDebugInfos.Sort((a, b) => {
int c = a.MethodRid.CompareTo(b.MethodRid);
if (c != 0)
return c;
c = a.ScopeStart.CompareTo(b.ScopeStart);
if (c != 0)
return c;
return b.ScopeLength.CompareTo(a.ScopeLength);
});
foreach (var info in methodScopeDebugInfos) {
uint localScopeRid = (uint)debugMetadata.localScopeInfos.infos.Count + 1;
var row = new RawLocalScopeRow(info.MethodRid, AddImportScope(info.Scope.ImportScope),
(uint)debugMetadata.tablesHeap.LocalVariableTable.Rows + 1,
(uint)debugMetadata.tablesHeap.LocalConstantTable.Rows + 1,
info.ScopeStart, info.ScopeLength);
debugMetadata.localScopeInfos.Add(info.Scope, row);
var variables = info.Scope.Variables;
int count = variables.Count;
for (int i = 0; i < count; i++) {
var local = variables[i];
AddLocalVariable(local);
}
var constants = info.Scope.Constants;
count = constants.Count;
for (int i = 0; i < count; i++) {
var constant = constants[i];
AddLocalConstant(constant);
}
AddCustomDebugInformationList(Table.LocalScope, localScopeRid, info.Scope.CustomDebugInfos);
}
debugMetadata.tablesHeap.LocalScopeTable.IsSorted = true;
foreach (var info in debugMetadata.localScopeInfos.infos)
debugMetadata.tablesHeap.LocalScopeTable.Create(info.row);
}
if (serializerMethodContext is not null)
Free(ref serializerMethodContext);
}
static bool IsEmptyRootScope(CilBody cilBody, PdbScope scope) {
if (scope.Variables.Count != 0)
return false;
if (scope.Constants.Count != 0)
return false;
if (scope.Namespaces.Count != 0)
return false;
if (scope.ImportScope is not null)
return false;
if (scope.Scopes.Count != 0)
return false;
if (scope.CustomDebugInfos.Count != 0)
return false;
if (scope.End is not null)
return false;
if (cilBody.Instructions.Count != 0 && cilBody.Instructions[0] != scope.Start)
return false;
return true;
}
/// <summary>
/// Checks whether a list is empty or whether it contains only <c>null</c>s
/// </summary>
/// <typeparam name="T">Any type</typeparam>
/// <param name="list">The list</param>
/// <returns><c>true</c> if the list is empty or if it contains only <c>null</c>s, <c>false</c> otherwise</returns>
protected static bool IsEmpty<T>(IList<T> list) where T : class {
if (list is null)
return true;
int count = list.Count;
for (int i = 0; i < count; i++) {
if (list[i] is not null)
return false;
}
return true;
}
/// <inheritdoc/>
public MDToken GetToken(object o) {
if (o is IMDTokenProvider tp)
return new MDToken(tp.MDToken.Table, AddMDTokenProvider(tp));
if (o is string s)
return new MDToken((Table)0x70, usHeap.Add(s));
if (o is MethodSig methodSig)
return new MDToken(Table.StandAloneSig, AddStandAloneSig(methodSig, methodSig.OriginalToken));
if (o is FieldSig fieldSig)
return new MDToken(Table.StandAloneSig, AddStandAloneSig(fieldSig, 0));
if (o is null)
Error("Instruction operand is null");
else
Error("Invalid instruction operand");
return new MDToken((Table)0xFF, 0x00FFFFFF);
}
/// <inheritdoc/>
public virtual MDToken GetToken(IList<TypeSig> locals, uint origToken) {
if (locals is null || locals.Count == 0)
return new MDToken((Table)0, 0);
var row = new RawStandAloneSigRow(GetSignature(new LocalSig(locals, false)));
uint rid = tablesHeap.StandAloneSigTable.Add(row);
//TODO: Add custom attributes
//TODO: Add custom debug infos
return new MDToken(Table.StandAloneSig, rid);
}
/// <summary>
/// Adds a <see cref="StandAloneSig"/>
/// </summary>
/// <param name="methodSig">Method signature</param>
/// <param name="origToken">Original <c>StandAloneSig</c> token or 0 if none</param>
/// <returns>Its new rid</returns>
protected virtual uint AddStandAloneSig(MethodSig methodSig, uint origToken) {
if (methodSig is null) {
Error("StandAloneSig: MethodSig is null");
return 0;
}
var row = new RawStandAloneSigRow(GetSignature(methodSig));
uint rid = tablesHeap.StandAloneSigTable.Add(row);
//TODO: Add custom attributes
//TODO: Add custom debug infos
return rid;
}
/// <summary>
/// Adds a <see cref="StandAloneSig"/>
/// </summary>
/// <param name="fieldSig">FIeld signature</param>
/// <param name="origToken">Original <c>StandAloneSig</c> token or 0 if none</param>
/// <returns>Its new rid</returns>
protected virtual uint AddStandAloneSig(FieldSig fieldSig, uint origToken) {
if (fieldSig is null) {
Error("StandAloneSig: FieldSig is null");
return 0;
}
var row = new RawStandAloneSigRow(GetSignature(fieldSig));
uint rid = tablesHeap.StandAloneSigTable.Add(row);
//TODO: Add custom attributes
//TODO: Add custom debug infos
return rid;
}
uint AddMDTokenProvider(IMDTokenProvider tp) {
if (tp is not null) {
switch (tp.MDToken.Table) {
case Table.Module:
return AddModule((ModuleDef)tp);
case Table.TypeRef:
return AddTypeRef((TypeRef)tp);
case Table.TypeDef:
return GetRid((TypeDef)tp);
case Table.Field:
return GetRid((FieldDef)tp);
case Table.Method:
return GetRid((MethodDef)tp);
case Table.Param:
return GetRid((ParamDef)tp);
case Table.MemberRef:
return AddMemberRef((MemberRef)tp);
case Table.StandAloneSig:
return AddStandAloneSig((StandAloneSig)tp);
case Table.Event:
return GetRid((EventDef)tp);
case Table.Property:
return GetRid((PropertyDef)tp);
case Table.ModuleRef:
return AddModuleRef((ModuleRef)tp);
case Table.TypeSpec:
return AddTypeSpec((TypeSpec)tp);
case Table.Assembly:
return AddAssembly((AssemblyDef)tp, null);
case Table.AssemblyRef:
return AddAssemblyRef((AssemblyRef)tp);
case Table.File:
return AddFile((FileDef)tp);
case Table.ExportedType:
return AddExportedType((ExportedType)tp);
case Table.MethodSpec:
return AddMethodSpec((MethodSpec)tp);
case Table.FieldPtr:
case Table.MethodPtr:
case Table.ParamPtr:
case Table.InterfaceImpl:
case Table.Constant:
case Table.CustomAttribute:
case Table.FieldMarshal:
case Table.DeclSecurity:
case Table.ClassLayout:
case Table.FieldLayout:
case Table.EventMap:
case Table.EventPtr:
case Table.PropertyMap:
case Table.PropertyPtr:
case Table.MethodSemantics:
case Table.MethodImpl:
case Table.ImplMap:
case Table.FieldRVA:
case Table.ENCLog:
case Table.ENCMap:
case Table.AssemblyProcessor:
case Table.AssemblyOS:
case Table.AssemblyRefProcessor:
case Table.AssemblyRefOS:
case Table.ManifestResource:
case Table.NestedClass:
case Table.GenericParam:
case Table.GenericParamConstraint:
case Table.Document:
case Table.MethodDebugInformation:
case Table.LocalScope:
case Table.LocalVariable:
case Table.LocalConstant:
case Table.ImportScope:
case Table.StateMachineMethod:
case Table.CustomDebugInformation:
default:
break;
}
}
if (tp is null)
Error("IMDTokenProvider is null");
else
Error("Invalid IMDTokenProvider");
return 0;
}
/// <summary>
/// Adds a <see cref="ITypeDefOrRef"/>
/// </summary>
/// <param name="tdr">Value</param>
/// <returns>Its encoded token</returns>
protected uint AddTypeDefOrRef(ITypeDefOrRef tdr) {
if (tdr is null) {
Error("TypeDefOrRef is null");
return 0;
}
var token = new MDToken(tdr.MDToken.Table, AddMDTokenProvider(tdr));
if (!CodedToken.TypeDefOrRef.Encode(token, out uint encodedToken)) {
Error("Can't encode TypeDefOrRef token 0x{0:X8}.", token.Raw);
encodedToken = 0;
}
return encodedToken;
}
/// <summary>
/// Adds a <see cref="IResolutionScope"/>
/// </summary>
/// <param name="rs">Value</param>
/// <returns>Its encoded token</returns>
protected uint AddResolutionScope(IResolutionScope rs) {
if (rs is null) {
return 0;
}
var token = new MDToken(rs.MDToken.Table, AddMDTokenProvider(rs));
if (!CodedToken.ResolutionScope.Encode(token, out uint encodedToken)) {
Error("Can't encode ResolutionScope token 0x{0:X8}.", token.Raw);
encodedToken = 0;
}
return encodedToken;
}
/// <summary>
/// Adds a <see cref="IMethodDefOrRef"/>
/// </summary>
/// <param name="mdr">Value</param>
/// <returns>Its encoded token</returns>
protected uint AddMethodDefOrRef(IMethodDefOrRef mdr) {
if (mdr is null) {
Error("MethodDefOrRef is null");
return 0;
}
var token = new MDToken(mdr.MDToken.Table, AddMDTokenProvider(mdr));
if (!CodedToken.MethodDefOrRef.Encode(token, out uint encodedToken)) {
Error("Can't encode MethodDefOrRef token 0x{0:X8}.", token.Raw);
encodedToken = 0;
}
return encodedToken;
}
/// <summary>
/// Adds a <see cref="IMemberRefParent"/>
/// </summary>
/// <param name="parent">Value</param>
/// <returns>Its encoded token</returns>
protected uint AddMemberRefParent(IMemberRefParent parent) {
if (parent is null) {
Error("MemberRefParent is null");
return 0;
}
var token = new MDToken(parent.MDToken.Table, AddMDTokenProvider(parent));
if (!CodedToken.MemberRefParent.Encode(token, out uint encodedToken)) {
Error("Can't encode MemberRefParent token 0x{0:X8}.", token.Raw);
encodedToken = 0;
}
return encodedToken;
}
/// <summary>
/// Adds a <see cref="IImplementation"/>
/// </summary>
/// <param name="impl">Value</param>
/// <returns>Its encoded token</returns>
protected uint AddImplementation(IImplementation impl) {
if (impl is null) {
Error("Implementation is null");
return 0;
}
var token = new MDToken(impl.MDToken.Table, AddMDTokenProvider(impl));
if (!CodedToken.Implementation.Encode(token, out uint encodedToken)) {
Error("Can't encode Implementation token 0x{0:X8}.", token.Raw);
encodedToken = 0;
}
return encodedToken;
}
/// <summary>
/// Adds a <see cref="ICustomAttributeType"/>
/// </summary>
/// <param name="cat">Value</param>
/// <returns>Its encoded token</returns>
protected uint AddCustomAttributeType(ICustomAttributeType cat) {
if (cat is null) {
Error("CustomAttributeType is null");
return 0;
}
var token = new MDToken(cat.MDToken.Table, AddMDTokenProvider(cat));
if (!CodedToken.CustomAttributeType.Encode(token, out uint encodedToken)) {
Error("Can't encode CustomAttributeType token 0x{0:X8}.", token.Raw);
encodedToken = 0;
}
return encodedToken;
}
/// <summary>
/// Adds a <c>NestedType</c> row
/// </summary>
/// <param name="nestedType">Nested type</param>
/// <param name="declaringType">Declaring type</param>
protected void AddNestedType(TypeDef nestedType, TypeDef declaringType) {
if (nestedType is null || declaringType is null)
return;
uint nestedRid = GetRid(nestedType);
uint dtRid = GetRid(declaringType);
if (nestedRid == 0 || dtRid == 0)
return;
var row = new RawNestedClassRow(nestedRid, dtRid);
nestedClassInfos.Add(declaringType, row);
}
/// <summary>
/// Adds a <c>Module</c> row
/// </summary>
/// <param name="module">Module</param>
/// <returns>Its new rid</returns>
protected uint AddModule(ModuleDef module) {
if (module is null) {
Error("Module is null");
return 0;
}
if (this.module != module)
Error("Module '{0}' must be referenced with a ModuleRef, not a ModuleDef.", module);
if (moduleDefInfos.TryGetRid(module, out uint rid))
return rid;
var row = new RawModuleRow(module.Generation,
stringsHeap.Add(module.Name),
guidHeap.Add(module.Mvid),
guidHeap.Add(module.EncId),
guidHeap.Add(module.EncBaseId));
rid = tablesHeap.ModuleTable.Add(row);
moduleDefInfos.Add(module, rid);
AddCustomAttributes(Table.Module, rid, module);
AddCustomDebugInformationList(Table.Module, rid, module);
return rid;
}
/// <summary>
/// Adds a <c>ModuleRef</c> row
/// </summary>
/// <param name="modRef">Module ref</param>
/// <returns>Its new rid</returns>
protected uint AddModuleRef(ModuleRef modRef) {
if (modRef is null) {
Error("ModuleRef is null");
return 0;
}
if (moduleRefInfos.TryGetRid(modRef, out uint rid))
return rid;
var row = new RawModuleRefRow(stringsHeap.Add(modRef.Name));
rid = tablesHeap.ModuleRefTable.Add(row);
moduleRefInfos.Add(modRef, rid);
AddCustomAttributes(Table.ModuleRef, rid, modRef);
AddCustomDebugInformationList(Table.ModuleRef, rid, modRef);
return rid;
}
/// <summary>
/// Adds an <c>AssemblyRef</c> row
/// </summary>
/// <param name="asmRef">Assembly ref</param>
/// <returns>Its new rid</returns>
protected uint AddAssemblyRef(AssemblyRef asmRef) {
if (asmRef is null) {
Error("AssemblyRef is null");
return 0;
}
if (assemblyRefInfos.TryGetRid(asmRef, out uint rid))
return rid;
var version = Utils.CreateVersionWithNoUndefinedValues(asmRef.Version);
var row = new RawAssemblyRefRow((ushort)version.Major,
(ushort)version.Minor,
(ushort)version.Build,
(ushort)version.Revision,
(uint)asmRef.Attributes,
blobHeap.Add(PublicKeyBase.GetRawData(asmRef.PublicKeyOrToken)),
stringsHeap.Add(asmRef.Name),
stringsHeap.Add(asmRef.Culture),
blobHeap.Add(asmRef.Hash));
rid = tablesHeap.AssemblyRefTable.Add(row);
assemblyRefInfos.Add(asmRef, rid);
AddCustomAttributes(Table.AssemblyRef, rid, asmRef);
AddCustomDebugInformationList(Table.AssemblyRef, rid, asmRef);
return rid;
}
/// <summary>
/// Adds an <c>Assembly</c> row
/// </summary>
/// <param name="asm">Assembly</param>
/// <param name="publicKey">The public key that should be used</param>
/// <returns>Its new rid</returns>
protected uint AddAssembly(AssemblyDef asm, byte[] publicKey) {
if (asm is null) {
Error("Assembly is null");
return 0;
}
if (assemblyInfos.TryGetRid(asm, out uint rid))
return rid;
var asmAttrs = asm.Attributes;
if (publicKey is not null)
asmAttrs |= AssemblyAttributes.PublicKey;
else
publicKey = PublicKeyBase.GetRawData(asm.PublicKeyOrToken);
var version = Utils.CreateVersionWithNoUndefinedValues(asm.Version);
var row = new RawAssemblyRow((uint)asm.HashAlgorithm,
(ushort)version.Major,
(ushort)version.Minor,
(ushort)version.Build,
(ushort)version.Revision,
(uint)asmAttrs,
blobHeap.Add(publicKey),
stringsHeap.Add(asm.Name),
stringsHeap.Add(asm.Culture));
rid = tablesHeap.AssemblyTable.Add(row);
assemblyInfos.Add(asm, rid);
AddDeclSecurities(new MDToken(Table.Assembly, rid), asm.DeclSecurities);
AddCustomAttributes(Table.Assembly, rid, asm);
AddCustomDebugInformationList(Table.Assembly, rid, asm);
return rid;
}
/// <summary>
/// Adds generic parameters
/// </summary>
/// <param name="token">New token of owner</param>
/// <param name="gps">All generic params</param>
protected void AddGenericParams(MDToken token, IList<GenericParam> gps) {
if (gps is null)
return;
int count = gps.Count;
for (int i = 0; i < count; i++)
AddGenericParam(token, gps[i]);
}
/// <summary>
/// Adds a generic param
/// </summary>
/// <param name="owner">New token of owner</param>
/// <param name="gp">Generic paramater</param>
protected void AddGenericParam(MDToken owner, GenericParam gp) {
if (gp is null) {
Error("GenericParam is null");
return;
}
if (!CodedToken.TypeOrMethodDef.Encode(owner, out uint encodedOwner)) {
Error("Can't encode TypeOrMethodDef token 0x{0:X8}.", owner.Raw);
encodedOwner = 0;
}
var row = new RawGenericParamRow(gp.Number,
(ushort)gp.Flags,
encodedOwner,
stringsHeap.Add(gp.Name),
gp.Kind is null ? 0 : AddTypeDefOrRef(gp.Kind));
genericParamInfos.Add(gp, row);
}
void AddGenericParamConstraints(IList<GenericParam> gps) {
if (gps is null)
return;
int count = gps.Count;
for (int i = 0; i < count; i++) {
var gp = gps[i];
if (gp is null)
continue;
uint rid = genericParamInfos.Rid(gp);
AddGenericParamConstraints(rid, gp.GenericParamConstraints);
}
}
/// <summary>
/// Adds generic parameter constraints
/// </summary>
/// <param name="gpRid">New rid of owner generic param</param>
/// <param name="constraints">Its constraints</param>
protected void AddGenericParamConstraints(uint gpRid, IList<GenericParamConstraint> constraints) {
if (constraints is null)
return;
int count = constraints.Count;
for (int i = 0; i < count; i++)
AddGenericParamConstraint(gpRid, constraints[i]);
}
/// <summary>
/// Adds a generic parameter constraint
/// </summary>
/// <param name="gpRid">New rid of owner generic param</param>
/// <param name="gpc">Generic parameter constraint</param>
protected void AddGenericParamConstraint(uint gpRid, GenericParamConstraint gpc) {
if (gpc is null) {
Error("GenericParamConstraint is null");
return;
}
var row = new RawGenericParamConstraintRow(gpRid, AddTypeDefOrRef(gpc.Constraint));
genericParamConstraintInfos.Add(gpc, row);
}
/// <summary>
/// Adds a <c>InterfaceImpl</c> row
/// </summary>
/// <param name="typeDefRid">New rid of owner</param>
/// <param name="ifaces">All interfaces</param>
protected void AddInterfaceImpls(uint typeDefRid, IList<InterfaceImpl> ifaces) {
int count = ifaces.Count;
for (int i = 0; i < count; i++) {
var iface = ifaces[i];
if (iface is null)
continue;
var row = new RawInterfaceImplRow(typeDefRid,
AddTypeDefOrRef(iface.Interface));
interfaceImplInfos.Add(iface, row);
}
}
/// <summary>
/// Adds a <c>FieldLayout</c> row
/// </summary>
/// <param name="field">Owner field</param>
protected void AddFieldLayout(FieldDef field) {
if (field is null || field.FieldOffset is null)
return;
var rid = GetRid(field);
var row = new RawFieldLayoutRow(field.FieldOffset.Value, rid);
fieldLayoutInfos.Add(field, row);
}
/// <summary>
/// Adds a <c>FieldMarshal</c> row
/// </summary>
/// <param name="parent">New owner token</param>
/// <param name="hfm">Owner</param>
protected void AddFieldMarshal(MDToken parent, IHasFieldMarshal hfm) {
if (hfm is null || hfm.MarshalType is null)
return;
var fieldMarshal = hfm.MarshalType;
if (!CodedToken.HasFieldMarshal.Encode(parent, out uint encodedParent)) {
Error("Can't encode HasFieldMarshal token 0x{0:X8}.", parent.Raw);
encodedParent = 0;
}
var row = new RawFieldMarshalRow(encodedParent,
blobHeap.Add(MarshalBlobWriter.Write(module, fieldMarshal, this, OptimizeCustomAttributeSerializedTypeNames)));
fieldMarshalInfos.Add(hfm, row);
}
/// <summary>
/// Adds a <c>FieldRVA</c> row
/// </summary>
/// <param name="field">The field</param>
protected void AddFieldRVA(FieldDef field) {
Debug.Assert(!isStandaloneDebugMetadata);
if (NoFieldData)
return;
if (field.RVA != 0 && KeepFieldRVA) {
uint rid = GetRid(field);
var row = new RawFieldRVARow((uint)field.RVA, rid);
fieldRVAInfos.Add(field, row);
}
else {
if (field is null || field.InitialValue is null)
return;
var ivBytes = field.InitialValue;
if (!VerifyFieldSize(field, ivBytes.Length))
Error("Field '{0}' (0x{1:X8}) initial value size != size of field type.", field, field.MDToken.Raw);
uint rid = GetRid(field);
uint alignment = ModuleWriterBase.DEFAULT_CONSTANTS_ALIGNMENT;
if (field.FieldType is TypeDefOrRefSig tdrSig && tdrSig.TypeDef?.ClassLayout is {} classLayout)
alignment = Math.Max(alignment, Utils.RoundToNextPowerOfTwo(classLayout.PackingSize));
var iv = constants.Add(new ByteArrayChunk(ivBytes, alignment), alignment);
fieldToInitialValue[field] = iv;
var row = new RawFieldRVARow(0, rid);
fieldRVAInfos.Add(field, row);
}
}
static bool VerifyFieldSize(FieldDef field, int size) {
if (field is null)
return false;
var sig = field.FieldSig;
if (sig is null)
return false;
return field.GetFieldSize() == size;
}
/// <summary>
/// Adds a <c>ImplMap</c> row
/// </summary>
/// <param name="parent">New owner token</param>
/// <param name="mf">Owner</param>
protected void AddImplMap(MDToken parent, IMemberForwarded mf) {
if (mf is null || mf.ImplMap is null)
return;
var implMap = mf.ImplMap;
if (!CodedToken.MemberForwarded.Encode(parent, out uint encodedParent)) {
Error("Can't encode MemberForwarded token 0x{0:X8}.", parent.Raw);
encodedParent = 0;
}
var row = new RawImplMapRow((ushort)implMap.Attributes,
encodedParent,
stringsHeap.Add(implMap.Name),
AddModuleRef(implMap.Module));
implMapInfos.Add(mf, row);
}
/// <summary>
/// Adds a <c>Constant</c> row
/// </summary>
/// <param name="parent">New owner token</param>
/// <param name="hc">Owner</param>
protected void AddConstant(MDToken parent, IHasConstant hc) {
if (hc is null || hc.Constant is null)
return;
var constant = hc.Constant;
if (!CodedToken.HasConstant.Encode(parent, out uint encodedParent)) {
Error("Can't encode HasConstant token 0x{0:X8}.", parent.Raw);
encodedParent = 0;
}
var row = new RawConstantRow((byte)constant.Type, 0,
encodedParent,
blobHeap.Add(GetConstantValueAsByteArray(constant.Type, constant.Value)));
hasConstantInfos.Add(hc, row);
}
static readonly byte[] constantClassByteArray = new byte[4];
static readonly byte[] constantDefaultByteArray = new byte[8];
byte[] GetConstantValueAsByteArray(ElementType etype, object o) {
if (o is null) {
if (etype == ElementType.Class)
return constantClassByteArray;
Error("Constant is null");
return constantDefaultByteArray;
}
var typeCode = Type.GetTypeCode(o.GetType());
switch (typeCode) {
case TypeCode.Boolean:
VerifyConstantType(etype, ElementType.Boolean);
return BitConverter.GetBytes((bool)o);
case TypeCode.Char:
VerifyConstantType(etype, ElementType.Char);
return BitConverter.GetBytes((char)o);
case TypeCode.SByte:
VerifyConstantType(etype, ElementType.I1);
return new byte[1] { (byte)(sbyte)o };
case TypeCode.Byte:
VerifyConstantType(etype, ElementType.U1);
return new byte[1] { (byte)o };
case TypeCode.Int16:
VerifyConstantType(etype, ElementType.I2);
return BitConverter.GetBytes((short)o);
case TypeCode.UInt16:
VerifyConstantType(etype, ElementType.U2);
return BitConverter.GetBytes((ushort)o);
case TypeCode.Int32:
VerifyConstantType(etype, ElementType.I4);
return BitConverter.GetBytes((int)o);
case TypeCode.UInt32:
VerifyConstantType(etype, ElementType.U4);
return BitConverter.GetBytes((uint)o);
case TypeCode.Int64:
VerifyConstantType(etype, ElementType.I8);
return BitConverter.GetBytes((long)o);
case TypeCode.UInt64:
VerifyConstantType(etype, ElementType.U8);
return BitConverter.GetBytes((ulong)o);
case TypeCode.Single:
VerifyConstantType(etype, ElementType.R4);
return BitConverter.GetBytes((float)o);
case TypeCode.Double:
VerifyConstantType(etype, ElementType.R8);
return BitConverter.GetBytes((double)o);
case TypeCode.String:
VerifyConstantType(etype, ElementType.String);
return Encoding.Unicode.GetBytes((string)o);
default:
Error("Invalid constant type: {0}", typeCode);
return constantDefaultByteArray;
}
}
void VerifyConstantType(ElementType realType, ElementType expectedType) {
if (realType != expectedType)
Error("Constant value's type is the wrong type: {0} != {1}", realType, expectedType);
}
/// <summary>
/// Adds a <c>DeclSecurity</c> row
/// </summary>
/// <param name="parent">New owner token</param>
/// <param name="declSecurities">All <c>DeclSecurity</c> rows</param>
protected void AddDeclSecurities(MDToken parent, IList<DeclSecurity> declSecurities) {
if (declSecurities is null)
return;
if (!CodedToken.HasDeclSecurity.Encode(parent, out uint encodedParent)) {
Error("Can't encode HasDeclSecurity token 0x{0:X8}.", parent.Raw);
encodedParent = 0;
}
var bwctx = AllocBinaryWriterContext();
int count = declSecurities.Count;
for (int i = 0; i < count; i++) {
var decl = declSecurities[i];
if (decl is null)
continue;
var row = new RawDeclSecurityRow((short)decl.Action,
encodedParent,
blobHeap.Add(DeclSecurityWriter.Write(module, decl.SecurityAttributes, this, OptimizeCustomAttributeSerializedTypeNames, bwctx)));
declSecurityInfos.Add(decl, row);
}
Free(ref bwctx);
}
/// <summary>
/// Adds <c>MethodSemantics</c> rows
/// </summary>
/// <param name="evt">Event</param>
protected void AddMethodSemantics(EventDef evt) {
if (evt is null) {
Error("Event is null");
return;
}
uint rid = GetRid(evt);
if (rid == 0)
return;
var token = new MDToken(Table.Event, rid);
AddMethodSemantics(token, evt.AddMethod, MethodSemanticsAttributes.AddOn);
AddMethodSemantics(token, evt.RemoveMethod, MethodSemanticsAttributes.RemoveOn);
AddMethodSemantics(token, evt.InvokeMethod, MethodSemanticsAttributes.Fire);
AddMethodSemantics(token, evt.OtherMethods, MethodSemanticsAttributes.Other);
}
/// <summary>
/// Adds <c>MethodSemantics</c> rows
/// </summary>
/// <param name="prop">Property</param>
protected void AddMethodSemantics(PropertyDef prop) {
if (prop is null) {
Error("Property is null");
return;
}
uint rid = GetRid(prop);
if (rid == 0)
return;
var token = new MDToken(Table.Property, rid);
AddMethodSemantics(token, prop.GetMethods, MethodSemanticsAttributes.Getter);
AddMethodSemantics(token, prop.SetMethods, MethodSemanticsAttributes.Setter);
AddMethodSemantics(token, prop.OtherMethods, MethodSemanticsAttributes.Other);
}
void AddMethodSemantics(MDToken owner, IList<MethodDef> methods, MethodSemanticsAttributes attrs) {
if (methods is null)
return;
int count = methods.Count;
for (int i = 0; i < count; i++)
AddMethodSemantics(owner, methods[i], attrs);
}
void AddMethodSemantics(MDToken owner, MethodDef method, MethodSemanticsAttributes flags) {
if (method is null)
return;
uint methodRid = GetRid(method);
if (methodRid == 0)
return;
if (!CodedToken.HasSemantic.Encode(owner, out uint encodedOwner)) {
Error("Can't encode HasSemantic token 0x{0:X8}.", owner.Raw);
encodedOwner = 0;
}
var row = new RawMethodSemanticsRow((ushort)flags, methodRid, encodedOwner);
methodSemanticsInfos.Add(method, row);
}
void AddMethodImpls(MethodDef method, IList<MethodOverride> overrides) {
if (overrides is null)
return;
if (method.DeclaringType is null) {
Error("Method declaring type is null");
return;
}
if (overrides.Count != 0) {
uint rid = GetRid(method.DeclaringType);
int count = overrides.Count;
for (int i = 0; i < count; i++) {
var ovr = overrides[i];
var row = new RawMethodImplRow(rid,
AddMethodDefOrRef(ovr.MethodBody),
AddMethodDefOrRef(ovr.MethodDeclaration));
methodImplInfos.Add(method, row);
}
}
}
/// <summary>
/// Adds a <c>ClassLayout</c> row
/// </summary>
/// <param name="type">Type</param>
protected void AddClassLayout(TypeDef type) {
if (type is null || type.ClassLayout is null)
return;
var rid = GetRid(type);
var classLayout = type.ClassLayout;
var row = new RawClassLayoutRow(classLayout.PackingSize, classLayout.ClassSize, rid);
classLayoutInfos.Add(type, row);
}
void AddResources(IList<Resource> resources) {
if (NoDotNetResources)
return;
if (resources is null)
return;
int count = resources.Count;
for (int i = 0; i < count; i++)
AddResource(resources[i]);
}
void AddResource(Resource resource) {
Debug.Assert(!NoDotNetResources);
if (resource is EmbeddedResource er) {
AddEmbeddedResource(er);
return;
}
if (resource is AssemblyLinkedResource alr) {
AddAssemblyLinkedResource(alr);
return;
}
if (resource is LinkedResource lr) {
AddLinkedResource(lr);
return;
}
if (resource is null)
Error("Resource is null");
else
Error("Invalid resource type: '{0}'.", resource.GetType());
}
uint AddEmbeddedResource(EmbeddedResource er) {
Debug.Assert(!isStandaloneDebugMetadata);
Debug.Assert(!NoDotNetResources);
if (er is null) {
Error("EmbeddedResource is null");
return 0;
}
if (manifestResourceInfos.TryGetRid(er, out uint rid))
return rid;
var row = new RawManifestResourceRow(netResources.NextOffset,
(uint)er.Attributes,
stringsHeap.Add(er.Name),
0);
rid = tablesHeap.ManifestResourceTable.Add(row);
manifestResourceInfos.Add(er, rid);
embeddedResourceToByteArray[er] = netResources.Add(er.CreateReader());
AddCustomAttributes(Table.ManifestResource, rid, er);
AddCustomDebugInformationList(Table.ManifestResource, rid, er);
return rid;
}
uint AddAssemblyLinkedResource(AssemblyLinkedResource alr) {
Debug.Assert(!NoDotNetResources);
if (alr is null) {
Error("AssemblyLinkedResource is null");
return 0;
}
if (manifestResourceInfos.TryGetRid(alr, out uint rid))
return rid;
var row = new RawManifestResourceRow(0,
(uint)alr.Attributes,
stringsHeap.Add(alr.Name),
AddImplementation(alr.Assembly));
rid = tablesHeap.ManifestResourceTable.Add(row);
manifestResourceInfos.Add(alr, rid);
AddCustomAttributes(Table.ManifestResource, rid, alr);
AddCustomDebugInformationList(Table.ManifestResource, rid, alr);
return rid;
}
uint AddLinkedResource(LinkedResource lr) {
Debug.Assert(!NoDotNetResources);
if (lr is null) {
Error("LinkedResource is null");
return 0;
}
if (manifestResourceInfos.TryGetRid(lr, out uint rid))
return rid;
var row = new RawManifestResourceRow(0,
(uint)lr.Attributes,
stringsHeap.Add(lr.Name),
AddImplementation(lr.File));
rid = tablesHeap.ManifestResourceTable.Add(row);
manifestResourceInfos.Add(lr, rid);
AddCustomAttributes(Table.ManifestResource, rid, lr);
AddCustomDebugInformationList(Table.ManifestResource, rid, lr);
return rid;
}
/// <summary>
/// Adds a <c>File</c> row
/// </summary>
/// <param name="file">File</param>
/// <returns>Its new rid</returns>
protected uint AddFile(FileDef file) {
if (file is null) {
Error("FileDef is null");
return 0;
}
if (fileDefInfos.TryGetRid(file, out uint rid))
return rid;
var row = new RawFileRow((uint)file.Flags,
stringsHeap.Add(file.Name),
blobHeap.Add(file.HashValue)); //TODO: Re-calculate the hash value if possible
rid = tablesHeap.FileTable.Add(row);
fileDefInfos.Add(file, rid);
AddCustomAttributes(Table.File, rid, file);
AddCustomDebugInformationList(Table.File, rid, file);
return rid;
}
/// <summary>
/// Adds a <c>ExportedType</c> row
/// </summary>
/// <param name="et">Exported type</param>
/// <returns>Its new rid</returns>
protected uint AddExportedType(ExportedType et) {
if (et is null) {
Error("ExportedType is null");
return 0;
}
if (exportedTypeInfos.TryGetRid(et, out uint rid))
return rid;
exportedTypeInfos.Add(et, 0); // Prevent inf recursion
var row = new RawExportedTypeRow((uint)et.Attributes,
et.TypeDefId, //TODO: Should be updated with the new rid
stringsHeap.Add(et.TypeName),
stringsHeap.Add(et.TypeNamespace),
AddImplementation(et.Implementation));
rid = tablesHeap.ExportedTypeTable.Add(row);
exportedTypeInfos.SetRid(et, rid);
AddCustomAttributes(Table.ExportedType, rid, et);
AddCustomDebugInformationList(Table.ExportedType, rid, et);
return rid;
}
/// <summary>
/// Gets a #Blob offset of a type signature
/// </summary>
/// <param name="ts">Type sig</param>
/// <param name="extraData">Extra data to append the signature if
/// <see cref="PreserveExtraSignatureData"/> is <c>true</c>.</param>
/// <returns>#Blob offset</returns>
protected uint GetSignature(TypeSig ts, byte[] extraData) {
byte[] blob;
if (ts is null) {
Error("TypeSig is null");
blob = null;
}
else {
var bwctx = AllocBinaryWriterContext();
blob = SignatureWriter.Write(this, ts, bwctx);
Free(ref bwctx);
}
AppendExtraData(ref blob, extraData);
return blobHeap.Add(blob);
}
/// <summary>
/// Gets a #Blob offset of a calling convention signature
/// </summary>
/// <param name="sig">Signature</param>
/// <returns>#Blob offset</returns>
protected uint GetSignature(CallingConventionSig sig) {
if (sig is null) {
Error("CallingConventionSig is null");
return 0;
}
var bwctx = AllocBinaryWriterContext();
var blob = SignatureWriter.Write(this, sig, bwctx);
Free(ref bwctx);
AppendExtraData(ref blob, sig.ExtraData);
return blobHeap.Add(blob);
}
void AppendExtraData(ref byte[] blob, byte[] extraData) {
if (PreserveExtraSignatureData && extraData is not null && extraData.Length > 0) {
int blen = blob is null ? 0 : blob.Length;
Array.Resize(ref blob, blen + extraData.Length);
Array.Copy(extraData, 0, blob, blen, extraData.Length);
}
}
/// <summary>
/// Adds a <c>CustomAttribute</c> row
/// </summary>
/// <param name="table">Owner table</param>
/// <param name="rid">New owner rid</param>
/// <param name="hca">Onwer</param>
protected void AddCustomAttributes(Table table, uint rid, IHasCustomAttribute hca) => AddCustomAttributes(table, rid, hca.CustomAttributes);
void AddCustomAttributes(Table table, uint rid, CustomAttributeCollection caList) {
var token = new MDToken(table, rid);
int count = caList.Count;
for (int i = 0; i < count; i++)
AddCustomAttribute(token, caList[i]);
}
void AddCustomAttribute(MDToken token, CustomAttribute ca) {
if (ca is null) {
Error("Custom attribute is null");
return;
}
if (!CodedToken.HasCustomAttribute.Encode(token, out uint encodedToken)) {
Error("Can't encode HasCustomAttribute token 0x{0:X8}.", token.Raw);
encodedToken = 0;
}
var bwctx = AllocBinaryWriterContext();
var caBlob = CustomAttributeWriter.Write(this, ca, bwctx);
Free(ref bwctx);
var row = new RawCustomAttributeRow(encodedToken,
AddCustomAttributeType(ca.Constructor),
blobHeap.Add(caBlob));
customAttributeInfos.Add(ca, row);
}
void AddCustomDebugInformationList(MethodDef method, uint rid, uint localVarSigToken) {
Debug.Assert(debugMetadata is not null);
if (debugMetadata is null)
return;
var serializerMethodContext = AllocSerializerMethodContext();
serializerMethodContext.SetBody(method);
if (method.CustomDebugInfos.Count != 0)
AddCustomDebugInformationCore(serializerMethodContext, Table.Method, rid, method.CustomDebugInfos);
AddMethodDebugInformation(method, rid, localVarSigToken);
Free(ref serializerMethodContext);
}
void AddMethodDebugInformation(MethodDef method, uint rid, uint localVarSigToken) {
Debug.Assert(debugMetadata is not null);
var body = method.Body;
if (body is null)
return;
GetSingleDocument(body, out var singleDoc, out var firstDoc, out bool hasNoSeqPoints);
if (hasNoSeqPoints)
return;
var bwctx = AllocBinaryWriterContext();
var outStream = bwctx.OutStream;
var writer = bwctx.Writer;
outStream.SetLength(0);
outStream.Position = 0;
writer.WriteCompressedUInt32(localVarSigToken);
if (singleDoc is null)
writer.WriteCompressedUInt32(VerifyGetRid(firstDoc));
var instrs = body.Instructions;
var currentDoc = firstDoc;
uint ilOffset = uint.MaxValue;
int line = -1, column = 0;
uint instrOffset = 0;
Instruction instr = null;
for (int i = 0; i < instrs.Count; i++, instrOffset += (uint)instr.GetSize()) {
instr = instrs[i];
var seqPoint = instr.SequencePoint;
if (seqPoint is null)
continue;
if (seqPoint.Document is null) {
Error("PDB document is null");
return;
}
if (currentDoc != seqPoint.Document) {
// document-record
currentDoc = seqPoint.Document;
writer.WriteCompressedUInt32(0);
writer.WriteCompressedUInt32(VerifyGetRid(currentDoc));
}
// SequencePointRecord
if (ilOffset == uint.MaxValue)
writer.WriteCompressedUInt32(instrOffset);
else
writer.WriteCompressedUInt32(instrOffset - ilOffset);
ilOffset = instrOffset;
if (seqPoint.StartLine == SequencePointConstants.HIDDEN_LINE && seqPoint.EndLine == SequencePointConstants.HIDDEN_LINE) {
// hidden-sequence-point-record
writer.WriteCompressedUInt32(0);
writer.WriteCompressedUInt32(0);
}
else {
// sequence-point-record
uint dlines = (uint)(seqPoint.EndLine - seqPoint.StartLine);
int dcolumns = seqPoint.EndColumn - seqPoint.StartColumn;
writer.WriteCompressedUInt32(dlines);
if (dlines == 0)
writer.WriteCompressedUInt32((uint)dcolumns);
else
writer.WriteCompressedInt32(dcolumns);
if (line < 0) {
writer.WriteCompressedUInt32((uint)seqPoint.StartLine);
writer.WriteCompressedUInt32((uint)seqPoint.StartColumn);
}
else {
writer.WriteCompressedInt32(seqPoint.StartLine - line);
writer.WriteCompressedInt32(seqPoint.StartColumn - column);
}
line = seqPoint.StartLine;
column = seqPoint.StartColumn;
}
}
var seqPointsBlob = outStream.ToArray();
var row = new RawMethodDebugInformationRow(singleDoc is null ? 0 : AddPdbDocument(singleDoc), debugMetadata.blobHeap.Add(seqPointsBlob));
debugMetadata.tablesHeap.MethodDebugInformationTable[rid] = row;
debugMetadata.methodDebugInformationInfosUsed = true;
Free(ref bwctx);
}
uint VerifyGetRid(PdbDocument doc) {
Debug.Assert(debugMetadata is not null);
if (!debugMetadata.pdbDocumentInfos.TryGetRid(doc, out uint rid)) {
Error("PDB document has been removed");
return 0;
}
return rid;
}
static void GetSingleDocument(CilBody body, out PdbDocument singleDoc, out PdbDocument firstDoc, out bool hasNoSeqPoints) {
var instrs = body.Instructions;
int docCount = 0;
singleDoc = null;
firstDoc = null;
for (int i = 0; i < instrs.Count; i++) {
var seqPt = instrs[i].SequencePoint;
if (seqPt is null)
continue;
var doc = seqPt.Document;
if (doc is null)
continue;
if (firstDoc is null)
firstDoc = doc;
if (singleDoc != doc) {
singleDoc = doc;
docCount++;
if (docCount > 1)
break;
}
}
hasNoSeqPoints = docCount == 0;
if (docCount != 1)
singleDoc = null;
}
/// <summary>
/// Adds a <c>CustomDebugInformation</c> row
/// </summary>
/// <param name="table">Owner table</param>
/// <param name="rid">New owner rid</param>
/// <param name="hcdi">Onwer</param>
protected void AddCustomDebugInformationList(Table table, uint rid, IHasCustomDebugInformation hcdi) {
Debug.Assert(table != Table.Method);
if (debugMetadata is null)
return;
if (hcdi.CustomDebugInfos.Count == 0)
return;
var serializerMethodContext = AllocSerializerMethodContext();
serializerMethodContext.SetBody(null);
AddCustomDebugInformationCore(serializerMethodContext, table, rid, hcdi.CustomDebugInfos);
Free(ref serializerMethodContext);
}
void AddCustomDebugInformationList(Table table, uint rid, IList<PdbCustomDebugInfo> cdis) {
Debug.Assert(table != Table.Method);
if (debugMetadata is null)
return;
if (cdis.Count == 0)
return;
var serializerMethodContext = AllocSerializerMethodContext();
serializerMethodContext.SetBody(null);
AddCustomDebugInformationCore(serializerMethodContext, table, rid, cdis);
Free(ref serializerMethodContext);
}
void AddCustomDebugInformationCore(SerializerMethodContext serializerMethodContext, Table table, uint rid, IList<PdbCustomDebugInfo> cdis) {
Debug.Assert(debugMetadata is not null);
Debug.Assert(cdis.Count != 0);
var token = new MDToken(table, rid);
if (!CodedToken.HasCustomDebugInformation.Encode(token, out uint encodedToken)) {
Error("Couldn't encode HasCustomDebugInformation token 0x{0:X8}.", token.Raw);
return;
}
for (int i = 0; i < cdis.Count; i++) {
var cdi = cdis[i];
if (cdi is null) {
Error("Custom debug info is null");
continue;
}
AddCustomDebugInformation(serializerMethodContext, token.Raw, encodedToken, cdi);
}
}
void AddCustomDebugInformation(SerializerMethodContext serializerMethodContext, uint token, uint encodedToken, PdbCustomDebugInfo cdi) {
Debug.Assert(debugMetadata is not null);
switch (cdi.Kind) {
case PdbCustomDebugInfoKind.UsingGroups:
case PdbCustomDebugInfoKind.ForwardMethodInfo:
case PdbCustomDebugInfoKind.ForwardModuleInfo:
case PdbCustomDebugInfoKind.StateMachineTypeName:
case PdbCustomDebugInfoKind.DynamicLocals:
case PdbCustomDebugInfoKind.TupleElementNames:
case PdbCustomDebugInfoKind.SourceServer:
// These are Windows PDB CDIs
Error("Unsupported custom debug info {0}", cdi.Kind);
break;
case PdbCustomDebugInfoKind.StateMachineHoistedLocalScopes:
case PdbCustomDebugInfoKind.EditAndContinueLocalSlotMap:
case PdbCustomDebugInfoKind.EditAndContinueLambdaMap:
case PdbCustomDebugInfoKind.Unknown:
case PdbCustomDebugInfoKind.TupleElementNames_PortablePdb:
case PdbCustomDebugInfoKind.DefaultNamespace:
case PdbCustomDebugInfoKind.DynamicLocalVariables:
case PdbCustomDebugInfoKind.EmbeddedSource:
case PdbCustomDebugInfoKind.SourceLink:
case PdbCustomDebugInfoKind.CompilationMetadataReferences:
case PdbCustomDebugInfoKind.CompilationOptions:
case PdbCustomDebugInfoKind.TypeDefinitionDocuments:
case PdbCustomDebugInfoKind.EditAndContinueStateMachineStateMap:
case PdbCustomDebugInfoKind.PrimaryConstructorInformationBlob:
AddCustomDebugInformationCore(serializerMethodContext, encodedToken, cdi, cdi.Guid);
break;
case PdbCustomDebugInfoKind.AsyncMethod:
// This is a portable PDB pseudo CDI
AddCustomDebugInformationCore(serializerMethodContext, encodedToken, cdi, CustomDebugInfoGuids.AsyncMethodSteppingInformationBlob);
AddStateMachineMethod(cdi, token, ((PdbAsyncMethodCustomDebugInfo)cdi).KickoffMethod);
break;
case PdbCustomDebugInfoKind.IteratorMethod:
// This is a portable PDB pseudo CDI
AddStateMachineMethod(cdi, token, ((PdbIteratorMethodCustomDebugInfo)cdi).KickoffMethod);
break;
default:
Error("Unknown custom debug info {0}.", cdi.Kind);
break;
}
}
void AddStateMachineMethod(PdbCustomDebugInfo cdi, uint moveNextMethodToken, MethodDef kickoffMethod) {
Debug.Assert(new MDToken(moveNextMethodToken).Table == Table.Method);
Debug.Assert(debugMetadata is not null);
if (kickoffMethod is null) {
Error("KickoffMethod is null");
return;
}
var row = new RawStateMachineMethodRow(new MDToken(moveNextMethodToken).Rid, GetRid(kickoffMethod));
debugMetadata.stateMachineMethodInfos.Add(cdi, row);
}
void AddCustomDebugInformationCore(SerializerMethodContext serializerMethodContext, uint encodedToken, PdbCustomDebugInfo cdi, Guid cdiGuid) {
Debug.Assert(debugMetadata is not null);
var bwctx = AllocBinaryWriterContext();
var cdiBlob = PortablePdbCustomDebugInfoWriter.Write(this, serializerMethodContext, this, cdi, bwctx);
Debug.Assert(cdiGuid != Guid.Empty);
Free(ref bwctx);
var row = new RawCustomDebugInformationRow(encodedToken,
debugMetadata.guidHeap.Add(cdiGuid),
debugMetadata.blobHeap.Add(cdiBlob));
debugMetadata.customDebugInfos.Add(cdi, row);
}
void InitializeMethodDebugInformation() {
if (debugMetadata is null)
return;
int numMethods = NumberOfMethods;
for (int i = 0; i < numMethods; i++)
debugMetadata.tablesHeap.MethodDebugInformationTable.Create(new RawMethodDebugInformationRow());
}
void AddPdbDocuments() {
if (debugMetadata is null)
return;
foreach (var doc in module.PdbState.Documents)
AddPdbDocument(doc);
}
uint AddPdbDocument(PdbDocument doc) {
Debug.Assert(debugMetadata is not null);
if (doc is null) {
Error("PdbDocument is null");
return 0;
}
if (debugMetadata.pdbDocumentInfos.TryGetRid(doc, out uint rid))
return rid;
var row = new RawDocumentRow(GetDocumentNameBlobOffset(doc.Url),
debugMetadata.guidHeap.Add(doc.CheckSumAlgorithmId),
debugMetadata.blobHeap.Add(doc.CheckSum),
debugMetadata.guidHeap.Add(doc.Language));
rid = debugMetadata.tablesHeap.DocumentTable.Add(row);
debugMetadata.pdbDocumentInfos.Add(doc, rid);
AddCustomDebugInformationList(Table.Document, rid, doc.CustomDebugInfos);
return rid;
}
uint GetDocumentNameBlobOffset(string name) {
Debug.Assert(debugMetadata is not null);
if (name is null) {
Error("Document name is null");
name = string.Empty;
}
var bwctx = AllocBinaryWriterContext();
var outStream = bwctx.OutStream;
var writer = bwctx.Writer;
outStream.SetLength(0);
outStream.Position = 0;
var parts = name.Split(directorySeparatorCharArray);
if (parts.Length == 1)
writer.WriteByte(0);
else
writer.WriteBytes(directorySeparatorCharUtf8);
for (int i = 0; i < parts.Length; i++) {
var part = parts[i];
uint partOffset = debugMetadata.blobHeap.Add(Encoding.UTF8.GetBytes(part));
writer.WriteCompressedUInt32(partOffset);
}
var res = debugMetadata.blobHeap.Add(outStream.ToArray());
Free(ref bwctx);
return res;
}
static readonly byte[] directorySeparatorCharUtf8 = Encoding.UTF8.GetBytes(Path.DirectorySeparatorChar.ToString());
static readonly char[] directorySeparatorCharArray = new char[] { Path.DirectorySeparatorChar };
uint AddImportScope(PdbImportScope scope) {
Debug.Assert(debugMetadata is not null);
if (scope is null)
return 0;
if (debugMetadata.importScopeInfos.TryGetRid(scope, out uint rid)) {
if (rid == 0)
Error("PdbImportScope has an infinite Parent loop");
return rid;
}
debugMetadata.importScopeInfos.Add(scope, 0); // Prevent inf recursion
var bwctx = AllocBinaryWriterContext();
var outStream = bwctx.OutStream;
var writer = bwctx.Writer;
outStream.SetLength(0);
outStream.Position = 0;
ImportScopeBlobWriter.Write(this, this, writer, debugMetadata.blobHeap, scope.Imports);
var importsData = outStream.ToArray();
Free(ref bwctx);
var row = new RawImportScopeRow(AddImportScope(scope.Parent), debugMetadata.blobHeap.Add(importsData));
rid = debugMetadata.tablesHeap.ImportScopeTable.Add(row);
debugMetadata.importScopeInfos.SetRid(scope, rid);
AddCustomDebugInformationList(Table.ImportScope, rid, scope.CustomDebugInfos);
return rid;
}
void AddLocalVariable(PdbLocal local) {
Debug.Assert(debugMetadata is not null);
if (local is null) {
Error("PDB local is null");
return;
}
var row = new RawLocalVariableRow((ushort)local.Attributes, (ushort)local.Index, debugMetadata.stringsHeap.Add(local.Name));
uint rid = debugMetadata.tablesHeap.LocalVariableTable.Create(row);
debugMetadata.localVariableInfos.Add(local, rid);
AddCustomDebugInformationList(Table.LocalVariable, rid, local.CustomDebugInfos);
}
void AddLocalConstant(PdbConstant constant) {
Debug.Assert(debugMetadata is not null);
if (constant is null) {
Error("PDB constant is null");
return;
}
var bwctx = AllocBinaryWriterContext();
var outStream = bwctx.OutStream;
var writer = bwctx.Writer;
outStream.SetLength(0);
outStream.Position = 0;
LocalConstantSigBlobWriter.Write(this, this, writer, constant.Type, constant.Value);
var signature = outStream.ToArray();
Free(ref bwctx);
var row = new RawLocalConstantRow(debugMetadata.stringsHeap.Add(constant.Name), debugMetadata.blobHeap.Add(signature));
uint rid = debugMetadata.tablesHeap.LocalConstantTable.Create(row);
debugMetadata.localConstantInfos.Add(constant, rid);
AddCustomDebugInformationList(Table.LocalConstant, rid, constant.CustomDebugInfos);
}
/// <summary>
/// Writes the portable PDB to <paramref name="output"/>.
/// </summary>
/// <param name="output">Output stream</param>
/// <param name="entryPointToken">Entry point token</param>
/// <param name="pdbIdOffset">Updated with the offset of the 20-byte PDB ID. The caller is responsible for initializing it with the PDB ID</param>
internal void WritePortablePdb(Stream output, uint entryPointToken, out long pdbIdOffset) {
if (debugMetadata is null)
throw new InvalidOperationException();
var pdbHeap = debugMetadata.PdbHeap;
pdbHeap.EntryPoint = entryPointToken;
tablesHeap.GetSystemTableRows(out ulong systemTablesMask, pdbHeap.TypeSystemTableRows);
debugMetadata.tablesHeap.SetSystemTableRows(pdbHeap.TypeSystemTableRows);
if (!debugMetadata.methodDebugInformationInfosUsed)
debugMetadata.tablesHeap.MethodDebugInformationTable.Reset();
pdbHeap.ReferencedTypeSystemTables = systemTablesMask;
var writer = new DataWriter(output);
debugMetadata.OnBeforeSetOffset();
debugMetadata.SetOffset(0, 0);
debugMetadata.GetFileLength();
debugMetadata.VerifyWriteTo(writer);
pdbIdOffset = (long)pdbHeap.PdbIdOffset;
}
/// <inheritdoc/>
uint ISignatureWriterHelper.ToEncodedToken(ITypeDefOrRef typeDefOrRef) => AddTypeDefOrRef(typeDefOrRef);
/// <inheritdoc/>
void IWriterError.Error(string message) => Error(message);
/// <inheritdoc/>
void IWriterError2.Error(string message, params object[] args) => Error(message, args);
/// <inheritdoc/>
bool IFullNameFactoryHelper.MustUseAssemblyName(IType type) =>
FullNameFactory.MustUseAssemblyName(module, type, OptimizeCustomAttributeSerializedTypeNames);
/// <summary>
/// Called before any other methods
/// </summary>
protected virtual void Initialize() {
}
/// <summary>
/// Gets all <see cref="TypeDef"/>s that should be saved in the meta data
/// </summary>
protected abstract TypeDef[] GetAllTypeDefs();
/// <summary>
/// Initializes <c>TypeDef</c> rids and creates raw rows, but does not initialize
/// any columns.
/// </summary>
protected abstract void AllocateTypeDefRids();
/// <summary>
/// Allocates <c>Field</c>, <c>Method</c>, <c>Property</c>, <c>Event</c>, <c>Param</c>:
/// rid and raw row, but doesn't initialize the raw row.
/// Initializes <c>TypeDef</c> columns: <c>FieldList</c>, <c>MethodList</c>.
/// Initializes <c>Method</c> column: <c>ParamList</c>.
/// Initializes <see cref="Metadata.eventMapInfos"/> and <see cref="Metadata.propertyMapInfos"/>.
/// </summary>
protected abstract void AllocateMemberDefRids();
/// <summary>
/// Adds a <see cref="TypeRef"/>. Its custom attributes are also added.
/// </summary>
/// <param name="tr">Type reference</param>
/// <returns>Its new rid</returns>
protected abstract uint AddTypeRef(TypeRef tr);
/// <summary>
/// Adds a <see cref="TypeSpec"/>. Its custom attributes are also added.
/// </summary>
/// <param name="ts">Type spec</param>
/// <returns>Its new rid</returns>
protected abstract uint AddTypeSpec(TypeSpec ts);
/// <summary>
/// Adds a <see cref="MemberRef"/>. Its custom attributes are also added.
/// </summary>
/// <param name="mr">Member ref</param>
/// <returns>Its new rid</returns>
protected abstract uint AddMemberRef(MemberRef mr);
/// <summary>
/// Adds a <see cref="StandAloneSig"/>. Its custom attributes are also added.
/// </summary>
/// <param name="sas">Stand alone sig</param>
/// <returns>Its new rid</returns>
protected abstract uint AddStandAloneSig(StandAloneSig sas);
/// <summary>
/// Adds a <see cref="MethodSpec"/>. Its custom attributes are also added.
/// </summary>
/// <param name="ms">Method spec</param>
/// <returns>Its new rid</returns>
protected abstract uint AddMethodSpec(MethodSpec ms);
/// <summary>
/// Called before sorting the <c>CustomAttribute</c> table. This is the last time anything
/// can be inserted into this table.
/// </summary>
protected virtual void BeforeSortingCustomAttributes() {
}
/// <summary>
/// Called after everything has been initialized. The sub class can initialize more
/// rows if necessary or do nothing. After this method has been called, nothing else
/// can be added.
/// </summary>
protected virtual void EverythingInitialized() {
}
const uint HEAP_ALIGNMENT = 4;
bool IReuseChunk.CanReuse(RVA origRva, uint origSize) {
// The caller should've called SetOffset() so we know our final size
Debug.Assert(length != 0);
if (length == 0)
throw new InvalidOperationException();
return length <= origSize;
}
/// <summary>
/// Should be called before all chunks get an RVA
/// </summary>
internal void OnBeforeSetOffset() =>
stringsHeap.AddOptimizedStringsAndSetReadOnly();
/// <inheritdoc/>
public void SetOffset(FileOffset offset, RVA rva) {
// This method can be called twice by NativeModuleWriter. It needs to know the size
// of the final metadata. If it fits in the old location, the new MD will be written
// there (smaller file size). If the new MD doesn't fit in the old location, this
// method gets called a second time with the updated offset + rva.
bool initAll = this.offset == 0;
this.offset = offset;
this.rva = rva;
if (initAll) {
// #Strings heap is initialized in OnBeforeSetOffset()
blobHeap.SetReadOnly();
guidHeap.SetReadOnly();
tablesHeap.SetReadOnly();
pdbHeap.SetReadOnly();
tablesHeap.BigStrings = stringsHeap.IsBig;
tablesHeap.BigBlob = blobHeap.IsBig;
tablesHeap.BigGuid = guidHeap.IsBig;
metadataHeader.Heaps = GetHeaps();
}
metadataHeader.SetOffset(offset, rva);
uint len = metadataHeader.GetFileLength();
offset += len;
rva += len;
foreach (var heap in metadataHeader.Heaps) {
offset = offset.AlignUp(HEAP_ALIGNMENT);
rva = rva.AlignUp(HEAP_ALIGNMENT);
heap.SetOffset(offset, rva);
len = heap.GetFileLength();
offset += len;
rva += len;
}
Debug.Assert(initAll || length == rva - this.rva);
if (!(initAll || length == rva - this.rva))
throw new InvalidOperationException();
length = rva - this.rva;
if (!isStandaloneDebugMetadata && initAll)
UpdateMethodAndFieldRvas();
}
internal void UpdateMethodAndFieldRvas() {
UpdateMethodRvas();
UpdateFieldRvas();
}
IList<IHeap> GetHeaps() {
var heaps = new List<IHeap>();
if (isStandaloneDebugMetadata) {
heaps.Add(pdbHeap);
heaps.Add(tablesHeap);
if (!stringsHeap.IsEmpty)
heaps.Add(stringsHeap);
if (!usHeap.IsEmpty)
heaps.Add(usHeap);
if (!guidHeap.IsEmpty)
heaps.Add(guidHeap);
if (!blobHeap.IsEmpty)
heaps.Add(blobHeap);
}
else {
heaps.Add(tablesHeap);
if (!stringsHeap.IsEmpty || AlwaysCreateStringsHeap)
heaps.Add(stringsHeap);
if (!usHeap.IsEmpty || AlwaysCreateUSHeap)
heaps.Add(usHeap);
if (!guidHeap.IsEmpty || AlwaysCreateGuidHeap)
heaps.Add(guidHeap);
if (!blobHeap.IsEmpty || AlwaysCreateBlobHeap)
heaps.Add(blobHeap);
heaps.AddRange(options.CustomHeaps);
options.RaiseMetadataHeapsAdded(new MetadataHeapsAddedEventArgs(this, heaps));
}
return heaps;
}
/// <inheritdoc/>
public uint GetFileLength() => length;
/// <inheritdoc/>
public uint GetVirtualSize() => GetFileLength();
/// <inheritdoc/>
public uint CalculateAlignment() => 0;
/// <inheritdoc/>
public void WriteTo(DataWriter writer) {
var rva2 = rva;
metadataHeader.VerifyWriteTo(writer);
rva2 += metadataHeader.GetFileLength();
foreach (var heap in metadataHeader.Heaps) {
writer.WriteZeroes((int)(rva2.AlignUp(HEAP_ALIGNMENT) - rva2));
rva2 = rva2.AlignUp(HEAP_ALIGNMENT);
heap.VerifyWriteTo(writer);
rva2 += heap.GetFileLength();
}
}
/// <summary>
/// Sorts the <see cref="ParamDef"/>s
/// </summary>
/// <param name="pds">All <see cref="ParamDef"/>s</param>
/// <returns>A sorted <see cref="ParamDef"/> list</returns>
protected static List<ParamDef> Sort(IEnumerable<ParamDef> pds) {
var sorted = new List<ParamDef>(pds);
sorted.Sort((a, b) => {
if (a is null)
return -1;
if (b is null)
return 1;
return a.Sequence.CompareTo(b.Sequence);
});
return sorted;
}
DataWriterContext AllocBinaryWriterContext() {
if (binaryWriterContexts.Count == 0)
return new DataWriterContext();
var res = binaryWriterContexts[binaryWriterContexts.Count - 1];
binaryWriterContexts.RemoveAt(binaryWriterContexts.Count - 1);
return res;
}
void Free(ref DataWriterContext ctx) {
binaryWriterContexts.Add(ctx);
ctx = null;
}
SerializerMethodContext AllocSerializerMethodContext() {
if (serializerMethodContexts.Count == 0)
return new SerializerMethodContext(this);
var res = serializerMethodContexts[serializerMethodContexts.Count - 1];
serializerMethodContexts.RemoveAt(serializerMethodContexts.Count - 1);
return res;
}
void Free(ref SerializerMethodContext ctx) {
serializerMethodContexts.Add(ctx);
ctx = null;
}
}
}
Reference in New Issue View Git Blame Copy Permalink