#include "stackprobe.h"
#include "eeconfig.h"
#include "eehash.h"
-#include "objecthandle.h"
#include "interoputil.h"
#include "typedesc.h"
#include "virtualcallstub.h"
#include "contractimpl.h"
#include "dynamicmethod.h"
#include "peimagelayout.inl"
-#include "security.h"
#include "eventtrace.h"
#include "invokeutil.h"
-FCIMPL3(FC_BOOL_RET, Utf8String::EqualsCaseSensitive, LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes)
+FCIMPL3(FC_BOOL_RET, MdUtf8String::EqualsCaseSensitive, LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes)
{
CONTRACTL {
FCALL_CHECK;
}
FCIMPLEND
-BOOL QCALLTYPE Utf8String::EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes)
+BOOL QCALLTYPE MdUtf8String::EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes)
{
QCALL_CONTRACT;
return fStringsEqual;
}
-ULONG QCALLTYPE Utf8String::HashCaseInsensitive(LPCUTF8 sz, INT32 stringNumBytes)
+ULONG QCALLTYPE MdUtf8String::HashCaseInsensitive(LPCUTF8 sz, INT32 stringNumBytes)
{
QCALL_CONTRACT;
if (pCACtor != NULL)
{
- // Allowing a dangerous method to be called in custom attribute instantiation is, well, dangerous.
- // E.g. a malicious user can craft a custom attribute record that fools us into creating a DynamicMethod
- // object attached to typeof(System.Reflection.CustomAttribute) and thus gain access to mscorlib internals.
- if (InvokeUtil::IsDangerousMethod(pCACtor))
- return FALSE;
-
_ASSERTE(pCACtor->IsCtor());
dwAttr = pCACtor->GetAttrs();
dwAttr,
pCACtor,
NULL,
- *AccessCheckOptions::s_pNormalAccessChecks,
- FALSE,
- FALSE);
+ *AccessCheckOptions::s_pNormalAccessChecks);
}
BOOL QCALLTYPE RuntimeMethodHandle::IsCAVisibleFromDecoratedType(
Module *pModule = refType->GetType().GetAssembly()->GetManifestModule();
pDomainFile = pModule->FindDomainFile(GetAppDomain());
-#ifdef FEATURE_LOADER_OPTIMIZATION
- if (pDomainFile == NULL)
- {
- HELPER_METHOD_FRAME_BEGIN_RET_1(refType);
-
- pDomainFile = GetAppDomain()->LoadDomainNeutralModuleDependency(pModule, FILE_LOADED);
-
- HELPER_METHOD_FRAME_END();
- }
-#endif // FEATURE_LOADER_OPTIMIZATION
-
FC_RETURN_ASSEMBLY_OBJECT((DomainAssembly *)pDomainFile, refType);
}
}
FCIMPLEND;
+
+FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::IsByRefLike, ReflectClassBaseObject *pTypeUNSAFE)
+{
+ CONTRACTL {
+ FCALL_CHECK;
+ }
+ CONTRACTL_END;
+
+ REFLECTCLASSBASEREF refType = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(pTypeUNSAFE);
+
+ _ASSERTE(refType != NULL);
+
+ TypeHandle typeHandle = refType->GetType();
+
+ FC_RETURN_BOOL(typeHandle.IsByRefLike());
+}
+FCIMPLEND
+
BOOL
QCALLTYPE
RuntimeTypeHandle::IsVisible(
return fIsExternallyVisible;
} // RuntimeTypeHandle::IsVisible
-FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::HasProxyAttribute, ReflectClassBaseObject *pTypeUNSAFE) {
- CONTRACTL {
- FCALL_CHECK;
- }
- CONTRACTL_END;
-
- REFLECTCLASSBASEREF refType = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(pTypeUNSAFE);
-
- if (refType == NULL)
- FCThrowRes(kArgumentNullException, W("Arg_InvalidHandle"));
-
- TypeHandle typeHandle = refType->GetType();
-
- // TODO: Justify this
- if (typeHandle.IsGenericVariable())
- FC_RETURN_BOOL(FALSE);
-
- if (typeHandle.IsTypeDesc()) {
- if (!typeHandle.IsArray())
- FC_RETURN_BOOL(FALSE);
- }
-
- MethodTable* pMT= typeHandle.GetMethodTable();
-
- if (!pMT)
- FCThrowRes(kArgumentException, W("Arg_InvalidHandle"));
-
- FC_RETURN_BOOL(pMT->GetClass()->HasRemotingProxyAttribute());
-}
-FCIMPLEND
-
FCIMPL2(FC_BOOL_RET, RuntimeTypeHandle::IsComObject, ReflectClassBaseObject *pTypeUNSAFE, CLR_BOOL isGenericCOM) {
-#ifdef FEATURE_COMINTEROP
CONTRACTL {
FCALL_CHECK;
}
HELPER_METHOD_FRAME_END();
FC_RETURN_BOOL(ret);
-#else
- CONTRACTL {
- DISABLED(NOTHROW);
- GC_NOTRIGGER;
- MODE_COOPERATIVE;
- PRECONDITION(CheckPointer(pTypeUNSAFE));
- }
- CONTRACTL_END;
- FCUnique(0x37);
- FC_RETURN_BOOL(FALSE);
-#endif
}
FCIMPLEND
TypeHandle th = TypeHandle::FromPtr(pTypeHandle);
assert(handleType >= HNDTYPE_WEAK_SHORT && handleType <= HNDTYPE_WEAK_WINRT);
- objHandle = th.GetDomain()->CreateTypedHandle(NULL, static_cast<HandleType>(handleType));
+ objHandle = AppDomain::GetCurrentDomain()->CreateTypedHandle(NULL, static_cast<HandleType>(handleType));
th.GetLoaderAllocator()->RegisterHandleForCleanup(objHandle);
END_QCALL;
END_QCALL;
}
-INT32 QCALLTYPE RuntimeTypeHandle::GetInterfaceMethodImplementationSlot(EnregisteredTypeHandle pTypeHandle, EnregisteredTypeHandle pOwner, MethodDesc * pMD)
+MethodDesc* QCALLTYPE RuntimeTypeHandle::GetInterfaceMethodImplementation(EnregisteredTypeHandle pTypeHandle, EnregisteredTypeHandle pOwner, MethodDesc * pMD)
{
QCALL_CONTRACT;
- INT32 slotNumber = -1;
+ MethodDesc* pResult = nullptr;
BEGIN_QCALL;
// with at least an abstract method. b19897_GetInterfaceMap_Abstract.exe tests this case.
//@TODO:STUBDISPATCH: Don't need to track down the implementation, just the declaration, and this can
//@TODO: be done faster - just need to make a function FindDispatchDecl.
- DispatchSlot slot(typeHandle.GetMethodTable()->FindDispatchSlotForInterfaceMD(thOwnerOfMD, pMD));
+ DispatchSlot slot(typeHandle.GetMethodTable()->FindDispatchSlotForInterfaceMD(thOwnerOfMD, pMD, TRUE /* throwOnConflict */));
if (!slot.IsNull())
- slotNumber = slot.GetMethodDesc()->GetSlot();
+ pResult = slot.GetMethodDesc();
END_QCALL;
- return slotNumber;
+ return pResult;
}
void QCALLTYPE RuntimeTypeHandle::GetDefaultConstructor(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retMethod)
return;
}
-void QCALLTYPE RuntimeTypeHandle::GetTypeByName(LPCWSTR pwzClassName, BOOL bThrowOnError, BOOL bIgnoreCase, BOOL bReflectionOnly,
+void QCALLTYPE RuntimeTypeHandle::GetTypeByName(LPCWSTR pwzClassName, BOOL bThrowOnError, BOOL bIgnoreCase,
QCall::StackCrawlMarkHandle pStackMark,
ICLRPrivBinder * pPrivHostBinder,
BOOL bLoadTypeFromPartialNameHack, QCall::ObjectHandleOnStack retType,
COMPlusThrowArgumentNull(W("className"),W("ArgumentNull_String"));
{
- typeHandle = TypeName::GetTypeManaged(pwzClassName, NULL, bThrowOnError, bIgnoreCase, bReflectionOnly, /*bProhibitAsmQualifiedName =*/ FALSE, pStackMark,
+ typeHandle = TypeName::GetTypeManaged(pwzClassName, NULL, bThrowOnError, bIgnoreCase, /*bProhibitAsmQualifiedName =*/ FALSE, pStackMark,
bLoadTypeFromPartialNameHack, (OBJECTREF*)keepAlive.m_ppObject,
pPrivHostBinder);
}
return funcPtr;
}
+
+BOOL QCALLTYPE RuntimeMethodHandle::GetIsCollectible(MethodDesc * pMethod)
+{
+ QCALL_CONTRACT;
+
+ BOOL isCollectible = FALSE;
+
+ BEGIN_QCALL;
+
+ isCollectible = pMethod->GetLoaderAllocator()->IsCollectible();
+
+ END_QCALL;
+
+ return isCollectible;
+}
FCIMPL1(LPCUTF8, RuntimeMethodHandle::GetUtf8Name, MethodDesc *pMethod) {
CONTRACTL {
}
FCIMPLEND
+FCIMPL1(INT32, RuntimeMethodHandle::GetGenericParameterCount, MethodDesc * pMethod)
+{
+ FCALL_CONTRACT;
+
+ return pMethod->GetNumGenericMethodArgs();
+}
+FCIMPLEND
+
FCIMPL1(FC_BOOL_RET, RuntimeMethodHandle::IsDynamicMethod, MethodDesc * pMethod)
{
FCALL_CONTRACT;
FCIMPLEND
-FCIMPL2(MethodBody *, RuntimeMethodHandle::GetMethodBody, ReflectMethodObject *pMethodUNSAFE, ReflectClassBaseObject *pDeclaringTypeUNSAFE)
+FCIMPL2(RuntimeMethodBody *, RuntimeMethodHandle::GetMethodBody, ReflectMethodObject *pMethodUNSAFE, ReflectClassBaseObject *pDeclaringTypeUNSAFE)
{
CONTRACTL
{
struct _gc
{
- METHODBODYREF MethodBodyObj;
- EXCEPTIONHANDLINGCLAUSEREF EHClauseObj;
- LOCALVARIABLEINFOREF LocalVariableInfoObj;
+ RUNTIMEMETHODBODYREF MethodBodyObj;
+ RUNTIMEEXCEPTIONHANDLINGCLAUSEREF EHClauseObj;
+ RUNTIMELOCALVARIABLEINFOREF RuntimeLocalVariableInfoObj;
U1ARRAYREF U1Array;
BASEARRAYREF TempArray;
REFLECTCLASSBASEREF declaringType;
gc.MethodBodyObj = NULL;
gc.EHClauseObj = NULL;
- gc.LocalVariableInfoObj = NULL;
+ gc.RuntimeLocalVariableInfoObj = NULL;
gc.U1Array = NULL;
gc.TempArray = NULL;
gc.declaringType = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(pDeclaringTypeUNSAFE);
if (pILHeader)
{
- MethodTable * pExceptionHandlingClauseMT = MscorlibBinder::GetClass(CLASS__EH_CLAUSE);
+ MethodTable * pExceptionHandlingClauseMT = MscorlibBinder::GetClass(CLASS__RUNTIME_EH_CLAUSE);
TypeHandle thEHClauseArray = ClassLoader::LoadArrayTypeThrowing(TypeHandle(pExceptionHandlingClauseMT), ELEMENT_TYPE_SZARRAY);
- MethodTable * pLocalVariableMT = MscorlibBinder::GetClass(CLASS__LOCAL_VARIABLE_INFO);
+ MethodTable * pLocalVariableMT = MscorlibBinder::GetClass(CLASS__RUNTIME_LOCAL_VARIABLE_INFO);
TypeHandle thLocalVariableArray = ClassLoader::LoadArrayTypeThrowing(TypeHandle(pLocalVariableMT), ELEMENT_TYPE_SZARRAY);
Module* pModule = pMethod->GetModule();
}
}
- gc.MethodBodyObj = (METHODBODYREF)AllocateObject(MscorlibBinder::GetClass(CLASS__METHOD_BODY));
+ gc.MethodBodyObj = (RUNTIMEMETHODBODYREF)AllocateObject(MscorlibBinder::GetClass(CLASS__RUNTIME_METHOD_BODY));
- gc.MethodBodyObj->m_maxStackSize = header.GetMaxStack();
- gc.MethodBodyObj->m_initLocals = !!(header.GetFlags() & CorILMethod_InitLocals);
+ gc.MethodBodyObj->_maxStackSize = header.GetMaxStack();
+ gc.MethodBodyObj->_initLocals = !!(header.GetFlags() & CorILMethod_InitLocals);
if (header.IsFat())
- gc.MethodBodyObj->m_localVarSigToken = header.GetLocalVarSigTok();
+ gc.MethodBodyObj->_localVarSigToken = header.GetLocalVarSigTok();
else
- gc.MethodBodyObj->m_localVarSigToken = 0;
+ gc.MethodBodyObj->_localVarSigToken = 0;
// Allocate the array of IL and fill it in from the method header.
BYTE* pIL = const_cast<BYTE*>(header.Code);
COUNT_T cIL = header.GetCodeSize();
gc.U1Array = (U1ARRAYREF) AllocatePrimitiveArray(ELEMENT_TYPE_U1, cIL);
- SetObjectReference((OBJECTREF*)&gc.MethodBodyObj->m_IL, gc.U1Array, GetAppDomain());
- memcpyNoGCRefs(gc.MethodBodyObj->m_IL->GetDataPtr(), pIL, cIL);
+ SetObjectReference((OBJECTREF*)&gc.MethodBodyObj->_IL, gc.U1Array, GetAppDomain());
+ memcpyNoGCRefs(gc.MethodBodyObj->_IL->GetDataPtr(), pIL, cIL);
// Allocate the array of exception clauses.
INT32 cEh = (INT32)header.EHCount();
const COR_ILMETHOD_SECT_EH* ehInfo = header.EH;
gc.TempArray = (BASEARRAYREF) AllocateArrayEx(thEHClauseArray, &cEh, 1);
- SetObjectReference((OBJECTREF*)&gc.MethodBodyObj->m_exceptionClauses, gc.TempArray, GetAppDomain());
+ SetObjectReference((OBJECTREF*)&gc.MethodBodyObj->_exceptionClauses, gc.TempArray, GetAppDomain());
for (INT32 i = 0; i < cEh; i++)
{
const COR_ILMETHOD_SECT_EH_CLAUSE_FAT* ehClause =
(const COR_ILMETHOD_SECT_EH_CLAUSE_FAT*)ehInfo->EHClause(i, &ehBuff);
- gc.EHClauseObj = (EXCEPTIONHANDLINGCLAUSEREF) AllocateObject(pExceptionHandlingClauseMT);
+ gc.EHClauseObj = (RUNTIMEEXCEPTIONHANDLINGCLAUSEREF) AllocateObject(pExceptionHandlingClauseMT);
- gc.EHClauseObj->m_flags = ehClause->GetFlags();
- gc.EHClauseObj->m_tryOffset = ehClause->GetTryOffset();
- gc.EHClauseObj->m_tryLength = ehClause->GetTryLength();
- gc.EHClauseObj->m_handlerOffset = ehClause->GetHandlerOffset();
- gc.EHClauseObj->m_handlerLength = ehClause->GetHandlerLength();
+ gc.EHClauseObj->_flags = ehClause->GetFlags();
+ gc.EHClauseObj->_tryOffset = ehClause->GetTryOffset();
+ gc.EHClauseObj->_tryLength = ehClause->GetTryLength();
+ gc.EHClauseObj->_handlerOffset = ehClause->GetHandlerOffset();
+ gc.EHClauseObj->_handlerLength = ehClause->GetHandlerLength();
if ((ehClause->GetFlags() & COR_ILEXCEPTION_CLAUSE_FILTER) == 0)
- gc.EHClauseObj->m_catchToken = ehClause->GetClassToken();
+ gc.EHClauseObj->_catchToken = ehClause->GetClassToken();
else
- gc.EHClauseObj->m_filterOffset = ehClause->GetFilterOffset();
+ gc.EHClauseObj->_filterOffset = ehClause->GetFilterOffset();
- gc.MethodBodyObj->m_exceptionClauses->SetAt(i, (OBJECTREF) gc.EHClauseObj);
- SetObjectReference((OBJECTREF*)&(gc.EHClauseObj->m_methodBody), (OBJECTREF)gc.MethodBodyObj, GetAppDomain());
+ gc.MethodBodyObj->_exceptionClauses->SetAt(i, (OBJECTREF) gc.EHClauseObj);
+ SetObjectReference((OBJECTREF*)&(gc.EHClauseObj->_methodBody), (OBJECTREF)gc.MethodBodyObj, GetAppDomain());
}
if (header.LocalVarSig != NULL)
MetaSig::sigLocalVars);
INT32 cLocals = metaSig.NumFixedArgs();
gc.TempArray = (BASEARRAYREF) AllocateArrayEx(thLocalVariableArray, &cLocals, 1);
- SetObjectReference((OBJECTREF*)&gc.MethodBodyObj->m_localVariables, gc.TempArray, GetAppDomain());
+ SetObjectReference((OBJECTREF*)&gc.MethodBodyObj->_localVariables, gc.TempArray, GetAppDomain());
for (INT32 i = 0; i < cLocals; i ++)
{
- gc.LocalVariableInfoObj = (LOCALVARIABLEINFOREF)AllocateObject(pLocalVariableMT);
+ gc.RuntimeLocalVariableInfoObj = (RUNTIMELOCALVARIABLEINFOREF)AllocateObject(pLocalVariableMT);
- gc.LocalVariableInfoObj->m_localIndex = i;
+ gc.RuntimeLocalVariableInfoObj->_localIndex = i;
metaSig.NextArg();
CorElementType eType;
IfFailThrow(metaSig.GetArgProps().PeekElemType(&eType));
if (ELEMENT_TYPE_PINNED == eType)
- gc.LocalVariableInfoObj->m_bIsPinned = TRUE;
+ gc.RuntimeLocalVariableInfoObj->_isPinned = TRUE;
TypeHandle tempType= metaSig.GetArgProps().GetTypeHandleThrowing(pModule, &sigTypeContext);
OBJECTREF refLocalType = tempType.GetManagedClassObject();
- gc.LocalVariableInfoObj->SetType(refLocalType);
- gc.MethodBodyObj->m_localVariables->SetAt(i, (OBJECTREF) gc.LocalVariableInfoObj);
+ gc.RuntimeLocalVariableInfoObj->SetType(refLocalType);
+ gc.MethodBodyObj->_localVariables->SetAt(i, (OBJECTREF) gc.RuntimeLocalVariableInfoObj);
}
}
else
{
INT32 cLocals = 0;
gc.TempArray = (BASEARRAYREF) AllocateArrayEx(thLocalVariableArray, &cLocals, 1);
- SetObjectReference((OBJECTREF*)&gc.MethodBodyObj->m_localVariables, gc.TempArray, GetAppDomain());
+ SetObjectReference((OBJECTREF*)&gc.MethodBodyObj->_localVariables, gc.TempArray, GetAppDomain());
}
}
}
HELPER_METHOD_FRAME_END();
- return (MethodBody*)OBJECTREFToObject(gc.MethodBodyObj);
+ return (RuntimeMethodBody*)OBJECTREFToObject(gc.MethodBodyObj);
}
FCIMPLEND
return;
}
+
projects / platform / upstream / coreclr.git / blobdiff