From ef1e2ab328087c61a6878c1e84f4fc5d710aebce Mon Sep 17 00:00:00 2001 From: dotnet-bot Date: Fri, 30 Jan 2015 14:14:42 -0800 Subject: Initial commit to populate CoreCLR repo [tfs-changeset: 1407945] --- src/vm/common.h | 528 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 528 insertions(+) create mode 100644 src/vm/common.h (limited to 'src/vm/common.h') diff --git a/src/vm/common.h b/src/vm/common.h new file mode 100644 index 0000000000..5d214818f1 --- /dev/null +++ b/src/vm/common.h @@ -0,0 +1,528 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// +// +// common.h - precompiled headers include for the COM+ Execution Engine +// + +// + + +#ifndef _common_h_ +#define _common_h_ + +#ifdef CLR_STANDALONE_BINDER + +#ifndef CLR_PRIV_BINDER_FOR_MDILBIND +#include "..\tools\mdilbind\common.h" +#endif //!CLR_PRIV_BINDER_FOR_MDILBIND + +#else //CLR_STANDALONE_BINDER + + +#if defined(_MSC_VER) && defined(_X86_) && !defined(FPO_ON) +#pragma optimize("y", on) // Small critical routines, don't put in EBP frame +#define FPO_ON 1 +#define COMMON_TURNED_FPO_ON 1 +#endif + +#define USE_COM_CONTEXT_DEF + +#if defined(_DEBUG) && !defined(CROSSGEN_COMPILE) +#define DEBUG_REGDISPLAY +#endif + +#ifdef _MSC_VER + + // These don't seem useful, so turning them off is no big deal +#pragma warning(disable:4201) // nameless struct/union +#pragma warning(disable:4510) // can't generate default constructor +//#pragma warning(disable:4511) // can't generate copy constructor +#pragma warning(disable:4512) // can't generate assignment constructor +#pragma warning(disable:4610) // user defined constructor required +#pragma warning(disable:4211) // nonstandard extention used (char name[0] in structs) +#pragma warning(disable:4268) // 'const' static/global data initialized with compiler generated default constructor fills the object with zeros +#pragma warning(disable:4238) // nonstandard extension used : class rvalue used as lvalue +#pragma warning(disable:4291) // no matching operator delete found +#pragma warning(disable:4345) // behavior change: an object of POD type constructed with an initializer of the form () will be default-initialized + + // Depending on the code base, you may want to not disable these +#pragma warning(disable:4245) // assigning signed / unsigned +//#pragma warning(disable:4146) // unary minus applied to unsigned +//#pragma warning(disable:4244) // loss of data int -> char .. +#pragma warning(disable:4127) // conditional expression is constant +#pragma warning(disable:4100) // unreferenced formal parameter + +#pragma warning(1:4189) // local variable initialized but not used + +#ifndef DEBUG +#pragma warning(disable:4505) // unreferenced local function has been removed +//#pragma warning(disable:4702) // unreachable code +#pragma warning(disable:4313) // 'format specifier' in format string conflicts with argument %d of type 'type' +#endif // !DEBUG + + // CONSIDER put these back in +#pragma warning(disable:4063) // bad switch value for enum (only in Disasm.cpp) +#pragma warning(disable:4710) // function not inlined +#pragma warning(disable:4527) // user-defined destructor required +#pragma warning(disable:4513) // destructor could not be generated + + // TODO we really probably need this one put back in!!! +//#pragma warning(disable:4701) // local variable may be used without being initialized +#endif // _MSC_VER + +#define _CRT_DEPENDENCY_ //this code depends on the crt file functions + + +#include +#include + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#ifdef _MSC_VER +//non inline intrinsics are faster +#pragma function(memcpy,memcmp,strcmp,strcpy,strlen,strcat) +#endif // _MSC_VER + +#include "volatile.h" + +// make all the unsafe redefinitions available +#include "unsafe.h" + +#include <../../debug/inc/dbgtargetcontext.h> + +//----------------------------------------------------------------------------------------------------------- + +#include "compatibilityflags.h" +extern BOOL GetCompatibilityFlag(CompatibilityFlag flag); +#ifndef FEATURE_CORECLR +extern DWORD* GetGlobalCompatibilityFlags(); +#endif // !FEATURE_CORECLR + +#include "strongname.h" +#include "stdmacros.h" + +#define POISONC ((UINT_PTR)((sizeof(int *) == 4)?0xCCCCCCCCL:I64(0xCCCCCCCCCCCCCCCC))) + +#include "ndpversion.h" +#include "switches.h" +#include "holder.h" +#include "classnames.h" +#include "util.hpp" +#include "corpriv.h" +//#include "WarningControl.h" + +#include + +typedef VPTR(class LoaderAllocator) PTR_LoaderAllocator; +typedef VPTR(class AppDomain) PTR_AppDomain; +typedef VPTR(class AppDomainBaseObject) PTR_AppDomainBaseObject; +typedef DPTR(class ArrayBase) PTR_ArrayBase; +typedef DPTR(class ArrayTypeDesc) PTR_ArrayTypeDesc; +typedef DPTR(class Assembly) PTR_Assembly; +typedef DPTR(class AssemblyBaseObject) PTR_AssemblyBaseObject; +typedef DPTR(class AssemblyNameBaseObject) PTR_AssemblyNameBaseObject; +typedef VPTR(class BaseDomain) PTR_BaseDomain; +typedef DPTR(class ClassLoader) PTR_ClassLoader; +typedef DPTR(class ComCallMethodDesc) PTR_ComCallMethodDesc; +typedef VPTR(class CompilationDomain) PTR_CompilationDomain; +typedef DPTR(class ComPlusCallMethodDesc) PTR_ComPlusCallMethodDesc; +typedef VPTR(class DebugInterface) PTR_DebugInterface; +typedef DPTR(class Dictionary) PTR_Dictionary; +typedef VPTR(class DomainAssembly) PTR_DomainAssembly; +typedef VPTR(class DomainFile) PTR_DomainFile; +typedef VPTR(class DomainModule) PTR_DomainModule; +typedef DPTR(struct FailedAssembly) PTR_FailedAssembly; +typedef VPTR(class EditAndContinueModule) PTR_EditAndContinueModule; +typedef DPTR(class EEClass) PTR_EEClass; +typedef DPTR(class DelegateEEClass) PTR_DelegateEEClass; +typedef DPTR(struct DomainLocalModule) PTR_DomainLocalModule; +typedef VPTR(class EECodeManager) PTR_EECodeManager; +typedef DPTR(class EEConfig) PTR_EEConfig; +typedef VPTR(class EEDbgInterfaceImpl) PTR_EEDbgInterfaceImpl; +typedef VPTR(class DebugInfoManager) PTR_DebugInfoManager; +typedef DPTR(class FieldDesc) PTR_FieldDesc; +typedef VPTR(class Frame) PTR_Frame; +typedef VPTR(class ICodeManager) PTR_ICodeManager; +typedef VPTR(class IJitManager) PTR_IJitManager; +typedef VPTR(struct IUnknown) PTR_IUnknown; +typedef DPTR(class InstMethodHashTable) PTR_InstMethodHashTable; +typedef DPTR(class MetaSig) PTR_MetaSig; +typedef DPTR(class MethodDesc) PTR_MethodDesc; +typedef DPTR(class MethodDescChunk) PTR_MethodDescChunk; +typedef DPTR(class MethodImpl) PTR_MethodImpl; +typedef DPTR(class MethodTable) PTR_MethodTable; +typedef DPTR(class MscorlibBinder) PTR_MscorlibBinder; +typedef VPTR(class Module) PTR_Module; +typedef DPTR(class NDirectMethodDesc) PTR_NDirectMethodDesc; +typedef VPTR(class Thread) PTR_Thread; +typedef DPTR(class Object) PTR_Object; +typedef DPTR(PTR_Object) PTR_PTR_Object; +typedef DPTR(class ObjHeader) PTR_ObjHeader; +typedef DPTR(class Precode) PTR_Precode; +typedef VPTR(class ReflectionModule) PTR_ReflectionModule; +typedef DPTR(class ReflectClassBaseObject) PTR_ReflectClassBaseObject; +typedef DPTR(class ReflectMethodObject) PTR_ReflectMethodObject; +typedef DPTR(class ReflectFieldObject) PTR_ReflectFieldObject; +typedef DPTR(class ReflectModuleBaseObject) PTR_ReflectModuleBaseObject; +typedef DPTR(class ReJitManager) PTR_ReJitManager; +typedef DPTR(struct ReJitInfo) PTR_ReJitInfo; +typedef DPTR(struct SharedReJitInfo) PTR_SharedReJitInfo; +typedef DPTR(class StringObject) PTR_StringObject; +typedef DPTR(class StringBufferObject) PTR_StringBufferObject; +typedef DPTR(class TypeHandle) PTR_TypeHandle; +typedef VPTR(class VirtualCallStubManager) PTR_VirtualCallStubManager; +typedef VPTR(class VirtualCallStubManagerManager) PTR_VirtualCallStubManagerManager; +typedef VPTR(class GCHeap) PTR_GCHeap; + +// +// _UNCHECKED_OBJECTREF is for code that can't deal with DEBUG OBJECTREFs +// +typedef PTR_Object _UNCHECKED_OBJECTREF; +typedef DPTR(PTR_Object) PTR_UNCHECKED_OBJECTREF; + +#ifdef USE_CHECKED_OBJECTREFS +class OBJECTREF; +#else +typedef PTR_Object OBJECTREF; +#endif +typedef DPTR(OBJECTREF) PTR_OBJECTREF; +typedef DPTR(PTR_OBJECTREF) PTR_PTR_OBJECTREF; + +EXTERN_C Thread* STDCALL GetThread(); +BOOL SetThread(Thread*); + +// This is a mechanism by which macros can make the Thread pointer available to inner scopes +// that is robust to code changes. If the outer Thread no longer is available for some reason +// (e.g. code refactoring), this GET_THREAD() macro will fall back to calling GetThread(). +const bool CURRENT_THREAD_AVAILABLE = false; +Thread * const CURRENT_THREAD = NULL; +#define GET_THREAD() (CURRENT_THREAD_AVAILABLE ? CURRENT_THREAD : GetThread()) + +#define MAKE_CURRENT_THREAD_AVAILABLE() \ + Thread * __pThread = GET_THREAD(); \ + MAKE_CURRENT_THREAD_AVAILABLE_EX(__pThread) + +#define MAKE_CURRENT_THREAD_AVAILABLE_EX(__pThread) \ + Thread * CURRENT_THREAD = __pThread; \ + const bool CURRENT_THREAD_AVAILABLE = true; \ + (void)CURRENT_THREAD_AVAILABLE; /* silence "local variable initialized but not used" warning */ \ + +#ifndef DACCESS_COMPILE +EXTERN_C AppDomain* STDCALL GetAppDomain(); +#endif //!DACCESS_COMPILE + +inline void RetailBreak() +{ +#ifdef _TARGET_X86_ + __asm int 3 +#else + DebugBreak(); +#endif +} + +extern BOOL isMemoryReadable(const TADDR start, unsigned len); + +#ifndef memcpyUnsafe_f +#define memcpyUnsafe_f + +// use this when you want to memcpy something that contains GC refs +FORCEINLINE void* memcpyUnsafe(void *dest, const void *src, size_t len) +{ + WRAPPER_NO_CONTRACT; + return memcpy(dest, src, len); +} + +#endif // !memcpyUnsafe_f + +// +// By default logging, and debug GC are enabled under debug +// +// These can be enabled in non-debug by removing the #ifdef _DEBUG +// allowing one to log/check_gc a free build. +// +#if defined(_DEBUG) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE) + + // You should be using CopyValueClass if you are doing an memcpy + // in the CG heap. + #if !defined(memcpy) + FORCEINLINE void* memcpyNoGCRefs(void * dest, const void * src, size_t len) { + WRAPPER_NO_CONTRACT; + return memcpy(dest, src, len); + } + extern "C" void * __cdecl GCSafeMemCpy(void *, const void *, size_t); + #define memcpy(dest, src, len) GCSafeMemCpy(dest, src, len) + #endif // !defined(memcpy) + + #if !defined(CHECK_APP_DOMAIN_LEAKS) + #define CHECK_APP_DOMAIN_LEAKS 1 + #endif +#else // !_DEBUG && !DACCESS_COMPILE && !CROSSGEN_COMPILE + FORCEINLINE void* memcpyNoGCRefs(void * dest, const void * src, size_t len) { + WRAPPER_NO_CONTRACT; + + return memcpy(dest, src, len); + } +#endif // !_DEBUG && !DACCESS_COMPILE && !CROSSGEN_COMPILE + +namespace Loader +{ + typedef enum + { + Load, //should load + DontLoad, //should not load + SafeLookup //take no locks, no allocations + } LoadFlag; +} + + +// src/inc +#include "utilcode.h" +#include "log.h" +#include "loaderheap.h" +#include "fixuppointer.h" +#include "lazycow.h" + +// src/vm +#include "util.hpp" +#include "ibclogger.h" +#include "eepolicy.h" + +#include "vars.hpp" +#include "crst.h" +#include "argslot.h" +#include "stublink.h" +#include "cgensys.h" +#include "ceemain.h" +#include "hash.h" +#include "eecontract.h" +#include "pedecoder.h" +#include "sstring.h" +#include "slist.h" + +#include "eeconfig.h" + +#include "spinlock.h" +#include "objecthandle.h" +#include "declsec.h" + +#ifdef FEATURE_COMINTEROP +#include "stdinterfaces.h" +#endif + +#include "typehandle.h" +#include "perfcounters.h" +#include "methodtable.h" +#include "typectxt.h" + +#include "eehash.h" + +#include "handletable.h" +#include "vars.hpp" +#include "eventstore.hpp" + +#include "synch.h" +#include "regdisp.h" +#include "stackframe.h" +#include "gms.h" +#include "stackprobe.h" +#include "fcall.h" +#include "syncblk.h" +#include "gcdesc.h" +#include "specialstatics.h" +#include "object.h" // We should not really need to put this so early... +#include "gchelpers.h" +#include "pefile.h" +#include "clrex.h" +#include "clsload.hpp" // We should not really need to put this so early... +#include "siginfo.hpp" +#include "binder.h" +#include "jitinterface.h" // We should not really need to put this so early... +#include "ceeload.h" +#include "memberload.h" +#include "genericdict.h" +#include "class.h" +#include "codeman.h" +#include "threads.h" +#include "clrex.inl" +#ifdef FEATURE_COMINTEROP + // These need to be included *after* threads.h so that they can properly use LeaveRuntimeHolder + #include "windowsruntime.h" + #include "windowsstring.h" +#endif +#include "loaderallocator.hpp" +#include "appdomain.hpp" +#include "appdomain.inl" +#include "assembly.hpp" +#include "pefile.inl" +#include "excep.h" +#include "method.hpp" +#include "callingconvention.h" +#include "frames.h" +#include "qcall.h" +#include "callhelpers.h" + +#include "stackwalk.h" +#include "stackingallocator.h" +#include "interoputil.h" +#include "wrappers.h" +#include "dynamicmethod.h" +#include "mixedmode.hpp" + +#include "gcstress.h" + +#ifndef DACCESS_COMPILE + +inline VOID UnsafeEEEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection) +{ + STATIC_CONTRACT_NOTHROW; + STATIC_CONTRACT_GC_NOTRIGGER; + STATIC_CONTRACT_CAN_TAKE_LOCK; + + if (CLRTaskHosted()) { + Thread::BeginThreadAffinity(); + } + UnsafeEnterCriticalSection(lpCriticalSection); + INCTHREADLOCKCOUNT(); +} + +inline VOID UnsafeEELeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection) +{ + STATIC_CONTRACT_NOTHROW; + STATIC_CONTRACT_GC_NOTRIGGER; + + UnsafeLeaveCriticalSection(lpCriticalSection); + DECTHREADLOCKCOUNT(); + if (CLRTaskHosted()) { + Thread::EndThreadAffinity(); + } +} + +inline BOOL UnsafeEETryEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection) +{ + STATIC_CONTRACT_NOTHROW; + STATIC_CONTRACT_GC_NOTRIGGER; + STATIC_CONTRACT_CAN_TAKE_LOCK; + + BOOL fEnteredCriticalSection = UnsafeTryEnterCriticalSection(lpCriticalSection); + if(fEnteredCriticalSection) + { + INCTHREADLOCKCOUNT(); + } + return fEnteredCriticalSection; +} + +#endif // !DACCESS_COMPILE + +HRESULT EnsureRtlFunctions(); +HINSTANCE GetModuleInst(); + +#if defined(_TARGET_X86_) || defined(_TARGET_AMD64_) +// +// Strong memory model. No memory barrier necessary before writing object references into GC heap. +// +#define GCHeapMemoryBarrier() +#else +// +// The weak memory model forces us to raise memory barriers before writing object references into GC heap. This is required +// for both security and to make most managed code written against strong memory model work. Under normal circumstances, this memory +// barrier is part of GC write barrier. However, there are a few places in the VM that set cards manually without going through +// regular GC write barrier. These places need to this macro. This macro is usually used before memcpy-like operation followed +// by SetCardsAfterBulkCopy. +// +#define GCHeapMemoryBarrier() MemoryBarrier() +#endif + + +// use this when you want to memcpy something that contains GC refs +void memmoveGCRefs(void *dest, const void *src, size_t len); + + +#if defined(_DEBUG) + +// This catches CANNOTTHROW macros that occur outside the scope of a CONTRACT. +// Note that it's important for m_CannotThrowLineNums to be NULL. +struct DummyGlobalContract +{ + int *m_CannotThrowLineNums; //= NULL; + LPVOID *m_CannotThrowRecords; //= NULL; +}; + +extern DummyGlobalContract ___contract; + +#endif // defined(_DEBUG) + + +// All files get to see all of these .inl files to make sure all files +// get the benefit of inlining. +#include "ceeload.inl" +#include "typedesc.inl" +#include "class.inl" +#include "methodtable.inl" +#include "typehandle.inl" +#include "object.inl" +#include "clsload.inl" +#include "domainfile.inl" +#include "handletable.inl" +#include "method.inl" +#include "stackprobe.inl" +#include "syncblk.inl" +#include "threads.inl" +#include "eehash.inl" +#include "mscorcfg.h" +#ifdef FEATURE_COMINTEROP +#include "WinRTRedirector.h" +#include "winrtredirector.inl" +#endif // FEATURE_COMINTEROP + +inline HRESULT CreateConfigStreamHelper(LPCWSTR filename, IStream** pOutStream) +{ + CONTRACTL + { + NOTHROW; + GC_NOTRIGGER; + MODE_ANY; + } + CONTRACTL_END + + HRESULT hr =S_OK; + + EX_TRY + { + hr = CreateConfigStream( filename, pOutStream); + } + EX_CATCH_HRESULT(hr); + + return hr; +} + + +#if defined(COMMON_TURNED_FPO_ON) +#pragma optimize("", on) // Go back to command line default optimizations +#undef COMMON_TURNED_FPO_ON +#undef FPO_ON +#endif + +extern INT64 g_PauseTime; // Total duration of all pauses in the runtime +extern Volatile g_IsPaused; // True if the runtime is Paused for FAS +extern CLREventStatic g_ClrResumeEvent; // Event fired when the runtime is resumed after a Pause for FAS +INT64 AdditionalWait(INT64 sPauseTime, INT64 sTime, INT64 expDuration); + +#endif // CLR_STANDALONE_BINDER + +#endif // !_common_h_ + + -- cgit v1.2.3