src/vm/runtimehandles.h

   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
   6
   7 #ifndef _RUNTIMEHANDLES_H_
   8 #define _RUNTIMEHANDLES_H_
   9
  10 #include "object.h"
  11 #include "typehandle.h"
  12 #include "fcall.h"
  13 #include "field.h"
  14 #include "typectxt.h"
  15 #include "constrainedexecutionregion.h"
  16
  17 typedef void* EnregisteredTypeHandle;
  18 class SignatureNative;
  19
  20 // NOTE: These are defined in CallingConventions.cs.
  21 typedef enum ReflectionCallConv {
  22     CALLCONV_Standard       = 0x0001,
  23     CALLCONV_VarArgs        = 0x0002,
  24     CALLCONV_Any            = CALLCONV_Standard | CALLCONV_VarArgs,
  25     CALLCONV_HasThis        = 0x0020,
  26     CALLCONV_ExplicitThis   = 0x0040,
  27     CALLCONV_ArgIteratorFlags = 0xFFFFFF00, // PRIVATE member -- cached ArgIterator flags -- Not exposed in CallingConventions.cs
  28     CALLCONV_ArgIteratorFlags_Shift = 8,
  29 } ReflectionCallConv;
  30
  31
  32 // Types used to expose method bodies via reflection.
  33
  34 class ExceptionHandlingClause;
  35 class MethodBody;
  36 class LocalVariableInfo;
  37
  38 #ifdef USE_CHECKED_OBJECTREFS
  39 typedef REF<ExceptionHandlingClause> EXCEPTIONHANDLINGCLAUSEREF;
  40 typedef REF<MethodBody> METHODBODYREF;
  41 typedef REF<LocalVariableInfo> LOCALVARIABLEINFOREF;
  42 #else
  43 typedef DPTR(ExceptionHandlingClause) EXCEPTIONHANDLINGCLAUSEREF;
  44 typedef DPTR(MethodBody) METHODBODYREF;
  45 typedef DPTR(LocalVariableInfo) LOCALVARIABLEINFOREF;
  46 #endif
  47
  48 class ExceptionHandlingClause : Object
  49 {
  50 private:
  51     // Disallow creation and copy construction of these.
  52     ExceptionHandlingClause() { }
  53     ExceptionHandlingClause(ExceptionHandlingClause &r) { }
  54
  55 public:
  56     METHODBODYREF m_methodBody;
  57     CorExceptionFlag m_flags;
  58     INT32 m_tryOffset;
  59     INT32 m_tryLength;
  60     INT32 m_handlerOffset;
  61     INT32 m_handlerLength;
  62     mdTypeDef m_catchToken;
  63     INT32 m_filterOffset;
  64 };
  65
  66 class MethodBody : Object
  67 {
  68 private:
  69     // Disallow creation and copy construction of these.
  70     MethodBody() { }
  71     MethodBody(MethodBody &r) { }
  72
  73 public:
  74     U1ARRAYREF m_IL;
  75     PTRARRAYREF m_exceptionClauses;
  76     PTRARRAYREF m_localVariables;
  77     OBJECTREF m_methodBase;
  78
  79     INT32 m_localVarSigToken;
  80     INT32 m_maxStackSize;
  81     CLR_BOOL m_initLocals;
  82 };
  83
  84 class LocalVariableInfo : Object
  85 {
  86 private:
  87     // Disallow creation and copy construction of these.
  88     LocalVariableInfo() { }
  89     LocalVariableInfo(LocalVariableInfo &r) { }
  90
  91 public:
  92
  93     REFLECTCLASSBASEREF GetType()
  94     {
  95         return (REFLECTCLASSBASEREF)m_type;
  96     }
  97
  98     void SetType(OBJECTREF type)
  99     {
 100         SetObjectReference(&m_type, type, GetAppDomain());
 101     }
 102
 103     OBJECTREF m_type;
 104     INT32 m_bIsPinned;
 105     INT32 m_localIndex;
 106 };
 107
 108 class Utf8String {
 109 public:
 110     static FCDECL3(FC_BOOL_RET, EqualsCaseSensitive, LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes);
 111
 112     static
 113     BOOL QCALLTYPE EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes);
 114
 115     static
 116     ULONG QCALLTYPE HashCaseInsensitive(LPCUTF8 sz, INT32 stringNumBytes);
 117 };
 118
 119 class RuntimeTypeHandle;
 120
 121 typedef RuntimeTypeHandle FCALLRuntimeTypeHandle;
 122 #define FCALL_RTH_TO_REFLECTCLASS(x) (x).pRuntimeTypeDONOTUSEDIRECTLY
 123
 124 class RuntimeTypeHandle {
 125     ReflectClassBaseObject *pRuntimeTypeDONOTUSEDIRECTLY;
 126 public:
 127
 128     // Static method on RuntimeTypeHandle
 129     static FCDECL1(Object*, Allocate, ReflectClassBaseObject *refType) ; //A.CI work
 130     static FCDECL6(Object*, CreateInstance, ReflectClassBaseObject* refThisUNSAFE,
 131                                             CLR_BOOL publicOnly,
 132                                             CLR_BOOL securityOff,
 133                                             CLR_BOOL *pbCanBeCached,
 134                                             MethodDesc** pConstructor,
 135                                             CLR_BOOL *pbNeedSecurityCheck);
 136
 137     static FCDECL2(Object*, CreateCaInstance, ReflectClassBaseObject* refCaType, ReflectMethodObject* pCtorUNSAFE);
 138
 139     static
 140     void QCALLTYPE MakeByRef(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType);
 141
 142     static
 143     void QCALLTYPE MakePointer(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType);
 144
 145     static
 146     void QCALLTYPE MakeSZArray(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType);
 147
 148     static
 149     void QCALLTYPE MakeArray(EnregisteredTypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType);
 150
 151     static BOOL QCALLTYPE IsCollectible(EnregisteredTypeHandle pTypeHandle);
 152
 153     static FCDECL1(ReflectClassBaseObject*, GetRuntimeType, void *th);
 154
 155     static FCDECL1_V(ReflectClassBaseObject*, GetTypeFromHandle, FCALLRuntimeTypeHandle th);
 156     static FCDECL1_V(EnregisteredTypeHandle, GetValueInternal, FCALLRuntimeTypeHandle RTH);
 157
 158     static FCDECL2(FC_BOOL_RET, TypeEQ, Object* left, Object* right);
 159     static FCDECL2(FC_BOOL_RET, TypeNEQ, Object* left, Object* right);
 160
 161
 162 #ifdef FEATURE_COMINTEROP
 163     static FCDECL1(FC_BOOL_RET, IsWindowsRuntimeObjectType, ReflectClassBaseObject *rtTypeUNSAFE);
 164     static FCDECL1(FC_BOOL_RET, IsTypeExportedToWindowsRuntime, ReflectClassBaseObject *rtTypeUNSAFE);
 165 #endif // FEATURE_COMINTEROP
 166
 167     static
 168     void QCALLTYPE PrepareMemberInfoCache(EnregisteredTypeHandle pMemberInfoCache);
 169
 170     static
 171     void QCALLTYPE ConstructName(EnregisteredTypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString);
 172
 173     static
 174     void QCALLTYPE GetTypeByNameUsingCARules(LPCWSTR pwzClassName, QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType);
 175
 176     static
 177     void QCALLTYPE GetTypeByName(LPCWSTR pwzClassName, BOOL bThrowOnError, BOOL bIgnoreCase, BOOL bReflectionOnly,
 178                                  QCall::StackCrawlMarkHandle pStackMark,
 179                                  ICLRPrivBinder * pPrivHostBinder,
 180                                  BOOL bLoadTypeFromPartialNameHack, QCall::ObjectHandleOnStack retType,
 181                                  QCall::ObjectHandleOnStack keepAlive);
 182
 183     static FCDECL1(AssemblyBaseObject*, GetAssembly, ReflectClassBaseObject *pType);
 184     static FCDECL1(ReflectClassBaseObject*, GetBaseType, ReflectClassBaseObject* pType);
 185     static FCDECL1(ReflectModuleBaseObject*, GetModule, ReflectClassBaseObject* pType);
 186     static FCDECL1(INT32, GetAttributes, ReflectClassBaseObject* pType);
 187     static FCDECL1(INT32, GetToken, ReflectClassBaseObject* pType);
 188     static FCDECL1(LPCUTF8, GetUtf8Name, ReflectClassBaseObject* pType);
 189     static FCDECL1(INT32, GetArrayRank, ReflectClassBaseObject* pType);
 190
 191     static FCDECL1(ReflectMethodObject*, GetDeclaringMethod, ReflectClassBaseObject *pType);
 192
 193     static
 194     void QCALLTYPE GetDefaultConstructor(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retMethod);
 195
 196     static FCDECL1(ReflectClassBaseObject*, GetDeclaringType, ReflectClassBaseObject* pType);
 197 #ifdef FEATURE_REMOTING
 198     static FCDECL1(FC_BOOL_RET, IsContextful, ReflectClassBaseObject* pType);
 199 #endif
 200     static FCDECL1(FC_BOOL_RET, IsValueType, ReflectClassBaseObject* pType);
 201     static FCDECL1(FC_BOOL_RET, IsInterface, ReflectClassBaseObject* pType);
 202
 203     static
 204     BOOL QCALLTYPE IsVisible(EnregisteredTypeHandle pTypeHandle);
 205
 206     static
 207     BOOL QCALLTYPE IsSecurityCritical(EnregisteredTypeHandle pTypeHandle);
 208
 209     static
 210     BOOL QCALLTYPE IsSecuritySafeCritical(EnregisteredTypeHandle pTypeHandle);
 211
 212     static
 213     BOOL QCALLTYPE IsSecurityTransparent(EnregisteredTypeHandle pTypeHandle);
 214
 215     static FCDECL1(FC_BOOL_RET, HasProxyAttribute, ReflectClassBaseObject *pType);
 216     static FCDECL2(FC_BOOL_RET, IsComObject, ReflectClassBaseObject *pType, CLR_BOOL isGenericCOM);
 217     static FCDECL2(FC_BOOL_RET, CanCastTo, ReflectClassBaseObject *pType, ReflectClassBaseObject *pTarget);
 218     static FCDECL2(FC_BOOL_RET, IsInstanceOfType, ReflectClassBaseObject *pType, Object *object);
 219
 220     static FCDECL6(FC_BOOL_RET, SatisfiesConstraints, PTR_ReflectClassBaseObject pGenericParameter, TypeHandle *typeContextArgs, INT32 typeContextCount, TypeHandle *methodContextArgs, INT32 methodContextCount, PTR_ReflectClassBaseObject pGenericArgument);
 221     static
 222     FCDECL1(FC_BOOL_RET, HasInstantiation, PTR_ReflectClassBaseObject pType);
 223
 224     static
 225     FCDECL1(FC_BOOL_RET, IsGenericTypeDefinition, PTR_ReflectClassBaseObject pType);
 226
 227     static
 228     FCDECL1(FC_BOOL_RET, IsGenericVariable, PTR_ReflectClassBaseObject pType);
 229
 230     static
 231     FCDECL1(INT32, GetGenericVariableIndex, PTR_ReflectClassBaseObject pType);
 232
 233     static
 234     FCDECL1(FC_BOOL_RET, ContainsGenericVariables, PTR_ReflectClassBaseObject pType);
 235
 236     static
 237     void QCALLTYPE GetInstantiation(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, BOOL fAsRuntimeTypeArray);
 238
 239     static
 240     void QCALLTYPE Instantiate(EnregisteredTypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType);
 241
 242     static
 243     void QCALLTYPE GetGenericTypeDefinition(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType);
 244
 245     static FCDECL2(FC_BOOL_RET, CompareCanonicalHandles, PTR_ReflectClassBaseObject pLeft, PTR_ReflectClassBaseObject pRight);
 246
 247     static FCDECL1(PtrArray*, GetInterfaces, ReflectClassBaseObject *pType);
 248
 249     static
 250     void QCALLTYPE GetConstraints(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypes);
 251
 252     static
 253     PVOID QCALLTYPE GetGCHandle(EnregisteredTypeHandle pTypeHandle, INT32 handleType);
 254
 255     static FCDECL1(INT32, GetCorElementType, PTR_ReflectClassBaseObject pType);
 256     static FCDECL1(ReflectClassBaseObject*, GetElementType, ReflectClassBaseObject* pType);
 257
 258     static FCDECL2(MethodDesc*, GetMethodAt, PTR_ReflectClassBaseObject pType, INT32 slot);
 259     static FCDECL1(INT32, GetNumVirtuals, ReflectClassBaseObject *pType);
 260
 261     static
 262     void QCALLTYPE VerifyInterfaceIsImplemented(EnregisteredTypeHandle pTypeHandle, EnregisteredTypeHandle pIFaceHandle);
 263
 264     static
 265     INT32 QCALLTYPE GetInterfaceMethodImplementationSlot(EnregisteredTypeHandle pTypeHandle, EnregisteredTypeHandle pOwner, MethodDesc * pMD);
 266
 267     static FCDECL3(FC_BOOL_RET, GetFields, ReflectClassBaseObject *pType, INT32 **result, INT32 *pCount);
 268
 269     static FCDECL1(MethodDesc *, GetFirstIntroducedMethod, ReflectClassBaseObject* pType);
 270     static FCDECL1(void, GetNextIntroducedMethod, MethodDesc **ppMethod);
 271
 272     static FCDECL2(Object*, CreateInstanceForGenericType, ReflectClassBaseObject* pType
 273         , ReflectClassBaseObject* parameterType );
 274
 275     static
 276     FCDECL1(IMDInternalImport*, GetMetadataImport, ReflectClassBaseObject * pModuleUNSAFE);
 277 };
 278
 279 class RuntimeMethodHandle {
 280
 281 public:
 282     static FCDECL1(ReflectMethodObject*, GetCurrentMethod, StackCrawlMark* stackMark);
 283
 284     static FCDECL4(Object*, InvokeMethod, Object *target, PTRArray *objs, SignatureNative* pSig, CLR_BOOL fConstructor);
 285
 286     struct StreamingContextData {
 287         Object * additionalContext;  // additionalContex was changed from OBJECTREF to Object to avoid having a
 288         INT32 contextStates;         // constructor in this struct. GCC doesn't allow structs with constructors to be
 289     };
 290
 291     // *******************************************************************************************
 292     // Keep these in sync with the version in bcl\system\runtime\serialization\streamingcontext.cs
 293     // *******************************************************************************************
 294     enum StreamingContextStates
 295     {
 296         CONTEXTSTATE_CrossProcess   = 0x01,
 297         CONTEXTSTATE_CrossMachine   = 0x02,
 298         CONTEXTSTATE_File           = 0x04,
 299         CONTEXTSTATE_Persistence    = 0x08,
 300         CONTEXTSTATE_Remoting       = 0x10,
 301         CONTEXTSTATE_Other          = 0x20,
 302         CONTEXTSTATE_Clone          = 0x40,
 303         CONTEXTSTATE_CrossAppDomain = 0x80,
 304         CONTEXTSTATE_All            = 0xFF
 305     };
 306
 307     // passed by value
 308     // STATIC IMPLEMENTATION
 309     static OBJECTREF InvokeMethod_Internal(
 310         MethodDesc *pMethod, OBJECTREF targetUNSAFE, INT32 attrs, OBJECTREF binderUNSAFE, PTRARRAYREF objsUNSAFE, OBJECTREF localeUNSAFE,
 311         BOOL isBinderDefault, Assembly *caller, Assembly *reflectedClassAssembly, TypeHandle declaringType, SignatureNative* pSig, BOOL verifyAccess);
 312
 313     static
 314     BOOL QCALLTYPE IsSecurityCritical(MethodDesc *pMD);
 315
 316     static
 317     BOOL QCALLTYPE IsSecuritySafeCritical(MethodDesc *pMD);
 318
 319     static
 320     BOOL QCALLTYPE IsSecurityTransparent(MethodDesc *pMD);
 321
 322     static FCDECL2(FC_BOOL_RET, IsTokenSecurityTransparent, ReflectModuleBaseObject *pModuleUNSAFE, INT32 tkToken);
 323
 324     static
 325     BOOL QCALLTYPE IsCAVisibleFromDecoratedType(
 326         EnregisteredTypeHandle targetTypeHandle,
 327         MethodDesc * pTargetCtor,
 328         EnregisteredTypeHandle sourceTypeHandle,
 329         QCall::ModuleHandle sourceModuleHandle);
 330
 331     static FCDECL3(void, CheckLinktimeDemands, ReflectMethodObject *pMethodUNSAFE, ReflectModuleBaseObject *pModuleUNSAFE, CLR_BOOL isDecoratedTargetSecurityTransparent);
 332     static FCDECL4(void, SerializationInvoke, ReflectMethodObject *pMethodUNSAFE, Object* targetUNSAFE,
 333         Object* serializationInfoUNSAFE, struct StreamingContextData * pContext);
 334
 335     static
 336     void QCALLTYPE ConstructInstantiation(MethodDesc * pMethod, DWORD format, QCall::StringHandleOnStack retString);
 337
 338     static
 339     void * QCALLTYPE GetFunctionPointer(MethodDesc * pMethod);
 340
 341     static FCDECL1(INT32, GetAttributes, MethodDesc *pMethod);
 342     static FCDECL1(INT32, GetImplAttributes, ReflectMethodObject *pMethodUNSAFE);
 343     static FCDECL1(ReflectClassBaseObject*, GetDeclaringType, MethodDesc *pMethod);
 344     static FCDECL1(INT32, GetSlot, MethodDesc *pMethod);
 345     static FCDECL1(INT32, GetMethodDef, ReflectMethodObject *pMethodUNSAFE);
 346     static FCDECL1(StringObject*, GetName, MethodDesc *pMethod);
 347     static FCDECL1(LPCUTF8, GetUtf8Name, MethodDesc *pMethod);
 348     static FCDECL2(FC_BOOL_RET, MatchesNameHash, MethodDesc * pMethod, ULONG hash);
 349
 350     static
 351     void QCALLTYPE GetMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray);
 352
 353     static
 354     FCDECL1(FC_BOOL_RET, HasMethodInstantiation, MethodDesc *pMethod);
 355
 356     static
 357     FCDECL1(FC_BOOL_RET, IsGenericMethodDefinition, MethodDesc *pMethod);
 358
 359     static
 360     FCDECL1(FC_BOOL_RET, IsTypicalMethodDefinition, ReflectMethodObject *pMethodUNSAFE);
 361
 362     static
 363     void QCALLTYPE GetTypicalMethodDefinition(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod);
 364
 365     static
 366     void QCALLTYPE StripMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod);
 367
 368     // see comment in the cpp file
 369     static FCDECL3(MethodDesc*, GetStubIfNeeded, MethodDesc *pMethod, ReflectClassBaseObject *pType, PtrArray* instArray);
 370     static FCDECL2(MethodDesc*, GetMethodFromCanonical, MethodDesc *pMethod, PTR_ReflectClassBaseObject pType);
 371
 372     static
 373     FCDECL1(FC_BOOL_RET, IsDynamicMethod, MethodDesc * pMethod);
 374
 375     static
 376     FCDECL1(Object*, GetResolver, MethodDesc * pMethod);
 377
 378     static
 379     void QCALLTYPE Destroy(MethodDesc * pMethod);
 380
 381     static
 382     void QCALLTYPE GetCallerType(QCall::StackCrawlMarkHandle pStackMark, QCall::ObjectHandleOnStack retType);
 383
 384     static FCDECL2(MethodBody*, GetMethodBody, ReflectMethodObject *pMethodUNSAFE, PTR_ReflectClassBaseObject pDeclaringType);
 385
 386     static FCDECL1(FC_BOOL_RET, IsConstructor, MethodDesc *pMethod);
 387
 388     static FCDECL1(Object*, GetLoaderAllocator, MethodDesc *pMethod);
 389 };
 390
 391 class RuntimeFieldHandle {
 392
 393 public:
 394     static FCDECL5(Object*, GetValue, ReflectFieldObject *pFieldUNSAFE, Object *instanceUNSAFE, ReflectClassBaseObject *pFieldType, ReflectClassBaseObject *pDeclaringType, CLR_BOOL *pDomainInitialized);
 395     static FCDECL7(void, SetValue, ReflectFieldObject *pFieldUNSAFE, Object *targetUNSAFE, Object *valueUNSAFE, ReflectClassBaseObject *pFieldType, DWORD attr, ReflectClassBaseObject *pDeclaringType, CLR_BOOL *pDomainInitialized);
 396     static FCDECL4(Object*, GetValueDirect, ReflectFieldObject *pFieldUNSAFE, ReflectClassBaseObject *pFieldType, TypedByRef *pTarget, ReflectClassBaseObject *pDeclaringType);
 397     static FCDECL5(void, SetValueDirect, ReflectFieldObject *pFieldUNSAFE, ReflectClassBaseObject *pFieldType, TypedByRef *pTarget, Object *valueUNSAFE, ReflectClassBaseObject *pContextType);
 398     static FCDECL1(StringObject*, GetName, ReflectFieldObject *pFieldUNSAFE);
 399     static FCDECL1(LPCUTF8, GetUtf8Name, FieldDesc *pField);
 400     static FCDECL2(FC_BOOL_RET, MatchesNameHash, FieldDesc * pField, ULONG hash);
 401
 402     static FCDECL1(INT32, GetAttributes, FieldDesc *pField);
 403     static FCDECL1(ReflectClassBaseObject*, GetApproxDeclaringType, FieldDesc *pField);
 404     static FCDECL1(INT32, GetToken, ReflectFieldObject *pFieldUNSAFE);
 405     static FCDECL2(FieldDesc*, GetStaticFieldForGenericType, FieldDesc *pField, ReflectClassBaseObject *pDeclaringType);
 406     static FCDECL1(FC_BOOL_RET, AcquiresContextFromThis, FieldDesc *pField);
 407
 408     static
 409     BOOL QCALLTYPE IsSecurityCritical(FieldDesc *pFD);
 410
 411     static
 412     BOOL QCALLTYPE IsSecuritySafeCritical(FieldDesc *pFD);
 413
 414     static
 415     BOOL QCALLTYPE IsSecurityTransparent(FieldDesc *pFD);
 416
 417     static
 418     void QCALLTYPE CheckAttributeAccess(FieldDesc *pFD, QCall::ModuleHandle pModule);
 419 };
 420
 421 class ModuleHandle {
 422
 423 public:
 424     static FCDECL5(ReflectMethodObject*, GetDynamicMethod, ReflectMethodObject *pMethodUNSAFE, ReflectModuleBaseObject *pModuleUNSAFE, StringObject *name, U1Array *sig, Object *resolver);
 425     static FCDECL1(INT32, GetToken, ReflectModuleBaseObject *pModuleUNSAFE);
 426
 427     static
 428     void QCALLTYPE GetModuleType(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType);
 429
 430     static
 431     FCDECL1(IMDInternalImport*, GetMetadataImport, ReflectModuleBaseObject * pModuleUNSAFE);
 432
 433     static
 434     BOOL QCALLTYPE ContainsPropertyMatchingHash(QCall::ModuleHandle pModule, INT32 tkProperty, ULONG hash);
 435
 436     static
 437     void QCALLTYPE ResolveType(QCall::ModuleHandle pModule, INT32 tkType, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retType);
 438
 439     static
 440     MethodDesc * QCALLTYPE ResolveMethod(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount);
 441
 442     static
 443     void QCALLTYPE ResolveField(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retField);
 444
 445     static
 446     void QCALLTYPE GetAssembly(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retAssembly);
 447
 448     static
 449     void QCALLTYPE GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine);
 450
 451     static
 452     FCDECL1(INT32, GetMDStreamVersion, ReflectModuleBaseObject * pModuleUNSAFE);
 453 };
 454
 455 class AssemblyHandle {
 456
 457 public:
 458     static FCDECL1(ReflectModuleBaseObject*, GetManifestModule, AssemblyBaseObject *pAssemblyUNSAFE);
 459
 460     static FCDECL1(INT32, GetToken, AssemblyBaseObject *pAssemblyUNSAFE);
 461 };
 462
 463 class SignatureNative;
 464
 465 typedef DPTR(SignatureNative) PTR_SignatureNative;
 466
 467 #ifdef USE_CHECKED_OBJECTREFS
 468 typedef REF<SignatureNative> SIGNATURENATIVEREF;
 469 #else
 470 typedef PTR_SignatureNative SIGNATURENATIVEREF;
 471 #endif
 472
 473 class SignatureNative : public Object
 474 {
 475     friend class RuntimeMethodHandle;
 476     friend class ArgIteratorForMethodInvoke;
 477
 478 public:
 479     static FCDECL6(void, GetSignature,
 480         SignatureNative* pSignatureNative,
 481         PCCOR_SIGNATURE pCorSig, DWORD cCorSig,
 482         FieldDesc *pFieldDesc, ReflectMethodObject *pMethodUNSAFE,
 483         ReflectClassBaseObject *pDeclaringType);
 484     static FCDECL3(Object *, GetCustomModifiers, SignatureNative* pSig, INT32 parameter, CLR_BOOL fRequired);
 485     static FCDECL2(FC_BOOL_RET, CompareSig, SignatureNative* pLhs, SignatureNative* pRhs);
 486     static FCDECL4(FC_BOOL_RET, CompareSigForAppCompat, SignatureNative* pLhs, ReflectClassBaseObject * pTypeLhs, SignatureNative* pRhs, ReflectClassBaseObject * pTypeRhs);
 487
 488
 489     BOOL HasThis() { LIMITED_METHOD_CONTRACT; return (m_managedCallingConvention & CALLCONV_HasThis); }
 490     INT32 NumFixedArgs() { WRAPPER_NO_CONTRACT; return m_PtrArrayarguments->GetNumComponents(); }
 491     TypeHandle GetReturnTypeHandle()
 492     {
 493         CONTRACTL {
 494             NOTHROW;
 495             GC_NOTRIGGER;
 496             MODE_COOPERATIVE;
 497         }
 498         CONTRACTL_END;
 499
 500         return ((REFLECTCLASSBASEREF)m_returnType)->GetType();
 501     }
 502
 503     PCCOR_SIGNATURE GetCorSig() { LIMITED_METHOD_CONTRACT; return m_sig; }
 504     DWORD GetCorSigSize() { LIMITED_METHOD_CONTRACT; return m_cSig; }
 505     Module* GetModule() { WRAPPER_NO_CONTRACT; return GetDeclaringType().GetModule(); }
 506
 507     TypeHandle GetArgumentAt(INT32 position)
 508     {
 509         CONTRACTL {
 510             NOTHROW;
 511             GC_NOTRIGGER;
 512             MODE_COOPERATIVE;
 513         }
 514         CONTRACTL_END;
 515
 516         REFLECTCLASSBASEREF refArgument = (REFLECTCLASSBASEREF)m_PtrArrayarguments->GetAt(position);
 517         return refArgument->GetType();
 518     }
 519
 520     DWORD GetArgIteratorFlags()
 521     {
 522         LIMITED_METHOD_CONTRACT;
 523         return VolatileLoad(&m_managedCallingConvention) >> CALLCONV_ArgIteratorFlags_Shift;
 524     }
 525
 526     INT32 GetSizeOfArgStack()
 527     {
 528         LIMITED_METHOD_CONTRACT;
 529         return m_nSizeOfArgStack;
 530     }
 531
 532     TypeHandle GetDeclaringType()
 533     {
 534         LIMITED_METHOD_CONTRACT;
 535         return m_declaringType->GetType();
 536     }
 537     MethodDesc* GetMethod()
 538     {
 539         LIMITED_METHOD_CONTRACT;
 540         return m_pMethod;
 541     }
 542
 543     const SigTypeContext * GetTypeContext(SigTypeContext *pTypeContext)
 544     {
 545         CONTRACTL
 546         {
 547             NOTHROW;
 548             GC_NOTRIGGER;
 549             MODE_COOPERATIVE;
 550         }
 551         CONTRACTL_END;
 552
 553        _ASSERTE(m_pMethod || !GetDeclaringType().IsNull());
 554         if (m_pMethod)
 555             return SigTypeContext::GetOptionalTypeContext(m_pMethod, GetDeclaringType(), pTypeContext);
 556         else
 557             return SigTypeContext::GetOptionalTypeContext(GetDeclaringType(), pTypeContext);
 558     }
 559
 560 private:
 561     void SetReturnType(OBJECTREF returnType)
 562     {
 563         CONTRACTL {
 564             THROWS;
 565             GC_TRIGGERS;
 566             MODE_COOPERATIVE;
 567         }
 568         CONTRACTL_END;
 569         SetObjectReference(&m_returnType, returnType, GetAppDomain());
 570     }
 571
 572     void SetKeepAlive(OBJECTREF keepAlive)
 573     {
 574         CONTRACTL {
 575             THROWS;
 576             GC_TRIGGERS;
 577             MODE_COOPERATIVE;
 578         }
 579         CONTRACTL_END;
 580         SetObjectReference(&m_keepalive, keepAlive, GetAppDomain());
 581     }
 582
 583     void SetDeclaringType(REFLECTCLASSBASEREF declaringType)
 584     {
 585         CONTRACTL {
 586             THROWS;
 587             GC_TRIGGERS;
 588             MODE_COOPERATIVE;
 589         }
 590         CONTRACTL_END;
 591         SetObjectReference((OBJECTREF*)&m_declaringType, (OBJECTREF)declaringType, GetAppDomain());
 592     }
 593
 594     void SetArgumentArray(PTRARRAYREF ptrArrayarguments)
 595     {
 596         CONTRACTL {
 597             THROWS;
 598             GC_TRIGGERS;
 599             MODE_COOPERATIVE;
 600         }
 601         CONTRACTL_END;
 602         SetObjectReference((OBJECTREF*)&m_PtrArrayarguments, (OBJECTREF)ptrArrayarguments, GetAppDomain());
 603     }
 604
 605     void SetArgument(INT32 argument, OBJECTREF argumentType)
 606     {
 607         CONTRACTL {
 608             THROWS;
 609             GC_TRIGGERS;
 610             MODE_COOPERATIVE;
 611         }
 612         CONTRACTL_END;
 613
 614         m_PtrArrayarguments->SetAt(argument, argumentType);
 615     }
 616
 617     void SetArgIteratorFlags(DWORD flags)
 618     {
 619         LIMITED_METHOD_CONTRACT;
 620         return VolatileStore(&m_managedCallingConvention, (INT32)(m_managedCallingConvention | (flags << CALLCONV_ArgIteratorFlags_Shift)));
 621     }
 622
 623     void SetSizeOfArgStack(INT32 nSizeOfArgStack)
 624     {
 625         LIMITED_METHOD_CONTRACT;
 626         m_nSizeOfArgStack = nSizeOfArgStack;
 627     }
 628
 629     void SetCallingConvention(INT32 mdCallingConvention)
 630     {
 631         LIMITED_METHOD_CONTRACT;
 632
 633         if ((mdCallingConvention & IMAGE_CEE_CS_CALLCONV_MASK) == IMAGE_CEE_CS_CALLCONV_VARARG)
 634             m_managedCallingConvention = CALLCONV_VarArgs;
 635         else
 636             m_managedCallingConvention = CALLCONV_Standard;
 637
 638         if ((mdCallingConvention & IMAGE_CEE_CS_CALLCONV_HASTHIS) != 0)
 639             m_managedCallingConvention |= CALLCONV_HasThis;
 640
 641         if ((mdCallingConvention & IMAGE_CEE_CS_CALLCONV_EXPLICITTHIS) != 0)
 642             m_managedCallingConvention |= CALLCONV_ExplicitThis;
 643     }
 644
 645     // Mirrored in the managed world (System.Signature)
 646     //
 647     // this is the layout the classloader chooses by default for the managed struct.
 648     //
 649     PTRARRAYREF m_PtrArrayarguments;
 650     REFLECTCLASSBASEREF m_declaringType;
 651     OBJECTREF m_returnType;
 652     OBJECTREF m_keepalive;
 653     PCCOR_SIGNATURE m_sig;
 654     INT32 m_managedCallingConvention;
 655     INT32 m_nSizeOfArgStack;
 656     DWORD m_cSig;
 657     MethodDesc* m_pMethod;
 658 };
 659
 660 class ReflectionPointer : public Object
 661 {
 662 public:
 663     OBJECTREF _ptrType;
 664     void * _ptr;
 665 };
 666
 667 #endif
 668