FCIMPLEND
/// "parse" tells us to parse the simple name of the assembly as if it was the full name
/// almost never the right thing to do, but needed for compat
/* static */
FCIMPL3(FC_BOOL_RET, AssemblyNameNative::ReferenceMatchesDefinition, AssemblyNameBaseObject* refUNSAFE, AssemblyNameBaseObject* defUNSAFE, CLR_BOOL fParse)
{
FCALL_CONTRACT;
struct _gc
{
ASSEMBLYNAMEREF pRef;
ASSEMBLYNAMEREF pDef;
} gc;
gc.pRef = (ASSEMBLYNAMEREF)ObjectToOBJECTREF (refUNSAFE);
gc.pDef = (ASSEMBLYNAMEREF)ObjectToOBJECTREF (defUNSAFE);
BOOL result = FALSE;
HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
Thread *pThread = GetThread();
CheckPointHolder cph(pThread->m_MarshalAlloc.GetCheckpoint()); //hold checkpoint for autorelease
if (gc.pRef == NULL)
COMPlusThrow(kArgumentNullException, W("ArgumentNull_AssemblyName"));
if (gc.pDef == NULL)
COMPlusThrow(kArgumentNullException, W("ArgumentNull_AssemblyName"));
AssemblySpec refSpec;
refSpec.InitializeSpec(&(pThread->m_MarshalAlloc), (ASSEMBLYNAMEREF*) &gc.pRef, fParse, FALSE);
AssemblySpec defSpec;
defSpec.InitializeSpec(&(pThread->m_MarshalAlloc), (ASSEMBLYNAMEREF*) &gc.pDef, fParse, FALSE);
#ifdef FEATURE_FUSION
SafeComHolder<IAssemblyName> pRefName (NULL);
IfFailThrow(refSpec.CreateFusionName(&pRefName, FALSE));
SafeComHolder <IAssemblyName> pDefName (NULL);
IfFailThrow(defSpec.CreateFusionName(&pDefName, FALSE));
// Order matters: Ref->IsEqual(Def)
result = (S_OK == pRefName->IsEqual(pDefName, ASM_CMPF_IL_ALL));
#else
result=AssemblySpec::RefMatchesDef(&refSpec,&defSpec);
#endif
HELPER_METHOD_FRAME_END();
FC_RETURN_BOOL(result);
}
//===============================================================================================
// Attaches an unmanaged symwriter to a newly created dynamic module.
//===============================================================================================
FCIMPL2(LPVOID, COMModule::nCreateISymWriterForDynamicModule, ReflectModuleBaseObject* reflectionModuleUNSAFE, StringObject* filenameUNSAFE)
{
FCALL_CONTRACT;
REFLECTMODULEBASEREF refModule = (REFLECTMODULEBASEREF)ObjectToOBJECTREF(reflectionModuleUNSAFE);
ReflectionModule *mod = (ReflectionModule*)refModule->GetModule();
STRINGREF filename = (STRINGREF)filenameUNSAFE;
LPVOID pInternalSymWriter = NULL;
HELPER_METHOD_FRAME_BEGIN_RET_2(filename, refModule);
SString name;
if (filename != NULL)
{
filename->GetSString(name);
}
GCX_PREEMP();
pInternalSymWriter = CreateISymWriterForDynamicModule(mod, name.GetUnicode());
HELPER_METHOD_FRAME_END();
return pInternalSymWriter;
} // COMModule::nCreateISymWriterForDynamicModule
void FinalizerThread::FinalizeAllObjects_Wrapper(void *ptr)
{
STATIC_CONTRACT_THROWS;
STATIC_CONTRACT_GC_TRIGGERS;
STATIC_CONTRACT_MODE_COOPERATIVE;
FinalizeAllObjects_Args *args = (FinalizeAllObjects_Args *) ptr;
_ASSERTE(args->fobj);
Object *fobj = OBJECTREFToObject(args->fobj);
args->fobj = NULL; // don't want to do this guy again, if we take an exception here:
args->fobj = ObjectToOBJECTREF(FinalizeAllObjects(fobj, args->bitToCheck));
}
void QCALLTYPE WindowsRuntimeBufferHelper::StoreOverlappedPtrInCCW(QCall::ObjectHandleOnStack winRtBuffer, LPOVERLAPPED lpOverlapped) {
QCALL_CONTRACT;
BEGIN_QCALL;
GCX_COOP();
OBJECTREF buffer = ObjectToOBJECTREF(*winRtBuffer.m_ppObject);
ComCallWrapper *ccw = ComCallWrapper::GetWrapperForObject(buffer);
SimpleComCallWrapper *simpleCCW = ccw->GetSimpleWrapper();
simpleCCW->StoreOverlappedPointer(lpOverlapped);
END_QCALL;
}
//
// Allocate an object from the reference counted heap.
//
OBJECTREF RCAllocateObject( MethodTable* pMT )
{
// TODO: locking
THROWSCOMPLUSEXCEPTION();
// allocate memory for it
Object* orObject = (Object*)g_pRCHeap->Alloc(pMT->GetBaseSize());
// verify that the memory is zeroed out.
_ASSERTE( ! orObject->HasSyncBlockIndex() );
// make sure it has a method table
orObject->SetMethodTable(pMT);
RCLogAlloc(pMT, orObject);
return( ObjectToOBJECTREF(orObject) );
}
Object * FinalizerThread::DoOneFinalization(Object* fobj, Thread* pThread,int bitToCheck,bool *pbTerminate)
{
STATIC_CONTRACT_THROWS;
STATIC_CONTRACT_GC_TRIGGERS;
STATIC_CONTRACT_MODE_COOPERATIVE;
bool fTerminate=false;
Object *pReturnObject = NULL;
AppDomain* targetAppDomain = fobj->GetAppDomain();
AppDomain* currentDomain = pThread->GetDomain();
if (! targetAppDomain || ! targetAppDomain->CanThreadEnter(pThread))
{
// if can't get into domain to finalize it, then it must be agile so finalize in current domain
targetAppDomain = currentDomain;
#if CHECK_APP_DOMAIN_LEAKS
{
// object must be agile if can't get into it's domain
if (g_pConfig->AppDomainLeaks() && !fobj->TrySetAppDomainAgile(FALSE))
_ASSERTE(!"Found non-agile GC object which should have been finalized during app domain unload.");
}
#endif
}
if (targetAppDomain == currentDomain)
{
if (!targetAppDomain->IsRudeUnload() ||
fobj->GetMethodTable()->HasCriticalFinalizer())
{
class ResetFinalizerStartTime
{
public:
ResetFinalizerStartTime()
{
if (CLRHosted())
{
g_ObjFinalizeStartTime = CLRGetTickCount64();
}
}
~ResetFinalizerStartTime()
{
if (g_ObjFinalizeStartTime)
{
g_ObjFinalizeStartTime = 0;
}
}
};
{
ThreadLocaleHolder localeHolder;
{
ResetFinalizerStartTime resetTime;
CallFinalizer(fobj);
}
}
pThread->InternalReset(FALSE);
}
}
else
{
if (! targetAppDomain->GetDefaultContext())
{
// Can no longer enter domain becuase the handle containing the context has been
// destroyed so just bail. Should only get this if are at the stage of nuking the
// handles in the domain if it's still open.
_ASSERTE(targetAppDomain->IsUnloading() && targetAppDomain->ShouldHaveFinalization());
}
else if (!currentDomain->IsDefaultDomain())
{
// this means we are in some other domain, so need to return back out through the DoADCallback
// and handle the object from there in another domain.
pReturnObject = fobj;
fTerminate = true;
}
else
{
// otherwise call back to ourselves to process as many as we can in that other domain
FinalizeAllObjects_Args args;
args.fobj = ObjectToOBJECTREF(fobj);
args.bitToCheck = bitToCheck;
GCPROTECT_BEGIN(args.fobj);
{
ThreadLocaleHolder localeHolder;
_ASSERTE(pThreadTurnAround != NULL);
ManagedThreadBase::FinalizerAppDomain(targetAppDomain,
FinalizeAllObjects_Wrapper,
&args,
pThreadTurnAround);
}
pThread->InternalReset(FALSE);
// process the object we got back or be done if we got back null
pReturnObject = OBJECTREFToObject(args.fobj);
GCPROTECT_END();
}
}
*pbTerminate = fTerminate;
return pReturnObject;
}
FCALL_CHECK;
PRECONDITION(thisString == 0);
PRECONDITION(ptr != NULL);
} CONTRACTL_END;
STRINGREF pString = NULL;
VALIDATEOBJECT(encoding);
HELPER_METHOD_FRAME_BEGIN_RET_1(encoding);
MethodDescCallSite createString(METHOD__STRING__CREATE_STRING);
ARG_SLOT args[] = {
PtrToArgSlot(ptr),
startIndex,
length,
ObjToArgSlot(ObjectToOBJECTREF(encoding)),
};
pString = createString.Call_RetSTRINGREF(args);
HELPER_METHOD_FRAME_END();
return OBJECTREFToObject(pString);
}
FCIMPLEND
/*==============================StringInitCharPtr===============================
**Action:
**Returns:
**Arguments:
**Exceptions:
==============================================================================*/
FCIMPL2(Object *, COMString::StringInitCharPtr, StringObject *stringThis, INT8 *ptr)