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