1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Reflection;
using System.Reflection.Metadata;
using System.Text;
namespace R2RDump
{
internal class DisassemblingGenericContext
{
public DisassemblingGenericContext(string[] typeParameters, string[] methodParameters)
{
MethodParameters = methodParameters;
TypeParameters = typeParameters;
}
public string[] MethodParameters { get; }
public string[] TypeParameters { get; }
}
// Test implementation of ISignatureTypeProvider<TType, TGenericContext> that uses strings in ilasm syntax as TType.
// A real provider in any sort of perf constraints would not want to allocate strings freely like this, but it keeps test code simple.
internal class DisassemblingTypeProvider : ISignatureTypeProvider<string, DisassemblingGenericContext>
{
public virtual string GetPrimitiveType(PrimitiveTypeCode typeCode)
{
return typeCode.ToString();
}
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;
}
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;
}
}
public virtual string GetTypeFromSpecification(MetadataReader reader, DisassemblingGenericContext genericContext, TypeSpecificationHandle handle, byte rawTypeKind = 0)
{
return reader.GetTypeSpecification(handle).DecodeSignature(this, genericContext);
}
public virtual string GetSZArrayType(string elementType)
{
return elementType + "[]";
}
public virtual string GetPointerType(string elementType)
{
return elementType + "*";
}
public virtual string GetByReferenceType(string elementType)
{
return "ref " + elementType;
}
public virtual string GetGenericMethodParameter(DisassemblingGenericContext genericContext, int index)
{
if (index >= genericContext.MethodParameters.Length)
{
R2RDump.WriteWarning("GenericMethodParameters index out of bounds");
return "";
}
return genericContext.MethodParameters[index];
}
public virtual string GetGenericTypeParameter(DisassemblingGenericContext genericContext, int index)
{
if (index >= genericContext.TypeParameters.Length)
{
R2RDump.WriteWarning("GenericTypeParameter index out of bounds");
return "";
}
return genericContext.TypeParameters[index];
}
public virtual string GetPinnedType(string elementType)
{
return elementType + " pinned";
}
public virtual string GetGenericInstantiation(string genericType, ImmutableArray<string> typeArguments)
{
return genericType + "<" + String.Join(",", typeArguments) + ">";
}
public virtual string GetArrayType(string elementType, ArrayShape shape)
{
var builder = new StringBuilder();
builder.Append(elementType);
builder.Append('[');
for (int i = 0; i < shape.Rank; i++)
{
int lowerBound = 0;
if (i < shape.LowerBounds.Length)
{
lowerBound = shape.LowerBounds[i];
builder.Append(lowerBound);
}
builder.Append("...");
if (i < shape.Sizes.Length)
{
builder.Append(lowerBound + shape.Sizes[i] - 1);
}
if (i < shape.Rank - 1)
{
builder.Append(',');
}
}
builder.Append(']');
return builder.ToString();
}
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));
}
}
public virtual string GetModifiedType(string modifierType, string unmodifiedType, bool isRequired)
{
return unmodifiedType + (isRequired ? " modreq(" : " modopt(") + modifierType + ")";
}
public virtual string GetFunctionPointerType(MethodSignature<string> signature)
{
ImmutableArray<string> parameterTypes = signature.ParameterTypes;
int requiredParameterCount = signature.RequiredParameterCount;
var builder = new StringBuilder();
builder.Append("method ");
builder.Append(signature.ReturnType);
builder.Append(" *(");
int i;
for (i = 0; i < requiredParameterCount; i++)
{
builder.Append(parameterTypes[i]);
if (i < parameterTypes.Length - 1)
{
builder.Append(", ");
}
}
if (i < parameterTypes.Length)
{
builder.Append("..., ");
for (; i < parameterTypes.Length; i++)
{
builder.Append(parameterTypes[i]);
if (i < parameterTypes.Length - 1)
{
builder.Append(", ");
}
}
}
builder.Append(')');
return builder.ToString();
}
}
}
|
