Add glob filters support to disassembler to allow disassembling specific methods (#2072)

* make it possible to specify filters for the disassembler via --disasmFilter and attribute

* implement support for ClrMD v2

* implement support for ClrMD v1

* add test

Author: adamsitnik

src/BenchmarkDotNet.Disassembler.x64/ClrMdV1Disassembler.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text.RegularExpressions;
 
 namespace BenchmarkDotNet.Disassemblers
 {
@@ -26,13 +27,20 @@ internal static DisassemblyResult AttachAndDisassemble(Settings settings)
 
                 var state = new State(runtime);
 
-                var typeWithBenchmark = state.Runtime.Heap.GetTypeByName(settings.TypeName);
+                if (settings.Filters.Length > 0)
+                {
+                    FilterAndEnqueue(state, settings);
+                }
+                else
+                {
+                    var typeWithBenchmark = state.Runtime.Heap.GetTypeByName(settings.TypeName);
 
-                state.Todo.Enqueue(
-                    new MethodInfo(
-                        // the Disassembler Entry Method is always parameterless, so check by name is enough
-                        typeWithBenchmark.Methods.Single(method => method.IsPublic && method.Name == settings.MethodName),
-                        0));
+                    state.Todo.Enqueue(
+                        new MethodInfo(
+                            // the Disassembler Entry Method is always parameterless, so check by name is enough
+                            typeWithBenchmark.Methods.Single(method => method.IsPublic && method.Name == settings.MethodName),
+                            0));
+                }
 
                 var disassembledMethods = Disassemble(settings, state);
 
@@ -59,6 +67,28 @@ private static void ConfigureSymbols(DataTarget dataTarget)
             control?.Execute(DEBUG_OUTCTL.NOT_LOGGED, ".reload", DEBUG_EXECUTE.NOT_LOGGED);
         }
 
+        private static void FilterAndEnqueue(State state, Settings settings)
+        {
+            Regex[] filters = settings.Filters
+                .Select(pattern => new Regex(WildcardToRegex(pattern), RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)).ToArray();
+
+            foreach (ClrModule module in state.Runtime.Modules)
+                foreach (ClrType type in module.EnumerateTypes())
+                    foreach (ClrMethod method in type.Methods.Where(method => CanBeDisassembled(method) && method.GetFullSignature() != null))
+                        foreach (Regex filter in filters)
+                        {
+                            if (filter.IsMatch(method.GetFullSignature()))
+                            {
+                                state.Todo.Enqueue(new MethodInfo(method,
+                                    depth: settings.MaxDepth)); // don't allow for recursive disassembling
+                                break;
+                            }
+                        }
+        }
+
+        // copied from GlobFilter type (this type must not reference BDN)
+        private static string WildcardToRegex(string pattern) => $"^{Regex.Escape(pattern).Replace(@"\*", ".*").Replace(@"\?", ".")}$";
+
         private static DisassembledMethod[] Disassemble(Settings settings, State state)
         {
             var result = new List<DisassembledMethod>();
@@ -77,11 +107,14 @@ private static DisassembledMethod[] Disassemble(Settings settings, State state)
             return result.ToArray();
         }
 
+        private static bool CanBeDisassembled(ClrMethod method)
+            => !((method.ILOffsetMap is null || method.ILOffsetMap.Length == 0) && (method.HotColdInfo is null || method.HotColdInfo.HotStart == 0 || method.HotColdInfo.HotSize == 0));
+
         private static DisassembledMethod DisassembleMethod(MethodInfo methodInfo, State state, Settings settings)
         {
             var method = methodInfo.Method;
 
-            if ((method.ILOffsetMap is null || method.ILOffsetMap.Length == 0) && (method.HotColdInfo is null || method.HotColdInfo.HotStart == 0 || method.HotColdInfo.HotSize == 0))
+            if (!CanBeDisassembled(method))
             {
                 if (method.IsPInvoke)
                     return CreateEmpty(method, "PInvoke method");

src/BenchmarkDotNet.Disassembler.x64/DataContracts.cs

@@ -101,21 +101,23 @@ public static class DisassemblerConstants
 
     internal class Settings
     {
-        internal Settings(int processId, string typeName, string methodName, bool printSource, int maxDepth, string resultsPath)
+        internal Settings(int processId, string typeName, string methodName, bool printSource, int maxDepth, string resultsPath, string[] filters)
         {
             ProcessId = processId;
             TypeName = typeName;
             MethodName = methodName;
             PrintSource = printSource;
             MaxDepth = methodName == DisassemblerConstants.DisassemblerEntryMethodName && maxDepth != int.MaxValue ? maxDepth + 1 : maxDepth;
             ResultsPath = resultsPath;
+            Filters = filters;
         }
 
         internal int ProcessId { get; }
         internal string TypeName { get; }
         internal string MethodName { get; }
         internal bool PrintSource { get; }
         internal int MaxDepth { get; }
+        internal string[] Filters;
         internal string ResultsPath { get; }
 
         internal static Settings FromArgs(string[] args)
@@ -125,7 +127,8 @@ internal static Settings FromArgs(string[] args)
                 methodName: args[2],
                 printSource: bool.Parse(args[3]),
                 maxDepth: int.Parse(args[4]),
-                resultsPath: args[5]
+                resultsPath: args[5],
+                filters: args.Skip(6).ToArray()
             );
     }
 

src/BenchmarkDotNet/Attributes/DisassemblyDiagnoserAttribute.cs

@@ -14,19 +14,22 @@ public class DisassemblyDiagnoserAttribute : Attribute, IConfigSource
         /// <param name="exportHtml">Exports to HTML with clickable links. False by default.</param>
         /// <param name="exportCombinedDisassemblyReport">Exports all benchmarks to a single HTML report. Makes it easy to compare different runtimes or methods (each becomes a column in HTML table).</param>
         /// <param name="exportDiff">Exports a diff of the assembly code to the Github markdown format. False by default.</param>
+        /// <param name="filters">Glob patterns applied to full method signatures by the the disassembler.</param>
         public DisassemblyDiagnoserAttribute(
             int maxDepth = 1,
             bool printSource = false,
             bool printInstructionAddresses = false,
             bool exportGithubMarkdown = true,
             bool exportHtml = false,
             bool exportCombinedDisassemblyReport = false,
-            bool exportDiff = false)
+            bool exportDiff = false,
+            params string[] filters)
         {
             Config = ManualConfig.CreateEmpty().AddDiagnoser(
                 new DisassemblyDiagnoser(
                     new DisassemblyDiagnoserConfig(
                         maxDepth: maxDepth,
+                        filters: filters,
                         printSource: printSource,
                         printInstructionAddresses: printInstructionAddresses,
                         exportGithubMarkdown: exportGithubMarkdown,
@@ -35,6 +38,14 @@ public DisassemblyDiagnoserAttribute(
                         exportDiff: exportDiff)));
         }
 
+        // CLS-Compliant Code requires a constructor without an array in the argument list
+        protected DisassemblyDiagnoserAttribute()
+        {
+            Config = ManualConfig.CreateEmpty().AddDiagnoser(
+                new DisassemblyDiagnoser(
+                    new DisassemblyDiagnoserConfig()));
+        }
+
         public IConfig Config { get; }
     }
 }

