checkpoint

dotnet · lambdageek · Apr 19, 2024 · Mar 28, 2024 · Mar 28, 2024 · Apr 1, 2024
commit 8518e9fbd8dfce811b838ba459c0155fd9c75413
diff --git a/src/coreclr/tools/cdac-build-tool/ObjectFileScraper.cs b/src/coreclr/tools/cdac-build-tool/ObjectFileScraper.cs
@@ -0,0 +1,91 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Buffers.Binary;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.DotNet.Diagnostics.DataContract.BuildTool;
+
+public class ObjectFileScraper
+{
+    public readonly ReadOnlyMemory<byte> MagicLE = new byte[4]{0x01, 0x02, 0x03, 0x4};
+    public readonly ReadOnlyMemory<byte> MagicBE = new byte[4]{0x04, 0x03, 0x02, 0x1};
+
+    public bool Verbose {get;}
+    public ObjectFileScraper(bool verbose) {
+        Verbose = verbose;
+    }
+
+    public async Task<bool> ScrapeInput(string inputPath, CancellationToken token)
+    {
+        using var file = File.Open(inputPath, FileMode.Open, FileAccess.Read, FileShare.Read);
+        var r = await FindMagic(file, token);
+
+        if (!r.Found){
+            return false;
+        }
+        if (Verbose) {
+            Console.WriteLine ($"{inputPath}: magic at {r.Position}");
+        }
+        file.Seek(r.Position, SeekOrigin.Begin);
+        var header = ReadHeader(file, r.LittleEndian);
+        if (Verbose) {
+            Console.WriteLine ($"{inputPath}: {header}");
+        }
+        return true;
+    }
+
+    struct MagicResult {
+        public bool Found {get; init;}
+        public long Position {get; init;}
+        public bool LittleEndian {get; init;}
+    }
+
+    private async Task<MagicResult> FindMagic(Stream stream, CancellationToken token)
+    {
+        var buf = new byte[4096];
+        long pos = stream.Position;
+        while (true) {
+            token.ThrowIfCancellationRequested();
+            int bytesRead = await stream.ReadAsync(buf, 0, buf.Length, token);
+            if (bytesRead == 0)
+                return new (){Found = false, Position = 0, LittleEndian = true};
+            // FIXME: what if magic spans a buffer boundary
+            if (FindMagic(buf, out int offset, out bool isLittleEndian)) {
+                pos += (long)offset;
+                return new (){Found = true, Position = pos, LittleEndian = isLittleEndian};
+            }
+            pos += bytesRead;
+        }
+    }
+
+    private bool FindMagic(ReadOnlySpan<byte> buffer, out int offset, out bool isLittleEndian)
+    {
+        int start = buffer.IndexOf(MagicLE.Span);
+        if (start != -1)
+        {
+            offset = start;
+            isLittleEndian = true;
+            return true;
+        }
+        start = buffer.IndexOf(MagicBE.Span);
+        if (start != -1)
+        {
+            offset = start;
+            isLittleEndian = false;
+            return true;
+        }
+        offset = 0;
+        isLittleEndian = false;
+        return false;
+    }
+
+    private string ReadHeader(Stream stream, bool isLittleEndian)
+    {
+        return "TODO: read a header";
+    }
+
+}
diff --git a/src/coreclr/tools/cdac-build-tool/Program.cs b/src/coreclr/tools/cdac-build-tool/Program.cs
@@ -0,0 +1,76 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.CommandLine.Help;
+using System.CommandLine.Parsing;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Metadata;
+using System.Reflection.Metadata.Ecma335;
+using System.Reflection.PortableExecutable;
+using System.Runtime.Serialization.Json;
+using System.Text;
+using System.Text.Json;
+using System.Text.Encodings.Web;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+
+
+namespace Microsoft.DotNet.Diagnostics.DataContract.BuildTool;
+
+public class Program
+{
+    internal class ComposeCommand : CliCommand
+    {
+        private readonly CliArgument<string[]> inputFiles = new ("INPUT [INPUTS...]") { Arity = ArgumentArity.OneOrMore, Description="One or more input files" };
+        private readonly CliOption<string> outputFile = new ("-o") { Arity = ArgumentArity.ExactlyOne, HelpName="OUTPUT", Required = true, Description = "Output file" };
+        private readonly CliOption<bool> _verboseOption;
+        public ComposeCommand (CliOption<bool> verboseOption) : base("compose")
+        {
+            _verboseOption = verboseOption;
+            Add(inputFiles);
+            Add(outputFile);
+            SetAction(Run);
+        }
+
+
+        private async Task<int> Run(ParseResult parse, CancellationToken token = default)
+        {
+            var inputs = parse.GetValue(inputFiles);
+            var output = parse.GetValue(outputFile);
+            var verbose = parse.GetValue(_verboseOption);
+            var scraper = new ObjectFileScraper(verbose);
+            foreach (var input in inputs) {
+                token.ThrowIfCancellationRequested();
+                if (!await scraper.ScrapeInput(input, token)) {
+                    Console.Error.WriteLine ($"could not scrape payload in {input}");
+                    return 1;
+                }
+            }
+            //var model = await scraper.BuildModel(token);
+            //using var modelWriter = new ModelWriter(output);
+            //await modelWriter.Write(model, token);
+            return 0;
+        }
+    }
+
+    public static async Task<int> Main(string[] args)
+    {
+        CliRootCommand rootCommand = new ();
+        var verboseOption = new CliOption<bool>("-v", "--verbose") {Recursive = true, Description = "Verbose"};
+        rootCommand.Add(verboseOption);
+        rootCommand.Add(new DiagramDirective());
+        rootCommand.Add(new ComposeCommand(verboseOption));
+        return await rootCommand.Parse(args).InvokeAsync();
+    }
+}
diff --git a/src/coreclr/tools/cdac-build-tool/cdac-build-tool.csproj b/src/coreclr/tools/cdac-build-tool/cdac-build-tool.csproj
@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <AssemblyName>cdac-build-tool</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <TargetFramework>$(NetCoreAppToolCurrent)</TargetFramework>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <OutputPath>$(RuntimeBinDir)/cdac-build-tool</OutputPath>
+    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
+    <EnableDefaultEmbeddedResourceItems>false</EnableDefaultEmbeddedResourceItems>
+    <IsPackable>true</IsPackable>
+    <PackAsTool>true</PackAsTool>
+    <ToolCommandName>cdac-build-tool</ToolCommandName>
+    <PackagedShimOutputRootDirectory>$(OutputPath)</PackagedShimOutputRootDirectory>
+    <IsShipping>false</IsShipping> <!-- This tool is an implementatino detail of the build process, it does not ship -->
+    <Description>.NET runtime data contract build tool</Description>
+    <PackageTags>Diagnostics</PackageTags>
+    <PackageReleaseNotes>$(Description)</PackageReleaseNotes>
+    <RootNamespace>Microsoft.DotNet.Diagnostics.DataContract</RootNamespace>
+    <RollForward>Major</RollForward>
+    <RunAnalyzers>false</RunAnalyzers>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="System.CommandLine" Version="$(SystemCommandLineVersion)" />
+  </ItemGroup>
+</Project>