public void Ctor_Errors() { var mdBuilder = new MetadataBuilder(); Assert.Throws<ArgumentNullException>(() => new PortablePdbBuilder(null, MetadataRootBuilder.EmptyRowCounts, default(MethodDefinitionHandle))); Assert.Throws<ArgumentNullException>(() => new PortablePdbBuilder(mdBuilder, default(ImmutableArray<int>), default(MethodDefinitionHandle))); var rowCounts = new int[128]; rowCounts[64] = 1; Assert.Throws<ArgumentException>(() => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle))); rowCounts = new int[64]; rowCounts[63] = 1; Assert.Throws<ArgumentException>(() => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle))); rowCounts = new int[64]; rowCounts[(int)TableIndex.EventPtr] = 1; Assert.Throws<ArgumentException>(() => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle))); rowCounts = new int[64]; rowCounts[(int)TableIndex.CustomDebugInformation] = 1; Assert.Throws<ArgumentException>(() => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle))); rowCounts = new int[64]; rowCounts[(int)TableIndex.MethodDef] = -1; Assert.Throws<ArgumentOutOfRangeException>(() => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle))); rowCounts = new int[64]; rowCounts[(int)TableIndex.GenericParamConstraint] = 0x01000000; Assert.Throws<ArgumentOutOfRangeException>(() => new PortablePdbBuilder(mdBuilder, ImmutableArray.Create(rowCounts), default(MethodDefinitionHandle))); }
public static ImageWriter CreateDebugWriter(ModuleDefinition module, MetadataBuilder metadata, Disposable<Stream> stream) { var writer = new ImageWriter (module, "PDB V1.0", metadata, stream, metadataOnly: true); var length = metadata.text_map.GetLength (); writer.text = new Section { SizeOfRawData = length, VirtualSize = length }; return writer; }
public void Ctor_Errors() { var mdBuilder = new MetadataBuilder(); Assert.Throws<ArgumentNullException>(() => new MetadataRootBuilder(null)); Assert.Throws<ArgumentException>(() => new MetadataRootBuilder(mdBuilder, new string('x', 255))); }
public NetTextBuilder(ImageNetDirectory directory) { _directory = directory; ImportBuilder = new ImageImportDirectoryBuilder(directory.Assembly, directory.Assembly.ImportDirectory); Segments.Add(ImportBuilder.AddressTablesBuilder); Segments.Add(directory); Segments.Add(MethodBodyTableBuilder = new MethodBodyTableBuilder()); Segments.Add(NetResourceDirectoryBuilder = new NetResourceDirectoryBuilder()); Segments.Add(DataBuilder = new NetDataTableBuilder()); if (directory.StrongNameData != null) Segments.Add(directory.StrongNameData); Segments.Add(Metadata = new MetadataBuilder(directory.MetadataHeader)); if (directory.Assembly.DebugDirectory != null) { Segments.Add(directory.Assembly.DebugDirectory); Segments.Add(directory.Assembly.DebugDirectory.Data); } Segments.Add(ImportBuilder); Segments.Add(StartupCode = new StartupCodeSegmentBuilder()); }
public CodeWriter (MetadataBuilder metadata) : base (0) { this.code_base = metadata.text_map.GetNextRVA (TextSegment.CLIHeader); this.current = code_base; this.metadata = metadata; this.standalone_signatures = new Dictionary<uint, MetadataToken> (); }
public void Serialize_Errors() { var mdBuilder = new MetadataBuilder(); var pdbBuilder = new PortablePdbBuilder(mdBuilder, MetadataRootBuilder.EmptyRowCounts, default(MethodDefinitionHandle)); var builder = new BlobBuilder(); Assert.Throws<ArgumentNullException>(() => pdbBuilder.Serialize(null)); }
public CodeWriter(MethodDefinition method) : base(0) { this.code_base = 0; this.metadata = null; this.method = method; this.reader = method.DeclaringType.Module.reader; this.body = method.Body; }
public void Serialize_Errors() { var mdBuilder = new MetadataBuilder(); var rootBuilder = new MetadataRootBuilder(mdBuilder); var builder = new BlobBuilder(); Assert.Throws<ArgumentNullException>(() => rootBuilder.Serialize(null, 0, 0)); Assert.Throws<ArgumentOutOfRangeException>(() => rootBuilder.Serialize(builder, -1, 0)); Assert.Throws<ArgumentOutOfRangeException>(() => rootBuilder.Serialize(builder, 0, -1)); }
ImageWriter(ModuleDefinition module, MetadataBuilder metadata, Stream stream) : base(stream) { this.module = module; this.metadata = metadata; this.GetDebugHeader (); this.GetWin32Resources (); this.text_map = BuildTextMap (); this.sections = 2; // text + reloc this.pe64 = module.Architecture != TargetArchitecture.I386; this.time_stamp = (uint) DateTime.UtcNow.Subtract (new DateTime (1970, 1, 1)).TotalSeconds; }
public static void BuildMetadata(MetadataBuilder<MainViewModel> builder) { builder.Property(x => x.FirstName) .Required(() => "Please enter the first name."); builder.Property(x => x.LastName) .Required(() => "Please enter the last name."); builder.Property(x => x.Email) .EmailAddressDataType(() => "Please enter a correct email address."); AddPasswordCheck(builder.Property(x => x.Password)) .Required(() => "Please enter the password."); AddPasswordCheck(builder.Property(x => x.ConfirmPassword)) .Required(() => "Please confirm the password."); }
public void Complex() { using (var peStream = new MemoryStream()) { var ilBuilder = new BlobBuilder(); var metadataBuilder = new MetadataBuilder(); var entryPoint = ComplexEmit(metadataBuilder, ilBuilder); WritePEImage(peStream, metadataBuilder, ilBuilder, entryPoint); // peStream.Position = 0; // File.WriteAllBytes(@"c:\temp\test.dll", peStream.ToArray()); } }
public void BasicValidation() { using (var peStream = new MemoryStream()) { var ilBuilder = new BlobBuilder(); var metadataBuilder = new MetadataBuilder(); var entryPoint = BasicValidationEmit(metadataBuilder, ilBuilder); WritePEImage(peStream, metadataBuilder, ilBuilder, entryPoint); peStream.Position = 0; var r = new PEReader(peStream); var h = r.PEHeaders; var mdReader = r.GetMetadataReader(); } }
ImageWriter(ModuleDefinition module, string runtime_version, MetadataBuilder metadata, Disposable<Stream> stream, bool metadataOnly = false) : base(stream.value) { this.module = module; this.runtime_version = runtime_version; this.text_map = metadata.text_map; this.stream = stream; this.metadata = metadata; if (metadataOnly) return; this.pe64 = module.Architecture == TargetArchitecture.AMD64 || module.Architecture == TargetArchitecture.IA64; this.has_reloc = module.Architecture == TargetArchitecture.I386; this.GetDebugHeader (); this.GetWin32Resources (); this.BuildTextMap (); this.sections = (ushort) (has_reloc ? 2 : 1); // text + reloc? }
private static void SerializeScope( MetadataBuilder metadataBuilder, MetadataModel metadataModel, MethodDefinitionHandle methodHandle, ImportScopeHandle importScopeHandle, ISymUnmanagedScope symScope, Dictionary <int, DynamicLocalInfo> dynamicSlots, Dictionary <string, DynamicLocalInfo> dynamicNames, bool vbSemantics, ref LocalVariableHandle lastLocalVariableHandle, ref LocalConstantHandle lastLocalConstantHandle) { // VB Windows PDB encode the range as end-inclusive, // all Portable PDBs use end-exclusive encoding. int start = symScope.GetStartOffset(); int end = symScope.GetEndOffset() + (vbSemantics ? 1 : 0); metadataBuilder.AddLocalScope( method: methodHandle, importScope: importScopeHandle, variableList: NextHandle(lastLocalVariableHandle), constantList: NextHandle(lastLocalConstantHandle), startOffset: start, length: end - start); foreach (var symLocal in symScope.GetLocals()) { int slot = symLocal.GetSlot(); string name = symLocal.GetName(); lastLocalVariableHandle = metadataBuilder.AddLocalVariable( attributes: (LocalVariableAttributes)symLocal.GetAttributes(), index: slot, name: metadataBuilder.GetOrAddString(name)); DynamicLocalInfo dynamicInfo; if (slot > 0 && dynamicSlots.TryGetValue(slot, out dynamicInfo) || slot == 0 && dynamicNames.TryGetValue(name, out dynamicInfo)) { metadataBuilder.AddCustomDebugInformation( parent: lastLocalVariableHandle, kind: metadataBuilder.GetOrAddGuid(PortableCustomDebugInfoKinds.DynamicLocalVariables), value: SerializeDynamicLocalBlob(metadataBuilder, dynamicInfo)); } } foreach (var symConstant in symScope.GetConstants()) { string name = symConstant.GetName(); object value = symConstant.GetValue(); lastLocalConstantHandle = metadataBuilder.AddLocalConstant( name: metadataBuilder.GetOrAddString(name), signature: SerializeConstantSignature(metadataBuilder, metadataModel, symConstant.GetSignature(), value)); DynamicLocalInfo dynamicInfo; if (dynamicNames.TryGetValue(name, out dynamicInfo)) { metadataBuilder.AddCustomDebugInformation( parent: lastLocalConstantHandle, kind: metadataBuilder.GetOrAddGuid(PortableCustomDebugInfoKinds.DynamicLocalVariables), value: SerializeDynamicLocalBlob(metadataBuilder, dynamicInfo)); } } int previousChildScopeEnd = start; foreach (ISymUnmanagedScope child in symScope.GetChildren()) { int childScopeStart = child.GetStartOffset(); int childScopeEnd = child.GetEndOffset(); // scopes are properly nested: if (childScopeStart < previousChildScopeEnd || childScopeEnd > end) { // TODO: loc/warning throw new BadImageFormatException($"Invalid scope IL offset range: [{childScopeStart}, {childScopeEnd}), method 0x{MetadataTokens.GetToken(methodHandle):x}."); } previousChildScopeEnd = childScopeEnd; SerializeScope(metadataBuilder, metadataModel, methodHandle, importScopeHandle, child, dynamicSlots, dynamicNames, vbSemantics, ref lastLocalVariableHandle, ref lastLocalConstantHandle); } }
private static BlobHandle SerializeSequencePoints( MetadataBuilder metadataBuilder, int localSignatureRowId, ImmutableArray <SymUnmanagedSequencePoint> sequencePoints, Dictionary <string, DocumentHandle> documentIndex, out DocumentHandle singleDocumentHandle) { if (sequencePoints.Length == 0) { singleDocumentHandle = default(DocumentHandle); return(default(BlobHandle)); } var writer = new BlobBuilder(); int previousNonHiddenStartLine = -1; int previousNonHiddenStartColumn = -1; // header: writer.WriteCompressedInteger(localSignatureRowId); DocumentHandle previousDocument = TryGetSingleDocument(sequencePoints, documentIndex); singleDocumentHandle = previousDocument; for (int i = 0; i < sequencePoints.Length; i++) { var currentDocument = documentIndex[sequencePoints[i].Document.GetName()]; if (previousDocument != currentDocument) { // optional document in header or document record: if (!previousDocument.IsNil) { writer.WriteCompressedInteger(0); } writer.WriteCompressedInteger(MetadataTokens.GetHeapOffset(currentDocument)); previousDocument = currentDocument; } // delta IL offset: if (i > 0) { writer.WriteCompressedInteger((sequencePoints[i].Offset - sequencePoints[i - 1].Offset)); } else { writer.WriteCompressedInteger(sequencePoints[i].Offset); } if (sequencePoints[i].IsHidden) { writer.WriteInt16(0); continue; } // Delta Lines & Columns: SerializeDeltaLinesAndColumns(writer, sequencePoints[i]); // delta Start Lines & Columns: if (previousNonHiddenStartLine < 0) { Debug.Assert(previousNonHiddenStartColumn < 0); writer.WriteCompressedInteger(sequencePoints[i].StartLine); writer.WriteCompressedInteger(sequencePoints[i].StartColumn); } else { writer.WriteCompressedSignedInteger(sequencePoints[i].StartLine - previousNonHiddenStartLine); writer.WriteCompressedSignedInteger(sequencePoints[i].StartColumn - previousNonHiddenStartColumn); } previousNonHiddenStartLine = sequencePoints[i].StartLine; previousNonHiddenStartColumn = sequencePoints[i].StartColumn; } return(metadataBuilder.GetOrAddBlob(writer)); }
public static void BuildMetadata(MetadataBuilder <PreferencesViewModel> builder) { builder.Property(x => x.EmailAddress).Required(() => "Email Address Required"); builder.Property(x => x.Password).Required(() => "Password Required"); }
public void ValidateLocalScopeTable() { var builder = new MetadataBuilder(); builder.AddLocalScope(MetadataTokens.MethodDefinitionHandle(2), default(ImportScopeHandle), default(LocalVariableHandle), default(LocalConstantHandle), startOffset: 0, length: 1); builder.AddLocalScope(MetadataTokens.MethodDefinitionHandle(1), default(ImportScopeHandle), default(LocalVariableHandle), default(LocalConstantHandle), startOffset: 0, length: 1); Assert.Throws<InvalidOperationException>(() => builder.ValidateOrder()); builder = new MetadataBuilder(); builder.AddLocalScope(MetadataTokens.MethodDefinitionHandle(1), default(ImportScopeHandle), default(LocalVariableHandle), default(LocalConstantHandle), startOffset: 1, length: 1); builder.AddLocalScope(MetadataTokens.MethodDefinitionHandle(1), default(ImportScopeHandle), default(LocalVariableHandle), default(LocalConstantHandle), startOffset: 0, length: 1); Assert.Throws<InvalidOperationException>(() => builder.ValidateOrder()); builder = new MetadataBuilder(); builder.AddLocalScope(MetadataTokens.MethodDefinitionHandle(1), default(ImportScopeHandle), default(LocalVariableHandle), default(LocalConstantHandle), startOffset: 0, length: 1); builder.AddLocalScope(MetadataTokens.MethodDefinitionHandle(1), default(ImportScopeHandle), default(LocalVariableHandle), default(LocalConstantHandle), startOffset: 0, length: 2); Assert.Throws<InvalidOperationException>(() => builder.ValidateOrder()); builder = new MetadataBuilder(); builder.AddLocalScope(MetadataTokens.MethodDefinitionHandle(1), default(ImportScopeHandle), default(LocalVariableHandle), default(LocalConstantHandle), startOffset: 0, length: 1); builder.AddLocalScope(MetadataTokens.MethodDefinitionHandle(1), default(ImportScopeHandle), default(LocalVariableHandle), default(LocalConstantHandle), startOffset: 0, length: 1); builder.ValidateOrder(); // ok }
internal static Schema GetModelSchema(IExceptionContext ectx, TFGraph graph, string opType = null) { var schemaBuilder = new SchemaBuilder(); foreach (var op in graph) { if (opType != null && opType != op.OpType) { continue; } var tfType = op[0].OutputType; // Determine element type in Tensorflow tensor. For example, a vector of floats may get NumberType.R4 here. var mlType = Tf2MlNetTypeOrNull(tfType); // If the type is not supported in ML.NET then we cannot represent it as a column in an Schema. // We also cannot output it with a TensorFlowTransform, so we skip it. // Furthermore, operators which have NumOutputs <= 0 needs to be filtered. // The 'GetTensorShape' method crashes TensorFlow runtime // (https://github.com/dotnet/machinelearning/issues/2156) when the operator has no outputs. if (mlType == null || op.NumOutputs <= 0) { continue; } // Construct the final ML.NET type of a Tensorflow variable. var tensorShape = graph.GetTensorShape(op[0]).ToIntArray(); var columnType = new VectorType(mlType); if (!(Utils.Size(tensorShape) == 1 && tensorShape[0] <= 0) && (Utils.Size(tensorShape) > 0 && tensorShape.Skip(1).All(x => x > 0))) { columnType = new VectorType(mlType, tensorShape[0] > 0 ? tensorShape : tensorShape.Skip(1).ToArray()); } // There can be at most two metadata fields. // 1. The first field always presents. Its value is this operator's type. For example, // if an output is produced by an "Softmax" operator, the value of this field should be "Softmax". // 2. The second field stores operators whose outputs are consumed by this operator. In other words, // these values are names of some upstream operators which should be evaluated before executing // the current operator. It's possible that one operator doesn't need any input, so this field // can be missing. var metadataBuilder = new MetadataBuilder(); // Create the first metadata field. metadataBuilder.Add(TensorflowOperatorTypeKind, TextType.Instance, (ref ReadOnlyMemory <char> value) => value = op.OpType.AsMemory()); if (op.NumInputs > 0) { // Put upstream operators' names to an array (type: VBuffer) of string (type: ReadOnlyMemory<char>). VBuffer <ReadOnlyMemory <char> > upstreamOperatorNames = default; var bufferEditor = VBufferEditor.Create(ref upstreamOperatorNames, op.NumInputs); for (int i = 0; i < op.NumInputs; ++i) { bufferEditor.Values[i] = op.GetInput(i).Operation.Name.AsMemory(); } upstreamOperatorNames = bufferEditor.Commit(); // Used in metadata's getter. // Create the second metadata field. metadataBuilder.Add(TensorflowUpstreamOperatorsKind, new VectorType(TextType.Instance, op.NumInputs), (ref VBuffer <ReadOnlyMemory <char> > value) => { upstreamOperatorNames.CopyTo(ref value); }); } schemaBuilder.AddColumn(op.Name, columnType, metadataBuilder.GetMetadata()); } return(schemaBuilder.GetSchema()); }
public void GetMetadataDocuments() { var metadata = MetadataBuilder.GetMetadataDocuments(_connection.V1C77); }
/// <summary> /// Converts Windows PDB stream to Portable PDB. /// </summary> /// <param name="peStream">PE image stream (.dll or .exe)</param> /// <param name="sourcePdbStream">Source stream of Windows PDB data. Must be readable.</param> /// <param name="targetPdbStream">Target stream of Portable PDB data. Must be writable.</param> /// <exception cref="ArgumentNullException"><paramref name="peStream"/>, <paramref name="sourcePdbStream"/>, or <paramref name="targetPdbStream"/> is null.</exception> /// <exception cref="ArgumentException"><paramref name="sourcePdbStream"/> does not support reading.</exception> /// <exception cref="ArgumentException"><paramref name="targetPdbStream"/> does not support writing.</exception> /// <exception cref="BadImageFormatException">The format of the PE image or the source PDB image is invalid.</exception> /// <exception cref="InvalidDataException">Unexpected data found in the PE image or the source PDB image.</exception> public static void Convert(Stream peStream, Stream sourcePdbStream, Stream targetPdbStream) { ValidateArguments(peStream, sourcePdbStream, targetPdbStream); var metadataBuilder = new MetadataBuilder(); ImmutableArray <int> typeSystemRowCounts; var debugEntryPointToken = default(MethodDefinitionHandle); var pdbId = default(BlobContentId); try { using (var peReader = new PEReader(peStream)) { pdbId = ReadPdbId(peReader); var symReader = SymReaderFactory.CreateWindowsPdbReader(sourcePdbStream, peReader); var metadataReader = peReader.GetMetadataReader(); var metadataModel = new MetadataModel(metadataReader); typeSystemRowCounts = metadataModel.GetRowCounts(); debugEntryPointToken = ReadEntryPointHandle(symReader); // documents: var documentIndex = new Dictionary <string, DocumentHandle>(StringComparer.Ordinal); var documents = symReader.GetDocuments(); metadataBuilder.SetCapacity(TableIndex.Document, documents.Length); bool vbSemantics = false; foreach (var document in documents) { string name = document.GetName(); Guid language = document.GetLanguage(); // TODO: // won't work for IL-merged assmemblies vbSemantics |= language == SymReaderHelpers.VisualBasicLanguageGuid; var rid = metadataBuilder.AddDocument( name: metadataBuilder.GetOrAddDocumentName(name), hashAlgorithm: metadataBuilder.GetOrAddGuid(document.GetHashAlgorithm()), hash: metadataBuilder.GetOrAddBlob(document.GetChecksum()), language: metadataBuilder.GetOrAddGuid(language)); documentIndex.Add(name, rid); } var lastLocalVariableHandle = default(LocalVariableHandle); var lastLocalConstantHandle = default(LocalConstantHandle); var importStringsByMethod = new Dictionary <int, ImmutableArray <string> >(); var importScopesByMethod = new Dictionary <int, ImportScopeHandle>(); // Maps import scope content to import scope handles var importScopeIndex = new Dictionary <ImportScopeInfo, ImportScopeHandle>(); var importScopes = new List <ImportScopeInfo>(); // reserve slot for module import scope: importScopes.Add(default(ImportScopeInfo)); var externAliasImports = new List <ImportInfo>(); var externAliasStringSet = new HashSet <string>(StringComparer.Ordinal); string vbDefaultNamespace = null; var vbProjectLevelImports = new List <ImportInfo>(); // first pass: foreach (var methodHandle in metadataReader.MethodDefinitions) { int methodToken = MetadataTokens.GetToken(methodHandle); ImmutableArray <ImmutableArray <ImportInfo> > importGroups; if (vbSemantics) { var importStrings = CustomDebugInfoReader.GetVisualBasicImportStrings( methodToken, symReader, getMethodImportStrings: (token, sr) => GetImportStrings(token, importStringsByMethod, sr)); if (importStrings.IsEmpty) { // no debug info continue; } var vbFileLevelImports = ArrayBuilder <ImportInfo> .GetInstance(); foreach (var importString in importStrings) { ImportInfo import; if (TryParseImportString(importString, out import, vbSemantics: true)) { if (import.Kind == ImportTargetKind.DefaultNamespace) { vbDefaultNamespace = import.Target; } else if (import.Scope == VBImportScopeKind.Project) { vbProjectLevelImports.Add(import); } else { vbFileLevelImports.Add(import); } } } importGroups = ImmutableArray.Create(vbFileLevelImports.ToImmutableAndFree()); } else { ImmutableArray <string> localExternAliasStrings; var importStringGroups = CustomDebugInfoReader.GetCSharpGroupedImportStrings( methodToken, symReader, getMethodCustomDebugInfo: (token, sr) => sr.GetCustomDebugInfo(token, methodVersion: 1), getMethodImportStrings: (token, sr) => GetImportStrings(token, importStringsByMethod, sr), externAliasStrings: out localExternAliasStrings); if (importStringGroups.IsDefault) { // no debug info continue; } if (!localExternAliasStrings.IsDefault) { foreach (var externAlias in localExternAliasStrings) { ImportInfo import; if (externAliasStringSet.Add(externAlias) && TryParseImportString(externAlias, out import, vbSemantics: false)) { externAliasImports.Add(import); } } } importGroups = ImmutableArray.CreateRange(importStringGroups.Select(g => ParseImportStrings(g, vbSemantics: false))); } var importScopeHandle = DefineImportScope(importGroups, importScopeIndex, importScopes); importScopesByMethod.Add(methodToken, importScopeHandle); } // import scopes: metadataBuilder.AddImportScope( parentScope: default(ImportScopeHandle), imports: SerializeModuleImportScope(metadataBuilder, externAliasImports, vbProjectLevelImports, vbDefaultNamespace, metadataModel)); for (int i = 1; i < importScopes.Count; i++) { metadataBuilder.AddImportScope( parentScope: importScopes[i].Parent, imports: SerializeImportsBlob(metadataBuilder, importScopes[i].Imports, metadataModel)); } var dynamicNames = new Dictionary <string, DynamicLocalInfo>(); var dynamicSlots = new Dictionary <int, DynamicLocalInfo>(); // methods: metadataBuilder.SetCapacity(TableIndex.MethodDebugInformation, metadataReader.MethodDefinitions.Count); foreach (var methodHandle in metadataReader.MethodDefinitions) { var methodDef = metadataReader.GetMethodDefinition(methodHandle); int methodToken = MetadataTokens.GetToken(methodHandle); var symMethod = symReader.GetMethod(methodToken); if (symMethod == null) { metadataBuilder.AddMethodDebugInformation(default(DocumentHandle), sequencePoints: default(BlobHandle)); continue; } // method debug info: int localSignatureRowId; if (methodDef.RelativeVirtualAddress != 0) { var methodBody = peReader.GetMethodBody(methodDef.RelativeVirtualAddress); localSignatureRowId = methodBody.LocalSignature.IsNil ? 0 : MetadataTokens.GetRowNumber(methodBody.LocalSignature); } else { localSignatureRowId = 0; } var symSequencePoints = symMethod.GetSequencePoints().ToImmutableArray(); DocumentHandle singleDocumentHandle; BlobHandle sequencePointsBlob = SerializeSequencePoints(metadataBuilder, localSignatureRowId, symSequencePoints, documentIndex, out singleDocumentHandle); metadataBuilder.AddMethodDebugInformation( document: singleDocumentHandle, sequencePoints: sequencePointsBlob); // state machine and async info: var symAsyncMethod = symMethod.AsAsyncMethod(); if (symAsyncMethod != null) { var kickoffToken = MetadataTokens.Handle(symAsyncMethod.GetKickoffMethod()); metadataBuilder.AddStateMachineMethod( moveNextMethod: methodHandle, kickoffMethod: (MethodDefinitionHandle)kickoffToken); metadataBuilder.AddCustomDebugInformation( parent: methodHandle, kind: metadataBuilder.GetOrAddGuid(PortableCustomDebugInfoKinds.AsyncMethodSteppingInformationBlob), value: SerializeAsyncMethodSteppingInfo(metadataBuilder, symAsyncMethod, MetadataTokens.GetRowNumber(methodHandle))); } // custom debug information: var dynamicLocals = default(ImmutableArray <DynamicLocalInfo>); byte[] customDebugInfoBytes = symReader.GetCustomDebugInfo(methodToken, methodVersion: 1); if (customDebugInfoBytes != null) { foreach (var record in CustomDebugInfoReader.GetCustomDebugInfoRecords(customDebugInfoBytes)) { switch (record.Kind) { case CustomDebugInfoKind.DynamicLocals: dynamicLocals = CustomDebugInfoReader.DecodeDynamicLocalsRecord(record.Data); break; case CustomDebugInfoKind.StateMachineHoistedLocalScopes: metadataBuilder.AddCustomDebugInformation( parent: methodHandle, kind: metadataBuilder.GetOrAddGuid(PortableCustomDebugInfoKinds.EncLocalSlotMap), value: SerializeStateMachineHoistedLocalsBlob(metadataBuilder, CustomDebugInfoReader.DecodeStateMachineHoistedLocalScopesRecord(record.Data))); break; case CustomDebugInfoKind.EditAndContinueLocalSlotMap: metadataBuilder.AddCustomDebugInformation( parent: methodHandle, kind: metadataBuilder.GetOrAddGuid(PortableCustomDebugInfoKinds.EncLocalSlotMap), value: metadataBuilder.GetOrAddBlob(record.Data)); break; case CustomDebugInfoKind.EditAndContinueLambdaMap: metadataBuilder.AddCustomDebugInformation( parent: methodHandle, kind: metadataBuilder.GetOrAddGuid(PortableCustomDebugInfoKinds.EncLambdaAndClosureMap), value: metadataBuilder.GetOrAddBlob(record.Data)); break; } } } var rootScope = symMethod.GetRootScope(); if (rootScope.GetNamespaces().Length == 0 || rootScope.GetLocals().Length == 0 || rootScope.GetConstants().Length == 0) { dynamicNames.Clear(); dynamicSlots.Clear(); foreach (var dynamicLocal in dynamicLocals) { if (dynamicLocal.SlotId == 0) { // All dynamic constants have slot id == 0, // but a variable can also have slot id == 0 if (!dynamicNames.ContainsKey(dynamicLocal.Name)) { dynamicNames.Add(dynamicLocal.Name, dynamicLocal); } else { // TODO: warning } } else if (!dynamicSlots.ContainsKey(dynamicLocal.SlotId)) { dynamicSlots.Add(dynamicLocal.SlotId, dynamicLocal); } else { // TODO: warning } } foreach (ISymUnmanagedScope scope in rootScope.GetChildren()) { SerializeScope( metadataBuilder, metadataModel, methodHandle, importScopesByMethod[methodToken], scope, dynamicSlots, dynamicNames, vbSemantics, ref lastLocalVariableHandle, ref lastLocalConstantHandle); } } else { // TODO: warning: // "Root scope must be empty (method 0x{0:x8})", MetadataTokens.GetToken(methodHandle)) } } } } catch (COMException e) { // TODO: loc throw new BadImageFormatException("Invalid PDB format: " + e.Message, e); } var serializer = new PortablePdbBuilder(metadataBuilder, typeSystemRowCounts, debugEntryPointToken, idProvider: _ => pdbId); BlobBuilder blobBuilder = new BlobBuilder(); serializer.Serialize(blobBuilder); blobBuilder.WriteContentTo(targetPdbStream); }
void IMetadataProvider <CommandAttributeViewModel_FluentAPI> .BuildMetadata(MetadataBuilder <CommandAttributeViewModel_FluentAPI> builder) { builder.CommandFromMethod(x => x.BaseClassCommand()); builder.CommandFromMethod(x => x.Simple()); builder.CommandFromMethod(x => x.MethodWithCommand()); builder.CommandFromMethod(x => x.CustomName()).CommandName("MyCommand"); builder.CommandFromMethod(x => x.MethodWithCanExecute()); builder.CommandFromMethod(x => x.MethodWithReturnType()); builder.CommandFromMethod(x => x.MethodWithParameter(default(int))); builder.CommandFromMethod(x => x.MethodWithCustomCanExecute()) .DoNotUseCommandManager() .CanExecuteMethod(x => x.CanMethodWithCustomCanExecute_()) .DoNotUseCommandManager(); builder.CommandFromMethod(x => x.SimpleAsync()); builder.CommandFromMethod(x => x.MethodWithCanExecuteAsync()); builder.CommandFromMethod(x => x.MethodWithParameterAsync(default(int))) .DoNotUseCommandManager(); builder.CommandFromMethod(x => x.MultiExecuteAsync()) .AllowMultipleExecution(); }
private static MethodDefinitionHandle ComplexEmit(MetadataBuilder metadata, BlobBuilder ilBuilder, out Blob mvidFixup) { metadata.AddModule( 0, metadata.GetOrAddString("ConsoleApplication.exe"), metadata.ReserveGuid(out mvidFixup), default(GuidHandle), default(GuidHandle)); metadata.AddAssembly( metadata.GetOrAddString("ConsoleApplication"), version: new Version(0, 0, 0, 0), culture: default(StringHandle), publicKey: default(BlobHandle), flags: default(AssemblyFlags), hashAlgorithm: AssemblyHashAlgorithm.Sha1); var mscorlibAssemblyRef = metadata.AddAssemblyReference( name: metadata.GetOrAddString("mscorlib"), version: new Version(4, 0, 0, 0), culture: default(StringHandle), publicKeyOrToken: metadata.GetOrAddBlob(ImmutableArray.Create <byte>(0xB7, 0x7A, 0x5C, 0x56, 0x19, 0x34, 0xE0, 0x89)), flags: default(AssemblyFlags), hashValue: default(BlobHandle)); // TypeRefs: var systemObjectTypeRef = metadata.AddTypeReference(mscorlibAssemblyRef, metadata.GetOrAddString("System"), metadata.GetOrAddString("Object")); var dictionaryTypeRef = metadata.AddTypeReference(mscorlibAssemblyRef, metadata.GetOrAddString("System.Collections.Generic"), metadata.GetOrAddString("Dictionary`2")); var strignBuilderTypeRef = metadata.AddTypeReference(mscorlibAssemblyRef, metadata.GetOrAddString("System.Text"), metadata.GetOrAddString("StringBuilder")); var typeTypeRef = metadata.AddTypeReference(mscorlibAssemblyRef, metadata.GetOrAddString("System"), metadata.GetOrAddString("Type")); var int32TypeRef = metadata.AddTypeReference(mscorlibAssemblyRef, metadata.GetOrAddString("System"), metadata.GetOrAddString("Int32")); var runtimeTypeHandleRef = metadata.AddTypeReference(mscorlibAssemblyRef, metadata.GetOrAddString("System"), metadata.GetOrAddString("RuntimeTypeHandle")); var invalidOperationExceptionTypeRef = metadata.AddTypeReference(mscorlibAssemblyRef, metadata.GetOrAddString("System"), metadata.GetOrAddString("InvalidOperationException")); // TypeDefs: metadata.AddTypeDefinition( default(TypeAttributes), default(StringHandle), metadata.GetOrAddString("<Module>"), baseType: default(EntityHandle), fieldList: MetadataTokens.FieldDefinitionHandle(1), methodList: MetadataTokens.MethodDefinitionHandle(1)); var baseClassTypeDef = metadata.AddTypeDefinition( TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.AutoLayout | TypeAttributes.BeforeFieldInit | TypeAttributes.Abstract, metadata.GetOrAddString("Lib"), metadata.GetOrAddString("BaseClass"), systemObjectTypeRef, fieldList: MetadataTokens.FieldDefinitionHandle(1), methodList: MetadataTokens.MethodDefinitionHandle(1)); var derivedClassTypeDef = metadata.AddTypeDefinition( TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.AutoLayout | TypeAttributes.BeforeFieldInit, metadata.GetOrAddString("Lib"), metadata.GetOrAddString("DerivedClass"), baseClassTypeDef, fieldList: MetadataTokens.FieldDefinitionHandle(4), methodList: MetadataTokens.MethodDefinitionHandle(1)); // FieldDefs: // Field1 var baseClassNumberFieldDef = metadata.AddFieldDefinition( FieldAttributes.Private, metadata.GetOrAddString("_number"), metadata.GetOrAddBlob(BuildSignature(e => e.FieldSignature().Int32()))); // Field2 var baseClassNegativeFieldDef = metadata.AddFieldDefinition( FieldAttributes.Assembly, metadata.GetOrAddString("negative"), metadata.GetOrAddBlob(BuildSignature(e => e.FieldSignature().Boolean()))); // Field3 var derivedClassSumCacheFieldDef = metadata.AddFieldDefinition( FieldAttributes.Assembly, metadata.GetOrAddString("_sumCache"), metadata.GetOrAddBlob(BuildSignature(e => { var inst = e.FieldSignature().GenericInstantiation(genericType: dictionaryTypeRef, genericArgumentCount: 2, isValueType: false); inst.AddArgument().Int32(); inst.AddArgument().Object(); }))); // Field4 var derivedClassCountFieldDef = metadata.AddFieldDefinition( FieldAttributes.Assembly, metadata.GetOrAddString("_count"), metadata.GetOrAddBlob(BuildSignature(e => e.FieldSignature().SZArray().Int32()))); // Field5 var derivedClassBCFieldDef = metadata.AddFieldDefinition( FieldAttributes.Assembly, metadata.GetOrAddString("_bc"), metadata.GetOrAddBlob(BuildSignature(e => e.FieldSignature().Type(type: baseClassTypeDef, isValueType: false)))); var methodBodies = new MethodBodiesEncoder(ilBuilder); var buffer = new BlobBuilder(); InstructionEncoder il; // // Foo // int fooBodyOffset; il = new InstructionEncoder(buffer); il.LoadString(metadata.GetOrAddUserString("asdsad")); il.OpCode(ILOpCode.Newobj); il.Token(invalidOperationExceptionTypeRef); il.OpCode(ILOpCode.Throw); methodBodies.AddMethodBody().WriteInstructions(buffer, out fooBodyOffset); buffer.Clear(); // Method1 var derivedClassFooMethodDef = metadata.AddMethodDefinition( MethodAttributes.PrivateScope | MethodAttributes.Private | MethodAttributes.HideBySig, MethodImplAttributes.IL, metadata.GetOrAddString("Foo"), metadata.GetOrAddBlob(BuildSignature(e => e.MethodSignature(isInstanceMethod: true).Parameters(0, returnType => returnType.Void(), parameters => { }))), fooBodyOffset, default(ParameterHandle)); return(default(MethodDefinitionHandle)); }
private static MethodDefinitionHandle BasicValidationEmit(MetadataBuilder metadata, BlobBuilder ilBuilder) { metadata.AddModule( 0, metadata.GetOrAddString("ConsoleApplication.exe"), metadata.GetOrAddGuid(s_guid), default(GuidHandle), default(GuidHandle)); metadata.AddAssembly( metadata.GetOrAddString("ConsoleApplication"), version: new Version(1, 0, 0, 0), culture: default(StringHandle), publicKey: metadata.GetOrAddBlob(ImmutableArray.Create(Misc.KeyPair_PublicKey)), flags: AssemblyFlags.PublicKey, hashAlgorithm: AssemblyHashAlgorithm.Sha1); var mscorlibAssemblyRef = metadata.AddAssemblyReference( name: metadata.GetOrAddString("mscorlib"), version: new Version(4, 0, 0, 0), culture: default(StringHandle), publicKeyOrToken: metadata.GetOrAddBlob(ImmutableArray.Create <byte>(0xB7, 0x7A, 0x5C, 0x56, 0x19, 0x34, 0xE0, 0x89)), flags: default(AssemblyFlags), hashValue: default(BlobHandle)); var systemObjectTypeRef = metadata.AddTypeReference( mscorlibAssemblyRef, metadata.GetOrAddString("System"), metadata.GetOrAddString("Object")); var systemConsoleTypeRefHandle = metadata.AddTypeReference( mscorlibAssemblyRef, metadata.GetOrAddString("System"), metadata.GetOrAddString("Console")); var consoleWriteLineSignature = new BlobBuilder(); new BlobEncoder(consoleWriteLineSignature). MethodSignature(). Parameters(1, returnType => returnType.Void(), parameters => parameters.AddParameter().Type().String()); var consoleWriteLineMemberRef = metadata.AddMemberReference( systemConsoleTypeRefHandle, metadata.GetOrAddString("WriteLine"), metadata.GetOrAddBlob(consoleWriteLineSignature)); var parameterlessCtorSignature = new BlobBuilder(); new BlobEncoder(parameterlessCtorSignature). MethodSignature(isInstanceMethod: true). Parameters(0, returnType => returnType.Void(), parameters => { }); var parameterlessCtorBlobIndex = metadata.GetOrAddBlob(parameterlessCtorSignature); var objectCtorMemberRef = metadata.AddMemberReference( systemObjectTypeRef, metadata.GetOrAddString(".ctor"), parameterlessCtorBlobIndex); var mainSignature = new BlobBuilder(); new BlobEncoder(mainSignature). MethodSignature(). Parameters(0, returnType => returnType.Void(), parameters => { }); var methodBodies = new MethodBodiesEncoder(ilBuilder); var codeBuilder = new BlobBuilder(); var branchBuilder = new BranchBuilder(); InstructionEncoder il; // // Program::.ctor // int ctorBodyOffset; il = new InstructionEncoder(codeBuilder); // ldarg.0 il.LoadArgument(0); // call instance void [mscorlib]System.Object::.ctor() il.Call(objectCtorMemberRef); // ret il.OpCode(ILOpCode.Ret); methodBodies.AddMethodBody().WriteInstructions(codeBuilder, out ctorBodyOffset); codeBuilder.Clear(); // // Program::Main // int mainBodyOffset; il = new InstructionEncoder(codeBuilder, branchBuilder); var endLabel = il.DefineLabel(); // .try int tryOffset = il.Offset; // ldstr "hello" il.LoadString(metadata.GetOrAddUserString("hello")); // call void [mscorlib]System.Console::WriteLine(string) il.Call(consoleWriteLineMemberRef); // leave.s END il.Branch(ILOpCode.Leave, endLabel); // .finally int handlerOffset = il.Offset; // ldstr "world" il.LoadString(metadata.GetOrAddUserString("world")); // call void [mscorlib]System.Console::WriteLine(string) il.Call(consoleWriteLineMemberRef); // .endfinally il.OpCode(ILOpCode.Endfinally); int handlerEnd = il.Offset; // END: il.MarkLabel(endLabel); // ret il.OpCode(ILOpCode.Ret); var body = methodBodies.AddMethodBody(exceptionRegionCount: 1); var eh = body.WriteInstructions(codeBuilder, branchBuilder, out mainBodyOffset); eh.StartRegions(); eh.AddFinally(tryOffset, handlerOffset - tryOffset, handlerOffset, handlerEnd - handlerOffset); eh.EndRegions(); codeBuilder.Clear(); branchBuilder.Clear(); var mainMethodDef = metadata.AddMethodDefinition( MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig, MethodImplAttributes.IL | MethodImplAttributes.Managed, metadata.GetOrAddString("Main"), metadata.GetOrAddBlob(mainSignature), mainBodyOffset, paramList: default(ParameterHandle)); var ctorDef = metadata.AddMethodDefinition( MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, MethodImplAttributes.IL | MethodImplAttributes.Managed, metadata.GetOrAddString(".ctor"), parameterlessCtorBlobIndex, ctorBodyOffset, paramList: default(ParameterHandle)); metadata.AddTypeDefinition( default(TypeAttributes), default(StringHandle), metadata.GetOrAddString("<Module>"), baseType: default(EntityHandle), fieldList: MetadataTokens.FieldDefinitionHandle(1), methodList: mainMethodDef); metadata.AddTypeDefinition( TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.AutoLayout | TypeAttributes.BeforeFieldInit, metadata.GetOrAddString("ConsoleApplication"), metadata.GetOrAddString("Program"), systemObjectTypeRef, fieldList: MetadataTokens.FieldDefinitionHandle(1), methodList: mainMethodDef); return(mainMethodDef); }
private void HashTestCore <T>(T val, PrimitiveType type, uint expected, uint expectedOrdered, uint expectedOrdered3) { const int bits = 10; var builder = new MetadataBuilder(); builder.AddPrimitiveValue("Foo", type, val); var inRow = MetadataUtils.MetadataAsRow(builder.GetMetadata()); // First do an unordered hash. var info = new HashingTransformer.ColumnInfo("Foo", "Bar", hashBits: bits); var xf = new HashingTransformer(Env, new[] { info }); var mapper = xf.GetRowToRowMapper(inRow.Schema); mapper.OutputSchema.TryGetColumnIndex("Bar", out int outCol); var outRow = mapper.GetRow(inRow, c => c == outCol, out var _); var getter = outRow.GetGetter <uint>(outCol); uint result = 0; getter(ref result); Assert.Equal(expected, result); // Next do an ordered hash. info = new HashingTransformer.ColumnInfo("Foo", "Bar", hashBits: bits, ordered: true); xf = new HashingTransformer(Env, new[] { info }); mapper = xf.GetRowToRowMapper(inRow.Schema); mapper.OutputSchema.TryGetColumnIndex("Bar", out outCol); outRow = mapper.GetRow(inRow, c => c == outCol, out var _); getter = outRow.GetGetter <uint>(outCol); getter(ref result); Assert.Equal(expectedOrdered, result); // Next build up a vector to make sure that hashing is consistent between scalar values // at least in the first position, and in the unordered case, the last position. const int vecLen = 5; var denseVec = new VBuffer <T>(vecLen, Utils.CreateArray(vecLen, val)); builder = new MetadataBuilder(); builder.Add("Foo", new VectorType(type, vecLen), (ref VBuffer <T> dst) => denseVec.CopyTo(ref dst)); inRow = MetadataUtils.MetadataAsRow(builder.GetMetadata()); info = new HashingTransformer.ColumnInfo("Foo", "Bar", hashBits: bits, ordered: false); xf = new HashingTransformer(Env, new[] { info }); mapper = xf.GetRowToRowMapper(inRow.Schema); mapper.OutputSchema.TryGetColumnIndex("Bar", out outCol); outRow = mapper.GetRow(inRow, c => c == outCol, out var _); var vecGetter = outRow.GetGetter <VBuffer <uint> >(outCol); VBuffer <uint> vecResult = default; vecGetter(ref vecResult); Assert.Equal(vecLen, vecResult.Length); // They all should equal this in this case. Assert.All(vecResult.DenseValues(), v => Assert.Equal(expected, v)); // Now do ordered with the dense vector. info = new HashingTransformer.ColumnInfo("Foo", "Bar", hashBits: bits, ordered: true); xf = new HashingTransformer(Env, new[] { info }); mapper = xf.GetRowToRowMapper(inRow.Schema); mapper.OutputSchema.TryGetColumnIndex("Bar", out outCol); outRow = mapper.GetRow(inRow, c => c == outCol, out var _); vecGetter = outRow.GetGetter <VBuffer <uint> >(outCol); vecGetter(ref vecResult); Assert.Equal(vecLen, vecResult.Length); Assert.Equal(expectedOrdered, vecResult.GetItemOrDefault(0)); Assert.Equal(expectedOrdered3, vecResult.GetItemOrDefault(3)); Assert.All(vecResult.DenseValues(), v => Assert.True((v == 0) == (expectedOrdered == 0))); // Let's now do a sparse vector. var sparseVec = new VBuffer <T>(10, 3, Utils.CreateArray(3, val), new[] { 0, 3, 7 }); builder = new MetadataBuilder(); builder.Add("Foo", new VectorType(type, vecLen), (ref VBuffer <T> dst) => sparseVec.CopyTo(ref dst)); inRow = MetadataUtils.MetadataAsRow(builder.GetMetadata()); info = new HashingTransformer.ColumnInfo("Foo", "Bar", hashBits: bits, ordered: false); xf = new HashingTransformer(Env, new[] { info }); mapper = xf.GetRowToRowMapper(inRow.Schema); mapper.OutputSchema.TryGetColumnIndex("Bar", out outCol); outRow = mapper.GetRow(inRow, c => c == outCol, out var _); vecGetter = outRow.GetGetter <VBuffer <uint> >(outCol); vecGetter(ref vecResult); Assert.Equal(10, vecResult.Length); Assert.Equal(expected, vecResult.GetItemOrDefault(0)); Assert.Equal(expected, vecResult.GetItemOrDefault(3)); Assert.Equal(expected, vecResult.GetItemOrDefault(7)); info = new HashingTransformer.ColumnInfo("Foo", "Bar", hashBits: bits, ordered: true); xf = new HashingTransformer(Env, new[] { info }); mapper = xf.GetRowToRowMapper(inRow.Schema); mapper.OutputSchema.TryGetColumnIndex("Bar", out outCol); outRow = mapper.GetRow(inRow, c => c == outCol, out var _); vecGetter = outRow.GetGetter <VBuffer <uint> >(outCol); vecGetter(ref vecResult); Assert.Equal(10, vecResult.Length); Assert.Equal(expectedOrdered, vecResult.GetItemOrDefault(0)); Assert.Equal(expectedOrdered3, vecResult.GetItemOrDefault(3)); }
void IMetadataSymbolWriter.SetMetadata(MetadataBuilder metadata) { ((IMetadataSymbolWriter)writer).SetMetadata(metadata); }
internal PortablePdbWriter(MetadataBuilder pdb_metadata, ModuleDefinition module, ImageWriter writer) : this(pdb_metadata, module) { this.writer = writer; }
internal PortablePdbWriter(MetadataBuilder pdb_metadata, ModuleDefinition module) { this.pdb_metadata = pdb_metadata; this.module = module; }
public override void OnBeforeAddingResources(MetadataBuilder builder) { if (!options.DecryptMethods) return; methodsDecrypter.encryptNativeMethods(builder); }
public void Add() { var builder = new MetadataBuilder(); builder.AddModule(default(Int32), default(StringHandle), default(GuidHandle), default(GuidHandle), default(GuidHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Module]); builder.AddAssembly(default(StringHandle), default(Version), default(StringHandle), default(BlobHandle), default(AssemblyFlags), default(AssemblyHashAlgorithm)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Assembly]); var assemblyReference = builder.AddAssemblyReference(default(StringHandle), default(Version), default(StringHandle), default(BlobHandle), default(AssemblyFlags), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.AssemblyRef]); Assert.Equal(1, MetadataTokens.GetRowNumber(assemblyReference)); var typeDefinition = builder.AddTypeDefinition(default(TypeAttributes), default(StringHandle), default(StringHandle), default(EntityHandle), default(FieldDefinitionHandle), default(MethodDefinitionHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.TypeDef]); Assert.Equal(1, MetadataTokens.GetRowNumber(typeDefinition)); builder.AddTypeLayout(default(TypeDefinitionHandle), default(UInt16), default(UInt32)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.ClassLayout]); builder.AddInterfaceImplementation(MetadataTokens.TypeDefinitionHandle(1), MetadataTokens.TypeDefinitionHandle(1)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.InterfaceImpl]); builder.AddNestedType(default(TypeDefinitionHandle), default(TypeDefinitionHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.NestedClass]); var typeReference = builder.AddTypeReference(EntityHandle.ModuleDefinition, default(StringHandle), default(StringHandle)); Assert.Equal(1, MetadataTokens.GetRowNumber(typeReference)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.TypeRef]); builder.AddTypeSpecification(default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.TypeSpec]); builder.AddStandaloneSignature(default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.StandAloneSig]); builder.AddProperty(default(PropertyAttributes), default(StringHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Property]); builder.AddPropertyMap(default(TypeDefinitionHandle), default(PropertyDefinitionHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.PropertyMap]); builder.AddEvent(default(EventAttributes), default(StringHandle), MetadataTokens.TypeDefinitionHandle(1)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Event]); builder.AddEventMap(default(TypeDefinitionHandle), default(EventDefinitionHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.EventMap]); builder.AddConstant(MetadataTokens.FieldDefinitionHandle(1), default(Object)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Constant]); builder.AddMethodSemantics(MetadataTokens.EventDefinitionHandle(1), default(UInt16), default(MethodDefinitionHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.MethodSemantics]); builder.AddCustomAttribute(MetadataTokens.TypeDefinitionHandle(1), MetadataTokens.MethodDefinitionHandle(1), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.CustomAttribute]); builder.AddMethodSpecification(MetadataTokens.MethodDefinitionHandle(1), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.MethodSpec]); builder.AddModuleReference(default(StringHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.ModuleRef]); builder.AddParameter(default(ParameterAttributes), default(StringHandle), default(Int32)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Param]); var genericParameter = builder.AddGenericParameter(MetadataTokens.MethodDefinitionHandle(1), default(GenericParameterAttributes), default(StringHandle), default(Int32)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.GenericParam]); Assert.Equal(1, MetadataTokens.GetRowNumber(genericParameter)); builder.AddGenericParameterConstraint(default(GenericParameterHandle), MetadataTokens.TypeDefinitionHandle(1)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.GenericParamConstraint]); builder.AddFieldDefinition(default(FieldAttributes), default(StringHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Field]); builder.AddFieldLayout(default(FieldDefinitionHandle), default(Int32)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.FieldLayout]); builder.AddMarshallingDescriptor(MetadataTokens.FieldDefinitionHandle(1), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.FieldMarshal]); builder.AddFieldRelativeVirtualAddress(default(FieldDefinitionHandle), default(Int32)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.FieldRva]); var methodDefinition = builder.AddMethodDefinition(default(MethodAttributes), default(MethodImplAttributes), default(StringHandle), default(BlobHandle), default(Int32), default(ParameterHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.MethodDef]); Assert.Equal(1, MetadataTokens.GetRowNumber(methodDefinition)); builder.AddMethodImport(MetadataTokens.MethodDefinitionHandle(1), default(MethodImportAttributes), default(StringHandle), default(ModuleReferenceHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.ImplMap]); builder.AddMethodImplementation(default(TypeDefinitionHandle), MetadataTokens.MethodDefinitionHandle(1), MetadataTokens.MethodDefinitionHandle(1)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.MethodImpl]); var memberReference = builder.AddMemberReference(MetadataTokens.TypeDefinitionHandle(1), default(StringHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.MemberRef]); Assert.Equal(1, MetadataTokens.GetRowNumber(memberReference)); builder.AddManifestResource(default(ManifestResourceAttributes), default(StringHandle), MetadataTokens.AssemblyFileHandle(1), default(Int64)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.ManifestResource]); builder.AddAssemblyFile(default(StringHandle), default(BlobHandle), default(Boolean)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.File]); builder.AddExportedType(default(TypeAttributes), default(StringHandle), default(StringHandle), MetadataTokens.AssemblyFileHandle(1), default(Int32)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.ExportedType]); builder.AddDeclarativeSecurityAttribute(MetadataTokens.TypeDefinitionHandle(1), default(DeclarativeSecurityAction), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.DeclSecurity]); builder.AddEncLogEntry(MetadataTokens.TypeDefinitionHandle(1), default(EditAndContinueOperation)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.EncLog]); builder.AddEncMapEntry(MetadataTokens.TypeDefinitionHandle(1)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.EncMap]); var document = builder.AddDocument(default(BlobHandle), default(GuidHandle), default(BlobHandle), default(GuidHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Document]); Assert.Equal(1, MetadataTokens.GetRowNumber(document)); builder.AddMethodDebugInformation(default(DocumentHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.MethodDebugInformation]); var localScope = builder.AddLocalScope(default(MethodDefinitionHandle), default(ImportScopeHandle), default(LocalVariableHandle), default(LocalConstantHandle), default(Int32), default(Int32)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.LocalScope]); Assert.Equal(1, MetadataTokens.GetRowNumber(localScope)); var localVariable = builder.AddLocalVariable(default(LocalVariableAttributes), default(Int32), default(StringHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.LocalVariable]); Assert.Equal(1, MetadataTokens.GetRowNumber(localVariable)); var localConstant = builder.AddLocalConstant(default(StringHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.LocalConstant]); Assert.Equal(1, MetadataTokens.GetRowNumber(localConstant)); var importScope = builder.AddImportScope(default(ImportScopeHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.ImportScope]); Assert.Equal(1, MetadataTokens.GetRowNumber(importScope)); builder.AddStateMachineMethod(default(MethodDefinitionHandle), default(MethodDefinitionHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.StateMachineMethod]); builder.AddCustomDebugInformation(default(EntityHandle), default(GuidHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.CustomDebugInformation]); }
void IMetadataProvider <T900549_VM_Base_FluentAPI> .BuildMetadata(MetadataBuilder <T900549_VM_Base_FluentAPI> builder) { builder.CommandFromMethod(x => x.Test()); builder.CommandFromMethod(x => x.Test2()); }
public void GetMetadataEnums() { var metadata = MetadataBuilder.GetMetadataEnums(_connection.V1C77); }
void IMetadataProvider <T900549_VM_FluentAPI> .BuildMetadata(MetadataBuilder <T900549_VM_FluentAPI> builder) { builder.CommandFromMethod(x => x.Test2()).DoNotCreateCommand(); }
void IMetadataProvider <MainViewModel> .BuildMetadata (MetadataBuilder <MainViewModel> p_builder) { p_builder.CommandFromMethod(p_x => p_x.OnProcessButtonCommand()).CommandName("ProcessButtonCommand"); p_builder.CommandFromMethod(p_x => p_x.OnProcessButtonListCommand()).CommandName("ProcessButtonListCommand"); }
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) { if (relocsOnly) { return(new ObjectData(Array.Empty <byte>(), null, 1, null)); } if (!_emissionCompleted) { foreach (ISignatureEmitter emitter in _signatureEmitters) { emitter.MaterializeSignature(); } _emissionCompleted = true; } MetadataBuilder metadataBuilder = new MetadataBuilder(); metadataBuilder.AddAssembly( metadataBuilder.GetOrAddString(_inputModuleName), new Version(0, 0, 0, 0), culture: default(StringHandle), publicKey: default(BlobHandle), flags: default(AssemblyFlags), hashAlgorithm: AssemblyHashAlgorithm.None); metadataBuilder.AddModule( 0, metadataBuilder.GetOrAddString(_inputModuleName), default(GuidHandle), default(GuidHandle), default(GuidHandle)); // Module type metadataBuilder.AddTypeDefinition( default(TypeAttributes), default(StringHandle), metadataBuilder.GetOrAddString("<Module>"), baseType: default(EntityHandle), fieldList: MetadataTokens.FieldDefinitionHandle(1), methodList: MetadataTokens.MethodDefinitionHandle(1)); foreach (AssemblyName assemblyName in _manifestAssemblies) { AssemblyFlags assemblyFlags = 0; byte[] publicKeyOrToken; if ((assemblyName.Flags & AssemblyNameFlags.PublicKey) != 0) { assemblyFlags |= AssemblyFlags.PublicKey; publicKeyOrToken = assemblyName.GetPublicKey(); } else { publicKeyOrToken = assemblyName.GetPublicKeyToken(); } if ((assemblyName.Flags & AssemblyNameFlags.Retargetable) != 0) { assemblyFlags |= AssemblyFlags.Retargetable; } AssemblyReferenceHandle newHandle = metadataBuilder.AddAssemblyReference( name: metadataBuilder.GetOrAddString(assemblyName.Name), version: assemblyName.Version, culture: metadataBuilder.GetOrAddString(assemblyName.CultureName), publicKeyOrToken: metadataBuilder.GetOrAddBlob(publicKeyOrToken), flags: assemblyFlags, hashValue: default(BlobHandle) /* TODO */); } MetadataRootBuilder metadataRootBuilder = new MetadataRootBuilder(metadataBuilder); BlobBuilder metadataBlobBuilder = new BlobBuilder(); metadataRootBuilder.Serialize(metadataBlobBuilder, methodBodyStreamRva: 0, mappedFieldDataStreamRva: 0); return(new ObjectData( data: metadataBlobBuilder.ToArray(), relocs: Array.Empty <Relocation>(), alignment: 1, definedSymbols: new ISymbolDefinitionNode[] { this })); }
public void ValidateNestedClassTable() { var builder = new MetadataBuilder(); builder.AddNestedType(MetadataTokens.TypeDefinitionHandle(2), default(TypeDefinitionHandle)); builder.AddNestedType(MetadataTokens.TypeDefinitionHandle(1), default(TypeDefinitionHandle)); Assert.Throws<InvalidOperationException>(() => builder.ValidateOrder()); builder = new MetadataBuilder(); builder.AddNestedType(MetadataTokens.TypeDefinitionHandle(1), default(TypeDefinitionHandle)); builder.AddNestedType(MetadataTokens.TypeDefinitionHandle(1), default(TypeDefinitionHandle)); Assert.Throws<InvalidOperationException>(() => builder.ValidateOrder()); }
public void Headers() { var mdBuilder = new MetadataBuilder(); var rootBuilder = new MetadataRootBuilder(mdBuilder); var builder = new BlobBuilder(); rootBuilder.Serialize(builder, 0, 0); AssertEx.Equal(new byte[] { // signature: 0x42, 0x53, 0x4A, 0x42, // major version (1) 0x01, 0x00, // minor version (1) 0x01, 0x00, // reserved (0) 0x00, 0x00, 0x00, 0x00, // padded version length: 0x0C, 0x00, 0x00, 0x00, // padded version: (byte)'v', (byte)'4', (byte)'.', (byte)'0', (byte)'.', (byte)'3', (byte)'0', (byte)'3', (byte)'1', (byte)'9', 0x00, 0x00, // flags (0): 0x00, 0x00, // stream count: 0x05, 0x00, // stream headers: 0x6C, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, (byte)'#', (byte)'~', 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, (byte)'#', (byte)'S', (byte)'t', (byte)'r', (byte)'i', (byte)'n', (byte)'g', (byte)'s', 0x00, 0x00, 0x00, 0x00, 0x8C, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, (byte)'#', (byte)'U', (byte)'S', 0x00, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, (byte)'#', (byte)'G', (byte)'U', (byte)'I', (byte)'D', 0x00, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, (byte)'#', (byte)'B', (byte)'l', (byte)'o', (byte)'b', 0x00, 0x00, 0x00, // -------- // #~ // -------- // Reserved (0) 0x00, 0x00, 0x00, 0x00, // Major Version (2) 0x02, // Minor Version (0) 0x00, // Heap Sizes 0x00, // Reserved (1) 0x01, // Present tables 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Sorted tables 0x00, 0xFA, 0x01, 0x33, 0x00, 0x16, 0x00, 0x00, // Rows (empty) // Tables (empty) // Padding and alignment 0x00, 0x00, 0x00, 0x00, // -------- // #Strings // -------- 0x00, 0x00, 0x00, 0x00, // -------- // #US // -------- 0x00, 0x00, 0x00, 0x00, // -------- // #GUID // -------- // -------- // #Blob // -------- 0x00, 0x00, 0x00, 0x00, }, builder.ToArray()); }
public void ValidateStateMachineMethodTable() { var builder = new MetadataBuilder(); builder.AddStateMachineMethod(MetadataTokens.MethodDefinitionHandle(2), default(MethodDefinitionHandle)); builder.AddStateMachineMethod(MetadataTokens.MethodDefinitionHandle(1), default(MethodDefinitionHandle)); Assert.Throws<InvalidOperationException>(() => builder.ValidateOrder()); builder = new MetadataBuilder(); builder.AddStateMachineMethod(MetadataTokens.MethodDefinitionHandle(1), default(MethodDefinitionHandle)); builder.AddStateMachineMethod(MetadataTokens.MethodDefinitionHandle(1), default(MethodDefinitionHandle)); Assert.Throws<InvalidOperationException>(() => builder.ValidateOrder()); }
public void EncHeaders() { var mdBuilder = new MetadataBuilder(); mdBuilder.AddEncLogEntry(MetadataTokens.MethodDefinitionHandle(1), EditAndContinueOperation.AddMethod); var rootBuilder = new MetadataRootBuilder(mdBuilder); var builder = new BlobBuilder(); rootBuilder.Serialize(builder, 0, 0); AssertEx.Equal(new byte[] { // signature: 0x42, 0x53, 0x4A, 0x42, // major version (1) 0x01, 0x00, // minor version (1) 0x01, 0x00, // reserved (0) 0x00, 0x00, 0x00, 0x00, // padded version length: 0x0C, 0x00, 0x00, 0x00, // padded version: (byte)'v', (byte)'4', (byte)'.', (byte)'0', (byte)'.', (byte)'3', (byte)'0', (byte)'3', (byte)'1', (byte)'9', 0x00, 0x00, // flags (0): 0x00, 0x00, // stream count: 0x06, 0x00, // stream headers: 0x7C, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, (byte)'#', (byte)'-', 0x00, 0x00, 0xA4, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, (byte)'#', (byte)'S', (byte)'t', (byte)'r', (byte)'i', (byte)'n', (byte)'g', (byte)'s', 0x00, 0x00, 0x00, 0x00, 0xA8, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, (byte)'#', (byte)'U', (byte)'S', 0x00, 0xAC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, (byte)'#', (byte)'G', (byte)'U', (byte)'I', (byte)'D', 0x00, 0x00, 0x00, 0xAC, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, (byte)'#', (byte)'B', (byte)'l', (byte)'o', (byte)'b', 0x00, 0x00, 0x00, 0xB0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, (byte)'#', (byte)'J', (byte)'T', (byte)'D', 0x00, 0x00, 0x00, 0x00, // -------- // #- // -------- // Reserved (0) 0x00, 0x00, 0x00, 0x00, // Major Version (2) 0x02, // Minor Version (0) 0x00, // Heap Sizes 0xA7, // Reserved (1) 0x01, // Present tables 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, // Sorted tables 0x00, 0xFA, 0x01, 0x33, 0x00, 0x16, 0x00, 0x00, // Rows 0x01, 0x00, 0x00, 0x00, // // EncLog Table (token, operation) // 0x01, 0x00, 0x00, 0x06, 0x01, 0x00, 0x00, 0x00, // Padding and alignment 0x00, 0x00, 0x00, 0x00, // -------- // #Strings // -------- 0x00, 0x00, 0x00, 0x00, // -------- // #US // -------- 0x00, 0x00, 0x00, 0x00, // -------- // #GUID // -------- // -------- // #Blob // -------- 0x00, 0x00, 0x00, 0x00, // -------- // #JTD // -------- }, builder.ToArray()); }
public static ImageWriter CreateWriter(ModuleDefinition module, MetadataBuilder metadata, Stream stream) { var writer = new ImageWriter (module, metadata, stream); writer.BuildSections (); (writer.BaseStream as VirtualStream).sects = writer.sections; return writer; }
public void HeapOverflow_UserString() { string veryLargeString = new string('x', 0x00fffff0 / 2); var builder1 = new MetadataBuilder(); Assert.Equal(0x70000001, MetadataTokens.GetToken(builder1.GetOrAddUserString(veryLargeString))); // TODO: https://github.com/dotnet/roslyn/issues/9852 // Should throw: Assert.Throws<ImageFormatLimitationException>(() => builder1.GetOrAddUserString("123")); // Assert.Equal(0x70fffff6, MetadataTokens.GetToken(builder1.GetOrAddUserString("12"))); // Assert.Equal(0x70fffff6, MetadataTokens.GetToken(builder1.GetOrAddUserString("12"))); Assert.Equal(0x70fffff6, MetadataTokens.GetToken(builder1.GetOrAddUserString(veryLargeString + "z"))); Assert.Throws<ImageFormatLimitationException>(() => builder1.GetOrAddUserString("12")); var builder2 = new MetadataBuilder(); Assert.Equal(0x70000001, MetadataTokens.GetToken(builder2.GetOrAddUserString("123"))); Assert.Equal(0x70000009, MetadataTokens.GetToken(builder2.GetOrAddUserString(veryLargeString))); Assert.Equal(0x70fffffe, MetadataTokens.GetToken(builder2.GetOrAddUserString("4"))); // TODO: should throw https://github.com/dotnet/roslyn/issues/9852 var builder3 = new MetadataBuilder(userStringHeapStartOffset: 0x00fffffe); Assert.Equal(0x70ffffff, MetadataTokens.GetToken(builder3.GetOrAddUserString("1"))); // TODO: should throw https://github.com/dotnet/roslyn/issues/9852 var builder4 = new MetadataBuilder(userStringHeapStartOffset: 0x00fffff7); Assert.Equal(0x70fffff8, MetadataTokens.GetToken(builder4.GetOrAddUserString("1"))); // 4B Assert.Equal(0x70fffffc, MetadataTokens.GetToken(builder4.GetOrAddUserString("2"))); // 4B var builder5 = new MetadataBuilder(userStringHeapStartOffset: 0x00fffff8); Assert.Equal(0x70fffff9, MetadataTokens.GetToken(builder5.GetOrAddUserString("1"))); // 4B Assert.Equal(0x70fffffd, MetadataTokens.GetToken(builder5.GetOrAddUserString("2"))); // 4B // TODO: should throw https://github.com/dotnet/roslyn/issues/9852 }
public void PdbStream_TypeSystemRowCounts() { var rowCounts = new int[MetadataTokens.TableCount]; rowCounts[(int)TableIndex.MethodDef] = 0xFFFFFF; rowCounts[(int)TableIndex.TypeDef] = 0x123456; var mdBuilder = new MetadataBuilder(); var pdbBuilder = new PortablePdbBuilder( mdBuilder, ImmutableArray.Create(rowCounts), MetadataTokens.MethodDefinitionHandle(0x123456), _ => new BlobContentId(new Guid("44332211-6655-8877-AA99-010203040506"), 0xFFEEDDCC)); var builder = new BlobBuilder(); pdbBuilder.Serialize(builder); AssertEx.Equal(new byte[] { // PDB ID 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0xAA, 0x99, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xCC, 0xDD, 0xEE, 0xFF, // EntryPoint 0x56, 0x34, 0x12, 0x06, // ReferencedTypeSystemTables 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // TypeSystemTableRows 0x56, 0x34, 0x12, 0x00, 0xFF, 0xFF, 0xFF, 0x00 }, builder.Slice(124, -40)); }
public static void CreateInternalCallsAssembly(string outputModuleName, string outputAssemblyName, Version version, string outputAssemblyFilePath) { var metadataBuilder = new MetadataBuilder(); metadataBuilder.AddModule(0, metadataBuilder.GetOrAddString(outputModuleName), metadataBuilder.GetOrAddGuid(Guid.NewGuid()), default, default);
public void Headers() { var mdBuilder = new MetadataBuilder(); var pdbBuilder = new PortablePdbBuilder( mdBuilder, MetadataRootBuilder.EmptyRowCounts, MetadataTokens.MethodDefinitionHandle(0x123456), _ => new BlobContentId(new Guid("44332211-6655-8877-AA99-010203040506"), 0xFFEEDDCC)); var builder = new BlobBuilder(); pdbBuilder.Serialize(builder); AssertEx.Equal(new byte[] { // signature: 0x42, 0x53, 0x4A, 0x42, // major version (1) 0x01, 0x00, // minor version (1) 0x01, 0x00, // reserved (0) 0x00, 0x00, 0x00, 0x00, // padded version length: 0x0C, 0x00, 0x00, 0x00, // padded version: (byte)'P', (byte)'D', (byte)'B', (byte)' ', (byte)'v', (byte)'1', (byte)'.', (byte)'0', 0x00, 0x00, 0x00, 0x00, // flags (0): 0x00, 0x00, // stream count: 0x06, 0x00, // stream headers (offset, size, padded name) 0x7C, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, (byte)'#', (byte)'P', (byte)'d', (byte)'b', 0x00, 0x00, 0x00, 0x00, 0x9C, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, (byte)'#', (byte)'~', 0x00, 0x00, 0xB8, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, (byte)'#', (byte)'S', (byte)'t', (byte)'r', (byte)'i', (byte)'n', (byte)'g', (byte)'s', 0x00, 0x00, 0x00, 0x00, 0xBC, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, (byte)'#', (byte)'U', (byte)'S', 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, (byte)'#', (byte)'G', (byte)'U', (byte)'I', (byte)'D', 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, (byte)'#', (byte)'B', (byte)'l', (byte)'o', (byte)'b', 0x00, 0x00, 0x00, // -------- // #Pdb // -------- // PDB ID 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0xAA, 0x99, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xCC, 0xDD, 0xEE, 0xFF, // EntryPoint 0x56, 0x34, 0x12, 0x06, // ReferencedTypeSystemTables 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // TypeSystemTableRows (empty) // -------- // #~ // -------- // Reserved (0) 0x00, 0x00, 0x00, 0x00, // Major Version (2) 0x02, // Minor Version (0) 0x00, // Heap Sizes 0x00, // Reserved (1) 0x01, // Present tables 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Sorted tables 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Rows (empty) // Tables (empty) // Padding and alignment 0x00, 0x00, 0x00, 0x00, // -------- // #Strings // -------- 0x00, 0x00, 0x00, 0x00, // -------- // #US // -------- 0x00, 0x00, 0x00, 0x00, // -------- // #GUID // -------- // -------- // #Blob // -------- 0x00, 0x00, 0x00, 0x00, }, builder.ToArray()); }
void PatchRawSection (ByteBuffer buffer, MetadataBuilder metadata) { var position = base.position; Align (4); buffer.WriteBytes (base.position - position); const byte fat_format = 0x40; const byte more_sects = 0x80; var flags = ReadByte (); if ((flags & fat_format) == 0) { buffer.WriteByte (flags); PatchRawSmallSection (buffer, metadata); } else PatchRawFatSection (buffer, metadata); if ((flags & more_sects) != 0) PatchRawSection (buffer, metadata); }
void PatchRawFatSection (ByteBuffer buffer, MetadataBuilder metadata) { position--; var length = ReadInt32 (); buffer.WriteInt32 (length); var count = (length >> 8) / 24; PatchRawExceptionHandlers (buffer, metadata, count, true); }
public static void BuildMetadata(MetadataBuilder <FluentAPIValidationData> builder) { #region validation builder.Property(x => x.Email) .EmailAddressDataType(); builder.Property(x => x.Phone) .PhoneNumberDataType(); builder.Property(x => x.Facebook) .UrlDataType(); builder.Property(x => x.Title) .MaxLength(20); builder.Property(x => x.HireDate) .MatchesRule(x => x <= DateTime.Today, () => "The {0} field cannot be in the future."); builder.Property(x => x.Salary) .InRange(0, 1000000); builder.Property(x => x.CreditCard) .CreditCardDataType(); builder.Property(x => x.AddressLine1) .Required(); builder.Property(x => x.ZipCode) .MatchesRegularExpression(@"^\d{5}$", () => "The {0} field is not a valid zip code."); #endregion #region display options builder.Property(x => x.Salary) .CurrencyDataType(); builder.Property(x => x.FirstName) .DisplayName("First name"); builder.Property(x => x.LastName) .DisplayName("Last name"); builder.Property(x => x.BirthDate) .DisplayName("Hire date"); builder.Property(x => x.BirthDate) .DisplayName("Birth date"); builder.Property(x => x.AddressLine1) .DisplayName("Address line 1"); builder.Property(x => x.AddressLine2) .DisplayName("Address line 2"); builder.Property(x => x.ZipCode) .DisplayName("Zip code"); builder.Property(x => x.CreditCard) .DisplayName("Credit card"); #endregion #region layout builder.Group("Name") .ContainsProperty(x => x.FirstName) .ContainsProperty(x => x.LastName); builder.Group("Job") .ContainsProperty(x => x.Group) .ContainsProperty(x => x.Title) .ContainsProperty(x => x.HireDate) .ContainsProperty(x => x.Salary) .ContainsProperty(x => x.CreditCard); builder.Group("Contact") .ContainsProperty(x => x.Phone) .ContainsProperty(x => x.Email) .ContainsProperty(x => x.Facebook); builder.Group("Personal") .ContainsProperty(x => x.Gender) .ContainsProperty(x => x.BirthDate); builder.Group("Address") .ContainsProperty(x => x.AddressLine1) .ContainsProperty(x => x.AddressLine2) .ContainsProperty(x => x.ZipCode); #endregion }
public static ImageWriter CreateWriter(ModuleDefinition module, MetadataBuilder metadata, Disposable<Stream> stream) { var writer = new ImageWriter (module, module.runtime_version, metadata, stream); writer.BuildSections (); return writer; }
public MetadataSerializer(MetadataBuilder tables, MetadataSizes sizes, string metadataVersion) { _tables = tables; _sizes = sizes; _metadataVersion = metadataVersion; }
public void encryptNativeMethods(MetadataBuilder builder) { if (methodToNativeMethod.Count == 0) return; Log.v("Encrypting native methods"); var stream = new MemoryStream(); var writer = new BinaryWriter(stream); writer.Write((uint)0); // patch count writer.Write((uint)0); // mode writer.Write(methodToNativeMethod.Count); int index = 0; var codeWriter = builder.CodeWriter; foreach (var pair in methodToNativeMethod) { var method = pair.Key; if (method.DeclaringType == null) continue; // Method was removed if (method.DeclaringType.Module == null) continue; // method.DeclaringType was removed var code = pair.Value; uint codeRva = builder.GetMethodBodyRva((int)method.MetadataToken.RID - 1); if ((codeWriter.ReadByteAtRva(codeRva) & 3) == 2) codeRva++; else codeRva += 4 * (uint)(codeWriter.ReadByteAtRva(codeRva + 1) >> 4); Log.v("Native method {0:X8}, code RVA {1:X8}", method.MetadataToken.ToInt32(), codeRva); writer.Write(codeRva); writer.Write(0x70000000 + index++); writer.Write(code.Length); writer.Write(code); } if (index != 0) Log.n("Re-encrypted {0}/{1} native methods", index, totalEncryptedNativeMethods); var encryptedData = stream.ToArray(); xorEncrypt(encryptedData); encryptedResource.updateResource(encryptedResource.encrypt(encryptedData)); }
public void Add() { var builder = new MetadataBuilder(); builder.AddModule(default(int), default(StringHandle), default(GuidHandle), default(GuidHandle), default(GuidHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.Module)); builder.AddAssembly(default(StringHandle), new Version(0, 0, 0, 0), default(StringHandle), default(BlobHandle), default(AssemblyFlags), default(AssemblyHashAlgorithm)); Assert.Equal(1, builder.GetRowCount(TableIndex.Assembly)); var assemblyReference = builder.AddAssemblyReference(default(StringHandle), new Version(0, 0, 0, 0), default(StringHandle), default(BlobHandle), default(AssemblyFlags), default(BlobHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.AssemblyRef)); Assert.Equal(1, MetadataTokens.GetRowNumber(assemblyReference)); var typeDefinition = builder.AddTypeDefinition(default(TypeAttributes), default(StringHandle), default(StringHandle), default(EntityHandle), default(FieldDefinitionHandle), default(MethodDefinitionHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.TypeDef)); Assert.Equal(1, MetadataTokens.GetRowNumber(typeDefinition)); builder.AddTypeLayout(default(TypeDefinitionHandle), default(ushort), default(uint)); Assert.Equal(1, builder.GetRowCount(TableIndex.ClassLayout)); builder.AddInterfaceImplementation(MetadataTokens.TypeDefinitionHandle(1), MetadataTokens.TypeDefinitionHandle(1)); Assert.Equal(1, builder.GetRowCount(TableIndex.InterfaceImpl)); builder.AddNestedType(default(TypeDefinitionHandle), default(TypeDefinitionHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.NestedClass)); var typeReference = builder.AddTypeReference(EntityHandle.ModuleDefinition, default(StringHandle), default(StringHandle)); Assert.Equal(1, MetadataTokens.GetRowNumber(typeReference)); Assert.Equal(1, builder.GetRowCount(TableIndex.TypeRef)); builder.AddTypeSpecification(default(BlobHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.TypeSpec)); builder.AddStandaloneSignature(default(BlobHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.StandAloneSig)); builder.AddProperty(default(PropertyAttributes), default(StringHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.Property)); builder.AddPropertyMap(default(TypeDefinitionHandle), default(PropertyDefinitionHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.PropertyMap)); builder.AddEvent(default(EventAttributes), default(StringHandle), MetadataTokens.TypeDefinitionHandle(1)); Assert.Equal(1, builder.GetRowCount(TableIndex.Event)); builder.AddEventMap(default(TypeDefinitionHandle), default(EventDefinitionHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.EventMap)); builder.AddConstant(MetadataTokens.FieldDefinitionHandle(1), default(object)); Assert.Equal(1, builder.GetRowCount(TableIndex.Constant)); builder.AddMethodSemantics(MetadataTokens.EventDefinitionHandle(1), default(ushort), default(MethodDefinitionHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.MethodSemantics)); builder.AddCustomAttribute(MetadataTokens.TypeDefinitionHandle(1), MetadataTokens.MethodDefinitionHandle(1), default(BlobHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.CustomAttribute)); builder.AddMethodSpecification(MetadataTokens.MethodDefinitionHandle(1), default(BlobHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.MethodSpec)); builder.AddModuleReference(default(StringHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.ModuleRef)); builder.AddParameter(default(ParameterAttributes), default(StringHandle), default(int)); Assert.Equal(1, builder.GetRowCount(TableIndex.Param)); var genericParameter = builder.AddGenericParameter(MetadataTokens.MethodDefinitionHandle(1), default(GenericParameterAttributes), default(StringHandle), default(int)); Assert.Equal(1, builder.GetRowCount(TableIndex.GenericParam)); Assert.Equal(1, MetadataTokens.GetRowNumber(genericParameter)); builder.AddGenericParameterConstraint(default(GenericParameterHandle), MetadataTokens.TypeDefinitionHandle(1)); Assert.Equal(1, builder.GetRowCount(TableIndex.GenericParamConstraint)); builder.AddFieldDefinition(default(FieldAttributes), default(StringHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.Field)); builder.AddFieldLayout(default(FieldDefinitionHandle), default(int)); Assert.Equal(1, builder.GetRowCount(TableIndex.FieldLayout)); builder.AddMarshallingDescriptor(MetadataTokens.FieldDefinitionHandle(1), default(BlobHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.FieldMarshal)); builder.AddFieldRelativeVirtualAddress(default(FieldDefinitionHandle), default(int)); Assert.Equal(1, builder.GetRowCount(TableIndex.FieldRva)); var methodDefinition = builder.AddMethodDefinition(default(MethodAttributes), default(MethodImplAttributes), default(StringHandle), default(BlobHandle), default(int), default(ParameterHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.MethodDef)); Assert.Equal(1, MetadataTokens.GetRowNumber(methodDefinition)); builder.AddMethodImport(MetadataTokens.MethodDefinitionHandle(1), default(MethodImportAttributes), default(StringHandle), default(ModuleReferenceHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.ImplMap)); builder.AddMethodImplementation(default(TypeDefinitionHandle), MetadataTokens.MethodDefinitionHandle(1), MetadataTokens.MethodDefinitionHandle(1)); Assert.Equal(1, builder.GetRowCount(TableIndex.MethodImpl)); var memberReference = builder.AddMemberReference(MetadataTokens.TypeDefinitionHandle(1), default(StringHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.MemberRef)); Assert.Equal(1, MetadataTokens.GetRowNumber(memberReference)); builder.AddManifestResource(default(ManifestResourceAttributes), default(StringHandle), MetadataTokens.AssemblyFileHandle(1), default(uint)); Assert.Equal(1, builder.GetRowCount(TableIndex.ManifestResource)); builder.AddAssemblyFile(default(StringHandle), default(BlobHandle), default(Boolean)); Assert.Equal(1, builder.GetRowCount(TableIndex.File)); builder.AddExportedType(default(TypeAttributes), default(StringHandle), default(StringHandle), MetadataTokens.AssemblyFileHandle(1), default(int)); Assert.Equal(1, builder.GetRowCount(TableIndex.ExportedType)); builder.AddDeclarativeSecurityAttribute(MetadataTokens.TypeDefinitionHandle(1), default(DeclarativeSecurityAction), default(BlobHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.DeclSecurity)); builder.AddEncLogEntry(MetadataTokens.TypeDefinitionHandle(1), default(EditAndContinueOperation)); Assert.Equal(1, builder.GetRowCount(TableIndex.EncLog)); builder.AddEncMapEntry(MetadataTokens.TypeDefinitionHandle(1)); Assert.Equal(1, builder.GetRowCount(TableIndex.EncMap)); var document = builder.AddDocument(default(BlobHandle), default(GuidHandle), default(BlobHandle), default(GuidHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.Document)); Assert.Equal(1, MetadataTokens.GetRowNumber(document)); builder.AddMethodDebugInformation(default(DocumentHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.MethodDebugInformation)); var localScope = builder.AddLocalScope(default(MethodDefinitionHandle), default(ImportScopeHandle), default(LocalVariableHandle), default(LocalConstantHandle), default(int), default(int)); Assert.Equal(1, builder.GetRowCount(TableIndex.LocalScope)); Assert.Equal(1, MetadataTokens.GetRowNumber(localScope)); var localVariable = builder.AddLocalVariable(default(LocalVariableAttributes), default(int), default(StringHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.LocalVariable)); Assert.Equal(1, MetadataTokens.GetRowNumber(localVariable)); var localConstant = builder.AddLocalConstant(default(StringHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.LocalConstant)); Assert.Equal(1, MetadataTokens.GetRowNumber(localConstant)); var importScope = builder.AddImportScope(default(ImportScopeHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.ImportScope)); Assert.Equal(1, MetadataTokens.GetRowNumber(importScope)); builder.AddStateMachineMethod(default(MethodDefinitionHandle), default(MethodDefinitionHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.StateMachineMethod)); builder.AddCustomDebugInformation(default(EntityHandle), default(GuidHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCount(TableIndex.CustomDebugInformation)); Assert.Equal(0, builder.GetRowCount(TableIndex.AssemblyOS)); Assert.Equal(0, builder.GetRowCount(TableIndex.AssemblyProcessor)); Assert.Equal(0, builder.GetRowCount(TableIndex.AssemblyRefOS)); Assert.Equal(0, builder.GetRowCount(TableIndex.AssemblyRefProcessor)); Assert.Equal(0, builder.GetRowCount(TableIndex.EventPtr)); Assert.Equal(0, builder.GetRowCount(TableIndex.FieldPtr)); Assert.Equal(0, builder.GetRowCount(TableIndex.MethodPtr)); Assert.Equal(0, builder.GetRowCount(TableIndex.ParamPtr)); Assert.Equal(0, builder.GetRowCount(TableIndex.PropertyPtr)); var rowCounts = builder.GetRowCounts(); Assert.Equal(MetadataTokens.TableCount, rowCounts.Length); foreach (TableIndex tableIndex in Enum.GetValues(typeof(TableIndex))) { Assert.Equal(builder.GetRowCount(tableIndex), rowCounts[(int)tableIndex]); } }
public static ImageWriter CreateWriter(ModuleDefinition module, MetadataBuilder metadata, Stream stream) { var writer = new ImageWriter (module, metadata, stream); writer.BuildSections (); return writer; }
public void GetOrAddDocumentName1() { var mdBuilder = new MetadataBuilder(); mdBuilder.GetOrAddDocumentName(""); mdBuilder.GetOrAddDocumentName("/a/b/c"); mdBuilder.GetOrAddDocumentName(@"\a\b\cc"); mdBuilder.GetOrAddDocumentName(@"/a/b\c"); mdBuilder.GetOrAddDocumentName(@"/\a/\b\\//c"); mdBuilder.GetOrAddDocumentName(@"a/"); mdBuilder.GetOrAddDocumentName(@"/"); mdBuilder.GetOrAddDocumentName(@"\\"); mdBuilder.GetOrAddDocumentName("\ud800"); // unpaired surrogate mdBuilder.GetOrAddDocumentName("\0"); var serialized = mdBuilder.GetSerializedMetadata(MetadataRootBuilder.EmptyRowCounts, 12, isStandaloneDebugMetadata: false); var heaps = new BlobBuilder(); mdBuilder.WriteHeapsTo(heaps, serialized.StringHeap); AssertEx.Equal(new byte[] { // #String 0x00, 0x00, 0x00, 0x00, // #US 0x00, 0x00, 0x00, 0x00, 0x00, // 0x00 // "" 0x02, (byte)'/', 0x00, 0x01, (byte)'a', // 0x04 0x01, (byte)'b', // 0x06 0x01, (byte)'c', // 0x08 // "/a/b/c" 0x05, (byte)'/', 0x00, 0x04, 0x06, 0x08, // 0x10 0x02, (byte)'c', (byte)'c', // @"\a\b\cc" 0x05, (byte)'\\', 0x00, 0x04, 0x06, 0x10, // 0x19 0x03, (byte)'b', (byte)'\\', (byte)'c', // @"/a/b\c" 0x04, (byte)'/', 0x00, 0x04, 0x19, // 0x22 0x02, (byte)'\\', (byte)'a', // 0x25 0x04, (byte)'\\', (byte)'b', (byte)'\\', (byte)'\\', // @"/\a/\b\\//c" 0x06, (byte)'/', 0x00, 0x22, 0x25, 0x00, 0x08, // @"a/" 0x03, (byte)'/', 0x04, 0x00, // @"/" 0x03, (byte)'/', 0x00, 0x00, // @"\\" 0x04, (byte)'\\', 0x00, 0x00, 0x00, // 0x3E 0x03, 0xED, 0xA0, 0x80, // "\ud800" 0x02, (byte)'/', 0x3E, // 0x45 0x01, 0x00, // "\0" 0x02, (byte)'/', 0x45, // heap padding 0x00, 0x00 }, heaps.ToArray()); }
public void Add() { var builder = new MetadataBuilder(); builder.AddModule(default(Int32), default(StringHandle), default(GuidHandle), default(GuidHandle), default(GuidHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Module]); builder.AddAssembly(default(StringHandle), default(Version), default(StringHandle), default(BlobHandle), default(AssemblyFlags), default(AssemblyHashAlgorithm)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Assembly]); var assemblyReference = builder.AddAssemblyReference(default(StringHandle), default(Version), default(StringHandle), default(BlobHandle), default(AssemblyFlags), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.AssemblyRef]); Assert.Equal(1, MetadataTokens.GetRowNumber(assemblyReference)); var typeDefinition = builder.AddTypeDefinition(default(TypeAttributes), default(StringHandle), default(StringHandle), default(EntityHandle), default(FieldDefinitionHandle), default(MethodDefinitionHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.TypeDef]); Assert.Equal(1, MetadataTokens.GetRowNumber(typeDefinition)); builder.AddTypeLayout(default(TypeDefinitionHandle), default(UInt16), default(UInt32)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.ClassLayout]); builder.AddInterfaceImplementation(MetadataTokens.TypeDefinitionHandle(1), MetadataTokens.TypeDefinitionHandle(1)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.InterfaceImpl]); builder.AddNestedType(default(TypeDefinitionHandle), default(TypeDefinitionHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.NestedClass]); var typeReference = builder.AddTypeReference(EntityHandle.ModuleDefinition, default(StringHandle), default(StringHandle)); Assert.Equal(1, MetadataTokens.GetRowNumber(typeReference)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.TypeRef]); builder.AddTypeSpecification(default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.TypeSpec]); builder.AddStandaloneSignature(default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.StandAloneSig]); builder.AddProperty(default(PropertyAttributes), default(StringHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Property]); builder.AddPropertyMap(default(TypeDefinitionHandle), default(PropertyDefinitionHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.PropertyMap]); builder.AddEvent(default(EventAttributes), default(StringHandle), MetadataTokens.TypeDefinitionHandle(1)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Event]); builder.AddEventMap(default(TypeDefinitionHandle), default(EventDefinitionHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.EventMap]); builder.AddConstant(MetadataTokens.FieldDefinitionHandle(1), default(Object)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Constant]); builder.AddMethodSemantics(MetadataTokens.EventDefinitionHandle(1), default(UInt16), default(MethodDefinitionHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.MethodSemantics]); builder.AddCustomAttribute(MetadataTokens.TypeDefinitionHandle(1), MetadataTokens.MethodDefinitionHandle(1), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.CustomAttribute]); builder.AddMethodSpecification(MetadataTokens.MethodDefinitionHandle(1), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.MethodSpec]); builder.AddModuleReference(default(StringHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.ModuleRef]); builder.AddParameter(default(ParameterAttributes), default(StringHandle), default(Int32)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Param]); var genericParameter = builder.AddGenericParameter(MetadataTokens.MethodDefinitionHandle(1), default(GenericParameterAttributes), default(StringHandle), default(Int32)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.GenericParam]); Assert.Equal(1, MetadataTokens.GetRowNumber(genericParameter)); builder.AddGenericParameterConstraint(default(GenericParameterHandle), MetadataTokens.TypeDefinitionHandle(1)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.GenericParamConstraint]); builder.AddFieldDefinition(default(FieldAttributes), default(StringHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Field]); builder.AddFieldLayout(default(FieldDefinitionHandle), default(Int32)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.FieldLayout]); builder.AddMarshallingDescriptor(MetadataTokens.FieldDefinitionHandle(1), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.FieldMarshal]); builder.AddFieldRelativeVirtualAddress(default(FieldDefinitionHandle), default(Int32)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.FieldRva]); var methodDefinition = builder.AddMethodDefinition(default(MethodAttributes), default(MethodImplAttributes), default(StringHandle), default(BlobHandle), default(Int32), default(ParameterHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.MethodDef]); Assert.Equal(1, MetadataTokens.GetRowNumber(methodDefinition)); builder.AddMethodImport(MetadataTokens.MethodDefinitionHandle(1), default(MethodImportAttributes), default(StringHandle), default(ModuleReferenceHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.ImplMap]); builder.AddMethodImplementation(default(TypeDefinitionHandle), MetadataTokens.MethodDefinitionHandle(1), MetadataTokens.MethodDefinitionHandle(1)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.MethodImpl]); var memberReference = builder.AddMemberReference(MetadataTokens.TypeDefinitionHandle(1), default(StringHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.MemberRef]); Assert.Equal(1, MetadataTokens.GetRowNumber(memberReference)); builder.AddManifestResource(default(ManifestResourceAttributes), default(StringHandle), MetadataTokens.AssemblyFileHandle(1), default(Int64)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.ManifestResource]); builder.AddAssemblyFile(default(StringHandle), default(BlobHandle), default(Boolean)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.File]); builder.AddExportedType(default(TypeAttributes), default(StringHandle), default(StringHandle), MetadataTokens.AssemblyFileHandle(1), default(Int32)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.ExportedType]); builder.AddDeclarativeSecurityAttribute(MetadataTokens.TypeDefinitionHandle(1), default(DeclarativeSecurityAction), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.DeclSecurity]); builder.AddEncLogEntry(MetadataTokens.TypeDefinitionHandle(1), default(EditAndContinueOperation)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.EncLog]); builder.AddEncMapEntry(MetadataTokens.TypeDefinitionHandle(1)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.EncMap]); var document = builder.AddDocument(default(BlobHandle), default(GuidHandle), default(BlobHandle), default(GuidHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.Document]); Assert.Equal(1, MetadataTokens.GetRowNumber(document)); builder.AddMethodDebugInformation(default(DocumentHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.MethodDebugInformation]); var localScope = builder.AddLocalScope(default(MethodDefinitionHandle), default(ImportScopeHandle), default(LocalVariableHandle), default(LocalConstantHandle), default(Int32), default(Int32)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.LocalScope]); Assert.Equal(1, MetadataTokens.GetRowNumber(localScope)); var localVariable = builder.AddLocalVariable(default(LocalVariableAttributes), default(Int32), default(StringHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.LocalVariable]); Assert.Equal(1, MetadataTokens.GetRowNumber(localVariable)); var localConstant = builder.AddLocalConstant(default(StringHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.LocalConstant]); Assert.Equal(1, MetadataTokens.GetRowNumber(localConstant)); var importScope = builder.AddImportScope(default(ImportScopeHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.ImportScope]); Assert.Equal(1, MetadataTokens.GetRowNumber(importScope)); builder.AddStateMachineMethod(default(MethodDefinitionHandle), default(MethodDefinitionHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.StateMachineMethod]); builder.AddCustomDebugInformation(default(EntityHandle), default(GuidHandle), default(BlobHandle)); Assert.Equal(1, builder.GetRowCounts()[(int)TableIndex.CustomDebugInformation]); }
public void Heaps_StartOffsets() { var mdBuilder = new MetadataBuilder( userStringHeapStartOffset: 0x10, stringHeapStartOffset: 0x20, blobHeapStartOffset: 0x30, guidHeapStartOffset: 0x40); var g = mdBuilder.GetOrAddGuid(new Guid("D39F3559-476A-4D1E-B6D2-88E66395230B")); Assert.Equal(5, g.Index); var s0 = mdBuilder.GetOrAddString(""); Assert.False(s0.IsVirtual); Assert.Equal(0, s0.GetWriterVirtualIndex()); var s1 = mdBuilder.GetOrAddString("foo"); Assert.True(s1.IsVirtual); Assert.Equal(1, s1.GetWriterVirtualIndex()); var us0 = mdBuilder.GetOrAddUserString(""); Assert.Equal(0x11, us0.GetHeapOffset()); var us1 = mdBuilder.GetOrAddUserString("bar"); Assert.Equal(0x13, us1.GetHeapOffset()); var b0 = mdBuilder.GetOrAddBlob(new byte[0]); Assert.Equal(0, b0.GetHeapOffset()); var b1 = mdBuilder.GetOrAddBlob(new byte[] { 1, 2 }); Assert.Equal(0x31, b1.GetHeapOffset()); var serialized = mdBuilder.GetSerializedMetadata(MetadataRootBuilder.EmptyRowCounts, 12, isStandaloneDebugMetadata: false); Assert.Equal(5, mdBuilder.SerializeHandle(g)); Assert.Equal(0, mdBuilder.SerializeHandle(serialized.StringMap, s0)); Assert.Equal(0x21, mdBuilder.SerializeHandle(serialized.StringMap, s1)); Assert.Equal(0x11, mdBuilder.SerializeHandle(us0)); Assert.Equal(0x13, mdBuilder.SerializeHandle(us1)); Assert.Equal(0, mdBuilder.SerializeHandle(b0)); Assert.Equal(0x31, mdBuilder.SerializeHandle(b1)); var heaps = new BlobBuilder(); mdBuilder.WriteHeapsTo(heaps, serialized.StringHeap); AssertEx.Equal(new byte[] { // #String 0x00, 0x66, 0x6F, 0x6F, 0x00, 0x00, 0x00, 0x00, // #US 0x00, 0x01, 0x00, 0x07, 0x62, 0x00, 0x61, 0x00, 0x72, 0x00, 0x00, 0x00, // #Guid 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59, 0x35, 0x9F, 0xD3, 0x6A, 0x47, 0x1E, 0x4D, 0xB6, 0xD2, 0x88, 0xE6, 0x63, 0x95, 0x23, 0x0B, // #Blob 0x00, 0x02, 0x01, 0x02 }, heaps.ToArray()); Assert.Throws <ArgumentNullException>(() => mdBuilder.GetOrAddString(null)); }
static MetadataToken GetOriginalToken (MetadataBuilder metadata, MethodDefinition method) { MetadataToken original; if (metadata.TryGetOriginalMethodToken (method.token, out original)) return original; return MetadataToken.Zero; }
void IMetadataSymbolWriter.SetMetadata(MetadataBuilder metadata) { this.metadata = metadata; }
void PatchRawSmallSection (ByteBuffer buffer, MetadataBuilder metadata) { var length = ReadByte (); buffer.WriteByte (length); Advance (2); buffer.WriteUInt16 (0); var count = length / 12; PatchRawExceptionHandlers (buffer, metadata, count, false); }
public void GetConstantMetadata() { var metadata = MetadataBuilder.GetMetadataConstants(_connection.V1C77); }
void PatchRawExceptionHandlers (ByteBuffer buffer, MetadataBuilder metadata, int count, bool fat_entry) { const int fat_entry_size = 16; const int small_entry_size = 6; for (int i = 0; i < count; i++) { ExceptionHandlerType handler_type; if (fat_entry) { var type = ReadUInt32 (); handler_type = (ExceptionHandlerType) (type & 0x7); buffer.WriteUInt32 (type); } else { var type = ReadUInt16 (); handler_type = (ExceptionHandlerType) (type & 0x7); buffer.WriteUInt16 (type); } buffer.WriteBytes (ReadBytes (fat_entry ? fat_entry_size : small_entry_size)); switch (handler_type) { case ExceptionHandlerType.Catch: var exception = reader.LookupToken (ReadToken ()); buffer.WriteUInt32 (metadata.LookupToken (exception).ToUInt32 ()); break; default: buffer.WriteUInt32 (ReadUInt32 ()); break; } } }
public void BuildMetadata(MetadataBuilder <TestData> builder) { builder.Property(x => x.Prop1).AddOrModifyAttribute <DisplayAttribute>(x => x.AutoGenerateField = true); }