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
|
// 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.IO;
using System.Collections.Generic;
using System.Text;
using Internal.IL.Stubs;
using Internal.TypeSystem;
using Internal.Metadata.NativeFormat.Writer;
using ILCompiler.Metadata;
using ILCompiler.DependencyAnalysis;
namespace ILCompiler
{
/// <summary>
/// Base class for metadata managers that generate metadata blobs.
/// </summary>
public abstract class GeneratingMetadataManager : MetadataManager
{
protected readonly string _metadataLogFile;
protected readonly StackTraceEmissionPolicy _stackTraceEmissionPolicy;
private readonly ModuleDesc _generatedAssembly;
public GeneratingMetadataManager(CompilerTypeSystemContext typeSystemContext, MetadataBlockingPolicy blockingPolicy,
ManifestResourceBlockingPolicy resourceBlockingPolicy, string logFile, StackTraceEmissionPolicy stackTracePolicy,
DynamicInvokeThunkGenerationPolicy invokeThunkGenerationPolicy)
: base(typeSystemContext, blockingPolicy, resourceBlockingPolicy, invokeThunkGenerationPolicy)
{
_metadataLogFile = logFile;
_stackTraceEmissionPolicy = stackTracePolicy;
_generatedAssembly = typeSystemContext.GeneratedAssembly;
}
public sealed override bool WillUseMetadataTokenToReferenceMethod(MethodDesc method)
{
return (GetMetadataCategory(method) & MetadataCategory.Description) != 0;
}
public sealed override bool WillUseMetadataTokenToReferenceField(FieldDesc field)
{
return (GetMetadataCategory(field) & MetadataCategory.Description) != 0;
}
protected void ComputeMetadata<TPolicy>(
TPolicy policy,
NodeFactory factory,
out byte[] metadataBlob,
out List<MetadataMapping<MetadataType>> typeMappings,
out List<MetadataMapping<MethodDesc>> methodMappings,
out List<MetadataMapping<FieldDesc>> fieldMappings,
out List<MetadataMapping<MethodDesc>> stackTraceMapping) where TPolicy : struct, IMetadataPolicy
{
var transformed = MetadataTransform.Run(policy, GetCompilationModulesWithMetadata());
MetadataTransform transform = transformed.Transform;
// TODO: DeveloperExperienceMode: Use transformed.Transform.HandleType() to generate
// TypeReference records for _typeDefinitionsGenerated that don't have metadata.
// (To be used in MissingMetadataException messages)
// Generate metadata blob
var writer = new MetadataWriter();
writer.ScopeDefinitions.AddRange(transformed.Scopes);
// Generate entries in the blob for methods that will be necessary for stack trace purposes.
var stackTraceRecords = new List<KeyValuePair<MethodDesc, MetadataRecord>>();
foreach (var methodBody in GetCompiledMethodBodies())
{
MethodDesc method = methodBody.Method;
MethodDesc typicalMethod = method.GetTypicalMethodDefinition();
// Methods that will end up in the reflection invoke table should not have an entry in stack trace table
// We'll try looking them up in reflection data at runtime.
if (transformed.GetTransformedMethodDefinition(typicalMethod) != null &&
ShouldMethodBeInInvokeMap(method) &&
(GetMetadataCategory(method) & MetadataCategory.RuntimeMapping) != 0)
continue;
if (!_stackTraceEmissionPolicy.ShouldIncludeMethod(method))
continue;
MetadataRecord record = CreateStackTraceRecord(transform, method);
stackTraceRecords.Add(new KeyValuePair<MethodDesc, MetadataRecord>(
method,
record));
writer.AdditionalRootRecords.Add(record);
}
var ms = new MemoryStream();
// .NET metadata is UTF-16 and UTF-16 contains code points that don't translate to UTF-8.
var noThrowUtf8Encoding = new UTF8Encoding(false, false);
using (var logWriter = _metadataLogFile != null ? new StreamWriter(File.Open(_metadataLogFile, FileMode.Create, FileAccess.Write, FileShare.Read), noThrowUtf8Encoding) : null)
{
writer.LogWriter = logWriter;
writer.Write(ms);
}
metadataBlob = ms.ToArray();
typeMappings = new List<MetadataMapping<MetadataType>>();
methodMappings = new List<MetadataMapping<MethodDesc>>();
fieldMappings = new List<MetadataMapping<FieldDesc>>();
stackTraceMapping = new List<MetadataMapping<MethodDesc>>();
// Generate type definition mappings
foreach (var type in factory.MetadataManager.GetTypesWithEETypes())
{
MetadataType definition = type.IsTypeDefinition ? type as MetadataType : null;
if (definition == null)
continue;
MetadataRecord record = transformed.GetTransformedTypeDefinition(definition);
// Reflection requires that we maintain type identity. Even if we only generated a TypeReference record,
// if there is an EEType for it, we also need a mapping table entry for it.
if (record == null)
record = transformed.GetTransformedTypeReference(definition);
if (record != null)
typeMappings.Add(new MetadataMapping<MetadataType>(definition, writer.GetRecordHandle(record)));
}
foreach (var method in GetCompiledMethods())
{
if (method.IsCanonicalMethod(CanonicalFormKind.Specific))
{
// Canonical methods are not interesting.
continue;
}
if (IsReflectionBlocked(method.Instantiation) || IsReflectionBlocked(method.OwningType.Instantiation))
continue;
if ((GetMetadataCategory(method) & MetadataCategory.RuntimeMapping) == 0)
continue;
MetadataRecord record = transformed.GetTransformedMethodDefinition(method.GetTypicalMethodDefinition());
if (record != null)
methodMappings.Add(new MetadataMapping<MethodDesc>(method, writer.GetRecordHandle(record)));
}
foreach (var field in GetFieldsWithRuntimeMapping())
{
Field record = transformed.GetTransformedFieldDefinition(field.GetTypicalFieldDefinition());
if (record != null)
fieldMappings.Add(new MetadataMapping<FieldDesc>(field, writer.GetRecordHandle(record)));
}
// Generate stack trace metadata mapping
foreach (var stackTraceRecord in stackTraceRecords)
{
stackTraceMapping.Add(new MetadataMapping<MethodDesc>(stackTraceRecord.Key, writer.GetRecordHandle(stackTraceRecord.Value)));
}
}
/// <summary>
/// Gets a list of fields that got "compiled" and are eligible for a runtime mapping.
/// </summary>
/// <returns></returns>
protected abstract IEnumerable<FieldDesc> GetFieldsWithRuntimeMapping();
/// <summary>
/// Gets a stub that can be used to reflection-invoke a method with a given signature.
/// </summary>
public sealed override MethodDesc GetCanonicalReflectionInvokeStub(MethodDesc method)
{
// Get a generic method that can be used to invoke method with this shape.
var lookupSig = new DynamicInvokeMethodSignature(method.Signature);
MethodDesc thunk = _typeSystemContext.GetDynamicInvokeThunk(lookupSig);
return InstantiateCanonicalDynamicInvokeMethodForMethod(thunk, method);
}
}
}
|
