Miscellaneous R2RDump improvements (dotnet/coreclr#23215)

1) In Naked mode, hide the distinction amongst METHOD_ENTRY vs.
METHOD_ENTRY_REF_TOKEN vs. METHOD_ENTRY_DEF_TOKEN as it's not
important for correctness and causes undesirable churn in diffs.
This required propagating the DumpOptions around in a couple
of places.

2) For historical reasons, the DisassemblingTypeProvider had
its own implementations of metadata formatting that is now provided
by MetadataNameFormatter. I have removed at least a part of this
duplication in this change. [It was causing undesirable diffs as
one version used to output type owner assemblies whereas the other
did not.]

Thanks

Tomas

Commit migrated from https://github.com/dotnet/coreclr/commit/368639e46a903b6ff44a21d67b0e0fea661c91d7

src/coreclr/src/tools/r2rdump/DisassemblingTypeProvider.cs

@@ -34,51 +34,17 @@ public virtual string GetPrimitiveType(PrimitiveTypeCode typeCode)
 
         public virtual string GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind = 0)
         {
-            TypeDefinition definition = reader.GetTypeDefinition(handle);
-
-            string name = definition.Namespace.IsNil
-                ? reader.GetString(definition.Name)
-                : reader.GetString(definition.Namespace) + "." + reader.GetString(definition.Name);
-
-            if ((definition.Attributes & TypeAttributes.NestedPublic) != 0 || (definition.Attributes & TypeAttributes.NestedFamily) != 0)
-            {
-                TypeDefinitionHandle declaringTypeHandle = definition.GetDeclaringType();
-                return GetTypeFromDefinition(reader, declaringTypeHandle, 0) + "." + name;
-            }
-
-            return name;
+            return MetadataNameFormatter.FormatHandle(reader, handle);
         }
 
         public virtual string GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind = 0)
         {
-            TypeReference reference = reader.GetTypeReference(handle);
-            Handle scope = reference.ResolutionScope;
-
-            string name = reference.Namespace.IsNil
-                ? reader.GetString(reference.Name)
-                : reader.GetString(reference.Namespace) + "." + reader.GetString(reference.Name);
-
-            switch (scope.Kind)
-            {
-                case HandleKind.ModuleReference:
-                    return "[.module  " + reader.GetString(reader.GetModuleReference((ModuleReferenceHandle)scope).Name) + "]" + name;
-
-                case HandleKind.AssemblyReference:
-                    var assemblyReferenceHandle = (AssemblyReferenceHandle)scope;
-                    var assemblyReference = reader.GetAssemblyReference(assemblyReferenceHandle);
-                    return "[" + reader.GetString(assemblyReference.Name) + "]" + name;
-
-                case HandleKind.TypeReference:
-                    return GetTypeFromReference(reader, (TypeReferenceHandle)scope) + "+" + name;
-
-                default:
-                    return name;
-            }
+            return MetadataNameFormatter.FormatHandle(reader, handle);
         }
 
         public virtual string GetTypeFromSpecification(MetadataReader reader, DisassemblingGenericContext genericContext, TypeSpecificationHandle handle, byte rawTypeKind = 0)
         {
-            return reader.GetTypeSpecification(handle).DecodeSignature(this, genericContext);
+            return MetadataNameFormatter.FormatHandle(reader, handle);
         }
 
         public virtual string GetSZArrayType(string elementType)
@@ -161,20 +127,7 @@ public virtual string GetArrayType(string elementType, ArrayShape shape)
 
         public virtual string GetTypeFromHandle(MetadataReader reader, DisassemblingGenericContext genericContext, EntityHandle handle)
         {
-            switch (handle.Kind)
-            {
-                case HandleKind.TypeDefinition:
-                    return GetTypeFromDefinition(reader, (TypeDefinitionHandle)handle);
-
-                case HandleKind.TypeReference:
-                    return GetTypeFromReference(reader, (TypeReferenceHandle)handle);
-
-                case HandleKind.TypeSpecification:
-                    return GetTypeFromSpecification(reader, genericContext, (TypeSpecificationHandle)handle);
-
-                default:
-                    throw new ArgumentOutOfRangeException(nameof(handle));
-            }
+            return MetadataNameFormatter.FormatHandle(reader, handle);
         }
 
         public virtual string GetModifiedType(string modifierType, string unmodifiedType, bool isRequired)

