// ==++==
//
//
// Copyright (c) 2006 Microsoft Corporation. All rights reserved.
//
// The use and distribution terms for this software are contained in the file
// named license.txt, which can be found in the root of this distribution.
// By using this software in any fashion, you are agreeing to be bound by the
// terms of this license.
//
// You must not remove this notice, or any other, from this software.
//
//
// ==--==
////////////////////////////////////////////////////////////////////////////////
// This file contains the native methods that support the ArrayInfo class
////////////////////////////////////////////////////////////////////////////////
#include "common.h"
#include "comarrayinfo.h"
#include "excep.h"
#include "field.h"
#include "remoting.h"
#include "security.h"
#include "invokeutil.h"
// Check we're allowed to create an array with the given element type.
void CheckElementType(TypeHandle elementType)
{
// Check for simple types first.
if (elementType.IsUnsharedMT())
{
MethodTable *pMT = elementType.AsMethodTable();
// Check for TypedReference, ArgIterator and RuntimeArgument.
if (pMT->ContainsStackPtr())
COMPlusThrow(kNotSupportedException, L"NotSupported_ContainsStackPtr[]");
// Check for open generic types.
if (pMT->IsGenericTypeDefinition() || pMT->ContainsGenericVariables())
COMPlusThrow(kNotSupportedException, L"NotSupported_OpenType");
// Check for Void.
if (elementType.GetSignatureCorElementType() == ELEMENT_TYPE_VOID)
COMPlusThrow(kNotSupportedException, L"NotSupported_Void[]");
// That's all the dangerous simple types we know, it must be OK.
return;
}
// Checks apply recursively for arrays of arrays etc.
if (elementType.IsArray())
{
CheckElementType(elementType.GetElementType());
return;
}
// ByRefs and generic type variables are never allowed.
if (elementType.IsByRef() || elementType.IsGenericVariable())
COMPlusThrow(kNotSupportedException, L"NotSupported_ContainsStackPtr[]");
// We can create pointers and function pointers, but it requires skip verification permission.
CorElementType etType = elementType.GetSignatureCorElementType();
if (etType == ELEMENT_TYPE_PTR || etType == ELEMENT_TYPE_FNPTR)
{
Security::SpecialDemand(SSWT_LATEBOUND_LINKDEMAND, SECURITY_SKIP_VER);
return;
}
// We shouldn't get here (it means we've encountered a new type of typehandle if we do).
_ASSERTE(!"Shouldn't get here, unknown type handle type");
COMPlusThrow(kNotSupportedException, L"NotSupported_ContainsStackPtr[]");
}
FCIMPL4(Object*, COMArrayInfo::CreateInstance, void* elementTypeHandle, INT32 rank, INT32* pLengths, INT32* pLowerBounds)
{
CONTRACTL {
SO_TOLERANT;
THROWS;
DISABLED(GC_TRIGGERS); // reenable once GC_TRIGGERS allowed in FCALLs
PRECONDITION(rank > 0);
PRECONDITION(CheckPointer(pLengths));
PRECONDITION(CheckPointer(pLowerBounds, NULL_OK));
} CONTRACTL_END;
OBJECTREF pRet = NULL;
TypeHandle elementType = TypeHandle::FromPtr(elementTypeHandle);
_ASSERTE(!elementType.IsNull());
// pLengths and pLowerBounds are pinned buffers. No need to protect them.
HELPER_METHOD_FRAME_BEGIN_RET_ATTRIB(Frame::FRAME_ATTR_RETURNOBJ);
CheckElementType(elementType);
CorElementType CorType = elementType.GetSignatureCorElementType();
CorElementType kind = ELEMENT_TYPE_ARRAY;
// Is it ELEMENT_TYPE_SZARRAY array?
if (rank == 1 && (pLowerBounds == NULL || pLowerBounds[0] == 0))
{
// Shortcut for common cases
if (CorTypeInfo::IsPrimitiveType(CorType))
{
pRet = AllocatePrimitiveArray(CorType,pLengths[0]);
goto Done;
}
else
if (CorTypeInfo::IsObjRef(CorType))
{
pRet = AllocateObjectArray(pLengths[0],elementType);
goto Done;
}
kind = ELEMENT_TYPE_SZARRAY;
pLowerBounds = NULL;
}
{
// Find the Array class...
TypeHandle typeHnd = ClassLoader::LoadArrayTypeThrowing(elementType, kind, rank);
DWORD boundsSize;
INT32* bounds;
if (pLowerBounds != NULL) {
boundsSize = rank*2;
bounds = (INT32*) _alloca(boundsSize * sizeof(INT32));
for (int i=0;i<rank;i++) {
bounds[2*i] = pLowerBounds[i];
bounds[2*i+1] = pLengths[i];
}
}
else {
boundsSize = rank;
bounds = (INT32*) _alloca(boundsSize * sizeof(INT32));
// We need to create a private copy of pLengths to avoid holes caused
// by caller mutating the array
for (int i=0;i<rank;i++)
bounds[i] = pLengths[i];
}
pRet = AllocateArrayEx(typeHnd, bounds, boundsSize);
}
Done: ;
HELPER_METHOD_FRAME_END();
return OBJECTREFToObject(pRet);
}
FCIMPLEND
FCIMPL4(void, COMArrayInfo::GetReference, ArrayBase* refThisUNSAFE, TypedByRef* elemRef, INT32 rank, INT32* pIndices)
{
CONTRACTL {
SO_TOLERANT;
THROWS;
DISABLED(GC_TRIGGERS); // reenable once GC_TRIGGERS allowed in FCALLs
} CONTRACTL_END;
// FC_GC_POLL not necessary. We poll for GC in Array.Rank that's always called
// right before this function
FC_GC_POLL_NOT_NEEDED();
BASEARRAYREF refThis = (BASEARRAYREF) refThisUNSAFE;
_ASSERTE(rank == (INT32)refThis->GetRank());
SIZE_T Offset = 0;
const INT32 *pBoundsPtr = refThis->GetBoundsPtr();
if (rank == 1)
{
Offset = pIndices[0] - refThis->GetLowerBoundsPtr()[0];
// Bounds check each index
// Casting to unsigned allows us to use one compare for [0..limit-1]
if (((UINT32) Offset) >= ((UINT32) pBoundsPtr[0]))
FCThrowVoid(kIndexOutOfRangeException);
}
else
{
// Avoid redundant computation in GetLowerBoundsPtr
const INT32 *pLowerBoundsPtr = pBoundsPtr + rank;
_ASSERTE(refThis->GetLowerBoundsPtr() == pLowerBoundsPtr);
SIZE_T Multiplier = 1;
for (int i = rank-1; i >= 0; i--) {
INT32 curIndex = pIndices[i] - pLowerBoundsPtr[i];
// Bounds check each index
// Casting to unsigned allows us to use one compare for [0..limit-1]
if (((UINT32) curIndex) >= ((UINT32) pBoundsPtr[i]))
FCThrowVoid(kIndexOutOfRangeException);
Offset += curIndex * Multiplier;
Multiplier *= pBoundsPtr[i];
}
}
TypeHandle arrayElementType = refThis->GetArrayElementTypeHandle();
// Legacy behavior
if (arrayElementType.IsTypeDesc())
{
CorElementType elemtype = arrayElementType.AsTypeDesc()->GetInternalCorElementType();
if (elemtype == ELEMENT_TYPE_PTR || elemtype == ELEMENT_TYPE_FNPTR)
FCThrowResVoid(kNotSupportedException, L"NotSupported_Type");
}
#ifdef _DEBUG
CorElementType elemtype = arrayElementType.GetInternalCorElementType();
_ASSERTE(elemtype != ELEMENT_TYPE_PTR && elemtype != ELEMENT_TYPE_FNPTR);
#endif
elemRef->data = refThis->GetDataPtr() + (Offset * refThis->GetComponentSize());
elemRef->type = arrayElementType;
}
FCIMPLEND
FCIMPL2(void, COMArrayInfo::SetValue, TypedByRef * target, Object* objUNSAFE)
{
CONTRACTL {
THROWS;
DISABLED(GC_TRIGGERS);
MODE_COOPERATIVE;
SO_TOLERANT;
}
CONTRACTL_END;
OBJECTREF obj = ObjectToOBJECTREF(objUNSAFE);
TypeHandle thTarget(target->type);
MethodTable* pTargetMT = thTarget.GetMethodTable();
PREFIX_ASSUME(NULL != pTargetMT);
if (obj == NULL)
{
// Null is the universal zero...
if (pTargetMT->IsValueType())
InitValueClass(target->data,pTargetMT);
else
ClearObjectReference((OBJECTREF*)target->data);
}
else
if (thTarget == TypeHandle(g_pObjectClass))
{
// Everything is compatible with Object
SetObjectReference((OBJECTREF*)target->data,(OBJECTREF)obj,GetAppDomain());
}
else
if (!pTargetMT->IsValueType())
{
if (ObjIsInstanceOfNoGC(OBJECTREFToObject(obj), thTarget) != TypeHandle::CanCast)
{
// target->data is protected by the caller
HELPER_METHOD_FRAME_BEGIN_1(obj);
if (!ObjIsInstanceOf(OBJECTREFToObject(obj), thTarget))
COMPlusThrow(kInvalidCastException,L"InvalidCast_StoreArrayElement");
HELPER_METHOD_FRAME_END();
}
SetObjectReference((OBJECTREF*)target->data,obj,GetAppDomain());
}
else
{
// value class or primitive type
if (!pTargetMT->UnBoxInto(target->data, obj))
{
// target->data is protected by the caller
HELPER_METHOD_FRAME_BEGIN_1(obj);
ARG_SLOT value = 0;
// Allow enum -> primitive conversion, disallow primitive -> enum conversion
TypeHandle thSrc = obj->GetTypeHandle();
CorElementType srcType = thSrc.GetVerifierCorElementType();
CorElementType targetType = thTarget.GetSignatureCorElementType();
if (!InvokeUtil::IsPrimitiveType(srcType) || !InvokeUtil::IsPrimitiveType(targetType))
COMPlusThrow(kInvalidCastException, L"InvalidCast_StoreArrayElement");
// Get a properly widened type
InvokeUtil::CreatePrimitiveValue(targetType,srcType,obj,&value);
UINT cbSize = CorTypeInfo::Size(targetType);
memcpyNoGCRefs(target->data, ArgSlotEndianessFixup(&value, cbSize), cbSize);
HELPER_METHOD_FRAME_END();
}
}
}
FCIMPLEND
// This method will initialize an array from a TypeHandle to a field.
FCIMPL2(void, COMArrayInfo::InitializeArray, ArrayBase* pArrayRef, HANDLE handle)
CONTRACTL {
SO_TOLERANT;
THROWS;
DISABLED(GC_TRIGGERS); // reenable once GC_TRIGGERS allowed in FCALLs
} CONTRACTL_END;
BASEARRAYREF arr = BASEARRAYREF(pArrayRef);
HELPER_METHOD_FRAME_BEGIN_1(arr);
if (arr == 0)
COMPlusThrow(kArgumentNullException);
FieldDesc* pField = (FieldDesc*) handle;
if (pField == NULL)
COMPlusThrow(kArgumentNullException);
if (pField->IsRVA() == FALSE)
COMPlusThrow(kArgumentException);
{
// We want to identify hot RVA blobs. To do that we need a place to put an IBC probe.
// But array initialization is done by a jit intrinsic; there is no code in the EE that gets
// executed. So there is no nice place to place a probe. So whats done is, in an instrumented
// ngen image, this intrinsic is turned off (see CEEInfo::getArrayInitializationData). Thus we
// force COMArrayInfo::InitializeArray to be called during an IBC run, and this gives us a
// place to probe. Now the problem is, this function calls lot of EE code which
// causes lot of IBC probes to execute. As a result, the EEClass/MethodTable/FieldDesc of
// the RVA field get reported as "hot", while it is only the blob that is really hot. So we turn
// off IBC logging in this function, and before returning, turn logging back on and report
// just the rva blob address to the logger.
IBCLoggingDisabler ibcld;
// Note that we do not check that the field is actually in the PE file that is initializing
// the array. Basically the data being published is can be accessed by anyone with the proper
// permissions (C# marks these as assembly visibility, and thus are protected from outside
// snooping)
CorElementType type = arr->GetArrayElementType();
if (!CorTypeInfo::IsPrimitiveType(type))
COMPlusThrow(kArgumentException);
DWORD dwCompSize = arr->GetComponentSize();
DWORD dwElemCnt = arr->GetNumComponents();
DWORD dwTotalSize = dwCompSize * dwElemCnt;
DWORD size = 0;
// Restore the declaring class in case it's instantiated
pField->GetApproxEnclosingMethodTable()->CheckRestore(); // <BUG> this probably should be Approx - see bug 184355 </BUG>
size = pField->LoadSize();
// make certain you don't go off the end of the rva static
if (dwTotalSize > size)
COMPlusThrow(kArgumentException);
void *src = pField->GetStaticAddressHandle(NULL);
void *dest = arr->GetDataPtr();
#if BIGENDIAN
DWORD i;
switch (dwCompSize) {
case 1:
memcpyNoGCRefs(dest, src, dwElemCnt);
break;
case 2:
for (i = 0; i < dwElemCnt; i++)
*((UINT16*)dest + i) = GET_UNALIGNED_VAL16((UINT16*)src + i);
break;
case 4:
for (i = 0; i < dwElemCnt; i++)
*((UINT32*)dest + i) = GET_UNALIGNED_VAL32((UINT32*)src + i);
break;
case 8:
for (i = 0; i < dwElemCnt; i++)
*((UINT64*)dest + i) = GET_UNALIGNED_VAL64((UINT64*)src + i);
break;
default:
// should not reach here.
UNREACHABLE_MSG("Incorrect primitive type size!");
break;
}
#else
memcpyNoGCRefs(dest, src, dwTotalSize);
#endif
}
// Report the RVA field to the logger.
g_IBCLogger.LogRVADataAccess(pField);
HELPER_METHOD_FRAME_END();
FCIMPLEND
