1 | // Licensed to the .NET Foundation under one or more agreements. |
2 | // The .NET Foundation licenses this file to you under the MIT license. |
3 | // See the LICENSE file in the project root for more information. |
4 | //***************************************************************************** |
5 | // File: rstype.cpp |
6 | // |
7 | |
8 | // |
9 | // Define implementation of ICorDebugType |
10 | //***************************************************************************** |
11 | |
12 | |
13 | #include "stdafx.h" |
14 | #include "winbase.h" |
15 | #include "corpriv.h" |
16 | |
17 | |
18 | //----------------------------------------------------------------------------- |
19 | // Public method to get the static field from a type. |
20 | // |
21 | // Parameters: |
22 | // fieldDef - metadata token for which field on this type to retrieve. |
23 | // pFrame - context for Thread/AppDomains statics. |
24 | // ppValue - OUT: out-parameter to get value. |
25 | // |
26 | // Returns: |
27 | // S_OK on success. |
28 | // |
29 | HRESULT CordbType::GetStaticFieldValue(mdFieldDef fieldDef, |
30 | ICorDebugFrame * pFrame, |
31 | ICorDebugValue ** ppValue) |
32 | { |
33 | PUBLIC_REENTRANT_API_ENTRY(this); |
34 | FAIL_IF_NEUTERED(this); |
35 | VALIDATE_POINTER_TO_OBJECT(ppValue, ICorDebugValue **); |
36 | ATT_REQUIRE_STOPPED_MAY_FAIL(GetProcess()); |
37 | |
38 | HRESULT hr = S_OK; |
39 | |
40 | IMetaDataImport * pImport = NULL; |
41 | |
42 | EX_TRY |
43 | { |
44 | // Ensure we were actually passed a mdFieldDef. This is especially useful to protect |
45 | // against an accidental mdPropertyDef, because properties look like fields. |
46 | // |
47 | if (TypeFromToken(fieldDef) != mdtFieldDef) |
48 | { |
49 | ThrowHR(E_INVALIDARG); |
50 | } |
51 | |
52 | pImport = m_pClass->GetModule()->GetMetaDataImporter(); // throws |
53 | |
54 | if (((m_elementType != ELEMENT_TYPE_CLASS) && (m_elementType != ELEMENT_TYPE_VALUETYPE)) || (m_pClass == NULL)) |
55 | { |
56 | ThrowHR(E_INVALIDARG); |
57 | } |
58 | |
59 | |
60 | |
61 | BOOL fSyncBlockField = FALSE; |
62 | |
63 | // If non generic type, then degenerate to CordbClass implementation. |
64 | if (m_inst.m_cInst == 0) |
65 | { |
66 | hr = m_pClass->GetStaticFieldValue(fieldDef, pFrame, ppValue); |
67 | } |
68 | else |
69 | { |
70 | *ppValue = NULL; |
71 | |
72 | // Validate the token. |
73 | if (!pImport->IsValidToken(fieldDef)) |
74 | { |
75 | ThrowHR(hr = E_INVALIDARG); |
76 | } |
77 | |
78 | // Make sure we have enough info about the class. |
79 | hr = Init(FALSE); |
80 | IfFailThrow(hr); |
81 | |
82 | // Lookup the field given its metadata token. |
83 | FieldData * pFieldData; |
84 | |
85 | hr = GetFieldInfo(fieldDef, &pFieldData); |
86 | |
87 | if (hr == CORDBG_E_ENC_HANGING_FIELD) |
88 | { |
89 | // Generics + EnC is Not supported. |
90 | hr = CORDBG_E_STATIC_VAR_NOT_AVAILABLE; |
91 | } |
92 | |
93 | IfFailThrow(hr); |
94 | |
95 | hr = CordbClass::GetStaticFieldValue2(m_pClass->GetModule(), |
96 | pFieldData, |
97 | fSyncBlockField, |
98 | &m_inst, |
99 | pFrame, |
100 | ppValue); |
101 | // fall through to translate HR |
102 | } |
103 | |
104 | } |
105 | EX_CATCH_HRESULT(hr); |
106 | if (pImport != NULL) |
107 | { |
108 | hr = CordbClass::PostProcessUnavailableHRESULT(hr, pImport, fieldDef); |
109 | } |
110 | return hr; |
111 | |
112 | } |
113 | |
114 | // Combine E_T_s and rank together to get an id for the m_sharedtypes table |
115 | #define CORDBTYPE_ID(elementType,rank) ((unsigned int) elementType * (rank + 1) + 1) |
116 | |
117 | |
118 | //----------------------------------------------------------------------------- |
119 | // Constructor |
120 | // Builds a CordbType around a primitive. |
121 | //----------------------------------------------------------------------------- |
122 | CordbType::CordbType(CordbAppDomain *appdomain, CorElementType et, unsigned int rank) |
123 | : CordbBase(appdomain->GetProcess(), CORDBTYPE_ID(et,rank) , enumCordbType), |
124 | m_elementType(et), |
125 | m_appdomain(appdomain), |
126 | m_pClass(NULL), |
127 | m_rank(rank), |
128 | m_spinetypes(2), |
129 | m_objectSize(0), |
130 | m_fieldInfoNeedsInit(TRUE) |
131 | { |
132 | m_typeHandleExact = VMPTR_TypeHandle::NullPtr(); |
133 | |
134 | _ASSERTE(m_elementType != ELEMENT_TYPE_VALUETYPE); |
135 | |
136 | HRESULT hr = S_OK; |
137 | EX_TRY |
138 | { |
139 | m_appdomain->AddToTypeList(this); |
140 | } |
141 | EX_CATCH_HRESULT(hr); |
142 | SetUnrecoverableIfFailed(GetProcess(), hr); |
143 | } |
144 | |
145 | //----------------------------------------------------------------------------- |
146 | // Constructor |
147 | // Builds a CordbType around a class. This is an Open CordbType. |
148 | // For a generic type, this CordbType will not have the generic parameters, |
149 | // but it will be a subordinate type to another Closed (instantiated) CordbType |
150 | //----------------------------------------------------------------------------- |
151 | CordbType::CordbType(CordbAppDomain *appdomain, CorElementType et, CordbClass *cls) |
152 | : CordbBase(appdomain->GetProcess(), et, enumCordbType), |
153 | m_elementType(et), |
154 | m_appdomain(appdomain), |
155 | m_pClass(cls), |
156 | m_rank(0), |
157 | m_spinetypes(2), |
158 | m_objectSize(0), |
159 | m_fieldInfoNeedsInit(TRUE) |
160 | { |
161 | m_typeHandleExact = VMPTR_TypeHandle::NullPtr(); |
162 | _ASSERTE(m_elementType != ELEMENT_TYPE_VALUETYPE); |
163 | |
164 | HRESULT hr = S_OK; |
165 | EX_TRY |
166 | { |
167 | m_appdomain->AddToTypeList(this); |
168 | } |
169 | EX_CATCH_HRESULT(hr); |
170 | SetUnrecoverableIfFailed(GetProcess(), hr); |
171 | } |
172 | |
173 | //----------------------------------------------------------------------------- |
174 | // Constructor |
175 | // Builds a Partial-Type, instantiation is tycon's instantation plus tyarg. |
176 | // Eg, if tycon is "Dict<int>", and tyarg is "string", then this yields |
177 | // "Dict<int, string>" |
178 | //----------------------------------------------------------------------------- |
179 | CordbType::CordbType(CordbType *tycon, CordbType *tyarg) |
180 | : CordbBase(tycon->GetProcess(), (UINT_PTR)tyarg, enumCordbType), |
181 | m_elementType(tycon->m_elementType), |
182 | m_appdomain(tycon->m_appdomain), |
183 | m_pClass(tycon->m_pClass), |
184 | m_rank(tycon->m_rank), |
185 | m_spinetypes(2), |
186 | m_objectSize(0), |
187 | m_fieldInfoNeedsInit(TRUE) |
188 | // tyarg is added as part of instantiation -see below... |
189 | { |
190 | m_typeHandleExact = VMPTR_TypeHandle::NullPtr(); |
191 | _ASSERTE(m_elementType != ELEMENT_TYPE_VALUETYPE); |
192 | |
193 | HRESULT hr = S_OK; |
194 | EX_TRY |
195 | { |
196 | m_appdomain->AddToTypeList(this); |
197 | } |
198 | EX_CATCH_HRESULT(hr); |
199 | SetUnrecoverableIfFailed(GetProcess(), hr); |
200 | } |
201 | |
202 | |
203 | ULONG STDMETHODCALLTYPE CordbType::AddRef() |
204 | { |
205 | // This AddRef/Release pair creates a weak ref-counted reference to the class for this |
206 | // type. This avoids a circularity in ref-counted references between |
207 | // classes and types - if we had a circularity the objects would never get |
208 | // collected at all... |
209 | //if (m_class) |
210 | // m_class->AddRef(); |
211 | return (BaseAddRef()); |
212 | } |
213 | ULONG STDMETHODCALLTYPE CordbType::Release() |
214 | { |
215 | // if (m_class) |
216 | // m_class->Release(); |
217 | return (BaseRelease()); |
218 | } |
219 | |
220 | /* |
221 | A list of which resources owened by this object are accounted for. |
222 | |
223 | HANDLED: |
224 | CordbClass *m_class; Weakly referenced by increasing count directly in AddRef() and Release() |
225 | Instantiation m_inst; // Internal pointers to CordbClass released in CordbClass::Neuter |
226 | CordbHashTable m_spinetypes; // Neutered |
227 | CordbHashTable m_fields; // Deleted in ~CordbType |
228 | */ |
229 | |
230 | //----------------------------------------------------------------------------- |
231 | // Cleanup memory for CordbTypes. |
232 | //----------------------------------------------------------------------------- |
233 | CordbType::~CordbType() |
234 | { |
235 | _ASSERTE(IsNeutered()); |
236 | } |
237 | |
238 | //----------------------------------------------------------------------------- |
239 | // Neutered by CordbModule |
240 | // See CordbBase::Neuter for neuter semantics. |
241 | //----------------------------------------------------------------------------- |
242 | void CordbType::Neuter() |
243 | { |
244 | _ASSERTE(GetProcess()->GetProcessLock()->HasLock()); |
245 | |
246 | // We have some direct releases below. If we call Neuter twice, that could |
247 | // result in double-releases. So check if we're already neutered, and |
248 | // if so, no work left to do. |
249 | if (IsNeutered()) |
250 | { |
251 | return; |
252 | } |
253 | |
254 | for (unsigned int i = 0; i < m_inst.m_cInst; i++) |
255 | { |
256 | m_inst.m_ppInst[i]->Release(); |
257 | } |
258 | |
259 | m_spinetypes.NeuterAndClear(GetProcess()->GetProcessLock()); |
260 | |
261 | if(m_inst.m_ppInst) |
262 | { |
263 | delete [] m_inst.m_ppInst; |
264 | m_inst.m_ppInst = NULL; |
265 | } |
266 | m_fieldList.Dealloc(); |
267 | |
268 | CordbBase::Neuter(); |
269 | } |
270 | |
271 | //----------------------------------------------------------------------------- |
272 | // Public method for IUnknown::QueryInterface. |
273 | // Has standard QI semantics. |
274 | //----------------------------------------------------------------------------- |
275 | HRESULT CordbType::QueryInterface(REFIID id, void **pInterface) |
276 | { |
277 | if (id == IID_ICorDebugType) |
278 | *pInterface = static_cast<ICorDebugType*>(this); |
279 | else if (id == IID_ICorDebugType2) |
280 | *pInterface = static_cast<ICorDebugType2*>(this); |
281 | else if (id == IID_IUnknown) |
282 | *pInterface = static_cast<IUnknown*>(static_cast<ICorDebugType*>(this)); |
283 | else |
284 | { |
285 | *pInterface = NULL; |
286 | return E_NOINTERFACE; |
287 | } |
288 | |
289 | ExternalAddRef(); |
290 | return S_OK; |
291 | } |
292 | |
293 | |
294 | //----------------------------------------------------------------------------- |
295 | // Make a simple type with no type arguments by specifying a CorElementType, |
296 | // e.g. ELEMENT_TYPE_I1 |
297 | // |
298 | // CordbType's are effectively a full representation of |
299 | // structured types. They are hashed via a combination of their constituent |
300 | // elements (e.g. CordbClass's or CordbType's) and the element type that is used to |
301 | // combine the elements, or if they have no elements then via |
302 | // the element type alone. The following is used to create all CordbTypes. |
303 | // |
304 | // An AppDomain holds a cache of CordbTypes for each of the basic CorElementTypes. |
305 | // |
306 | // Arguments: |
307 | // pAppDomain - the AppDomain that the type lives in. |
308 | // elementType - element_type to create the CordbType around. |
309 | // ppResultType - OUT: out-parameter to get the CordbType. |
310 | // |
311 | // Returns: |
312 | // S_OK on success. |
313 | // |
314 | // |
315 | HRESULT CordbType::MkType(CordbAppDomain * pAppDomain, |
316 | CorElementType elementType, |
317 | CordbType ** ppResultType) |
318 | { |
319 | _ASSERTE(pAppDomain != NULL); |
320 | _ASSERTE(ppResultType != NULL); |
321 | |
322 | RSLockHolder lockHolder(pAppDomain->GetProcess()->GetProcessLock()); |
323 | |
324 | // Some points in the code create types via element types that are clearly objects but where |
325 | // no further information is given. This is always done when creating a CordbValue, prior |
326 | // to actually going over to the EE to discover what kind of value it is. In all these |
327 | // cases we can just use the type for "Object" - the code for dereferencing the value |
328 | // will update the type correctly once it has been determined. We don't do this for ELEMENT_TYPE_STRING |
329 | // as that is actually a NullaryType and at other places in the code we will want exactly that type! |
330 | if ((elementType == ELEMENT_TYPE_CLASS) || |
331 | (elementType == ELEMENT_TYPE_SZARRAY) || |
332 | (elementType == ELEMENT_TYPE_ARRAY)) |
333 | { |
334 | elementType = ELEMENT_TYPE_OBJECT; |
335 | } |
336 | |
337 | switch (elementType) |
338 | { |
339 | // this one is included because we need a "seed" type to uniquely hash FNPTR types, |
340 | // i.e. the nullary FNPTR type is used as the type constructor for all function pointer types, |
341 | // when combined with an appropriate instantiation. |
342 | case ELEMENT_TYPE_FNPTR: |
343 | // fall through ... |
344 | |
345 | case ELEMENT_TYPE_VOID: |
346 | case ELEMENT_TYPE_BOOLEAN: |
347 | case ELEMENT_TYPE_CHAR: |
348 | case ELEMENT_TYPE_I1: |
349 | case ELEMENT_TYPE_U1: |
350 | case ELEMENT_TYPE_I2: |
351 | case ELEMENT_TYPE_U2: |
352 | case ELEMENT_TYPE_I4: |
353 | case ELEMENT_TYPE_U4: |
354 | case ELEMENT_TYPE_I8: |
355 | case ELEMENT_TYPE_U8: |
356 | case ELEMENT_TYPE_R4: |
357 | case ELEMENT_TYPE_R8: |
358 | case ELEMENT_TYPE_STRING: |
359 | case ELEMENT_TYPE_OBJECT: |
360 | case ELEMENT_TYPE_TYPEDBYREF: |
361 | case ELEMENT_TYPE_I: |
362 | case ELEMENT_TYPE_U: |
363 | |
364 | *ppResultType = pAppDomain->m_sharedtypes.GetBase(CORDBTYPE_ID(elementType, 0)); |
365 | |
366 | if (*ppResultType == NULL) |
367 | { |
368 | CordbType * pNewType = new (nothrow) CordbType(pAppDomain, elementType, (unsigned int) 0); |
369 | |
370 | if (pNewType == NULL) |
371 | { |
372 | return E_OUTOFMEMORY; |
373 | } |
374 | |
375 | HRESULT hr = pAppDomain->m_sharedtypes.AddBase(pNewType); |
376 | |
377 | if (SUCCEEDED(hr)) |
378 | { |
379 | *ppResultType = pNewType; |
380 | } |
381 | else |
382 | { |
383 | _ASSERTE(!"unexpected failure!" ); |
384 | delete pNewType; |
385 | } |
386 | |
387 | return hr; |
388 | } |
389 | return S_OK; |
390 | |
391 | default: |
392 | _ASSERTE(!"unexpected element type!" ); |
393 | return E_FAIL; |
394 | } |
395 | |
396 | } |
397 | |
398 | //----------------------------------------------------------------------------- |
399 | // Internal method to make a type with exactly one type argument by specifying |
400 | // ELEMENT_TYPE_PTR, ELEMENT_TYPE_BYREF, ELEMENT_TYPE_SZARRAY or |
401 | // ELEMENT_TYPE_ARRAY. |
402 | // |
403 | // Arguments: |
404 | // pAppDomain - appdomain containing the type. |
405 | // elementType - element type to create around. This is limited to: ELEMENT_TYPE_PTR, |
406 | // ELEMENT_TYPE_BYREF, ELEMENT_TYPE_SZARRAY or ELEMENT_TYPE_ARRAY. |
407 | // rank - for non-arrays, this must be 0. For szarray, this must be 1. |
408 | // For multi-dimensional arrays, this is the rank. |
409 | // pType - the single input type-parameter required for the specified element type. |
410 | // ppResultType - OUT: the output parameter to get the corresponding CordbType |
411 | // |
412 | // Returns: |
413 | // S_OK on success. |
414 | // |
415 | HRESULT CordbType::MkType(CordbAppDomain *pAppDomain, |
416 | CorElementType elementType, |
417 | ULONG rank, |
418 | CordbType * pType, |
419 | CordbType ** ppResultType) |
420 | { |
421 | _ASSERTE(pAppDomain != NULL); |
422 | _ASSERTE(ppResultType != NULL); |
423 | |
424 | RSLockHolder lockHolder(pAppDomain->GetProcess()->GetProcessLock()); |
425 | |
426 | switch (elementType) |
427 | { |
428 | |
429 | case ELEMENT_TYPE_PTR: |
430 | case ELEMENT_TYPE_BYREF: |
431 | _ASSERTE(rank == 0); |
432 | goto LUnary; |
433 | |
434 | case ELEMENT_TYPE_SZARRAY: |
435 | _ASSERTE(rank == 1); |
436 | goto LUnary; |
437 | |
438 | case ELEMENT_TYPE_ARRAY: |
439 | LUnary: |
440 | { |
441 | CordbType * pFoundType = pAppDomain->m_sharedtypes.GetBase(CORDBTYPE_ID(elementType, rank)); |
442 | |
443 | if (pFoundType == NULL) |
444 | { |
445 | pFoundType = new (nothrow) CordbType(pAppDomain, elementType, rank); |
446 | |
447 | if (pFoundType == NULL) |
448 | { |
449 | return E_OUTOFMEMORY; |
450 | } |
451 | |
452 | HRESULT hr = pAppDomain->m_sharedtypes.AddBase(pFoundType); |
453 | |
454 | if (FAILED(hr)) |
455 | { |
456 | _ASSERTE(!"unexpected failure!" ); |
457 | delete pFoundType; |
458 | return hr; |
459 | } |
460 | } |
461 | |
462 | Instantiation inst(1, &pType); |
463 | |
464 | return MkTyAppType(pAppDomain, pFoundType, &inst, ppResultType); |
465 | |
466 | } |
467 | |
468 | default: |
469 | _ASSERTE(!"unexpected element type!" ); |
470 | return E_FAIL; |
471 | } |
472 | |
473 | } |
474 | |
475 | //----------------------------------------------------------------------------- |
476 | // Internal method to make a type for an instantiation of a class or value type, or just for the |
477 | // class or value type if it accepts no type parameters. |
478 | // Creates a CordbType instantiation around an uninstantiated CordbType and TypeParameter list. |
479 | // In other words, this does: |
480 | // CordbType(List<T>) + Instantiation({T=int}) --> CordbType(List<int>) |
481 | // |
482 | // This will create the subordinate types. Eg, for Triple<x,y,z>, it will create: |
483 | // CordbType(Triple<x>), CordbType(Triple<x,y>), and CordbType(Triple<x,y,z)). |
484 | // The fully instantiated one (the last one) is returned via the out parameter *pRes. |
485 | // |
486 | // Arguments: |
487 | // pAppDomain - the appdomain that the type lives in. |
488 | // pType - the open type to instantiate. Eg, CordbType(List<T>) |
489 | // pInst - instantiation parameters. |
490 | // ppResultType - OUT: out parameter to hold resulting type. |
491 | // |
492 | // Returns: |
493 | // S_OK on success. |
494 | // |
495 | HRESULT CordbType::MkTyAppType(CordbAppDomain * pAppDomain, |
496 | CordbType * pType, |
497 | const Instantiation * pInst, |
498 | CordbType ** ppResultType) |
499 | { |
500 | _ASSERTE(pAppDomain == pType->GetAppDomain()); |
501 | |
502 | CordbType * pCordbType = pType; |
503 | |
504 | // Loop through and create each of the subordinate types, building up to the final fully Closed type. |
505 | for (unsigned int i = 0; i < pInst->m_cClassTyPars; i++) |
506 | { |
507 | |
508 | CordbType * pCordbBaseType = pCordbType->m_spinetypes.GetBase((UINT_PTR) (pInst->m_ppInst[i])); |
509 | |
510 | if (pCordbBaseType == NULL) |
511 | { |
512 | pCordbBaseType = new (nothrow) CordbType(pCordbType, pInst->m_ppInst[i]); |
513 | |
514 | if (pCordbBaseType == NULL) |
515 | { |
516 | return E_OUTOFMEMORY; |
517 | } |
518 | |
519 | HRESULT hr = pCordbType->m_spinetypes.AddBase(pCordbBaseType); |
520 | |
521 | if (FAILED(hr)) |
522 | { |
523 | _ASSERTE(!"unexpected failure!" ); |
524 | delete pCordbBaseType; |
525 | // @dbgtodo Microsoft leaks: Release the previously created types if this fails later in the loop |
526 | return hr; |
527 | } |
528 | |
529 | pCordbBaseType->m_inst.m_cInst = i + 1; |
530 | pCordbBaseType->m_inst.m_cClassTyPars = i + 1; |
531 | pCordbBaseType->m_inst.m_ppInst = new (nothrow) CordbType *[i+1]; |
532 | |
533 | if (pCordbBaseType->m_inst.m_ppInst == NULL) |
534 | { |
535 | delete pCordbBaseType; |
536 | // @dbgtodo Microsoft leaks: Doesn't release the previously created types if this fails later in the loop |
537 | return E_OUTOFMEMORY; |
538 | } |
539 | |
540 | for (unsigned int j = 0; j < (i + 1); j++) |
541 | { |
542 | // Constructed types include pointers across to other types - increase |
543 | // the reference counts on these.... |
544 | pInst->m_ppInst[j]->AddRef(); |
545 | |
546 | pCordbBaseType->m_inst.m_ppInst[j] = pInst->m_ppInst[j]; |
547 | } |
548 | } |
549 | pCordbType = pCordbBaseType; |
550 | } |
551 | |
552 | *ppResultType = pCordbType; |
553 | return S_OK; |
554 | } |
555 | |
556 | //----------------------------------------------------------------------------- |
557 | // Creates a CordbType instantation around a cordbClass and TypeParameter list. |
558 | // In other words, this does: |
559 | // CordbClass(List<T>) + Instantiation({T=int}) --> CordbType(List<int>) |
560 | // |
561 | // This really just converts CordbClass(List<T>) --> CordbType(List<T>), and then calls CordbType::MkTyAppType |
562 | // |
563 | // Arguments: |
564 | // pAppDomain - the AD that the class lives in. |
565 | // elementType - element type of the class. Either ELEMENT_TYPE_CLASS or ELEMENT_TYPE_VALUETYPE |
566 | // pClass - the uninstantiated class (eg, List<T>). This function will fill out the tycon->m_type field |
567 | // to an uninstantiated CordbType (eg CordbType(List<T>)) |
568 | // pInst - the list of type parameters to instantiate with. |
569 | // ppResultType - OUT: the CordbType instantiated with the type parameters (eg, CordbType(List<int>)) |
570 | // |
571 | // Returns: |
572 | // S_OK on success. |
573 | // |
574 | HRESULT CordbType::MkType(CordbAppDomain * pAppDomain, |
575 | CorElementType elementType, |
576 | CordbClass * pClass, |
577 | const Instantiation * pInst, |
578 | CordbType ** ppResultType) |
579 | { |
580 | _ASSERTE(pAppDomain != NULL); |
581 | _ASSERTE(ppResultType != NULL); |
582 | |
583 | switch (elementType) |
584 | { |
585 | // Normalize E_T_VALUETYPE away, so types do not record whether they are VCs or not, but CorDebugClass does. |
586 | // Update our view of whether a class is a VC based on the evidence we have here. |
587 | case ELEMENT_TYPE_VALUETYPE: |
588 | |
589 | _ASSERTE(((pClass != NULL) && (!pClass->IsValueClassKnown() || pClass->IsValueClassNoInit())) || |
590 | !"A non-value class is being used with ELEMENT_TYPE_VALUETYPE" ); |
591 | |
592 | pClass->SetIsValueClass(true); |
593 | pClass->SetIsValueClassKnown(true); |
594 | // drop through |
595 | |
596 | case ELEMENT_TYPE_CLASS: |
597 | { |
598 | // This probably isn't needed... |
599 | if (pClass == NULL) |
600 | { |
601 | elementType = ELEMENT_TYPE_OBJECT; |
602 | goto LReallyObject; |
603 | } |
604 | |
605 | CordbType * pType = NULL; |
606 | |
607 | pType = pClass->GetType(); |
608 | |
609 | if (pType == NULL) |
610 | { |
611 | pType = new (nothrow) CordbType(pAppDomain, ELEMENT_TYPE_CLASS, pClass); |
612 | |
613 | if (pType == NULL) |
614 | { |
615 | return E_OUTOFMEMORY; |
616 | } |
617 | |
618 | pClass->SetType(pType); |
619 | } |
620 | |
621 | _ASSERTE(pClass->GetType() != NULL); |
622 | |
623 | return CordbType::MkTyAppType(pAppDomain, pType, pInst, ppResultType); |
624 | } |
625 | |
626 | default: |
627 | LReallyObject: |
628 | |
629 | _ASSERTE(pInst->m_cInst == 0); |
630 | return MkType(pAppDomain, elementType, ppResultType); |
631 | |
632 | } |
633 | } |
634 | |
635 | //----------------------------------------------------------------------------- |
636 | // Make a CordbType for a function pointer type (ELEMENT_TYPE_FNPTR). |
637 | // |
638 | // Arguments: |
639 | // pAppDomain - the Appdomain the type lives in. |
640 | // elementType - must be ELEMENT_TYPE_FNPTR. |
641 | // pInst - instantiation information. |
642 | // ppResultType - OUT: out-parameter to hold resulting CordbType |
643 | // |
644 | // Return: |
645 | // S_OK on success. |
646 | // |
647 | HRESULT CordbType::MkType(CordbAppDomain * pAppDomain, |
648 | CorElementType elementType, |
649 | const Instantiation * pInst, |
650 | CordbType ** ppResultType) |
651 | { |
652 | CordbType * pType; |
653 | |
654 | _ASSERTE(elementType == ELEMENT_TYPE_FNPTR); |
655 | |
656 | HRESULT hr = MkType(pAppDomain, elementType, &pType); |
657 | |
658 | if (!SUCCEEDED(hr)) |
659 | { |
660 | return hr; |
661 | } |
662 | return CordbType::MkTyAppType(pAppDomain, pType, pInst, ppResultType); |
663 | } |
664 | |
665 | |
666 | //----------------------------------------------------------------------------- |
667 | // Public API to get the CorElementType of the type. |
668 | // |
669 | // Parameters: |
670 | // pType - OUT: on return, gets the CorElementType |
671 | // |
672 | // Returns: |
673 | // S_OK on success. CORDBG_E_CLASS_NOT_LOADED or synchronization errors on failure |
674 | //----------------------------------------------------------------------------- |
675 | HRESULT CordbType::GetType(CorElementType *pType) |
676 | { |
677 | PUBLIC_REENTRANT_API_ENTRY(this); |
678 | FAIL_IF_NEUTERED(this); |
679 | // See if this E_T_CLASS is really a value type? |
680 | if (m_elementType == ELEMENT_TYPE_CLASS) |
681 | { |
682 | _ASSERTE(m_pClass); |
683 | bool isVC = false; |
684 | // Determining if something is a VC or not can involve asking the EE. |
685 | // We could do it ourselves based on the metadata but it's non-trivial |
686 | // determining if a class has System.ValueType as a parent (we have |
687 | // to find and OpenScope the mscorlib.dll which we don't currently do |
688 | // on the right-side). But the IsValueClass call can fail if the |
689 | // class is not yet loaded on the right side. In that case we |
690 | // ignore the failure and return ELEMENT_TYPE_CLASS |
691 | HRESULT hr = S_OK; |
692 | EX_TRY |
693 | { |
694 | isVC = m_pClass->IsValueClass(); |
695 | } |
696 | EX_CATCH_HRESULT(hr); |
697 | if (!FAILED(hr) && isVC) |
698 | { |
699 | *pType = ELEMENT_TYPE_VALUETYPE; |
700 | return S_OK; |
701 | } |
702 | } |
703 | *pType = m_elementType; |
704 | return S_OK; |
705 | } |
706 | |
707 | //----------------------------------------------------------------------------- |
708 | // Public method to get the ICorDebugClass that matches this type. |
709 | // ICorDebugType has instantiated type-params (eg, List<int>), whereas |
710 | // ICorDebugClass is open (eg, List<T>). |
711 | // |
712 | // Parameters: |
713 | // pClass - OUT: gets class on return. |
714 | // Returns: |
715 | // S_OK on success. CORDBG_E_CLASS_NOT_LOADED if the class is not loaded. |
716 | // Else some other error. |
717 | //----------------------------------------------------------------------------- |
718 | HRESULT CordbType::GetClass(ICorDebugClass **pClass) |
719 | { |
720 | PUBLIC_REENTRANT_API_ENTRY(this); |
721 | ATT_REQUIRE_STOPPED_MAY_FAIL(GetProcess()); |
722 | |
723 | if ((m_pClass == NULL) && (m_elementType == ELEMENT_TYPE_STRING || |
724 | m_elementType == ELEMENT_TYPE_OBJECT)) |
725 | { |
726 | Init(FALSE); |
727 | } |
728 | if (m_pClass == NULL) |
729 | { |
730 | *pClass = NULL; |
731 | return CORDBG_E_CLASS_NOT_LOADED; |
732 | } |
733 | *pClass = m_pClass; |
734 | m_pClass->ExternalAddRef(); |
735 | return S_OK; |
736 | } |
737 | |
738 | //----------------------------------------------------------------------------- |
739 | // Public method to get array rank. This is only valid for arrays. |
740 | // |
741 | // Parameters: |
742 | // pnRank - OUT: *pnRank is set to rank on return |
743 | // |
744 | // Return: |
745 | // S_OK if success. E_INVALIDARG is this Type doesn't have a rank. |
746 | //----------------------------------------------------------------------------- |
747 | HRESULT CordbType::GetRank(ULONG32 *pnRank) |
748 | { |
749 | PUBLIC_REENTRANT_API_ENTRY(this); |
750 | VALIDATE_POINTER_TO_OBJECT(pnRank, ULONG32 *); |
751 | |
752 | if (m_elementType != ELEMENT_TYPE_SZARRAY && |
753 | m_elementType != ELEMENT_TYPE_ARRAY) |
754 | return E_INVALIDARG; |
755 | |
756 | *pnRank = (ULONG32) m_rank; |
757 | |
758 | return S_OK; |
759 | } |
760 | |
761 | //----------------------------------------------------------------------------- |
762 | // Public convenience method to get the first type parameter. |
763 | // This is purely to avoid needing to call EnumerateTypeParameters for |
764 | // the set of types that only have 1 type-parameter. |
765 | // |
766 | // Parameters: |
767 | // pType - OUT: get the ICorDebugType for the first type-parameter. |
768 | // Returns: |
769 | // S_OK on success. |
770 | //----------------------------------------------------------------------------- |
771 | HRESULT CordbType::GetFirstTypeParameter(ICorDebugType **pType) |
772 | { |
773 | PUBLIC_REENTRANT_API_ENTRY(this); |
774 | VALIDATE_POINTER_TO_OBJECT(pType, ICorDebugType **); |
775 | |
776 | // Since this is a public API, make sure there actually is at least 1 type-parameter. |
777 | if (m_inst.m_cInst == 0) |
778 | { |
779 | return E_INVALIDARG; |
780 | } |
781 | |
782 | _ASSERTE(m_inst.m_ppInst != NULL); |
783 | _ASSERTE(m_inst.m_ppInst[0] != NULL); |
784 | |
785 | *pType = m_inst.m_ppInst[0]; |
786 | if (*pType) |
787 | (*pType)->AddRef(); |
788 | return S_OK; |
789 | } |
790 | |
791 | //----------------------------------------------------------------------------- |
792 | // Internal worker to create a CordbType around a CordbClass. |
793 | // Parameters: |
794 | // appdomain - AD that the type lives in. |
795 | // et - CorElementType of the incoming CordbClass |
796 | // cl - CordbClass representing the type to build a CordbType for |
797 | // pRes - OUT: out parameter to return the newly created CordbType object. |
798 | // |
799 | // Return: |
800 | // S_OK on success. |
801 | //----------------------------------------------------------------------------- |
802 | HRESULT CordbType::MkUnparameterizedType(CordbAppDomain *appdomain, CorElementType et, CordbClass *cl,CordbType **pRes) |
803 | { |
804 | // Pass in empty instantiation since CordbClass has no generic info. |
805 | // We should make some assert between et and cl->GetType(). |
806 | Instantiation emptyInstantiation; |
807 | |
808 | return CordbType::MkType(appdomain, et, cl, &emptyInstantiation, pRes); |
809 | } |
810 | |
811 | |
812 | //----------------------------------------------------------------------------- |
813 | // Internal helper to get the First type parameter. |
814 | // This is an internal convenience function for the public GetFirstTypeParameter. |
815 | // |
816 | // Parameters: |
817 | // pRes - OUT: out-param to get the unary type-parameter. |
818 | //----------------------------------------------------------------------------- |
819 | void |
820 | CordbType::DestUnaryType(CordbType **pRes) |
821 | { |
822 | _ASSERTE(m_elementType == ELEMENT_TYPE_PTR |
823 | || m_elementType == ELEMENT_TYPE_BYREF |
824 | || m_elementType == ELEMENT_TYPE_ARRAY |
825 | || m_elementType == ELEMENT_TYPE_SZARRAY); |
826 | _ASSERTE(m_inst.m_cInst == 1); |
827 | _ASSERTE(m_inst.m_ppInst != NULL); |
828 | *pRes = m_inst.m_ppInst[0]; |
829 | } |
830 | |
831 | |
832 | |
833 | //----------------------------------------------------------------------------- |
834 | // Internal method to get the Class and type-parameters from a CordbType. |
835 | //----------------------------------------------------------------------------- |
836 | void |
837 | CordbType::DestConstructedType(CordbClass **cls, Instantiation *inst) |
838 | { |
839 | ASSERT(m_elementType == ELEMENT_TYPE_CLASS); |
840 | *cls = m_pClass; |
841 | *inst = m_inst; |
842 | } |
843 | |
844 | //----------------------------------------------------------------------------- |
845 | // Internal method to get all the type-parameters for a FnPtr |
846 | //----------------------------------------------------------------------------- |
847 | void |
848 | CordbType::DestNaryType(Instantiation *inst) |
849 | { |
850 | ASSERT(m_elementType == ELEMENT_TYPE_FNPTR); |
851 | *inst = m_inst; |
852 | } |
853 | |
854 | |
855 | //----------------------------------------------------------------------------- |
856 | // CordbType::SigToType |
857 | // Internal helper to create a CordbType from a Metadata signature (SigParser) |
858 | // |
859 | // This parses a metadata signature in the context of a module to return a CordbType. |
860 | // This heavily relies on the metadata and signature format. See ECMA Partition II for details. |
861 | // Since signatures may be recursive, this function can be called recursively. |
862 | // Since metadata signatures exist all over, this can be called in many different scenarios, including |
863 | // resolving a TypeSpec, looking up a field. |
864 | // |
865 | // pModule - module that the signature lives in. |
866 | // pSigParse - Signature, positioned at the point to read the Type from. |
867 | // This will not change the SigParser's current position. |
868 | // inst - instantiation containing Type Params for the context of the SigParser. |
869 | // For a local var or argument lookup, this would be the type-params from the Frame. |
870 | // For a field lookup, this would be the type-params for the containing type. |
871 | // pRes - OUT: yields the CordbType for this signature. |
872 | // |
873 | // Returns: |
874 | // S_OK on success |
875 | //----------------------------------------------------------------------------- |
876 | HRESULT |
877 | CordbType::SigToType(CordbModule * pModule, |
878 | SigParser * pSigParser, |
879 | const Instantiation * pInst, |
880 | CordbType ** ppResultType) |
881 | { |
882 | FAIL_IF_NEUTERED(pModule); |
883 | INTERNAL_SYNC_API_ENTRY(pModule->GetProcess()); |
884 | |
885 | _ASSERTE(pSigParser != NULL); |
886 | |
887 | |
888 | // |
889 | // Make a local copy of the SigParser since we are going to mutate it. |
890 | // |
891 | SigParser sigParser = *pSigParser; |
892 | |
893 | CorElementType elementType; |
894 | HRESULT hr; |
895 | |
896 | IfFailRet(sigParser.GetElemType(&elementType)); |
897 | |
898 | switch (elementType) |
899 | { |
900 | case ELEMENT_TYPE_VAR: |
901 | case ELEMENT_TYPE_MVAR: |
902 | { |
903 | ULONG tyvar_num; |
904 | |
905 | IfFailRet(sigParser.GetData(&tyvar_num)); |
906 | |
907 | |
908 | if (elementType == ELEMENT_TYPE_VAR) |
909 | { |
910 | // ELEMENT_TYPE_VAR refers to an indexed type-parameter in the containing Type. |
911 | // Eg, we may be doing a field lookup on 'List<T> { T m_head}', and the field's return type 'T' is Type-parameter #0. |
912 | // Or this maybe part of a base class's TypeSpec. |
913 | _ASSERTE (tyvar_num < (pInst->m_cClassTyPars)); |
914 | if (tyvar_num >= (pInst->m_cClassTyPars)) |
915 | return E_FAIL; |
916 | |
917 | _ASSERTE (pInst->m_ppInst != NULL); |
918 | *ppResultType = pInst->m_ppInst[tyvar_num]; |
919 | } |
920 | else |
921 | { |
922 | //ELEMENT_TYPE_MVAR refers to an indexed type-parameter in the containing Method. |
923 | // Eg, we may be in Class::Func<T> and refering to T. |
924 | // The Instantiation array has Type type-parameters first, and then any Method Type-parameters. |
925 | // The m_cClassTyPars field indicats where the split is between Type and Method type-parameters. Type type-params |
926 | // come first. |
927 | _ASSERTE(elementType == ELEMENT_TYPE_MVAR); |
928 | |
929 | |
930 | _ASSERTE (tyvar_num < (pInst->m_cInst - pInst->m_cClassTyPars)); |
931 | if (tyvar_num >= (pInst->m_cInst - pInst->m_cClassTyPars)) |
932 | return E_FAIL; |
933 | |
934 | _ASSERTE (pInst->m_ppInst != NULL); |
935 | *ppResultType = pInst->m_ppInst[tyvar_num + pInst->m_cClassTyPars]; |
936 | } |
937 | |
938 | return S_OK; |
939 | } |
940 | case ELEMENT_TYPE_GENERICINST: |
941 | { |
942 | //ELEMENT_TYPE_GENERICINST is that start of a instantiated generic type. |
943 | //Format for the signature blob is: |
944 | // 1) CorElementType, Token - this is the uninstantiated type (eg, for Pair<int, string>, it would be token for Pair<T,U>) |
945 | // 2) int - Count of generic args - eg, for Pair<T,U>, it would be "2". |
946 | // 3) type1,type2, ... - meteadata representation for generic args. For example above, it would be Type(int), Type(string). |
947 | |
948 | |
949 | // ignore "WITH", look at next ELEMENT_TYPE to get CLASS or VALUE |
950 | |
951 | IfFailRet(sigParser.GetElemType(&elementType)); |
952 | |
953 | mdToken token; |
954 | |
955 | IfFailRet(sigParser.GetToken(&token)); |
956 | |
957 | CordbClass * pClass; |
958 | |
959 | IfFailRet( pModule->ResolveTypeRefOrDef(token, &pClass)); |
960 | |
961 | // The use of a class in a signature provides definite evidence as to whether it is a VC or not. |
962 | _ASSERTE(!pClass->IsValueClassKnown() || |
963 | (pClass->IsValueClassNoInit() == (elementType == ELEMENT_TYPE_VALUETYPE)) || |
964 | !"A value class is being used with ELEMENT_TYPE_GENERICINST" ); |
965 | |
966 | pClass->SetIsValueClass(elementType == ELEMENT_TYPE_VALUETYPE); |
967 | pClass->SetIsValueClassKnown(true); |
968 | |
969 | // Build up the array of generic arguments. |
970 | ULONG cArgs; // number of generic arguments in the type. |
971 | |
972 | IfFailRet(sigParser.GetData(&cArgs)); |
973 | |
974 | S_UINT32 allocSize = S_UINT32( cArgs ) * S_UINT32( sizeof(CordbType *) ); |
975 | |
976 | if (allocSize.IsOverflow()) |
977 | { |
978 | IfFailRet(E_OUTOFMEMORY); |
979 | } |
980 | |
981 | CordbType ** ppTypeInstantiations = reinterpret_cast<CordbType **>(_alloca( allocSize.Value())); |
982 | |
983 | for (unsigned int i = 0; i < cArgs;i++) |
984 | { |
985 | IfFailRet(CordbType::SigToType(pModule, &sigParser, pInst, &ppTypeInstantiations[i])); |
986 | |
987 | IfFailRet(sigParser.SkipExactlyOne()); |
988 | } |
989 | |
990 | // Now we have the Open type (eg, Pair<T,U>) and the instantiation list, so create the Closed CordbType.. |
991 | Instantiation typeInstantiation(cArgs, ppTypeInstantiations); |
992 | |
993 | return CordbType::MkType(pModule->GetAppDomain(), elementType, pClass, &typeInstantiation, ppResultType); |
994 | } |
995 | case ELEMENT_TYPE_CLASS: |
996 | case ELEMENT_TYPE_VALUETYPE: // OK: this E_T_VALUETYPE comes from signature |
997 | { |
998 | // Path for non-generic types |
999 | |
1000 | mdToken token; |
1001 | |
1002 | IfFailRet(sigParser.GetToken(&token)); |
1003 | |
1004 | CordbClass * pClass; |
1005 | |
1006 | IfFailRet(pModule->ResolveTypeRefOrDef(token, &pClass)); |
1007 | |
1008 | // The use of a class in a signature provides definite evidence as to whether it is a VC or not. |
1009 | |
1010 | _ASSERTE(!pClass->IsValueClassKnown() || |
1011 | (pClass->IsValueClassNoInit() == (elementType == ELEMENT_TYPE_VALUETYPE)) || |
1012 | !"A non-value class is being used with ELEMENT_TYPE_VALUETYPE" ); |
1013 | |
1014 | pClass->SetIsValueClass(elementType == ELEMENT_TYPE_VALUETYPE); |
1015 | pClass->SetIsValueClassKnown(true); |
1016 | |
1017 | return CordbType::MkUnparameterizedType(pModule->GetAppDomain(), elementType, pClass, ppResultType); |
1018 | } |
1019 | case ELEMENT_TYPE_SENTINEL: |
1020 | case ELEMENT_TYPE_MODIFIER: |
1021 | case ELEMENT_TYPE_PINNED: |
1022 | { |
1023 | IfFailRet(CordbType::SigToType(pModule, &sigParser, pInst, ppResultType)); |
1024 | // Throw away SENTINELS on all CordbTypes... |
1025 | return S_OK; |
1026 | } |
1027 | case ELEMENT_TYPE_CMOD_REQD: |
1028 | case ELEMENT_TYPE_CMOD_OPT: |
1029 | { |
1030 | mdToken token; |
1031 | |
1032 | IfFailRet(sigParser.GetToken(&token)); |
1033 | |
1034 | IfFailRet(CordbType::SigToType(pModule, &sigParser, pInst, ppResultType)); |
1035 | // Throw away CMOD on all CordbTypes... |
1036 | return S_OK; |
1037 | } |
1038 | |
1039 | case ELEMENT_TYPE_ARRAY: |
1040 | { |
1041 | CordbType * pType; |
1042 | |
1043 | IfFailRet(CordbType::SigToType(pModule, &sigParser, pInst, &pType)); |
1044 | |
1045 | IfFailRet(sigParser.SkipExactlyOne()); |
1046 | |
1047 | ULONG rank; |
1048 | |
1049 | IfFailRet(sigParser.GetData(&rank)); |
1050 | |
1051 | return CordbType::MkType(pModule->GetAppDomain(), elementType, rank, pType, ppResultType); |
1052 | } |
1053 | case ELEMENT_TYPE_SZARRAY: |
1054 | { |
1055 | CordbType * pType; |
1056 | |
1057 | IfFailRet(CordbType::SigToType(pModule, &sigParser, pInst, &pType)); |
1058 | |
1059 | return CordbType::MkType(pModule->GetAppDomain(), elementType, 1, pType, ppResultType); |
1060 | } |
1061 | |
1062 | case ELEMENT_TYPE_PTR: |
1063 | case ELEMENT_TYPE_BYREF: |
1064 | { |
1065 | CordbType * pType; |
1066 | |
1067 | IfFailRet(CordbType::SigToType(pModule, &sigParser, pInst, &pType)); |
1068 | |
1069 | return CordbType::MkType(pModule->GetAppDomain(),elementType, 0, pType, ppResultType); |
1070 | } |
1071 | |
1072 | case ELEMENT_TYPE_FNPTR: |
1073 | { |
1074 | ULONG cArgs; |
1075 | |
1076 | IfFailRet(sigParser.GetData(&cArgs)); // Skip callingConv |
1077 | |
1078 | IfFailRet(sigParser.GetData(&cArgs)); // Get number of parameters |
1079 | |
1080 | S_UINT32 allocSize = ( S_UINT32(cArgs) + S_UINT32(1) ) * S_UINT32( sizeof(CordbType *) ); |
1081 | |
1082 | if (allocSize.IsOverflow()) |
1083 | { |
1084 | IfFailRet(E_OUTOFMEMORY); |
1085 | } |
1086 | |
1087 | CordbType ** ppTypeInstantiations = (CordbType **) _alloca( allocSize.Value() ); |
1088 | |
1089 | for (unsigned int i = 0; i <= cArgs; i++) |
1090 | { |
1091 | IfFailRet(CordbType::SigToType(pModule, &sigParser, pInst, &ppTypeInstantiations[i])); |
1092 | |
1093 | IfFailRet(sigParser.SkipExactlyOne()); |
1094 | } |
1095 | |
1096 | Instantiation typeInstantiation(cArgs + 1, ppTypeInstantiations); |
1097 | |
1098 | return CordbType::MkType(pModule->GetAppDomain(), elementType, &typeInstantiation, ppResultType); |
1099 | } |
1100 | |
1101 | case ELEMENT_TYPE_VOID: |
1102 | case ELEMENT_TYPE_BOOLEAN: |
1103 | case ELEMENT_TYPE_CHAR: |
1104 | case ELEMENT_TYPE_I1: |
1105 | case ELEMENT_TYPE_U1: |
1106 | case ELEMENT_TYPE_I2: |
1107 | case ELEMENT_TYPE_U2: |
1108 | case ELEMENT_TYPE_I4: |
1109 | case ELEMENT_TYPE_U4: |
1110 | case ELEMENT_TYPE_I8: |
1111 | case ELEMENT_TYPE_U8: |
1112 | case ELEMENT_TYPE_R4: |
1113 | case ELEMENT_TYPE_R8: |
1114 | case ELEMENT_TYPE_STRING: |
1115 | case ELEMENT_TYPE_TYPEDBYREF: |
1116 | case ELEMENT_TYPE_OBJECT: |
1117 | case ELEMENT_TYPE_I: |
1118 | case ELEMENT_TYPE_U: |
1119 | return CordbType::MkType(pModule->GetAppDomain(), elementType, ppResultType); |
1120 | |
1121 | default: |
1122 | _ASSERTE(!"unexpected element type!" ); |
1123 | return E_FAIL; |
1124 | } |
1125 | } // CordbType::SigToType |
1126 | |
1127 | //----------------------------------------------------------------------------- |
1128 | // Marshal a DebuggerIPCE_BasicTypeData --> CordbType. |
1129 | // |
1130 | // This will build up a DebuggerIPCE_ExpandedTypeData and convert that into |
1131 | // a CordbType. This may send additional IPC events if needed to |
1132 | // go from Basic --> Expanded data. Note that this is designed to handle generics. |
1133 | // |
1134 | // Parameters: |
1135 | // pAppDomain - the AppDomain the type lives in. |
1136 | // data - DebuggerIPCE_BasicTypeData from Left-Side containing type description. |
1137 | // pRes - OUT: out-parameter to hold built type. |
1138 | // |
1139 | // Returns: |
1140 | // S_OK on success. |
1141 | //----------------------------------------------------------------------------- |
1142 | HRESULT CordbType::TypeDataToType(CordbAppDomain *pAppDomain, DebuggerIPCE_BasicTypeData *data, CordbType **pRes) |
1143 | { |
1144 | FAIL_IF_NEUTERED(pAppDomain); |
1145 | INTERNAL_SYNC_API_ENTRY(pAppDomain->GetProcess()); // |
1146 | |
1147 | |
1148 | |
1149 | HRESULT hr = S_OK; |
1150 | CorElementType et = data->elementType; |
1151 | switch (et) |
1152 | { |
1153 | case ELEMENT_TYPE_ARRAY: |
1154 | case ELEMENT_TYPE_SZARRAY: |
1155 | case ELEMENT_TYPE_PTR: |
1156 | case ELEMENT_TYPE_BYREF: |
1157 | // For these element types the "Basic" type data only contains the type handle. |
1158 | // So we fetch some more data, and the go onto the "Expanded" case... |
1159 | { |
1160 | EX_TRY |
1161 | { |
1162 | DebuggerIPCE_ExpandedTypeData typeInfo; |
1163 | CordbProcess * pProcess = pAppDomain->GetProcess(); |
1164 | |
1165 | { |
1166 | RSLockHolder lockHolder(pProcess->GetProcessLock()); |
1167 | pProcess->GetDAC()->TypeHandleToExpandedTypeInfo(NoValueTypeBoxing, // could be generics |
1168 | // which are never boxed |
1169 | pAppDomain->GetADToken(), |
1170 | data->vmTypeHandle, |
1171 | &typeInfo); |
1172 | } |
1173 | |
1174 | IfFailThrow(CordbType::TypeDataToType(pAppDomain,&typeInfo, pRes)); |
1175 | } |
1176 | EX_CATCH_HRESULT(hr); |
1177 | return hr; |
1178 | |
1179 | } |
1180 | |
1181 | case ELEMENT_TYPE_FNPTR: |
1182 | { |
1183 | DebuggerIPCE_ExpandedTypeData e; |
1184 | e.elementType = et; |
1185 | e.NaryTypeData.typeHandle = data->vmTypeHandle; |
1186 | return CordbType::TypeDataToType(pAppDomain, &e, pRes); |
1187 | } |
1188 | default: |
1189 | // For all other element types the "Basic" view of a type |
1190 | // contains the same information as the "expanded" |
1191 | // view, so just reuse the code for the Expanded view... |
1192 | DebuggerIPCE_ExpandedTypeData e; |
1193 | e.elementType = et; |
1194 | e.ClassTypeData.metadataToken = data->metadataToken; |
1195 | e.ClassTypeData.vmDomainFile = data->vmDomainFile; |
1196 | e.ClassTypeData.vmModule = data->vmModule; |
1197 | e.ClassTypeData.typeHandle = data->vmTypeHandle; |
1198 | return CordbType::TypeDataToType(pAppDomain, &e, pRes); |
1199 | } |
1200 | } |
1201 | |
1202 | //----------------------------------------------------------------------------- |
1203 | // Marshal DebuggerIPCE_ExpandedTypeData --> CordbType |
1204 | // The ExpandedTypeData just contains top level generic info, and so |
1205 | // the RS may need to send more IPC events to fill out details. |
1206 | // |
1207 | // Parameters: |
1208 | // pAppDomain - the appdomain that all the types live in. |
1209 | // data - data used to build up CordbType |
1210 | // pRes - OUT: out param to get back CordbType on return. |
1211 | // |
1212 | // Returns: |
1213 | // S_OK on success. |
1214 | //----------------------------------------------------------------------------- |
1215 | HRESULT CordbType::TypeDataToType(CordbAppDomain *pAppDomain, DebuggerIPCE_ExpandedTypeData *data, CordbType **pRes) |
1216 | { |
1217 | INTERNAL_SYNC_API_ENTRY(pAppDomain->GetProcess()); // |
1218 | |
1219 | CorElementType et = data->elementType; |
1220 | HRESULT hr = S_OK; |
1221 | switch (et) |
1222 | { |
1223 | |
1224 | case ELEMENT_TYPE_OBJECT: |
1225 | case ELEMENT_TYPE_VOID: |
1226 | case ELEMENT_TYPE_BOOLEAN: |
1227 | case ELEMENT_TYPE_CHAR: |
1228 | case ELEMENT_TYPE_I1: |
1229 | case ELEMENT_TYPE_U1: |
1230 | case ELEMENT_TYPE_I2: |
1231 | case ELEMENT_TYPE_U2: |
1232 | case ELEMENT_TYPE_I4: |
1233 | case ELEMENT_TYPE_U4: |
1234 | case ELEMENT_TYPE_I8: |
1235 | case ELEMENT_TYPE_U8: |
1236 | case ELEMENT_TYPE_R4: |
1237 | case ELEMENT_TYPE_R8: |
1238 | case ELEMENT_TYPE_STRING: |
1239 | case ELEMENT_TYPE_TYPEDBYREF: |
1240 | case ELEMENT_TYPE_I: |
1241 | case ELEMENT_TYPE_U: |
1242 | ETObject: |
1243 | // It's a primitive (therefore non-generic) type, so we can just create it immediately. |
1244 | IfFailRet (CordbType::MkType(pAppDomain, et, pRes)); |
1245 | break; |
1246 | |
1247 | case ELEMENT_TYPE_CLASS: |
1248 | case ELEMENT_TYPE_VALUETYPE: // OK: this E_T_VALUETYPE comes from the EE |
1249 | { |
1250 | // |
1251 | if (data->ClassTypeData.metadataToken == mdTokenNil) { |
1252 | et = ELEMENT_TYPE_OBJECT; |
1253 | goto ETObject; |
1254 | } |
1255 | CordbModule * pClassModule = NULL; |
1256 | EX_TRY |
1257 | { |
1258 | pClassModule = pAppDomain->LookupOrCreateModule(data->ClassTypeData.vmModule, data->ClassTypeData.vmDomainFile); |
1259 | } |
1260 | EX_CATCH_HRESULT(hr); |
1261 | if( pClassModule == NULL ) |
1262 | { |
1263 | // We don't know anything about this module - shouldn't happen. |
1264 | // <TODO>This can be hit by the issue described in VSWhidbey 465120</TODO> |
1265 | _ASSERTE(!"Unrecognized module" ); |
1266 | return CORDBG_E_MODULE_NOT_LOADED; |
1267 | } |
1268 | |
1269 | CordbClass *tycon; |
1270 | IfFailRet (pClassModule->LookupOrCreateClass(data->ClassTypeData.metadataToken,&tycon)); |
1271 | if (!(data->ClassTypeData.typeHandle.IsNull())) |
1272 | { |
1273 | // It's a generic type. We have the typehandle, use that to query for the rest of |
1274 | // the tyeparameters and build up the instantiation for the CordbType. |
1275 | |
1276 | IfFailRet (CordbType::InstantiateFromTypeHandle(pAppDomain, data->ClassTypeData.typeHandle, et, tycon, pRes)); |
1277 | // Set the type handle regardless of how we found |
1278 | // the type. For example if type was already |
1279 | // constructed without the type handle still set |
1280 | // it here. |
1281 | if (*pRes) |
1282 | { |
1283 | (*pRes)->m_typeHandleExact = data->ClassTypeData.typeHandle; |
1284 | } |
1285 | break; |
1286 | } |
1287 | else |
1288 | { |
1289 | // Non generic type. Since we already have the CordbClass for it, we can trivially create the CordbType |
1290 | IfFailRet (CordbType::MkUnparameterizedType(pAppDomain, et,tycon,pRes)); |
1291 | break; |
1292 | } |
1293 | |
1294 | } |
1295 | case ELEMENT_TYPE_ARRAY: |
1296 | case ELEMENT_TYPE_SZARRAY: |
1297 | { |
1298 | CordbType *argty; |
1299 | IfFailRet (CordbType::TypeDataToType(pAppDomain, &(data->ArrayTypeData.arrayTypeArg), &argty)); |
1300 | IfFailRet (CordbType::MkType(pAppDomain, et, data->ArrayTypeData.arrayRank, argty, pRes)); |
1301 | break; |
1302 | } |
1303 | |
1304 | case ELEMENT_TYPE_PTR: |
1305 | case ELEMENT_TYPE_BYREF: |
1306 | { |
1307 | CordbType *argty; |
1308 | IfFailRet (CordbType::TypeDataToType(pAppDomain, &(data->UnaryTypeData.unaryTypeArg), &argty)); |
1309 | IfFailRet (CordbType::MkType(pAppDomain, et, 0, argty, pRes)); |
1310 | break; |
1311 | } |
1312 | case ELEMENT_TYPE_FNPTR: |
1313 | { |
1314 | IfFailRet (CordbType::InstantiateFromTypeHandle(pAppDomain, data->NaryTypeData.typeHandle, et, NULL, pRes)); |
1315 | if (*pRes) |
1316 | { |
1317 | (*pRes)->m_typeHandleExact = data->NaryTypeData.typeHandle; |
1318 | } |
1319 | break; |
1320 | } |
1321 | case ELEMENT_TYPE_END: |
1322 | *pRes = NULL; |
1323 | return E_FAIL; |
1324 | |
1325 | default: |
1326 | _ASSERTE(!"unexpected element type!" ); |
1327 | return E_FAIL; |
1328 | |
1329 | } |
1330 | return S_OK; |
1331 | } |
1332 | |
1333 | //----------------------------------------------------------------------------- |
1334 | // CordbType::InstantiateFromTypeHandle |
1335 | // Internal helper method. |
1336 | // Builds (Left-Side) TypeHandle --> (Right-Side) CordbType |
1337 | // This is very useful when we get a typehandle from the LeftSide. A common |
1338 | // scenario is when we get an Object back from the LS, which happens when |
1339 | // we build the CordbType corresponding to a Cordb*Value. |
1340 | // |
1341 | // Parameters: |
1342 | // pAppdomain - the appdomain the type lives in. |
1343 | // vmTypeHandle - a Left-Side typehandle describing the type. |
1344 | // elementType - convenient way to indicate whether we've got ELEMENT_TYPE_FNPTR or |
1345 | // something else. We should be able to retrieve this from the TypeHandle, |
1346 | // but our caller already has it available. |
1347 | // typeConstructor - CordbClass corresponding to the typeHandle. This could be built |
1348 | // up from typehandle, but our caller already has it. |
1349 | // Will be NULL for ELEMENT_TYPE_FNPTR |
1350 | // pResultType - OUT: out parameter to yield CordbType for the TypeHandle. |
1351 | // |
1352 | // Returns: |
1353 | // S_OK on success. |
1354 | //----------------------------------------------------------------------------- |
1355 | HRESULT CordbType::InstantiateFromTypeHandle(CordbAppDomain * pAppDomain, |
1356 | VMPTR_TypeHandle vmTypeHandle, |
1357 | CorElementType elementType, |
1358 | CordbClass * typeConstructor, |
1359 | CordbType ** pResultType) |
1360 | { |
1361 | HRESULT hr = S_OK; |
1362 | |
1363 | // Should already by synced by caller. |
1364 | INTERNAL_SYNC_API_ENTRY(pAppDomain->GetProcess()); // |
1365 | _ASSERTE((pAppDomain->GetProcess()->GetShim() == NULL) || (pAppDomain->GetProcess()->GetSynchronized())); |
1366 | |
1367 | EX_TRY |
1368 | { |
1369 | CordbProcess * pProcess = pAppDomain->GetProcess(); |
1370 | // |
1371 | // Step 1) Ask DacDbi interface for a list of type-parameters given a TypeHandle. |
1372 | // |
1373 | |
1374 | TypeParamsList params; |
1375 | { |
1376 | RSLockHolder lockHolder(pProcess->GetProcessLock()); |
1377 | pProcess->GetDAC()->GetTypeHandleParams(pAppDomain->GetADToken(), vmTypeHandle, ¶ms); |
1378 | } |
1379 | |
1380 | // convert the parameter type information to a list of CordbTypeInstances (one for each parameter) |
1381 | // note: typeList will be destroyed on exit, running destructors for each element. In this case, that |
1382 | // means it will simply assert IsNeutered. |
1383 | DacDbiArrayList<CordbType *> typeList; |
1384 | typeList.Alloc(params.Count()); |
1385 | for (int i = 0; i < params.Count(); ++i) |
1386 | { |
1387 | IfFailThrow(TypeDataToType(pAppDomain, &(params[i]), &(typeList[i]))); |
1388 | } |
1389 | |
1390 | // now make an instance of CordbType from an instantiation |
1391 | Instantiation instantiation(params.Count(), &(typeList[0])); |
1392 | if (elementType == ELEMENT_TYPE_FNPTR) |
1393 | { |
1394 | IfFailThrow(CordbType::MkType(pAppDomain, elementType, &instantiation, pResultType)); |
1395 | } |
1396 | else |
1397 | { |
1398 | IfFailThrow(CordbType::MkType(pAppDomain, elementType, typeConstructor, &instantiation, pResultType)); |
1399 | } |
1400 | } |
1401 | EX_CATCH_HRESULT(hr); |
1402 | return hr; |
1403 | } // CordbType::InstantiateFromTypeHandle |
1404 | |
1405 | //----------------------------------------------------------------------------- |
1406 | // Initialize the CordbType. |
1407 | // This will involve a lot of queries to the Left-side. |
1408 | // This means finding the type-handle, getting / creating associated CordbClass, |
1409 | // filling out the instantiation, getting field info, etc. |
1410 | // |
1411 | // Parameters: |
1412 | // fForceInit - if false, may skip initialization if TypeHandle already known. |
1413 | // |
1414 | // Returns: |
1415 | // S_OK if success, CORDBG_E_CLASS_NOT_LOADED, E_INVALIDARG, OOM on failure |
1416 | //----------------------------------------------------------------------------- |
1417 | HRESULT CordbType::Init(BOOL fForceInit) |
1418 | { |
1419 | INTERNAL_SYNC_API_ENTRY(GetProcess()); // |
1420 | |
1421 | HRESULT hr = S_OK; |
1422 | |
1423 | if (m_pClass && m_pClass->GetLoadLevel() != CordbClass::FullInfo) |
1424 | fForceInit = TRUE; |
1425 | |
1426 | // Step 1. initialize the type constructor (if one exists) |
1427 | // and the (class) type parameters.... |
1428 | if (m_elementType == ELEMENT_TYPE_CLASS) |
1429 | { |
1430 | |
1431 | // start by initing only enough so that we can determine whether |
1432 | // or not this is a generic class. When dealing with generic |
1433 | // type instantiations there is no guarantee the open generic |
1434 | // type is fully restored. If we load too eagerly it might fail |
1435 | // and we wouldn't actually need that extra data anyways. |
1436 | _ASSERTE(m_pClass != NULL); |
1437 | EX_TRY |
1438 | { |
1439 | m_pClass->Init(CordbClass::BasicInfo); |
1440 | } |
1441 | EX_CATCH_HRESULT(hr); |
1442 | IfFailRet(hr); |
1443 | |
1444 | // non-generic classes need the class object to be fully inited |
1445 | // in the generic case we won't ever use that data |
1446 | if (!m_pClass->HasTypeParams()) |
1447 | { |
1448 | EX_TRY |
1449 | { |
1450 | m_pClass->Init(CordbClass::FullInfo); |
1451 | } |
1452 | EX_CATCH_HRESULT(hr); |
1453 | IfFailRet(hr); |
1454 | |
1455 | return S_OK; // Non-generic, that's all - no clean-up required |
1456 | } |
1457 | } |
1458 | |
1459 | _ASSERTE(m_elementType != ELEMENT_TYPE_CLASS || m_pClass->HasTypeParams()); |
1460 | |
1461 | for (unsigned int i = 0; i<m_inst.m_cClassTyPars; i++) |
1462 | { |
1463 | _ASSERTE(m_inst.m_ppInst != NULL); |
1464 | _ASSERTE(m_inst.m_ppInst[i] != NULL); |
1465 | IfFailRet( m_inst.m_ppInst[i]->Init(fForceInit) ); |
1466 | } |
1467 | |
1468 | // Step 2. Try to fetch the type handle if necessary (only |
1469 | // for instantiated class types, pointer types etc.) |
1470 | // We do this by preparing an event specifying the type and |
1471 | // then fetching the type handle from the left-side. This |
1472 | // will not always succeed, as forcing the load of the type handle would be the |
1473 | // equivalent of doing a FuncEval, i.e. the instantiation may |
1474 | // not have been created. But we try anyway to reduce the number of |
1475 | // failures. |
1476 | // |
1477 | // Note that in the normal case we will have the type handle from the EE |
1478 | // anyway, e.g. if the CordbType was created when reporting the type |
1479 | // of an actual object. |
1480 | |
1481 | // Initialize m_typeHandleExact if it needs it |
1482 | if (m_elementType == ELEMENT_TYPE_ARRAY || |
1483 | m_elementType == ELEMENT_TYPE_SZARRAY || |
1484 | m_elementType == ELEMENT_TYPE_BYREF || |
1485 | m_elementType == ELEMENT_TYPE_PTR || |
1486 | m_elementType == ELEMENT_TYPE_FNPTR || |
1487 | (m_elementType == ELEMENT_TYPE_CLASS && m_pClass->HasTypeParams())) |
1488 | { |
1489 | // It is OK if getting an exact type handle |
1490 | // fails with CORDBG_E_CLASS_NOT_LOADED. In that case we leave |
1491 | // the type information incomplete and subsequent operations |
1492 | // will try to call Init() again. The immediate operation will fail later if |
1493 | // TypeToBasicTypeData requests the exact type information for this type. |
1494 | hr = InitInstantiationTypeHandle(fForceInit); |
1495 | if (hr != CORDBG_E_CLASS_NOT_LOADED) |
1496 | IfFailRet(hr); |
1497 | } |
1498 | |
1499 | |
1500 | // For OBJECT and STRING we may not have a value for m_class |
1501 | // object. Go try and get it. |
1502 | if (m_elementType == ELEMENT_TYPE_STRING || |
1503 | m_elementType == ELEMENT_TYPE_OBJECT) |
1504 | { |
1505 | IfFailRet(InitStringOrObjectClass(fForceInit)); |
1506 | } |
1507 | |
1508 | // Step 3. Fetch the information that is specific to the type where necessary... |
1509 | // Now we have the type handle for the constructed type, we can ask for the size of |
1510 | // the object. Only do this for constructed value types. |
1511 | // |
1512 | // Note that the exact and/or approximate type handles may not be available. |
1513 | if ((m_elementType == ELEMENT_TYPE_CLASS) && m_pClass->HasTypeParams()) |
1514 | { |
1515 | IfFailRet(InitInstantiationFieldInfo(fForceInit)); |
1516 | } |
1517 | |
1518 | return S_OK; |
1519 | } |
1520 | |
1521 | //----------------------------------------------------------------------------- |
1522 | // Internal function to communicate with Left-Side to get an exact TypeHandle |
1523 | // (runtime type representation) for this CordbType. |
1524 | // |
1525 | // Parameters: |
1526 | // fForceInit - if false, may skip initialization if TypeHandle already known. |
1527 | // |
1528 | // Returns: |
1529 | // S_OK on success or failure HR E_INVALIDARG, OOM, CORDBG_E_CLASS_NOT_LOADED |
1530 | // on failure |
1531 | //----------------------------------------------------------------------------- |
1532 | HRESULT CordbType::InitInstantiationTypeHandle(BOOL fForceInit) |
1533 | { |
1534 | |
1535 | // Check if we've already done this Init |
1536 | if (!fForceInit && !m_typeHandleExact.IsNull()) |
1537 | return S_OK; |
1538 | |
1539 | HRESULT hr = S_OK; |
1540 | |
1541 | // Create an array of DebuggerIPCE_BasicTypeData structures from the array of type parameters. |
1542 | // First, get a buffer to hold the information |
1543 | CordbProcess *pProcess = GetProcess(); |
1544 | S_UINT32 bufferSize = S_UINT32(sizeof(DebuggerIPCE_BasicTypeData)) * |
1545 | S_UINT32(m_inst.m_cClassTyPars); |
1546 | EX_TRY |
1547 | { |
1548 | if( bufferSize.IsOverflow() ) |
1549 | { |
1550 | ThrowHR(E_INVALIDARG); |
1551 | } |
1552 | NewHolder<DebuggerIPCE_BasicTypeData> pArgTypeData(new DebuggerIPCE_BasicTypeData[bufferSize.Value()]); |
1553 | |
1554 | // We will have already called Init on each of the type parameters further above. Now we build a |
1555 | // list of type information for each type parameter. |
1556 | for (unsigned int i = 0; i < m_inst.m_cClassTyPars; i++) |
1557 | { |
1558 | _ASSERTE(m_inst.m_ppInst != NULL); |
1559 | _ASSERTE(m_inst.m_ppInst[i] != NULL); |
1560 | IfFailThrow(m_inst.m_ppInst[i]->TypeToBasicTypeData(&pArgTypeData[i])); |
1561 | } |
1562 | |
1563 | DebuggerIPCE_ExpandedTypeData typeData; |
1564 | |
1565 | // get the top-level type information |
1566 | TypeToExpandedTypeData(&typeData); |
1567 | |
1568 | ArgInfoList argInfo(pArgTypeData, m_inst.m_cClassTyPars); |
1569 | |
1570 | { |
1571 | // Get the TypeHandle based on the type data |
1572 | RSLockHolder lockHolder(GetProcess()->GetProcessLock()); |
1573 | hr = pProcess->GetDAC()->GetExactTypeHandle(&typeData, &argInfo, m_typeHandleExact); |
1574 | } |
1575 | } |
1576 | EX_CATCH_HRESULT(hr); |
1577 | |
1578 | return hr; |
1579 | } // CordbType::InitInstantiationTypeHandle |
1580 | |
1581 | //----------------------------------------------------------------------------- |
1582 | // Internal helper for CordbType::Init to finish initialize types for |
1583 | // System.String or System.Object. |
1584 | // This just needs to set the m_class field. |
1585 | // |
1586 | // Parameters: |
1587 | // fForceInit - force re-initialization if already initialized. |
1588 | // |
1589 | // Returns: |
1590 | // S_OK on success or CORDBG_E_CLASS_NOT_LOADED on failure. |
1591 | // |
1592 | // Note: verification with IPC result may assert |
1593 | //----------------------------------------------------------------------------- |
1594 | |
1595 | HRESULT CordbType::InitStringOrObjectClass(BOOL fForceInit) |
1596 | { |
1597 | // This CordbType is a non-generic class, either System.String or System.Object. |
1598 | // Need to find the CordbClass instance (in the proper AppDomain) that matches that type. |
1599 | |
1600 | // Check if we've already done this Init |
1601 | if (!fForceInit && m_pClass != NULL) |
1602 | { |
1603 | return S_OK; |
1604 | } |
1605 | |
1606 | HRESULT hr = S_OK; |
1607 | |
1608 | EX_TRY |
1609 | { |
1610 | // |
1611 | // Step 1a) Send a request to the DAC to map: CorElementType --> {token, Module} |
1612 | // |
1613 | CordbProcess *pProcess = GetProcess(); |
1614 | mdTypeDef metadataToken; |
1615 | VMPTR_DomainFile vmDomainFile = VMPTR_DomainFile::NullPtr(); |
1616 | VMPTR_Module vmModule = VMPTR_Module::NullPtr(); |
1617 | |
1618 | { |
1619 | RSLockHolder lockHolder(GetProcess()->GetProcessLock()); |
1620 | pProcess->GetDAC()->GetSimpleType(m_appdomain->GetADToken(), |
1621 | m_elementType, |
1622 | &metadataToken, |
1623 | &vmModule, |
1624 | &vmDomainFile); |
1625 | } |
1626 | |
1627 | // |
1628 | // Step 2) Lookup CordbClass based off token + Module. |
1629 | // |
1630 | CordbModule * pTypeModule = m_appdomain->LookupOrCreateModule(vmModule, vmDomainFile); |
1631 | |
1632 | _ASSERTE(pTypeModule != NULL); |
1633 | IfFailThrow(pTypeModule->LookupOrCreateClass(metadataToken, &m_pClass)); |
1634 | |
1635 | _ASSERTE(m_pClass != NULL); |
1636 | |
1637 | _ASSERTE(SUCCEEDED(hr)); |
1638 | m_pClass->AddRef(); |
1639 | |
1640 | } |
1641 | EX_CATCH_HRESULT(hr); |
1642 | return hr; |
1643 | } // CordbType::InitStringOrObjectClass |
1644 | |
1645 | //----------------------------------------------------------------------------- |
1646 | // Internal helper for CordbType::Init to get FieldInfos for a generic Type. |
1647 | // Non-generic types can use the FieldInfos off their associated CordbClass. |
1648 | // |
1649 | // Parameters: |
1650 | // fForceInit - force re-initialization if already initialized? |
1651 | // |
1652 | // Returns: |
1653 | // S_OK on success. |
1654 | //----------------------------------------------------------------------------- |
1655 | HRESULT CordbType::InitInstantiationFieldInfo(BOOL fForceInit) |
1656 | { |
1657 | HRESULT hr = S_OK; |
1658 | |
1659 | // Check if we've already done this Init |
1660 | if (!m_fieldInfoNeedsInit && !fForceInit) |
1661 | { |
1662 | return hr; |
1663 | } |
1664 | |
1665 | _ASSERTE(m_elementType == ELEMENT_TYPE_CLASS); |
1666 | _ASSERTE(m_pClass->HasTypeParams()); |
1667 | |
1668 | VMPTR_TypeHandle typeHandleApprox = m_typeHandleExact; |
1669 | |
1670 | // If the exact type handle is not available then get the approximate type handle. |
1671 | if (typeHandleApprox.IsNull()) |
1672 | { |
1673 | // set up a buffer to hold type parameter information for the type. (See |
1674 | // code:CordbType::GatherTypeData for more information). First, compute its size. |
1675 | unsigned int typeDataNodeCount = 0; |
1676 | this->CountTypeDataNodes(&typeDataNodeCount); |
1677 | |
1678 | EX_TRY |
1679 | { |
1680 | // allocate a buffer to hold the parameter data |
1681 | TypeInfoList typeData; |
1682 | |
1683 | typeData.Alloc(typeDataNodeCount); |
1684 | |
1685 | // fill the buffer |
1686 | DebuggerIPCE_TypeArgData * pCurrent = &(typeData[0]); |
1687 | GatherTypeData(this, &pCurrent); |
1688 | |
1689 | // request the type handle from the DAC |
1690 | CordbProcess *pProcess = GetProcess(); |
1691 | { |
1692 | RSLockHolder lockHolder(pProcess->GetProcessLock()); |
1693 | typeHandleApprox = pProcess->GetDAC()->GetApproxTypeHandle(&typeData); |
1694 | } |
1695 | } |
1696 | EX_CATCH_HRESULT(hr); |
1697 | if(FAILED(hr)) return hr; |
1698 | } |
1699 | |
1700 | // OK, now get the field info if we can. |
1701 | CordbProcess *pProcess = GetProcess(); |
1702 | EX_TRY |
1703 | { |
1704 | { |
1705 | // this may be called multiple times. Each call will discard previous values in m_fieldList and reinitialize |
1706 | // the list with updated information |
1707 | RSLockHolder lockHolder(pProcess->GetProcessLock()); |
1708 | pProcess->GetDAC()->GetInstantiationFieldInfo(m_pClass->GetModule()->GetRuntimeDomainFile(), |
1709 | m_typeHandleExact, |
1710 | typeHandleApprox, |
1711 | &m_fieldList, |
1712 | &m_objectSize); |
1713 | } |
1714 | } |
1715 | EX_CATCH_HRESULT(hr); |
1716 | |
1717 | return hr; |
1718 | } |
1719 | |
1720 | HRESULT CordbType::ReturnedByValue() |
1721 | { |
1722 | HRESULT hr = S_OK; |
1723 | |
1724 | if (!IsValueType()) |
1725 | return S_OK; |
1726 | |
1727 | |
1728 | ULONG32 unboxedSize = 0; |
1729 | IfFailRet(GetUnboxedObjectSize(&unboxedSize)); |
1730 | |
1731 | if (unboxedSize > sizeof(SIZE_T)) |
1732 | return S_FALSE; |
1733 | |
1734 | mdToken mdClass = m_pClass->GetToken(); |
1735 | |
1736 | int fieldCount = 0; |
1737 | bool unsupported = false; |
1738 | |
1739 | HCORENUM fields = 0; |
1740 | ULONG fetched = 0; |
1741 | mdToken mdField; |
1742 | IMetaDataImport *pImport = m_pClass->GetModule()->GetMetaDataImporter(); |
1743 | IfFailRet(pImport->EnumFields(&fields, mdClass, &mdField, 1, &fetched)); |
1744 | |
1745 | while (hr == S_OK && fetched == 1) |
1746 | { |
1747 | DWORD attr = 0; |
1748 | PCCOR_SIGNATURE sigBlob = 0; |
1749 | ULONG sigLen = 0; |
1750 | hr = pImport->GetFieldProps(mdField, NULL, NULL, 0, NULL, &attr, &sigBlob, &sigLen, NULL, NULL, NULL); |
1751 | |
1752 | if (SUCCEEDED(hr)) |
1753 | { |
1754 | // !static |
1755 | if ((attr & 0x10) == 0) |
1756 | { |
1757 | if (fieldCount++) |
1758 | break; |
1759 | |
1760 | CorElementType et; |
1761 | SigParser parser(sigBlob, sigLen); |
1762 | parser.GetByte(NULL); // 0x6, field signature |
1763 | parser.SkipCustomModifiers(); |
1764 | hr = parser.GetElemType(&et); |
1765 | if (SUCCEEDED(hr)) |
1766 | { |
1767 | switch (et) |
1768 | { |
1769 | case ELEMENT_TYPE_R4: |
1770 | case ELEMENT_TYPE_R8: |
1771 | unsupported = true; |
1772 | break; |
1773 | |
1774 | case ELEMENT_TYPE_CLASS: |
1775 | case ELEMENT_TYPE_STRING: |
1776 | case ELEMENT_TYPE_PTR: |
1777 | // OK |
1778 | break; |
1779 | |
1780 | default: |
1781 | if (!CorIsPrimitiveType(et)) |
1782 | unsupported = true; |
1783 | break; |
1784 | } |
1785 | |
1786 | if (unsupported) |
1787 | break; |
1788 | } |
1789 | } |
1790 | |
1791 | hr = pImport->EnumFields(&fields, mdClass, &mdField, 1, &fetched); |
1792 | } |
1793 | |
1794 | if (FAILED(hr)) |
1795 | { |
1796 | pImport->CloseEnum(fields); |
1797 | return hr; |
1798 | } |
1799 | } |
1800 | |
1801 | pImport->CloseEnum(fields); |
1802 | |
1803 | if (unsupported) |
1804 | return S_FALSE; |
1805 | |
1806 | return fieldCount <= 1 ? S_OK : S_FALSE; |
1807 | } |
1808 | |
1809 | |
1810 | //----------------------------------------------------------------------------- |
1811 | // Internal helper to get the size (in bytes) of the unboxed object. |
1812 | // For a generic type, the size of the type depends on the size of the |
1813 | // type-parameters. |
1814 | // This is commonly used by Cordb*Value in their Initialization when they |
1815 | // need to cache the size of the Target object they refer to. |
1816 | // |
1817 | // This should only be called on Value-types and Primitives (eg, i4, FnPtr). |
1818 | // It should not be called on Reference types. |
1819 | // |
1820 | // Parameters: |
1821 | // pObjectSize - OUT: out-parameter to get the size in bytes. |
1822 | // |
1823 | // Returns: |
1824 | // S_OK on success. |
1825 | //----------------------------------------------------------------------------- |
1826 | HRESULT |
1827 | CordbType::GetUnboxedObjectSize(ULONG32 *pObjectSize) |
1828 | { |
1829 | INTERNAL_SYNC_API_ENTRY(GetProcess()); // |
1830 | |
1831 | HRESULT hr = S_OK; |
1832 | bool isVC = false; |
1833 | |
1834 | EX_TRY |
1835 | { |
1836 | isVC = IsValueType(); |
1837 | } |
1838 | EX_CATCH_HRESULT(hr); |
1839 | |
1840 | IfFailRet(hr); |
1841 | |
1842 | if (isVC) |
1843 | { |
1844 | *pObjectSize = 0; |
1845 | |
1846 | hr = Init(FALSE); |
1847 | |
1848 | if (!SUCCEEDED(hr)) |
1849 | return hr; |
1850 | |
1851 | *pObjectSize = (ULONG) ((!m_pClass->HasTypeParams()) ? m_pClass->ObjectSize() : this->m_objectSize); |
1852 | |
1853 | return hr; |
1854 | } |
1855 | else |
1856 | { |
1857 | // Caller guarantees that we're not a class. And the check above guarantees we're not a value-type. |
1858 | // So we're some sort of primitive, and thus we can determine size from the signature. |
1859 | // |
1860 | // @dbgtodo inspection - We didn't have this assert in Whidbey, and it's firing in vararg |
1861 | // scenarios even though it's returning the right value for reference types (i.e. 4 on x86 and 8 on |
1862 | // 64-bit). Commenting it out for now. |
1863 | //_ASSERTE(m_elementType != ELEMENT_TYPE_CLASS); |
1864 | |
1865 | // We need to use a temporary variable here -- attempting to cast among pointer types |
1866 | // (i.e., (PCCOR_SIGNATURE) &m_elementType) yields incorrect results on big-endian machines |
1867 | COR_SIGNATURE corSig = (COR_SIGNATURE) m_elementType; |
1868 | |
1869 | SigParser sigParser(&corSig, sizeof(corSig)); |
1870 | |
1871 | ULONG size; |
1872 | |
1873 | IfFailRet(sigParser.PeekElemTypeSize(&size)); |
1874 | |
1875 | *pObjectSize = size; |
1876 | return hr; |
1877 | } |
1878 | } |
1879 | |
1880 | VMPTR_DomainFile CordbType::GetDomainFile() |
1881 | { |
1882 | if (m_pClass != NULL) |
1883 | { |
1884 | CordbModule * pModule = m_pClass->GetModule(); |
1885 | if (pModule) |
1886 | { |
1887 | return pModule->m_vmDomainFile; |
1888 | } |
1889 | else |
1890 | { |
1891 | return VMPTR_DomainFile::NullPtr(); |
1892 | } |
1893 | } |
1894 | else |
1895 | { |
1896 | return VMPTR_DomainFile::NullPtr(); |
1897 | } |
1898 | } |
1899 | |
1900 | |
1901 | VMPTR_Module CordbType::GetModule() |
1902 | { |
1903 | if (m_pClass != NULL) |
1904 | { |
1905 | CordbModule * pModule = m_pClass->GetModule(); |
1906 | if (pModule) |
1907 | { |
1908 | return pModule->GetRuntimeModule(); |
1909 | } |
1910 | else |
1911 | { |
1912 | return VMPTR_Module::NullPtr(); |
1913 | } |
1914 | } |
1915 | else |
1916 | { |
1917 | return VMPTR_Module::NullPtr(); |
1918 | } |
1919 | } |
1920 | //----------------------------------------------------------------------------- |
1921 | // Internal method to Marshal: CordbType --> DebuggerIPCE_BasicTypeData |
1922 | // Nb. CordbType::Init will call this. The operation |
1923 | // fails if the exact type information has been requested but was not available |
1924 | // |
1925 | // Parameters: |
1926 | // data - OUT: BasicTypeData instance to fill out. |
1927 | // |
1928 | // Returns: |
1929 | // S_OK on success, CORDBG_E_CLASS_NOT_LOADED on failure |
1930 | //----------------------------------------------------------------------------- |
1931 | HRESULT CordbType::TypeToBasicTypeData(DebuggerIPCE_BasicTypeData *data) |
1932 | { |
1933 | switch (m_elementType) |
1934 | { |
1935 | case ELEMENT_TYPE_ARRAY: |
1936 | case ELEMENT_TYPE_SZARRAY: |
1937 | case ELEMENT_TYPE_BYREF: |
1938 | case ELEMENT_TYPE_PTR: |
1939 | data->elementType = m_elementType; |
1940 | data->metadataToken = mdTokenNil; |
1941 | data->vmDomainFile = VMPTR_DomainFile::NullPtr(); |
1942 | data->vmTypeHandle = m_typeHandleExact; |
1943 | if (data->vmTypeHandle.IsNull()) |
1944 | { |
1945 | return CORDBG_E_CLASS_NOT_LOADED; |
1946 | } |
1947 | _ASSERTE(!data->vmTypeHandle.IsNull()); |
1948 | break; |
1949 | |
1950 | case ELEMENT_TYPE_CLASS: |
1951 | _ASSERTE(m_pClass != NULL); |
1952 | data->elementType = m_pClass->IsValueClassNoInit() ? ELEMENT_TYPE_VALUETYPE : ELEMENT_TYPE_CLASS; |
1953 | data->metadataToken = m_pClass->MDToken(); |
1954 | data->vmDomainFile = GetDomainFile(); |
1955 | data->vmTypeHandle = m_typeHandleExact; |
1956 | if (m_pClass->HasTypeParams() && data->vmTypeHandle.IsNull()) |
1957 | { |
1958 | return CORDBG_E_CLASS_NOT_LOADED; |
1959 | } |
1960 | break; |
1961 | default: |
1962 | // This includes all the "primitive" types, in which CorElementType is a sufficient description. |
1963 | data->elementType = m_elementType; |
1964 | data->metadataToken = mdTokenNil; |
1965 | data->vmDomainFile = VMPTR_DomainFile::NullPtr(); |
1966 | data->vmTypeHandle = VMPTR_TypeHandle::NullPtr(); |
1967 | break; |
1968 | } |
1969 | return S_OK; |
1970 | } |
1971 | |
1972 | //----------------------------------------------------------------------------- |
1973 | // Internal method to marshal: CordbType --> ExpandedTypeData |
1974 | // |
1975 | // Nb. CordbType::Init need NOT have been called before this... |
1976 | // Also, this does not write the type arguments. How this is done depends |
1977 | // depends on where this is called from. |
1978 | // |
1979 | // Parameters: |
1980 | // data - OUT: outgoing ExpandedTypeData to fill in with stats about CordbType. |
1981 | //----------------------------------------------------------------------------- |
1982 | void CordbType::TypeToExpandedTypeData(DebuggerIPCE_ExpandedTypeData *data) |
1983 | { |
1984 | |
1985 | switch (m_elementType) |
1986 | { |
1987 | case ELEMENT_TYPE_ARRAY: |
1988 | case ELEMENT_TYPE_SZARRAY: |
1989 | |
1990 | data->ArrayTypeData.arrayRank = m_rank; |
1991 | data->elementType = m_elementType; |
1992 | break; |
1993 | |
1994 | case ELEMENT_TYPE_BYREF: |
1995 | case ELEMENT_TYPE_PTR: |
1996 | case ELEMENT_TYPE_FNPTR: |
1997 | |
1998 | data->elementType = m_elementType; |
1999 | break; |
2000 | |
2001 | case ELEMENT_TYPE_CLASS: |
2002 | { |
2003 | data->elementType = m_pClass->IsValueClassNoInit() ? ELEMENT_TYPE_VALUETYPE : ELEMENT_TYPE_CLASS; |
2004 | data->ClassTypeData.metadataToken = m_pClass->GetToken(); |
2005 | data->ClassTypeData.vmDomainFile = GetDomainFile(); |
2006 | data->ClassTypeData.vmModule = GetModule(); |
2007 | data->ClassTypeData.typeHandle = VMPTR_TypeHandle::NullPtr(); |
2008 | |
2009 | break; |
2010 | } |
2011 | case ELEMENT_TYPE_END: |
2012 | _ASSERTE(!"bad element type!" ); |
2013 | |
2014 | default: |
2015 | data->elementType = m_elementType; |
2016 | break; |
2017 | } |
2018 | } |
2019 | |
2020 | |
2021 | void CordbType::TypeToTypeArgData(DebuggerIPCE_TypeArgData *data) |
2022 | { |
2023 | TypeToExpandedTypeData(&(data->data)); |
2024 | data->numTypeArgs = m_inst.m_cClassTyPars; |
2025 | } |
2026 | |
2027 | |
2028 | //----------------------------------------------------------------------------- |
2029 | // Query if this CordbType represents a ValueType (Does not include primitives). |
2030 | // Since CordbType doesn't record ValueType status, this may involve querying |
2031 | // the CordbClass or even asking the Left-Side (if the CordbClass is not init) |
2032 | // |
2033 | // Return Value: |
2034 | // indicates whether this is a value type |
2035 | // Note: |
2036 | // Throws. |
2037 | //----------------------------------------------------------------------------- |
2038 | bool CordbType::IsValueType() |
2039 | { |
2040 | if (m_elementType == ELEMENT_TYPE_CLASS) |
2041 | { |
2042 | return m_pClass->IsValueClass(); |
2043 | } |
2044 | else |
2045 | return false; |
2046 | } |
2047 | |
2048 | //------------------------------------------------------------------------ |
2049 | // If this is a ptr type, get the CordbType that it points to. |
2050 | // Eg, for CordbType("Int*") or CordbType("Int&"), returns CordbType("Int"). |
2051 | // If not a ptr type, returns null. |
2052 | // Since it's all internal, no reference counting. |
2053 | // This is effectively a specialized version of DestUnaryType. |
2054 | //------------------------------------------------------------------------ |
2055 | CordbType * CordbType::GetPointerElementType() |
2056 | { |
2057 | if ((m_elementType != ELEMENT_TYPE_PTR) && (m_elementType != ELEMENT_TYPE_BYREF)) |
2058 | { |
2059 | return NULL; |
2060 | } |
2061 | |
2062 | CordbType * pOut; |
2063 | DestUnaryType(&pOut); |
2064 | |
2065 | _ASSERTE(pOut != NULL); |
2066 | return pOut; |
2067 | } |
2068 | //------------------------------------------------------------------------ |
2069 | // Helper for IsGcRoot. |
2070 | // Determine if the element type is a non GC-root candidate. |
2071 | // Updating GC-roots requires coordinating with the GC's write-barrier. |
2072 | // Whereas non-GC roots can be updated more freely. |
2073 | // |
2074 | // Parameters: |
2075 | // et - An element type. |
2076 | // Returns: |
2077 | // True if variables of et can be used as a GC root. |
2078 | //------------------------------------------------------------------------ |
2079 | static inline bool IsElementTypeNonGcRoot(CorElementType et) |
2080 | { |
2081 | // Functon ptrs are raw data, not GC-roots. |
2082 | if (et == ELEMENT_TYPE_FNPTR) |
2083 | { |
2084 | return true; |
2085 | } |
2086 | |
2087 | // This is almost exactly if we're a primitive, but |
2088 | // primitives include some things that could be GC-roots, so we strip those out, |
2089 | return CorIsPrimitiveType(et) |
2090 | && (et != ELEMENT_TYPE_STRING) && (et != ELEMENT_TYPE_VOID); // exlcude these from primitives |
2091 | |
2092 | } |
2093 | //------------------------------------------------------------------------ |
2094 | // Helper for IsGcRoot |
2095 | // Non-gc roots include Value types + non-gc elemement types (like E_T_I4, E_T_FNPTR) |
2096 | // |
2097 | // Parameters: |
2098 | // pType - type to check whether it's a GC-root. |
2099 | // Returns: |
2100 | // true if we know we're not a GC-root |
2101 | // false if we still might be (so caller must do further checkin) |
2102 | //------------------------------------------------------------------------ |
2103 | static inline bool _IsNonGCRootHelper(CordbType * pType) |
2104 | { |
2105 | _ASSERTE(pType != NULL); |
2106 | |
2107 | CorElementType et = pType->GetElementType(); |
2108 | if (IsElementTypeNonGcRoot(et)) |
2109 | { |
2110 | return true; |
2111 | } |
2112 | |
2113 | HRESULT hr = S_OK; |
2114 | bool fValueClass = false; |
2115 | |
2116 | // If we are a value-type, then we can't be a Gc-root. |
2117 | EX_TRY |
2118 | { |
2119 | fValueClass = pType->IsValueType(); |
2120 | } |
2121 | EX_CATCH_HRESULT(hr); |
2122 | if (FAILED(hr) || fValueClass) |
2123 | { |
2124 | return true; |
2125 | } |
2126 | |
2127 | // Don't know |
2128 | return false; |
2129 | } |
2130 | |
2131 | //----------------------------------------------------------------------------- |
2132 | // Is this type a GC-root. (Not to be confused w/ "does this contain embedded GC roots") |
2133 | // All object references are GC-roots. E_T_PTR are actually not GC-roots. |
2134 | // |
2135 | // Returns: |
2136 | // True - if this is a GC-root. |
2137 | // False - not a GC root. |
2138 | //----------------------------------------------------------------------------- |
2139 | bool CordbType::IsGCRoot() |
2140 | { |
2141 | // If it's a E_T_PTR type, then look at what it's a a pointer of. |
2142 | CordbType * pPtr = this->GetPointerElementType(); |
2143 | if (pPtr == NULL) |
2144 | { |
2145 | // If non pointer, than we can just look at our current type. |
2146 | return !_IsNonGCRootHelper(this); |
2147 | } |
2148 | |
2149 | return !_IsNonGCRootHelper(pPtr); |
2150 | } |
2151 | |
2152 | |
2153 | //------------------------------------------------------------------------ |
2154 | // Public function to enumerate type-parameters. |
2155 | // Parameters: |
2156 | // ppTypeParameterEnum - OUT: on return, get an enumerator. |
2157 | // Returns: |
2158 | // S_OK on success. |
2159 | //------------------------------------------------------------------------ |
2160 | HRESULT CordbType::EnumerateTypeParameters(ICorDebugTypeEnum **ppTypeParameterEnum) |
2161 | { |
2162 | PUBLIC_API_ENTRY(this); |
2163 | VALIDATE_POINTER_TO_OBJECT(ppTypeParameterEnum, ICorDebugTypeEnum **); |
2164 | ATT_REQUIRE_STOPPED_MAY_FAIL(GetProcess()); |
2165 | |
2166 | |
2167 | CordbTypeEnum *icdTPE = CordbTypeEnum::Build(m_appdomain, m_appdomain->GetLongExitNeuterList(), this->m_inst.m_cInst, this->m_inst.m_ppInst); |
2168 | if ( icdTPE == NULL ) |
2169 | { |
2170 | (*ppTypeParameterEnum) = NULL; |
2171 | return E_OUTOFMEMORY; |
2172 | } |
2173 | |
2174 | (*ppTypeParameterEnum) = static_cast<ICorDebugTypeEnum*> (icdTPE); |
2175 | icdTPE->ExternalAddRef(); |
2176 | return S_OK; |
2177 | } |
2178 | |
2179 | |
2180 | //----------------------------------------------------------------------------- |
2181 | // CordbType::GetBase |
2182 | // Public convenience method to get the instantiated base type. |
2183 | // |
2184 | // Parameters: |
2185 | // ppType - OUT: yields the base type for the current type. |
2186 | // |
2187 | // Returns: |
2188 | // S_OK if succeeded. |
2189 | // |
2190 | HRESULT CordbType::GetBase(ICorDebugType ** ppType) |
2191 | { |
2192 | PUBLIC_REENTRANT_API_ENTRY(this); |
2193 | ATT_ALLOW_LIVE_DO_STOPGO(this->GetProcess()); // @todo - can this by RequiredStopped? |
2194 | |
2195 | HRESULT hr = S_OK; |
2196 | |
2197 | LOG((LF_CORDB, LL_EVERYTHING, "CordbType::GetBase called\n" )); |
2198 | |
2199 | VALIDATE_POINTER_TO_OBJECT(ppType, ICorDebugType **); |
2200 | |
2201 | if (m_elementType != ELEMENT_TYPE_CLASS) |
2202 | { |
2203 | return E_INVALIDARG; |
2204 | } |
2205 | |
2206 | EX_TRY |
2207 | { |
2208 | CordbType * pType = NULL; |
2209 | |
2210 | _ASSERTE(m_pClass != NULL); |
2211 | |
2212 | // Get the supertype from metadata for m_class |
2213 | mdToken extendsToken; |
2214 | |
2215 | IMetaDataImport * pImport = m_pClass->GetModule()->GetMetaDataImporter(); // throws |
2216 | |
2217 | hr = pImport->GetTypeDefProps(m_pClass->MDToken(), NULL, 0, NULL, NULL, &extendsToken); |
2218 | IfFailThrow(hr); |
2219 | |
2220 | // Now create a CordbType instance for the base type that has the same type parameters as the derived type. |
2221 | if ((extendsToken == mdTypeDefNil) || (extendsToken == mdTypeRefNil) || (extendsToken == mdTokenNil)) |
2222 | { |
2223 | // No base class. |
2224 | pType = NULL; |
2225 | } |
2226 | else if (TypeFromToken(extendsToken) == mdtTypeSpec) |
2227 | { |
2228 | // TypeSpec has a signature. So get the sig and convert it to a CordbType. |
2229 | // generic base class of a generic type is a TypeSpec. |
2230 | // If we have: |
2231 | // class Triple<T,U,V> derives from Pair<T,V>, |
2232 | // then the base class for Triple would be a TypeSpec: |
2233 | // Class(Pair<T,V>), 2 args, ELEMENT_TYPE_VAR #0, ELEMENT_TYPE_VAR#2. |
2234 | // m_inst provides the type-parameters to resolve the ELEMENT_TYPE_VAR types. |
2235 | |
2236 | PCCOR_SIGNATURE pSig; |
2237 | ULONG sigSize; |
2238 | |
2239 | // Get the signature for the constructed supertype... |
2240 | hr = pImport->GetTypeSpecFromToken(extendsToken, &pSig, &sigSize); |
2241 | IfFailThrow(hr); |
2242 | |
2243 | _ASSERTE(pSig != NULL); |
2244 | |
2245 | SigParser sigParser(pSig, sigSize); |
2246 | |
2247 | // Instantiate the signature of the supertype using the type instantiation for |
2248 | // the current type.... |
2249 | hr = SigToType(m_pClass->GetModule(), &sigParser, &m_inst, &pType); |
2250 | IfFailThrow(hr); |
2251 | } |
2252 | else if ((TypeFromToken(extendsToken) == mdtTypeRef) || (TypeFromToken(extendsToken) == mdtTypeDef)) |
2253 | { |
2254 | // TypeDef/TypeRef for non-generic base-class class. |
2255 | CordbClass * pSuperClass; |
2256 | |
2257 | hr = m_pClass->GetModule()->ResolveTypeRefOrDef(extendsToken, &pSuperClass); |
2258 | IfFailThrow(hr); |
2259 | |
2260 | _ASSERTE(pSuperClass != NULL); |
2261 | |
2262 | hr = MkUnparameterizedType(m_appdomain, ELEMENT_TYPE_CLASS, pSuperClass, &pType); |
2263 | IfFailThrow(hr); |
2264 | } |
2265 | else |
2266 | { |
2267 | pType = NULL; |
2268 | _ASSERTE(!"unexpected token!" ); |
2269 | } |
2270 | |
2271 | // At this point, we've succeeded |
2272 | _ASSERTE(SUCCEEDED(hr)); |
2273 | |
2274 | (*ppType) = pType; |
2275 | |
2276 | if (*ppType) |
2277 | { |
2278 | pType->AddRef(); |
2279 | } |
2280 | } |
2281 | EX_CATCH_HRESULT(hr); |
2282 | return hr; |
2283 | } |
2284 | |
2285 | //----------------------------------------------------------------------------- |
2286 | // CordbType::GetTypeID |
2287 | // Method to get the COR_TYPEID corresponding to this CordbType. |
2288 | // |
2289 | // Parameters: |
2290 | // pId - OUT: gives the COR_TYPEID for this CordbType |
2291 | // |
2292 | // Returns: |
2293 | // S_OK if succeeded. |
2294 | // CORDBG_E_CLASS_NOT_LOADED if the type which this CordbType represents has |
2295 | // not been loaded in the runtime. |
2296 | // E_POINTER if pId is NULL |
2297 | // CORDBG_E_UNSUPPORTED for unsupported types. |
2298 | // |
2299 | HRESULT CordbType::GetTypeID(COR_TYPEID *pId) |
2300 | { |
2301 | LOG((LF_CORDB, LL_INFO1000, "GetTypeID\n" )); |
2302 | if (pId == NULL) |
2303 | return E_POINTER; |
2304 | |
2305 | HRESULT hr = S_OK; |
2306 | |
2307 | PUBLIC_API_ENTRY(this); |
2308 | RSLockHolder stopGoLock(GetProcess()->GetStopGoLock()); |
2309 | RSLockHolder procLock(GetProcess()->GetProcessLock()); |
2310 | |
2311 | EX_TRY |
2312 | { |
2313 | hr = Init(FALSE); |
2314 | IfFailThrow(hr); |
2315 | |
2316 | VMPTR_TypeHandle vmTypeHandle; |
2317 | |
2318 | CorElementType et = GetElementType(); |
2319 | switch (et) |
2320 | { |
2321 | case ELEMENT_TYPE_OBJECT: |
2322 | case ELEMENT_TYPE_VOID: |
2323 | case ELEMENT_TYPE_BOOLEAN: |
2324 | case ELEMENT_TYPE_CHAR: |
2325 | case ELEMENT_TYPE_I1: |
2326 | case ELEMENT_TYPE_U1: |
2327 | case ELEMENT_TYPE_I2: |
2328 | case ELEMENT_TYPE_U2: |
2329 | case ELEMENT_TYPE_I4: |
2330 | case ELEMENT_TYPE_U4: |
2331 | case ELEMENT_TYPE_I8: |
2332 | case ELEMENT_TYPE_U8: |
2333 | case ELEMENT_TYPE_R4: |
2334 | case ELEMENT_TYPE_R8: |
2335 | case ELEMENT_TYPE_STRING: |
2336 | case ELEMENT_TYPE_TYPEDBYREF: |
2337 | case ELEMENT_TYPE_I: |
2338 | case ELEMENT_TYPE_U: |
2339 | { |
2340 | mdTypeDef mdToken; |
2341 | VMPTR_Module vmModule = VMPTR_Module::NullPtr(); |
2342 | VMPTR_DomainFile vmDomainFile = VMPTR_DomainFile::NullPtr(); |
2343 | |
2344 | // get module and token of the simple type |
2345 | GetProcess()->GetDAC()->GetSimpleType(GetAppDomain()->GetADToken(), |
2346 | et, |
2347 | &mdToken, |
2348 | &vmModule, |
2349 | &vmDomainFile); |
2350 | |
2351 | vmTypeHandle = GetProcess()->GetDAC()->GetTypeHandle(vmModule, mdToken); |
2352 | } |
2353 | break; |
2354 | case ELEMENT_TYPE_ARRAY: |
2355 | case ELEMENT_TYPE_SZARRAY: |
2356 | { |
2357 | LOG((LF_CORDB, LL_INFO1000, "GetTypeID: parameterized type\n" )); |
2358 | if (m_typeHandleExact.IsNull()) |
2359 | { |
2360 | hr = InitInstantiationTypeHandle(FALSE); |
2361 | IfFailThrow(hr); |
2362 | } |
2363 | vmTypeHandle = m_typeHandleExact; |
2364 | } |
2365 | break; |
2366 | case ELEMENT_TYPE_CLASS: |
2367 | { |
2368 | ICorDebugClass *pICDClass = NULL; |
2369 | hr = GetClass(&pICDClass); |
2370 | IfFailThrow(hr); |
2371 | CordbClass *pClass = (CordbClass*)pICDClass; |
2372 | _ASSERTE(pClass != NULL); |
2373 | |
2374 | if (pClass->HasTypeParams()) |
2375 | { |
2376 | vmTypeHandle = m_typeHandleExact; |
2377 | } |
2378 | else |
2379 | { |
2380 | mdTypeDef mdToken; |
2381 | hr = pClass->GetToken(&mdToken); |
2382 | IfFailThrow(hr); |
2383 | |
2384 | VMPTR_Module vmModule = GetModule(); |
2385 | vmTypeHandle = GetProcess()->GetDAC()->GetTypeHandle(vmModule, mdToken); |
2386 | } |
2387 | } |
2388 | break; |
2389 | case ELEMENT_TYPE_PTR: |
2390 | case ELEMENT_TYPE_BYREF: |
2391 | case ELEMENT_TYPE_FNPTR: |
2392 | IfFailThrow(CORDBG_E_UNSUPPORTED); |
2393 | default: |
2394 | _ASSERTE(!"unexpected element type!" ); |
2395 | IfFailThrow(CORDBG_E_UNSUPPORTED); |
2396 | break; |
2397 | } |
2398 | |
2399 | GetProcess()->GetDAC()->GetTypeIDForType(vmTypeHandle, pId); |
2400 | } |
2401 | EX_CATCH_HRESULT(hr); |
2402 | |
2403 | return hr; |
2404 | } |
2405 | |
2406 | //----------------------------------------------------------------------------- |
2407 | // Get rich field information given a token. |
2408 | // |
2409 | // Parameters: |
2410 | // fldToken - metadata field token specifying a field on this Type. |
2411 | // ppFieldData - OUT: get the rich field information for the given field |
2412 | // |
2413 | // Returns: |
2414 | // S_OK on success. CORDBG_E_ENC_HANGING_FIELD for EnC fields (common case) |
2415 | // Other errors on failure case. |
2416 | //----------------------------------------------------------------------------- |
2417 | HRESULT CordbType::GetFieldInfo(mdFieldDef fldToken, FieldData ** ppFieldData) |
2418 | { |
2419 | INTERNAL_SYNC_API_ENTRY(GetProcess()); // |
2420 | HRESULT hr = S_OK; |
2421 | |
2422 | *ppFieldData = NULL; |
2423 | |
2424 | EX_TRY |
2425 | { |
2426 | if (m_elementType != ELEMENT_TYPE_CLASS) |
2427 | { |
2428 | ThrowHR(E_INVALIDARG); |
2429 | } |
2430 | |
2431 | // Initialize so that the field information is up-to-date. |
2432 | hr = Init(FALSE); |
2433 | IfFailThrow(hr); |
2434 | |
2435 | if (m_pClass->HasTypeParams()) |
2436 | { |
2437 | if (m_fieldList.IsEmpty()) |
2438 | { |
2439 | ThrowHR(CORDBG_E_FIELD_NOT_AVAILABLE); |
2440 | } |
2441 | else |
2442 | { |
2443 | // Use a static helper function in CordbClass, though we're really |
2444 | // searching through this->m_fields |
2445 | hr = CordbClass::SearchFieldInfo(m_pClass->GetModule(), |
2446 | &m_fieldList, |
2447 | m_pClass->MDToken(), |
2448 | fldToken, |
2449 | ppFieldData); |
2450 | // fall through and return. |
2451 | // Let possible CORDBG_E_ENC_HANGING_FIELD errors propogate |
2452 | } |
2453 | } |
2454 | else |
2455 | { |
2456 | hr = m_pClass->GetFieldInfo(fldToken, ppFieldData); // this is for non-generic types.... |
2457 | // Let possible CORDBG_E_ENC_HANGING_FIELD errors propogate |
2458 | } |
2459 | } |
2460 | EX_CATCH_HRESULT(hr); |
2461 | _ASSERTE(SUCCEEDED(hr) == (*ppFieldData != NULL)); |
2462 | return hr; |
2463 | } |
2464 | |
2465 | |
2466 | //----------------------------------------------------------------------------- |
2467 | // Class is a class somewhere on the hierarchy for m_type. Search for |
2468 | // a CordbType corresponding to the CordbClass, but which has the type-parameters |
2469 | // from the current CordbType. |
2470 | // In other words, instantiate a CordbType from baseClass, using the type-params |
2471 | // in the current Type. |
2472 | // |
2473 | // For example, given: |
2474 | // class C<T> |
2475 | // class D : C<int> |
2476 | // then if the CordbObjectValue is of type D and pClass is the class |
2477 | // for "C", then searching will set relevantType to C<int>. This |
2478 | // type is then used to fetch fields from the object. |
2479 | // |
2480 | // Adds a reference to the resulting type. Since this is for internal |
2481 | // use only we probably don't need todo this... |
2482 | // |
2483 | // Parameters: |
2484 | // baseClass - open Type that needs to be instantiated with this CordbType's params. |
2485 | // ppRes - OUT: out-parameter to get CordbType. ppRes->GetClass() should equal baseClass. |
2486 | // |
2487 | // Returns: |
2488 | // S_OK on success. CORDBG_E_OBJECT_NEUTERED, CORDBG_E_CLASS_NOT_LOADED, E_INVALIDARG, OOM |
2489 | //----------------------------------------------------------------------------- |
2490 | HRESULT CordbType::GetParentType(CordbClass *baseClass, CordbType **ppRes) |
2491 | { |
2492 | INTERNAL_SYNC_API_ENTRY(GetProcess()); // |
2493 | |
2494 | // Ensure that we're not trying to match up against a neutered class. |
2495 | if (baseClass->IsNeutered()) |
2496 | { |
2497 | return CORDBG_E_OBJECT_NEUTERED; |
2498 | } |
2499 | |
2500 | HRESULT hr = S_OK; |
2501 | _ASSERTE(ppRes); |
2502 | *ppRes = NULL; |
2503 | CordbType *res = this; |
2504 | res->AddRef(); |
2505 | int safety = 20000; // no inheritance hierarchy is 20000 deep... we include this just in case there's a issue below and we don't terminate |
2506 | while (safety--) |
2507 | { |
2508 | if (res->m_pClass == NULL) |
2509 | { |
2510 | if (FAILED(hr = res->Init(FALSE))) |
2511 | { |
2512 | res->Release(); |
2513 | return hr; |
2514 | } |
2515 | } |
2516 | _ASSERTE(res->m_pClass); |
2517 | if (res->m_pClass == baseClass) |
2518 | { |
2519 | // Found it! |
2520 | break; |
2521 | } |
2522 | |
2523 | // Another way to determine if we're talking about the |
2524 | // same class... Compare tokens and module. |
2525 | mdTypeDef tok; |
2526 | mdTypeDef targetTok; |
2527 | if (FAILED(hr = res->m_pClass->GetToken(&tok)) |
2528 | || FAILED(hr = baseClass->GetToken(&targetTok))) |
2529 | { |
2530 | res->Release(); |
2531 | return hr; |
2532 | } |
2533 | if (tok == targetTok && res->m_pClass->GetModule() == baseClass->GetModule()) |
2534 | { |
2535 | // Found it! |
2536 | break; |
2537 | } |
2538 | |
2539 | // OK, this is not the right class so look up the inheritance chain |
2540 | ICorDebugType *nextType = NULL; |
2541 | if (FAILED(hr = res->GetBase(&nextType))) |
2542 | { |
2543 | res->Release(); |
2544 | return hr; |
2545 | } |
2546 | |
2547 | res->Release(); // matches the AddRef above and/or the one implicit in GetBase, for all but last time around the loop |
2548 | res = static_cast<CordbType *> (nextType); |
2549 | if (!res || res->m_elementType == ELEMENT_TYPE_OBJECT) |
2550 | { |
2551 | // Did not find it... |
2552 | break; |
2553 | } |
2554 | } |
2555 | // We exit the loop above owning one reference to res. |
2556 | // Upon exit res will either be the appropriate type for the |
2557 | // class we're looking for or will be the CordbType for System.Object |
2558 | // or will be NULL |
2559 | |
2560 | // If it's System.Object then assume something's gone wrong with |
2561 | // the way we did the search and bail out to an old fashioned |
2562 | // MkUnparameterizedType on the class given originally |
2563 | if (!res || res->m_elementType == ELEMENT_TYPE_OBJECT) |
2564 | { |
2565 | if (res) |
2566 | res->Release(); // matches the one left over from the loop |
2567 | IfFailRet(CordbType::MkUnparameterizedType(baseClass->GetAppDomain(), ELEMENT_TYPE_CLASS, baseClass, &res)); |
2568 | res->AddRef(); |
2569 | } |
2570 | |
2571 | |
2572 | *ppRes = res; |
2573 | return hr; |
2574 | } |
2575 | |
2576 | |
2577 | //----------------------------------------------------------------------------- |
2578 | // Walk a type tree, writing the number of type args including internal nodes. |
2579 | // |
2580 | // Parameters: |
2581 | // count - IN/OUT: counter to update. |
2582 | //----------------------------------------------------------------------------- |
2583 | void CordbType::CountTypeDataNodes(unsigned int *count) |
2584 | { |
2585 | (*count)++; |
2586 | for (unsigned int i = 0; i < this->m_inst.m_cClassTyPars; i++) |
2587 | { |
2588 | this->m_inst.m_ppInst[i]->CountTypeDataNodes(count); |
2589 | } |
2590 | } |
2591 | |
2592 | //----------------------------------------------------------------------------- |
2593 | // Internal helper method. |
2594 | // Counts the total generic args (including sub-args) for an Instantiation. |
2595 | // Eg, for List<int, Pair<string, float>>, it would return 3. |
2596 | // |
2597 | // Parameters: |
2598 | // genericArgsCount - size of the genericArgs array in elements. |
2599 | // genericArgs - array of type parameters. |
2600 | // count - IN/OUT - will increment with total number of generic args. |
2601 | // caller must intialize this (likely to 0). |
2602 | //----------------------------------------------------------------------------- |
2603 | void CordbType::CountTypeDataNodesForInstantiation(unsigned int genericArgsCount, ICorDebugType *genericArgs[], unsigned int *count) |
2604 | { |
2605 | for (unsigned int i = 0; i < genericArgsCount; i++) |
2606 | { |
2607 | (static_cast<CordbType *>(genericArgs[i]))->CountTypeDataNodes(count); |
2608 | } |
2609 | } |
2610 | |
2611 | //----------------------------------------------------------------------------- |
2612 | // Recursively walk a type tree, writing the type args into a linear. |
2613 | // Eg, for List<A, Pair<B, C>>, this will write the TypeArgData buffer |
2614 | // for { A, B, C }. |
2615 | // |
2616 | // Parameters: |
2617 | // curr_tyargData - IN/OUT: Pointer into buffer of TypeArgData structures. |
2618 | // Caller must ensure this buffer is large enough (probably by calling |
2619 | // CountTypeDataNodes). |
2620 | // On output, set to the next element in the buffer. |
2621 | //----------------------------------------------------------------------------- |
2622 | void CordbType::GatherTypeData(CordbType *type, DebuggerIPCE_TypeArgData **curr_tyargData) |
2623 | { |
2624 | type->TypeToTypeArgData(*curr_tyargData); |
2625 | (*curr_tyargData)++; |
2626 | for (unsigned int i = 0; i < type->m_inst.m_cClassTyPars; i++) |
2627 | { |
2628 | GatherTypeData(type->m_inst.m_ppInst[i], curr_tyargData); |
2629 | } |
2630 | } |
2631 | |
2632 | //----------------------------------------------------------------------------- |
2633 | // Flatten Instantiation into a linear buffer of TypeArgData |
2634 | // Use CountTypeDataNodesForInstantiation on the instantiation to get a large |
2635 | // enough buffer. |
2636 | // |
2637 | // Parameters: |
2638 | // genericArgsCount - size of genericArgs array in elements. |
2639 | // genericArgs - incoming array to walk |
2640 | // curr_tyargData - IN/OUT: Pointer into buffer of TypeArgData structures. |
2641 | // Caller must ensure this buffer is large enough (probably by calling |
2642 | // CountTypeDataNodes). |
2643 | // On output, set to the next element in the buffer. |
2644 | // |
2645 | //----------------------------------------------------------------------------- |
2646 | void CordbType::GatherTypeDataForInstantiation(unsigned int genericArgsCount, ICorDebugType *genericArgs[], DebuggerIPCE_TypeArgData **curr_tyargData) |
2647 | { |
2648 | for (unsigned int i = 0; i < genericArgsCount; i++) |
2649 | { |
2650 | GatherTypeData(static_cast<CordbType *> (genericArgs[i]), curr_tyargData); |
2651 | } |
2652 | } |
2653 | |
2654 | #ifdef FEATURE_64BIT_ALIGNMENT |
2655 | // checks if the type requires 8-byte alignment. the algorithm used here |
2656 | // was adapted from AdjustArgPtrForAlignment() in bcltype/VarArgsNative.cpp |
2657 | HRESULT CordbType::RequiresAlign8(BOOL* isRequired) |
2658 | { |
2659 | if (isRequired == NULL) |
2660 | return E_INVALIDARG; |
2661 | |
2662 | HRESULT hr = S_OK; |
2663 | |
2664 | EX_TRY |
2665 | { |
2666 | *isRequired = FALSE; |
2667 | |
2668 | ULONG32 size = 0; |
2669 | GetUnboxedObjectSize(&size); |
2670 | |
2671 | if (size >= 8) |
2672 | { |
2673 | CorElementType type; |
2674 | GetType(&type); |
2675 | |
2676 | if (type != ELEMENT_TYPE_TYPEDBYREF) |
2677 | { |
2678 | if (type == ELEMENT_TYPE_VALUETYPE) |
2679 | { |
2680 | if (m_typeHandleExact.IsNull()) |
2681 | InitInstantiationTypeHandle(FALSE); |
2682 | |
2683 | *isRequired = GetProcess()->GetDAC()->RequiresAlign8(m_typeHandleExact); |
2684 | } |
2685 | else |
2686 | { |
2687 | *isRequired = TRUE; |
2688 | } |
2689 | } |
2690 | } |
2691 | } |
2692 | EX_CATCH_HRESULT(hr); |
2693 | |
2694 | return hr; |
2695 | } |
2696 | #endif |
2697 | |
2698 | /* ------------------------------------------------------------------------- * |
2699 | * TypeParameter Enumerator class |
2700 | * ------------------------------------------------------------------------- */ |
2701 | |
2702 | // Factory methods |
2703 | CordbTypeEnum* CordbTypeEnum::Build(CordbAppDomain * pAppDomain, NeuterList * pNeuterList, unsigned int cTypars, CordbType **ppTypars) |
2704 | { |
2705 | return BuildImpl( pAppDomain, pNeuterList, cTypars, ppTypars ); |
2706 | } |
2707 | |
2708 | CordbTypeEnum* CordbTypeEnum::Build(CordbAppDomain * pAppDomain, NeuterList * pNeuterList, unsigned int cTypars, RSSmartPtr<CordbType> *ppTypars) |
2709 | { |
2710 | return BuildImpl( pAppDomain, pNeuterList, cTypars, ppTypars ); |
2711 | } |
2712 | |
2713 | //----------------------------------------------------------------------------- |
2714 | // We need to support taking both an array of CordbType* and an array of RSSmartPtr<CordbType>, |
2715 | // but the code is identical in both cases. Rather than duplicate any code explicity, it's better to |
2716 | // have the compiler do it for us using this template method. |
2717 | // Another option would be to create an IList<T> interface and implementations for both arrays |
2718 | // of T* and arrays of RSSmartPtr<T>. This would be more generally useful, but much more code. |
2719 | //----------------------------------------------------------------------------- |
2720 | template<class T> CordbTypeEnum* CordbTypeEnum::BuildImpl(CordbAppDomain * pAppDomain, NeuterList * pNeuterList, unsigned int cTypars, T* ppTypars) |
2721 | { |
2722 | CordbTypeEnum* newEnum = new (nothrow) CordbTypeEnum( pAppDomain, pNeuterList ); |
2723 | if( NULL == newEnum ) |
2724 | { |
2725 | return NULL; |
2726 | } |
2727 | |
2728 | _ASSERTE( newEnum->m_ppTypars == NULL ); |
2729 | newEnum->m_ppTypars = new (nothrow) RSSmartPtr<CordbType> [cTypars]; |
2730 | if( newEnum->m_ppTypars == NULL ) |
2731 | { |
2732 | delete newEnum; |
2733 | return NULL; |
2734 | } |
2735 | |
2736 | newEnum->m_iMax = cTypars; |
2737 | for (unsigned int i = 0; i < cTypars; i++) |
2738 | { |
2739 | newEnum->m_ppTypars[i].Assign(ppTypars[i]); |
2740 | } |
2741 | |
2742 | return newEnum; |
2743 | } |
2744 | |
2745 | // Private, called only by Build above |
2746 | CordbTypeEnum::CordbTypeEnum(CordbAppDomain * pAppDomain, NeuterList * pNeuterList) : |
2747 | CordbBase(pAppDomain->GetProcess(), 0), |
2748 | m_ppTypars(NULL), |
2749 | m_iCurrent(0), |
2750 | m_iMax(0) |
2751 | { |
2752 | _ASSERTE(pAppDomain != NULL); |
2753 | _ASSERTE(pNeuterList != NULL); |
2754 | |
2755 | m_pAppDomain = pAppDomain; |
2756 | |
2757 | HRESULT hr = S_OK; |
2758 | EX_TRY |
2759 | { |
2760 | pNeuterList->Add(GetProcess(), this); |
2761 | } |
2762 | EX_CATCH_HRESULT(hr); |
2763 | SetUnrecoverableIfFailed(GetProcess(), hr); |
2764 | } |
2765 | |
2766 | CordbTypeEnum::~CordbTypeEnum() |
2767 | { |
2768 | _ASSERTE(this->IsNeutered()); |
2769 | } |
2770 | |
2771 | void CordbTypeEnum::Neuter() |
2772 | { |
2773 | delete [] m_ppTypars; |
2774 | m_ppTypars = NULL; |
2775 | m_pAppDomain = NULL; |
2776 | |
2777 | CordbBase::Neuter(); |
2778 | } |
2779 | |
2780 | |
2781 | HRESULT CordbTypeEnum::QueryInterface(REFIID id, void **pInterface) |
2782 | { |
2783 | if (id == IID_ICorDebugEnum) |
2784 | *pInterface = static_cast<ICorDebugEnum*>(this); |
2785 | else if (id == IID_ICorDebugTypeEnum) |
2786 | *pInterface = static_cast<ICorDebugTypeEnum*>(this); |
2787 | else if (id == IID_IUnknown) |
2788 | *pInterface = static_cast<IUnknown*>(static_cast<ICorDebugTypeEnum*>(this)); |
2789 | else |
2790 | { |
2791 | *pInterface = NULL; |
2792 | return E_NOINTERFACE; |
2793 | } |
2794 | |
2795 | ExternalAddRef(); |
2796 | return S_OK; |
2797 | } |
2798 | |
2799 | HRESULT CordbTypeEnum::Skip(ULONG celt) |
2800 | { |
2801 | PUBLIC_API_ENTRY(this); |
2802 | FAIL_IF_NEUTERED(this); |
2803 | ATT_REQUIRE_STOPPED_MAY_FAIL(GetProcess()); |
2804 | |
2805 | HRESULT hr = E_FAIL; |
2806 | if ( (m_iCurrent+celt) < m_iMax || |
2807 | celt == 0) |
2808 | { |
2809 | m_iCurrent += celt; |
2810 | hr = S_OK; |
2811 | } |
2812 | |
2813 | return hr; |
2814 | } |
2815 | |
2816 | HRESULT CordbTypeEnum::Reset(void) |
2817 | { |
2818 | PUBLIC_API_ENTRY(this); |
2819 | FAIL_IF_NEUTERED(this); |
2820 | ATT_REQUIRE_STOPPED_MAY_FAIL(GetProcess()); |
2821 | |
2822 | m_iCurrent = 0; |
2823 | return S_OK; |
2824 | } |
2825 | |
2826 | HRESULT CordbTypeEnum::Clone(ICorDebugEnum **ppEnum) |
2827 | { |
2828 | PUBLIC_API_ENTRY(this); |
2829 | FAIL_IF_NEUTERED(this); |
2830 | ATT_REQUIRE_STOPPED_MAY_FAIL(GetProcess()); |
2831 | |
2832 | |
2833 | VALIDATE_POINTER_TO_OBJECT(ppEnum, ICorDebugEnum **); |
2834 | |
2835 | HRESULT hr = S_OK; |
2836 | |
2837 | CordbTypeEnum *pCVE = CordbTypeEnum::Build( m_pAppDomain, m_pAppDomain->GetLongExitNeuterList(), m_iMax, m_ppTypars ); |
2838 | if ( pCVE == NULL ) |
2839 | { |
2840 | (*ppEnum) = NULL; |
2841 | hr = E_OUTOFMEMORY; |
2842 | goto LExit; |
2843 | } |
2844 | |
2845 | pCVE->AddRef(); |
2846 | (*ppEnum) = (ICorDebugEnum*)pCVE; |
2847 | |
2848 | LExit: |
2849 | return hr; |
2850 | } |
2851 | |
2852 | HRESULT CordbTypeEnum::GetCount(ULONG *pcelt) |
2853 | { |
2854 | PUBLIC_API_ENTRY(this); |
2855 | FAIL_IF_NEUTERED(this); |
2856 | ATT_REQUIRE_STOPPED_MAY_FAIL(GetProcess()); |
2857 | |
2858 | VALIDATE_POINTER_TO_OBJECT(pcelt, ULONG *); |
2859 | |
2860 | if( pcelt == NULL) |
2861 | return E_INVALIDARG; |
2862 | |
2863 | (*pcelt) = m_iMax; |
2864 | return S_OK; |
2865 | } |
2866 | |
2867 | // |
2868 | // In the event of failure, the current pointer will be left at |
2869 | // one element past the troublesome element. Thus, if one were |
2870 | // to repeatedly ask for one element to iterate through the |
2871 | // array, you would iterate exactly m_iMax times, regardless |
2872 | // of individual failures. |
2873 | HRESULT CordbTypeEnum::Next(ULONG celt, ICorDebugType *values[], ULONG *pceltFetched) |
2874 | { |
2875 | PUBLIC_API_ENTRY(this); |
2876 | FAIL_IF_NEUTERED(this); |
2877 | ATT_REQUIRE_STOPPED_MAY_FAIL(GetProcess()); |
2878 | |
2879 | |
2880 | VALIDATE_POINTER_TO_OBJECT_ARRAY(values, ICorDebugClass *, |
2881 | celt, true, true); |
2882 | VALIDATE_POINTER_TO_OBJECT_OR_NULL(pceltFetched, ULONG *); |
2883 | |
2884 | if ((pceltFetched == NULL) && (celt != 1)) |
2885 | { |
2886 | return E_INVALIDARG; |
2887 | } |
2888 | |
2889 | if (celt == 0) |
2890 | { |
2891 | if (pceltFetched != NULL) |
2892 | { |
2893 | *pceltFetched = 0; |
2894 | } |
2895 | return S_OK; |
2896 | } |
2897 | |
2898 | HRESULT hr = S_OK; |
2899 | |
2900 | int iMax = min( m_iMax, m_iCurrent+celt); |
2901 | int i; |
2902 | |
2903 | for (i = m_iCurrent; i < iMax; i++) |
2904 | { |
2905 | //printf("CordbTypeEnum::Next, returning = 0x%08x.\n", m_ppTypars[i]); |
2906 | values[i-m_iCurrent] = m_ppTypars[i]; |
2907 | values[i-m_iCurrent]->AddRef(); |
2908 | } |
2909 | |
2910 | int count = (i - m_iCurrent); |
2911 | |
2912 | if ( FAILED( hr ) ) |
2913 | { //we failed: +1 pushes us past troublesome element |
2914 | m_iCurrent += 1 + count; |
2915 | } |
2916 | else |
2917 | { |
2918 | m_iCurrent += count; |
2919 | } |
2920 | |
2921 | if (pceltFetched != NULL) |
2922 | { |
2923 | *pceltFetched = count; |
2924 | } |
2925 | |
2926 | // |
2927 | // If we reached the end of the enumeration, but not the end |
2928 | // of the number of requested items, we return S_FALSE. |
2929 | // |
2930 | if (((ULONG)count) < celt) |
2931 | { |
2932 | return S_FALSE; |
2933 | } |
2934 | |
2935 | return hr; |
2936 | } |
2937 | |
2938 | |