src/BenchmarkDotNet/ConsoleArguments/CommandLineOptions.cs

@@ -148,6 +148,9 @@ public class CommandLineOptions
         [Option("disasmDepth", Required = false, Default = 1, HelpText = "Sets the recursive depth for the disassembler.")]
         public int DisassemblerRecursiveDepth { get; set; }
 
+        [Option("disasmFilter", Required = false, HelpText = "Glob patterns applied to full method signatures by the the disassembler.")]
+        public IEnumerable<string> DisassemblerFilters { get; set; }
+
         [Option("disasmDiff", Required = false, Default = false, HelpText = "Generates diff reports for the disassembler.")]
         public bool DisassemblerDiff { get; set; }
 

src/BenchmarkDotNet/ConsoleArguments/ConfigParser.cs

@@ -214,7 +214,10 @@ private static IConfig CreateConfig(CommandLineOptions options, IConfig globalCo
             if (options.UseThreadingDiagnoser)
                 config.AddDiagnoser(ThreadingDiagnoser.Default);
             if (options.UseDisassemblyDiagnoser)
-                config.AddDiagnoser(new DisassemblyDiagnoser(new DisassemblyDiagnoserConfig(maxDepth: options.DisassemblerRecursiveDepth, exportDiff: options.DisassemblerDiff)));
+                config.AddDiagnoser(new DisassemblyDiagnoser(new DisassemblyDiagnoserConfig(
+                    maxDepth: options.DisassemblerRecursiveDepth,
+                    filters: options.DisassemblerFilters.ToArray(),
+                    exportDiff: options.DisassemblerDiff)));
             if (!string.IsNullOrEmpty(options.Profiler))
                 config.AddDiagnoser(DiagnosersLoader.GetImplementation<IProfiler>(profiler => profiler.ShortName.EqualsWithIgnoreCase(options.Profiler)));
 

src/BenchmarkDotNet/Disassemblers/ClrMdV2Disassembler.cs

@@ -1,8 +1,10 @@
-using Iced.Intel;
+using BenchmarkDotNet.Filters;
+using Iced.Intel;
 using Microsoft.Diagnostics.Runtime;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text.RegularExpressions;
 
 namespace BenchmarkDotNet.Disassemblers
 {
@@ -21,13 +23,20 @@ internal static DisassemblyResult AttachAndDisassemble(Settings settings)
 
                 var state = new State(runtime);
 
-                var typeWithBenchmark = state.Runtime.EnumerateModules().Select(module => module.GetTypeByName(settings.TypeName)).First(type => type != null);
+                if (settings.Filters.Length > 0)
+                {
+                    FilterAndEnqueue(state, settings);
+                }
+                else
+                {
+                    ClrType typeWithBenchmark = state.Runtime.EnumerateModules().Select(module => module.GetTypeByName(settings.TypeName)).First(type => type != null);
 
-                state.Todo.Enqueue(
-                    new MethodInfo(
-                        // the Disassembler Entry Method is always parameterless, so check by name is enough
-                        typeWithBenchmark.Methods.Single(method => method.IsPublic && method.Name == settings.MethodName),
-                        0));
+                    state.Todo.Enqueue(
+                        new MethodInfo(
+                            // the Disassembler Entry Method is always parameterless, so check by name is enough
+                            typeWithBenchmark.Methods.Single(method => method.IsPublic && method.Name == settings.MethodName),
+                            0));
+                }
 
                 var disassembledMethods = Disassemble(settings, state);
 
@@ -51,6 +60,24 @@ private static void ConfigureSymbols(DataTarget dataTarget)
             dataTarget.SetSymbolPath("http://msdl.microsoft.com/download/symbols");
         }
 
+        private static void FilterAndEnqueue(State state, Settings settings)
+        {
+            Regex[] filters = GlobFilter.ToRegex(settings.Filters);
+
+            foreach (ClrModule module in state.Runtime.EnumerateModules())
+                foreach (ClrType type in module.EnumerateTypeDefToMethodTableMap().Select(map => state.Runtime.GetTypeByMethodTable(map.MethodTable)).Where(type => type is not null))
+                    foreach (ClrMethod method in type.Methods.Where(method => CanBeDisassembled(method) && method.Signature != null))
+                        foreach (Regex filter in filters)
+                        {
+                            if (filter.IsMatch(method.Signature))
+                            {
+                                state.Todo.Enqueue(new MethodInfo(method,
+                                    depth: settings.MaxDepth)); // don't allow for recursive disassembling
+                                break;
+                            }
+                        }
+        }
+
         private static DisassembledMethod[] Disassemble(Settings settings, State state)
         {
             var result = new List<DisassembledMethod>();
@@ -69,11 +96,14 @@ private static DisassembledMethod[] Disassemble(Settings settings, State state)
             return result.ToArray();
         }
 
+        private static bool CanBeDisassembled(ClrMethod method)
+            => !(method.ILOffsetMap.Length == 0 && (method.HotColdInfo.HotStart == 0 || method.HotColdInfo.HotSize == 0));
+
         private static DisassembledMethod DisassembleMethod(MethodInfo methodInfo, State state, Settings settings)
         {
             var method = methodInfo.Method;
 
-            if (method.ILOffsetMap.Length == 0 && (method.HotColdInfo.HotStart == 0 || method.HotColdInfo.HotSize == 0))
+            if (!CanBeDisassembled(method))
             {
                 if (method.IsPInvoke)
                     return CreateEmpty(method, "PInvoke method");

src/BenchmarkDotNet/Disassemblers/DisassemblyDiagnoserConfig.cs

@@ -1,13 +1,15 @@
 using BenchmarkDotNet.Disassemblers.Exporters;
 using Iced.Intel;
 using JetBrains.Annotations;
+using System;
 using System.Collections.Generic;
 
 namespace BenchmarkDotNet.Diagnosers
 {
     public class DisassemblyDiagnoserConfig
     {
         /// <param name="maxDepth">Includes called methods to given level. 1 by default, indexed from 1. To print just the benchmark set it to 0.</param>
+        /// <param name="filters">Glob patterns applied to full method signatures by the the disassembler.</param>
         /// <param name="formatter">Assembly code formatter. If not provided, MasmFormatter with the recommended settings will be used.</param>
         /// <param name="printSource">C#|F#|VB source code will be printed. False by default.</param>
         /// <param name="printInstructionAddresses">Print instruction addresses. False by default</param>
@@ -18,6 +20,7 @@ public class DisassemblyDiagnoserConfig
         [PublicAPI]
         public DisassemblyDiagnoserConfig(
             int maxDepth = 1,
+            string[] filters = null,
             Formatter formatter = null,
             bool printSource = false,
             bool printInstructionAddresses = false,
@@ -27,6 +30,7 @@ public DisassemblyDiagnoserConfig(
             bool exportDiff = false)
         {
             MaxDepth = maxDepth;
+            Filters = filters ?? Array.Empty<string>();
             Formatter = formatter ?? CreateDefaultFormatter();
             PrintSource = printSource;
             PrintInstructionAddresses = printInstructionAddresses;
@@ -39,6 +43,7 @@ public DisassemblyDiagnoserConfig(
         public bool PrintSource { get; }
         public bool PrintInstructionAddresses { get; }
         public int MaxDepth { get; }
+        public string[] Filters { get; }
         public bool ExportGithubMarkdown { get; }
         public bool ExportHtml { get; }
         public bool ExportCombinedDisassemblyReport { get; }

src/BenchmarkDotNet/Disassemblers/LinuxDisassembler.cs renamed to src/BenchmarkDotNet/Disassemblers/SameArchitectureDisassembler.cs

@@ -18,6 +18,7 @@ private Settings BuildDisassemblerSettings(DiagnoserActionParameters parameters)
                 methodName: DisassemblerConstants.DisassemblerEntryMethodName,
                 printSource: config.PrintSource,
                 maxDepth: config.MaxDepth,
+                filters: config.Filters,
                 resultsPath: default
             );
     }

src/BenchmarkDotNet/Disassemblers/WindowsDisassembler.cs

@@ -141,9 +141,13 @@ private string BuildArguments(DiagnoserActionParameters parameters, string resul
                 .Append(DisassemblerConstants.DisassemblerEntryMethodName).Append(' ')
                 .Append(config.PrintSource).Append(' ')
                 .Append(config.MaxDepth).Append(' ')
-                .Append($"\"{resultsPath}\"")
+                .Append(Escape(resultsPath))
+                .Append(' ')
+                .Append(string.Join(" ", config.Filters.Select(Escape)))
                 .ToString();
 
+        private static string Escape(string value) => $"\"{value}\"";
+
         // code copied from https://stackoverflow.com/a/33206186/5852046
         private static class NativeMethods
         {

src/BenchmarkDotNet/Filters/GlobFilter.cs

@@ -9,19 +9,21 @@ namespace BenchmarkDotNet.Filters
     /// </summary>
     public class GlobFilter : IFilter
     {
-        private readonly (string userValue, Regex regex)[] patterns;
+        private readonly Regex[] patterns;
 
-        public GlobFilter(string[] patterns)
-            => this.patterns = patterns.Select(pattern => (pattern, new Regex(WildcardToRegex(pattern), RegexOptions.IgnoreCase | RegexOptions.CultureInvariant))).ToArray();
+        public GlobFilter(string[] patterns) => this.patterns = ToRegex(patterns);
 
         public bool Predicate(BenchmarkCase benchmarkCase)
         {
             var benchmark = benchmarkCase.Descriptor.WorkloadMethod;
             string fullBenchmarkName = benchmarkCase.Descriptor.GetFilterName();
 
-            return patterns.Any(pattern => pattern.regex.IsMatch(fullBenchmarkName));
+            return patterns.Any(pattern => pattern.IsMatch(fullBenchmarkName));
         }
 
+        internal static Regex[] ToRegex(string[] patterns)
+            => patterns.Select(pattern => new Regex(WildcardToRegex(pattern), RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)).ToArray();
+
         // https://stackoverflow.com/a/6907849/5852046 not perfect but should work for all we need
         private static string WildcardToRegex(string pattern) => $"^{Regex.Escape(pattern).Replace(@"\*", ".*").Replace(@"\?", ".")}$";
     }