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