JIT: Simplify JitDisasm matching behavior and support namespaces/generics in release

docs/design/coreclr/jit/viewing-jit-dumps.md

@@ -120,29 +120,31 @@ These can be set in one of three ways:
 
 ## Specifying method names
 
-The complete syntax for specifying a single method name (for a flag that takes a method name, such as `COMPlus_JitDump`) is:
+Some environment variables such as `COMPlus_JitDump` take a set of patterns specifying method names. The matching works in the following way:
+* The environment variable is a space-separated list of patterns that can be quoted if they need to contain spaces.
+* Patterns can contain * and ? wildcards matching respectively any characters and any 1 character.
+* If the pattern contains a : character, then the string matched against is prefixed with `ClassName:`.
+* If the patter ncontains a ( character, then the string matched against is suffixed with its signature.
 
+In particular, the matching is done against strings of the following format which coincides with how the JIT displays method signatures:
 ```
-[[<Namespace>.]<ClassName>::]<MethodName>[([<types>)]
+[<ClassName>:]<MethodName>[([<types>)]
 ```
 
-For example
+In debug builds the class name is allowed to contain the namespace as well and the JIT will try to match both with and without the namespace.
 
-```
-System.Object::ToString(System.Object)
-```
-
-The namespace, class name, and argument types are optional, and if they are not present, default to a wildcard. Thus stating:
-
-```
-Main
-```
-
-will match all methods named Main from any class and any number of arguments.
+The following are equivalent:
+* `WriteLine`
+* `*:WriteLine`
+* `*:WriteLine(*)`
 
-`<types>` is a comma separated list of type names. Note that presently only the number of arguments and not the types themselves are used to distinguish methods. Thus, `Main(Foo, Bar)` and `Main(int, int)` will both match any main method with two arguments.
+So are the following:
+* `*`
+* `*:*`
+* `*:*(*)`
 
-The wildcard character `*` can be used for `<ClassName>` and `<MethodName>`. In particular `*` by itself indicates every method.
+The following will only match the string overload of `Console.WriteLine`:
+* `Console:WriteLine(String)`
 
 ## Useful COMPlus variables
 

src/coreclr/jit/compiler.cpp

@@ -2879,7 +2879,7 @@ void Compiler::compInitOptions(JitFlags* jitFlags)
                 opts.disAsm = true;
             }
 
-            if (JitConfig.JitDisasm().contains("SPILLED", nullptr, nullptr))
+            if (JitConfig.JitDisasmSpilled())
             {
                 opts.disAsmSpilled = true;
             }
@@ -3017,8 +3017,9 @@ void Compiler::compInitOptions(JitFlags* jitFlags)
 #else  // DEBUG
     if (!JitConfig.JitDisasm().isEmpty())
     {
-        const char* methodName = info.compCompHnd->getMethodName(info.compMethodHnd, nullptr);
-        const char* className  = info.compCompHnd->getClassName(info.compClassHnd);
+        const char* className;
+        const char* methodName = info.compCompHnd->getMethodName(info.compMethodHnd, &className);
+
         if (JitConfig.JitDisasm().contains(methodName, className, &info.compMethodInfo->args))
         {
             opts.disAsm = true;

src/coreclr/jit/compiler.h

@@ -7562,6 +7562,14 @@ class Compiler
 
     var_types eeGetFieldType(CORINFO_FIELD_HANDLE fldHnd, CORINFO_CLASS_HANDLE* pStructHnd = nullptr);
 
+    void eeFormatMethodName(char**            buffer,
+                            size_t            bufferMax,
+                            const char*       className,
+                            const char*       methodName,
+                            CORINFO_SIG_INFO* sig,
+                            bool              includeReturnType,
+                            bool              includeThis);
+
 #if defined(DEBUG) || defined(FEATURE_JIT_METHOD_PERF) || defined(FEATURE_SIMD) || defined(TRACK_LSRA_STATS)
 
     const char* eeGetMethodName(CORINFO_METHOD_HANDLE hnd, const char** className);