forked from dotnet/runtime
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathassemblybinder.cpp
More file actions
222 lines (184 loc) · 7.46 KB
/
Copy pathassemblybinder.cpp
File metadata and controls
222 lines (184 loc) · 7.46 KB
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
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#include "common.h"
#include "assemblybinder.h"
#include "nativeimage.h"
#include "../binder/inc/assemblyname.hpp"
#ifndef DACCESS_COMPILE
HRESULT AssemblyBinder::BindAssemblyByName(AssemblyNameData* pAssemblyNameData,
BINDER_SPACE::Assembly** ppAssembly)
{
_ASSERTE(pAssemblyNameData != nullptr && ppAssembly != nullptr);
HRESULT hr = S_OK;
*ppAssembly = nullptr;
ReleaseHolder<BINDER_SPACE::AssemblyName> pAssemblyName;
SAFE_NEW(pAssemblyName, BINDER_SPACE::AssemblyName);
IF_FAIL_GO(pAssemblyName->Init(*pAssemblyNameData));
hr = BindUsingAssemblyName(pAssemblyName, ppAssembly);
Exit:
return hr;
}
NativeImage* AssemblyBinder::LoadNativeImage(Module* componentModule, LPCUTF8 nativeImageName)
{
STANDARD_VM_CONTRACT;
BaseDomain::LoadLockHolder lock(AppDomain::GetCurrentDomain());
AssemblyBinder* binder = componentModule->GetPEAssembly()->GetAssemblyBinder();
PTR_LoaderAllocator moduleLoaderAllocator = componentModule->GetLoaderAllocator();
bool isNewNativeImage;
NativeImage* nativeImage = NativeImage::Open(componentModule, nativeImageName, binder, moduleLoaderAllocator, &isNewNativeImage);
return nativeImage;
}
#ifdef FEATURE_READYTORUN
static void MvidMismatchFatalError(GUID mvidActual, GUID mvidExpected, LPCUTF8 simpleName, bool compositeComponent, LPCUTF8 assemblyRequirementName)
{
CHAR assemblyMvidText[GUID_STR_BUFFER_LEN];
GuidToLPSTR(mvidActual, assemblyMvidText);
CHAR componentMvidText[GUID_STR_BUFFER_LEN];
GuidToLPSTR(mvidExpected, componentMvidText);
SString message;
if (compositeComponent)
{
message.Printf("MVID mismatch between loaded assembly '%s' (MVID = %s) and an assembly with the same simple name embedded in the native image '%s' (MVID = %s)",
simpleName,
assemblyMvidText,
assemblyRequirementName,
componentMvidText);
}
else
{
message.Printf("MVID mismatch between loaded assembly '%s' (MVID = %s) and version of assembly '%s' expected by assembly '%s' (MVID = %s)",
simpleName,
assemblyMvidText,
simpleName,
assemblyRequirementName,
componentMvidText);
}
EEPOLICY_HANDLE_FATAL_ERROR_WITH_MESSAGE(COR_E_FAILFAST, message.GetUnicode());
}
void AssemblyBinder::DeclareDependencyOnMvid(LPCUTF8 simpleName, GUID mvid, bool compositeComponent, LPCUTF8 imageName)
{
_ASSERTE(imageName != NULL);
// If the table is empty, then we didn't fill it with all the loaded assemblies as they were loaded. Record this detail, and fix after adding the dependency
bool addAllLoadedModules = false;
if (m_assemblySimpleNameMvidCheckHash.GetCount() == 0)
{
addAllLoadedModules = true;
}
SimpleNameToExpectedMVIDAndRequiringAssembly* foundElem = (SimpleNameToExpectedMVIDAndRequiringAssembly*)m_assemblySimpleNameMvidCheckHash.LookupPtr(simpleName);
if (foundElem == NULL)
{
SimpleNameToExpectedMVIDAndRequiringAssembly newElem(simpleName, mvid, compositeComponent, imageName);
m_assemblySimpleNameMvidCheckHash.Add(newElem);
}
else
{
// Elem already exists. Determine if the existing elem is another one with the same mvid, in which case just record that a dependency is in play.
// If the existing elem has a different mvid, fail.
if (IsEqualGUID(mvid, foundElem->Mvid))
{
// Mvid matches exactly.
if (foundElem->AssemblyRequirementName == NULL)
{
foundElem->AssemblyRequirementName = imageName;
foundElem->CompositeComponent = compositeComponent;
}
}
else
{
MvidMismatchFatalError(foundElem->Mvid, mvid, simpleName, compositeComponent, imageName);
}
}
if (addAllLoadedModules)
{
for (COUNT_T assemblyIndex = 0; assemblyIndex < m_loadedAssemblies.GetCount(); assemblyIndex++)
{
DeclareLoadedAssembly(m_loadedAssemblies[assemblyIndex]);
}
}
}
void AssemblyBinder::DeclareLoadedAssembly(Assembly* loadedAssembly)
{
// If table is empty, then no mvid dependencies have been declared, so we don't need to record this information
if (m_assemblySimpleNameMvidCheckHash.GetCount() == 0)
return;
GUID mvid;
loadedAssembly->GetMDImport()->GetScopeProps(NULL, &mvid);
LPCUTF8 simpleName = loadedAssembly->GetSimpleName();
SimpleNameToExpectedMVIDAndRequiringAssembly* foundElem = (SimpleNameToExpectedMVIDAndRequiringAssembly*)m_assemblySimpleNameMvidCheckHash.LookupPtr(simpleName);
if (foundElem == NULL)
{
SimpleNameToExpectedMVIDAndRequiringAssembly newElem(simpleName, mvid, false, NULL);
m_assemblySimpleNameMvidCheckHash.Add(newElem);
}
else
{
// Elem already exists. Determine if the existing elem is another one with the same mvid, in which case do nothing. Everything is fine here.
// If the existing elem has a different mvid, but isn't a dependency on exact mvid elem, then set the mvid to all 0.
// If the existing elem has a different mvid, and is a dependency on exact mvid elem, then we've hit a fatal error.
if (IsEqualGUID(mvid, foundElem->Mvid))
{
// Mvid matches exactly.
}
else if (foundElem->AssemblyRequirementName == NULL)
{
// Another loaded assembly, set the stored Mvid to all zeroes to indicate that it isn't a unique mvid
memset(&foundElem->Mvid, 0, sizeof(GUID));
}
else
{
MvidMismatchFatalError(mvid, foundElem->Mvid, simpleName, foundElem->CompositeComponent, foundElem->AssemblyRequirementName);
}
}
}
#endif // FEATURE_READYTORUN
void AssemblyBinder::AddLoadedAssembly(Assembly* loadedAssembly)
{
BaseDomain::LoadLockHolder lock(AppDomain::GetCurrentDomain());
m_loadedAssemblies.Append(loadedAssembly);
#ifdef FEATURE_READYTORUN
DeclareLoadedAssembly(loadedAssembly);
#endif // FEATURE_READYTORUN
}
void AssemblyBinder::GetNameForDiagnosticsFromManagedALC(INT_PTR managedALC, /* out */ SString& alcName)
{
if (managedALC == GetAppDomain()->GetDefaultBinder()->GetManagedAssemblyLoadContext())
{
alcName.Set(W("Default"));
return;
}
OBJECTREF* alc = reinterpret_cast<OBJECTREF*>(managedALC);
GCX_COOP();
struct {
STRINGREF alcName;
} gc;
gc.alcName = NULL;
GCPROTECT_BEGIN(gc);
PREPARE_VIRTUAL_CALLSITE(METHOD__OBJECT__TO_STRING, *alc);
DECLARE_ARGHOLDER_ARRAY(args, 1);
args[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(*alc);
CALL_MANAGED_METHOD_RETREF(gc.alcName, STRINGREF, args);
gc.alcName->GetSString(alcName);
GCPROTECT_END();
}
void AssemblyBinder::GetNameForDiagnostics(/*out*/ SString& alcName)
{
_ASSERTE(this != nullptr);
if (IsDefault())
{
alcName.Set(W("Default"));
}
else
{
GetNameForDiagnosticsFromManagedALC(GetManagedAssemblyLoadContext(), alcName);
}
}
void AssemblyBinder::GetNameForDiagnosticsFromSpec(AssemblySpec* spec, /*out*/ SString& alcName)
{
_ASSERTE(spec != nullptr);
AppDomain* domain = spec->GetAppDomain();
AssemblyBinder* binder = spec->GetBinder();
if (binder == nullptr)
binder = spec->GetBinderFromParentAssembly(domain);
binder->GetNameForDiagnostics(alcName);
}
#endif //DACCESS_COMPILE