public ProjectLoader(IEditorLogger logger, IObjectDumper objectDumper, ISettingsSerializer settingsSerializer) { Check.IfIsNull(logger).Throw<ArgumentNullException>(() => logger); Check.IfIsNull(objectDumper).Throw<ArgumentNullException>(() => objectDumper); this.logger = logger; this.objectDumper = objectDumper; this.settingsSerializer = settingsSerializer; }
private static ItemDeserializer SetupClass(IPathFacade pathFacade = null, IEditorLogger logger = null, IProjectLoader projectLoader = null, IObjectDumper objectDumper = null, IXmlDeserializer xmlDeserializer = null, IFileReader fileReader = null) { return new ItemDeserializer(pathFacade, logger, projectLoader, objectDumper, xmlDeserializer, fileReader); }
/// <summary> /// Dumps <c>object</c>. /// </summary> /// <typeparam name="TResult">Type of dump resut.</typeparam> /// <param name="dumper">Dumper to use.</param> /// <param name="target">Object to dump.</param> /// <returns>Object dump.</returns> public static TResult Dump <TResult>(this IObjectDumper dumper, object target) { if (dumper == null) { throw new ArgumentNullException(nameof(dumper)); } if (target == null) { throw new ArgumentNullException(nameof(target)); } return((TResult)dumper.Filter(target.GetType(), null, target)); }
public static void SetDumpMethod(ObjectDumpMethod method) { switch (method) { case ObjectDumpMethod.Recursive: _dumper = new RecursiveObjectDumper(); break; case ObjectDumpMethod.Traverse: _dumper = new TraversalObjectDumper(); break; default: throw new InvalidEnumArgumentException(method.ToString()); } }
public ItemDeserializer(IPathFacade pathFacade, IEditorLogger logger, IProjectLoader projectLoader, IObjectDumper objectDumper, IXmlDeserializer xmlDeserializer, IFileReader fileReader) : base(pathFacade, logger, projectLoader) { Check.IfIsNull(objectDumper).Throw<ArgumentNullException>(() => objectDumper); Check.IfIsNull(xmlDeserializer).Throw<ArgumentNullException>(() => xmlDeserializer); Check.IfIsNull(fileReader).Throw<ArgumentNullException>(() => fileReader); this.objectDumper = objectDumper; this.xmlDeserializer = xmlDeserializer; this.fileReader = fileReader; }
internal SampleRunnerImpl(FormSampleRunner form, IObjectDumper dumper) : base(dumper) { _form = form; }
public static void EmitObject(string objectFilePath, IEnumerable <DependencyNode> nodes, NodeFactory factory, WebAssemblyCodegenCompilation compilation, IObjectDumper dumper) { WebAssemblyObjectWriter objectWriter = new WebAssemblyObjectWriter(objectFilePath, factory, compilation); bool succeeded = false; try { //ObjectNodeSection managedCodeSection = null; var listOfOffsets = new List <int>(); foreach (DependencyNode depNode in nodes) { ObjectNode node = depNode as ObjectNode; if (node == null) { continue; } if (node.ShouldSkipEmittingObjectNode(factory)) { continue; } objectWriter.StartObjectNode(node); ObjectData nodeContents = node.GetData(factory); if (dumper != null) { dumper.DumpObjectNode(factory.NameMangler, node, nodeContents); } #if DEBUG foreach (ISymbolNode definedSymbol in nodeContents.DefinedSymbols) { try { _previouslyWrittenNodeNames.Add(definedSymbol.GetMangledName(factory.NameMangler), definedSymbol); } catch (ArgumentException) { ISymbolNode alreadyWrittenSymbol = _previouslyWrittenNodeNames[definedSymbol.GetMangledName(factory.NameMangler)]; Debug.Fail("Duplicate node name emitted to file", $"Symbol {definedSymbol.GetMangledName(factory.NameMangler)} has already been written to the output object file {objectFilePath} with symbol {alreadyWrittenSymbol}"); } } #endif ObjectNodeSection section = node.Section; if (objectWriter.ShouldShareSymbol(node)) { section = objectWriter.GetSharedSection(section, ((ISymbolNode)node).GetMangledName(factory.NameMangler)); } // Ensure section and alignment for the node. objectWriter.SetSection(section); objectWriter.EmitAlignment(nodeContents.Alignment); objectWriter.ResetByteRunInterruptionOffsets(nodeContents.Relocs); // Build symbol definition map. objectWriter.BuildSymbolDefinitionMap(node, nodeContents.DefinedSymbols); Relocation[] relocs = nodeContents.Relocs; int nextRelocOffset = -1; int nextRelocIndex = -1; if (relocs.Length > 0) { nextRelocOffset = relocs[0].Offset; nextRelocIndex = 0; } int i = 0; listOfOffsets.Clear(); listOfOffsets.AddRange(objectWriter._byteInterruptionOffsets); int offsetIndex = 0; while (i < nodeContents.Data.Length) { // Emit symbol definitions if necessary objectWriter.EmitSymbolDefinition(i); if (i == nextRelocOffset) { Relocation reloc = relocs[nextRelocIndex]; long delta; unsafe { fixed(void *location = &nodeContents.Data[i]) { delta = Relocation.ReadValue(reloc.RelocType, location); } } int size = objectWriter.EmitSymbolReference(reloc.Target, (int)delta, reloc.RelocType); /* * WebAssembly has no thumb * // Emit a copy of original Thumb2 instruction that came from RyuJIT * if (reloc.RelocType == RelocType.IMAGE_REL_BASED_THUMB_MOV32 || * reloc.RelocType == RelocType.IMAGE_REL_BASED_THUMB_BRANCH24) * { * unsafe * { * fixed (void* location = &nodeContents.Data[i]) * { * objectWriter.EmitBytes((IntPtr)location, size); * } * } * }*/ // Update nextRelocIndex/Offset if (++nextRelocIndex < relocs.Length) { nextRelocOffset = relocs[nextRelocIndex].Offset; } else { // This is the last reloc. Set the next reloc offset to -1 in case the last reloc has a zero size, // which means the reloc does not have vacant bytes corresponding to in the data buffer. E.g, // IMAGE_REL_THUMB_BRANCH24 is a kind of 24-bit reloc whose bits scatte over the instruction that // references it. We do not vacate extra bytes in the data buffer for this kind of reloc. nextRelocOffset = -1; } i += size; } else { while (offsetIndex < listOfOffsets.Count && listOfOffsets[offsetIndex] <= i) { offsetIndex++; } int nextOffset = offsetIndex == listOfOffsets.Count ? nodeContents.Data.Length : listOfOffsets[offsetIndex]; unsafe { // Todo: Use Span<T> instead once it's available to us in this repo fixed(byte *pContents = &nodeContents.Data[i]) { objectWriter.EmitBytes((IntPtr)(pContents), nextOffset - i); i += nextOffset - i; } } } } Debug.Assert(i == nodeContents.Data.Length); // It is possible to have a symbol just after all of the data. objectWriter.EmitSymbolDefinition(nodeContents.Data.Length); objectWriter.DoneObjectNode(); } succeeded = true; } finally { objectWriter.Dispose(); if (!succeeded) { // If there was an exception while generating the OBJ file, make sure we don't leave the unfinished // object file around. try { File.Delete(objectFilePath); } catch { } } } }
public static void EmitObject(string objectFilePath, IEnumerable <DependencyNode> nodes, NodeFactory factory, IObjectDumper dumper) { ObjectWriter objectWriter = new ObjectWriter(objectFilePath, factory); bool succeeded = false; try { ObjectNodeSection managedCodeSection; if (factory.Target.OperatingSystem == TargetOS.Windows) { managedCodeSection = MethodCodeNode.WindowsContentSection; // Emit sentinels for managed code section. ObjectNodeSection codeStartSection = factory.CompilationModuleGroup.IsSingleFileCompilation ? MethodCodeNode.StartSection : MethodCodeNode.StartSection.GetSharedSection("__managedcode_a"); objectWriter.SetSection(codeStartSection); objectWriter.EmitSymbolDef(new Utf8StringBuilder().Append("__managedcode_a")); objectWriter.EmitIntValue(0, 1); ObjectNodeSection codeEndSection = factory.CompilationModuleGroup.IsSingleFileCompilation ? MethodCodeNode.EndSection : MethodCodeNode.EndSection.GetSharedSection("__managedcode_z"); objectWriter.SetSection(codeEndSection); objectWriter.EmitSymbolDef(new Utf8StringBuilder().Append("__managedcode_z")); objectWriter.EmitIntValue(1, 1); } else { managedCodeSection = MethodCodeNode.UnixContentSection; // TODO 2916: managed code section has to be created here, switch is not necessary. objectWriter.SetSection(MethodCodeNode.UnixContentSection); objectWriter.SetSection(LsdaSection); } objectWriter.SetCodeSectionAttribute(managedCodeSection); // Build file info map. objectWriter.BuildFileInfoMap(nodes); foreach (DependencyNode depNode in nodes) { ObjectNode node = depNode as ObjectNode; if (node == null) { continue; } if (node.ShouldSkipEmittingObjectNode(factory)) { continue; } ObjectData nodeContents = node.GetData(factory); if (dumper != null) { dumper.DumpObjectNode(factory.NameMangler, node, nodeContents); } #if DEBUG foreach (ISymbolNode definedSymbol in nodeContents.DefinedSymbols) { try { _previouslyWrittenNodeNames.Add(definedSymbol.GetMangledName(factory.NameMangler), definedSymbol); } catch (ArgumentException) { ISymbolNode alreadyWrittenSymbol = _previouslyWrittenNodeNames[definedSymbol.GetMangledName(factory.NameMangler)]; Debug.Assert(false, "Duplicate node name emitted to file", $"Symbol {definedSymbol.GetMangledName(factory.NameMangler)} has already been written to the output object file {objectFilePath} with symbol {alreadyWrittenSymbol}"); } } #endif ObjectNodeSection section = node.Section; if (objectWriter.ShouldShareSymbol(node)) { section = section.GetSharedSection(((ISymbolNode)node).GetMangledName(factory.NameMangler)); } // Ensure section and alignment for the node. objectWriter.SetSection(section); objectWriter.EmitAlignment(nodeContents.Alignment); // Build symbol definition map. objectWriter.BuildSymbolDefinitionMap(node, nodeContents.DefinedSymbols); if (!factory.Target.IsWindows) { objectWriter.BuildCFIMap(factory, node); } // Build debug location map objectWriter.BuildDebugLocInfoMap(node); Relocation[] relocs = nodeContents.Relocs; int nextRelocOffset = -1; int nextRelocIndex = -1; if (relocs.Length > 0) { nextRelocOffset = relocs[0].Offset; nextRelocIndex = 0; } int i = 0; while (i < nodeContents.Data.Length) { // Emit symbol definitions if necessary objectWriter.EmitSymbolDefinition(i); // Emit CFI codes for the given offset. objectWriter.EmitCFICodes(i); // Emit debug loc info if needed. objectWriter.EmitDebugLocInfo(i); if (i == nextRelocOffset) { Relocation reloc = relocs[nextRelocIndex]; long delta; unsafe { fixed(void *location = &nodeContents.Data[i]) { delta = Relocation.ReadValue(reloc.RelocType, location); } } int size = objectWriter.EmitSymbolReference(reloc.Target, (int)delta, reloc.RelocType); // Update nextRelocIndex/Offset if (++nextRelocIndex < relocs.Length) { nextRelocOffset = relocs[nextRelocIndex].Offset; } else { // This is the last reloc. Set the next reloc offset to -1 in case the last reloc has a zero size, // which means the reloc does not have vacant bytes corresponding to in the data buffer. E.g, // IMAGE_REL_THUMB_BRANCH24 is a kind of 24-bit reloc whose bits scatte over the instruction that // references it. We do not vacate extra bytes in the data buffer for this kind of reloc. nextRelocOffset = -1; } i += size; } else { objectWriter.EmitIntValue(nodeContents.Data[i], 1); i++; } } // It is possible to have a symbol just after all of the data. objectWriter.EmitSymbolDefinition(nodeContents.Data.Length); // Publish Windows unwind info. if (factory.Target.IsWindows) { objectWriter.PublishUnwindInfo(node); } // Emit the last CFI to close the frame. objectWriter.EmitCFICodes(nodeContents.Data.Length); if (objectWriter.HasFunctionDebugInfo()) { // Build debug local var info objectWriter.EmitDebugVarInfo(node); objectWriter.EmitDebugFunctionInfo(nodeContents.Data.Length); } } objectWriter.EmitDebugModuleInfo(); succeeded = true; } finally { objectWriter.Dispose(); if (!succeeded) { // If there was an exception while generating the OBJ file, make sure we don't leave the unfinished // object file around. try { File.Delete(objectFilePath); } catch { } } } }
public MethodCallDumper(IObjectDumper objectDumper) { this.objectDumper = objectDumper; }
static ArtifactObjectDumper() { Default = new ArtifactObjectDumper(new HtmlObjectVisitorFactory(), ServiceMessages.Default, Environment.GetEnvironmentVariable("CSharpRunner_ArtifactsPath")); }
public static void EmitObject(string objectFilePath, IEnumerable <DependencyNode> nodes, NodeFactory factory, IObjectDumper dumper) { ObjectWriter objectWriter = new ObjectWriter(objectFilePath, factory); bool succeeded = false; try { ObjectNodeSection managedCodeSection; if (factory.Target.OperatingSystem == TargetOS.Windows) { managedCodeSection = ObjectNodeSection.ManagedCodeWindowsContentSection; } else { managedCodeSection = ObjectNodeSection.ManagedCodeUnixContentSection; // TODO 2916: managed code section has to be created here, switch is not necessary. objectWriter.SetSection(ObjectNodeSection.ManagedCodeUnixContentSection); objectWriter.SetSection(LsdaSection); } objectWriter.SetCodeSectionAttribute(managedCodeSection); // Build file info map. objectWriter.BuildFileInfoMap(nodes); var listOfOffsets = new List <int>(); foreach (DependencyNode depNode in nodes) { ObjectNode node = depNode as ObjectNode; if (node == null) { continue; } if (node.ShouldSkipEmittingObjectNode(factory)) { continue; } ObjectData nodeContents = node.GetData(factory); if (dumper != null) { dumper.DumpObjectNode(factory.NameMangler, node, nodeContents); } #if DEBUG foreach (ISymbolNode definedSymbol in nodeContents.DefinedSymbols) { try { _previouslyWrittenNodeNames.Add(definedSymbol.GetMangledName(factory.NameMangler), definedSymbol); } catch (ArgumentException) { ISymbolNode alreadyWrittenSymbol = _previouslyWrittenNodeNames[definedSymbol.GetMangledName(factory.NameMangler)]; Debug.Fail("Duplicate node name emitted to file", $"Symbol {definedSymbol.GetMangledName(factory.NameMangler)} has already been written to the output object file {objectFilePath} with symbol {alreadyWrittenSymbol}"); } } #endif ObjectNodeSection section = node.Section; if (objectWriter.ShouldShareSymbol(node)) { section = objectWriter.GetSharedSection(section, ((ISymbolNode)node).GetMangledName(factory.NameMangler)); } // Ensure section and alignment for the node. objectWriter.SetSection(section); objectWriter.EmitAlignment(nodeContents.Alignment); objectWriter.ResetByteRunInterruptionOffsets(nodeContents.Relocs); // Build symbol definition map. objectWriter.BuildSymbolDefinitionMap(node, nodeContents.DefinedSymbols); // The DWARF CFI unwind is implemented for AMD64 & ARM32 only. TargetArchitecture tarch = factory.Target.Architecture; if (!factory.Target.IsWindows && (tarch == TargetArchitecture.X64 || tarch == TargetArchitecture.ARM)) { objectWriter.BuildCFIMap(factory, node); } // Build debug location map objectWriter.BuildDebugLocInfoMap(node); Relocation[] relocs = nodeContents.Relocs; int nextRelocOffset = -1; int nextRelocIndex = -1; if (relocs.Length > 0) { nextRelocOffset = relocs[0].Offset; nextRelocIndex = 0; } int i = 0; listOfOffsets.Clear(); listOfOffsets.AddRange(objectWriter._byteInterruptionOffsets); int offsetIndex = 0; while (i < nodeContents.Data.Length) { // Emit symbol definitions if necessary objectWriter.EmitSymbolDefinition(i); // Emit CFI codes for the given offset. objectWriter.EmitCFICodes(i); // Emit debug loc info if needed. objectWriter.EmitDebugLocInfo(i); if (i == nextRelocOffset) { Relocation reloc = relocs[nextRelocIndex]; long delta; unsafe { fixed(void *location = &nodeContents.Data[i]) { delta = Relocation.ReadValue(reloc.RelocType, location); } } int size = objectWriter.EmitSymbolReference(reloc.Target, (int)delta, reloc.RelocType); // Emit a copy of original Thumb2 instruction that came from RyuJIT if (reloc.RelocType == RelocType.IMAGE_REL_BASED_THUMB_MOV32 || reloc.RelocType == RelocType.IMAGE_REL_BASED_THUMB_BRANCH24) { unsafe { fixed(void *location = &nodeContents.Data[i]) { objectWriter.EmitBytes((IntPtr)location, size); } } } // Update nextRelocIndex/Offset if (++nextRelocIndex < relocs.Length) { nextRelocOffset = relocs[nextRelocIndex].Offset; } else { // This is the last reloc. Set the next reloc offset to -1 in case the last reloc has a zero size, // which means the reloc does not have vacant bytes corresponding to in the data buffer. E.g, // IMAGE_REL_THUMB_BRANCH24 is a kind of 24-bit reloc whose bits scatte over the instruction that // references it. We do not vacate extra bytes in the data buffer for this kind of reloc. nextRelocOffset = -1; } i += size; } else { while (offsetIndex < listOfOffsets.Count && listOfOffsets[offsetIndex] <= i) { offsetIndex++; } int nextOffset = offsetIndex == listOfOffsets.Count ? nodeContents.Data.Length : listOfOffsets[offsetIndex]; unsafe { // Todo: Use Span<T> instead once it's available to us in this repo fixed(byte *pContents = &nodeContents.Data[i]) { objectWriter.EmitBytes((IntPtr)(pContents), nextOffset - i); i += nextOffset - i; } } } } Debug.Assert(i == nodeContents.Data.Length); // It is possible to have a symbol just after all of the data. objectWriter.EmitSymbolDefinition(nodeContents.Data.Length); // Publish Windows unwind info. if (factory.Target.IsWindows) { objectWriter.PublishUnwindInfo(node); } // Emit the last CFI to close the frame. objectWriter.EmitCFICodes(nodeContents.Data.Length); if (objectWriter.HasFunctionDebugInfo()) { objectWriter.EmitDebugVarInfo(node); objectWriter.EmitDebugEHClauseInfo(node); objectWriter.EmitDebugFunctionInfo(node, nodeContents.Data.Length); } } objectWriter.EmitDebugModuleInfo(); succeeded = true; } finally { objectWriter.Dispose(); if (!succeeded) { // If there was an exception while generating the OBJ file, make sure we don't leave the unfinished // object file around. try { File.Delete(objectFilePath); } catch { } } } }
static DumpExtensions() { Dumper = ArtifactObjectDumper.Default; }
public SampleRunner(IObjectDumper dumper) { _objectDumper = dumper; }