src/coreclr/src/tools/r2rdump/R2RDump.cs

@@ -449,7 +449,7 @@ private int Run(string[] args)
                 foreach (string filename in _inputFilenames)
                 {
                     // parse the ReadyToRun image
-                    R2RReader r2r = new R2RReader(filename);
+                    R2RReader r2r = new R2RReader(_options, filename);
 
                     if (_options.Disasm)
                     {

src/coreclr/src/tools/r2rdump/R2RReader.cs

@@ -77,6 +77,11 @@ public InstanceMethod(byte bucket, R2RMethod method)
 
     public class R2RReader
     {
+        /// <summary>
+        /// Option are used to specify details of signature formatting.
+        /// </summary>
+        public readonly DumpOptions Options;
+
         /// <summary>
         /// Underlying PE image reader is used to access raw PE structures like header
         /// or section list.
@@ -178,8 +183,9 @@ public class R2RReader
         /// </summary>
         /// <param name="filename">PE image</param>
         /// <exception cref="BadImageFormatException">The Cor header flag must be ILLibrary</exception>
-        public unsafe R2RReader(string filename)
+        public unsafe R2RReader(DumpOptions options, string filename)
         {
+            Options = options;
             Filename = filename;
             Image = File.ReadAllBytes(filename);
 
@@ -370,7 +376,7 @@ private void ParseInstanceMethodEntrypoints(bool[] isEntryPoint)
             NativeParser curParser = allEntriesEnum.GetNext();
             while (!curParser.IsNull())
             {
-                SignatureDecoder decoder = new SignatureDecoder(this, (int)curParser.Offset);
+                SignatureDecoder decoder = new SignatureDecoder(Options, this, (int)curParser.Offset);
 
                 string owningType = null;
 
@@ -634,7 +640,7 @@ private void ParseImportSections()
                     long section = NativeReader.ReadInt64(Image, ref sectionOffset);
                     uint sigRva = NativeReader.ReadUInt32(Image, ref signatureOffset);
                     int sigOffset = GetOffset((int)sigRva);
-                    string cellName = MetadataNameFormatter.FormatSignature(this, sigOffset);
+                    string cellName = MetadataNameFormatter.FormatSignature(Options, this, sigOffset);
                     entries.Add(new R2RImportSection.ImportSectionEntry(entries.Count, entryOffset, entryOffset + rva, section, sigRva, cellName));
                     ImportCellNames.Add(rva + entrySize * i, cellName);
                 }

src/coreclr/src/tools/r2rdump/R2RSignature.cs

@@ -41,9 +41,9 @@ public static string FormatHandle(MetadataReader metadataReader, Handle handle,
             return formatter.EmitHandleName(handle, namespaceQualified, owningTypeOverride);
         }
 
-        public static string FormatSignature(R2RReader r2rReader, int imageOffset)
+        public static string FormatSignature(DumpOptions options, R2RReader r2rReader, int imageOffset)
         {
-            SignatureDecoder decoder = new SignatureDecoder(r2rReader, imageOffset);
+            SignatureDecoder decoder = new SignatureDecoder(options, r2rReader, imageOffset);
             string result = decoder.ReadR2RSignature();
             return result;
         }
@@ -142,7 +142,7 @@ private string EmitMethodDefinitionName(MethodDefinitionHandle methodDefinitionH
             builder.Append(" ");
             if (owningTypeOverride == null)
             {
-                owningTypeOverride = EmitHandleName(methodDef.GetDeclaringType(), namespaceQualified: false, owningTypeOverride: null);
+                owningTypeOverride = EmitHandleName(methodDef.GetDeclaringType(), namespaceQualified: true, owningTypeOverride: null);
             }
             builder.Append(owningTypeOverride);
             builder.Append(".");
@@ -295,6 +295,11 @@ public class SignatureDecoder
         /// </summary>
         private readonly MetadataReader _metadataReader;
 
+        /// <summary>
+        /// Dump options are used to specify details of signature formatting.
+        /// </summary>
+        private readonly DumpOptions _options;
+
         /// <summary>
         /// Byte array representing the R2R PE file read from disk.
         /// </summary>
@@ -315,10 +320,12 @@ public class SignatureDecoder
         /// </summary>
         /// <param name="reader">R2RReader object representing the R2R PE file</param>
         /// <param name="offset">Signature offset within the array</param>
-        public SignatureDecoder(R2RReader reader, int offset)
+        /// <param name="options">Formatting options</param>
+        public SignatureDecoder(DumpOptions options, R2RReader reader, int offset)
         {
-            _image = reader.Image;
             _metadataReader = reader.MetadataReader;
+            _options = options;
+            _image = reader.Image;
             _offset = offset;
         }
 
@@ -328,10 +335,11 @@ public SignatureDecoder(R2RReader reader, int offset)
         /// <param name="metadataReader">Metadata reader for the R2R image</param>
         /// <param name="signature">Signature to parse</param>
         /// <param name="offset">Optional signature offset within the signature byte array, 0 by default</param>
-        public SignatureDecoder(MetadataReader metadataReader, byte[] signature, int offset = 0)
+        public SignatureDecoder(DumpOptions options, MetadataReader metadataReader, byte[] signature, int offset = 0)
         {
-            _image = signature;
             _metadataReader = metadataReader;
+            _options = options;
+            _image = signature;
             _offset = offset;
         }
 
@@ -516,12 +524,14 @@ private void ParseSignature(StringBuilder builder)
                     {
                         ParseMethodDefToken(builder, owningTypeOverride: null);
                     }
-                    builder.Append(" (METHOD_ENTRY_DEF_TOKEN)");
+                    builder.Append(" (METHOD_ENTRY");
+                    builder.Append(_options.Naked ? ")" : "_DEF_TOKEN)");
                     break;
 
                 case ReadyToRunFixupKind.READYTORUN_FIXUP_MethodEntry_RefToken:
                     ParseMethodRefToken(builder, owningTypeOverride: null);
-                    builder.Append(" (METHOD_ENTRY_REF_TOKEN)");
+                    builder.Append(" (METHOD_ENTRY");
+                    builder.Append(_options.Naked ? ")" : "_REF_TOKEN)");
                     break;
 
 
@@ -535,12 +545,14 @@ private void ParseSignature(StringBuilder builder)
 
                 case ReadyToRunFixupKind.READYTORUN_FIXUP_VirtualEntry_DefToken:
                     ParseMethodDefToken(builder, owningTypeOverride: null);
-                    builder.Append(" (VIRTUAL_ENTRY_DEF_TOKEN)");
+                    builder.Append(" (VIRTUAL_ENTRY");
+                    builder.Append(_options.Naked ? ")" : "_DEF_TOKEN)");
                     break;
 
                 case ReadyToRunFixupKind.READYTORUN_FIXUP_VirtualEntry_RefToken:
                     ParseMethodRefToken(builder, owningTypeOverride: null);
-                    builder.Append(" (VIRTUAL_ENTRY_REF_TOKEN)");
+                    builder.Append(" (VIRTUAL_ENTRY");
+                    builder.Append(_options.Naked ? ")" : "_REF_TOKEN)");
                     break;
 
                 case ReadyToRunFixupKind.READYTORUN_FIXUP_VirtualEntry_Slot:
@@ -622,12 +634,13 @@ private void ParseSignature(StringBuilder builder)
 
 
                 case ReadyToRunFixupKind.READYTORUN_FIXUP_FieldBaseOffset:
-                    builder.Append("FIELD_BASE_OFFSET");
-                    // TODO
+                    ParseType(builder);
+                    builder.Append(" (FIELD_BASE_OFFSET)");
                     break;
 
                 case ReadyToRunFixupKind.READYTORUN_FIXUP_FieldOffset:
-                    builder.Append("FIELD_OFFSET");
+                    ParseField(builder);
+                    builder.Append(" (FIELD_OFFSET)");
                     // TODO
                     break;
 
@@ -915,7 +928,7 @@ private void ParseMethod(StringBuilder builder)
             string owningTypeOverride = null;
             if ((methodFlags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_OwnerType) != 0)
             {
-                SignatureDecoder owningTypeDecoder = new SignatureDecoder(_metadataReader, _image, _offset);
+                SignatureDecoder owningTypeDecoder = new SignatureDecoder(_options, _metadataReader, _image, _offset);
                 owningTypeOverride = owningTypeDecoder.ReadTypeSignature();
                 _offset = owningTypeDecoder._offset;
             }